source: stable/HeuristicLab.Parameters/3.3/LookupParameter.cs @ 12009

Last change on this file since 12009 was 12009, checked in by ascheibe, 7 years ago

#2212 updated copyright year

File size: 9.7 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Threading;
24using HeuristicLab.Common;
25using HeuristicLab.Core;
26using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
27
28namespace HeuristicLab.Parameters {
29  /// <summary>
30  /// A parameter whose value is retrieved from the scope.
31  /// </summary>
32  [Item("LookupParameter", "A parameter whose value is retrieved from or written to a scope.")]
33  [StorableClass]
34  public class LookupParameter<T> : Parameter, IStatefulItem, ILookupParameter<T> where T : class, IItem {
35    [Storable]
36    private string actualName;
37    public string ActualName {
38      get { return actualName; }
39      set {
40        if (value == null) throw new ArgumentNullException();
41        if (string.IsNullOrWhiteSpace(value)) {
42          actualName = Name;
43          OnActualNameChanged();
44        } else if (!actualName.Equals(value)) {
45          actualName = value;
46          OnActualNameChanged();
47        }
48      }
49    }
50    public string TranslatedName {
51      get {
52        string translatedName;
53        GetValueParameterAndTranslateName(out translatedName);
54        return translatedName;
55      }
56    }
57    public new T ActualValue {
58      get { return (T)base.ActualValue; }
59      set { base.ActualValue = value; }
60    }
61
62    private Lazy<ThreadLocal<IItem>> cachedActualValues;
63    private IItem CachedActualValue {
64      get { return cachedActualValues.Value.Value; }
65    }
66
67    private Lazy<ThreadLocal<IExecutionContext>> executionContexts;
68    public IExecutionContext ExecutionContext {
69      get { return executionContexts.Value.Value; }
70      set {
71        if (value != executionContexts.Value.Value) {
72          executionContexts.Value.Value = value;
73          cachedActualValues.Value.Value = null;
74        }
75      }
76    }
77
78    [StorableConstructor]
79    protected LookupParameter(bool deserializing)
80      : base(deserializing) {
81      cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
82      executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
83    }
84    protected LookupParameter(LookupParameter<T> original, Cloner cloner)
85      : base(original, cloner) {
86      actualName = original.actualName;
87      cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
88      executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
89    }
90    public LookupParameter()
91      : base("Anonymous", typeof(T)) {
92      this.actualName = Name;
93      this.Hidden = true;
94      cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
95      executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
96    }
97    public LookupParameter(string name)
98      : base(name, typeof(T)) {
99      this.actualName = Name;
100      this.Hidden = true;
101      cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
102      executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
103    }
104    public LookupParameter(string name, string description)
105      : base(name, description, typeof(T)) {
106      this.actualName = Name;
107      this.Hidden = true;
108      cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
109      executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
110    }
111    public LookupParameter(string name, string description, string actualName)
112      : base(name, description, typeof(T)) {
113      this.actualName = string.IsNullOrWhiteSpace(actualName) ? Name : actualName;
114      this.Hidden = true;
115      cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
116      executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
117    }
118
119    public override IDeepCloneable Clone(Cloner cloner) {
120      return new LookupParameter<T>(this, cloner);
121    }
122
123    public override string ToString() {
124      if (Name.Equals(ActualName))
125        return Name;
126      else
127        return Name + ": " + ActualName;
128    }
129
130    private IValueParameter GetValueParameterAndTranslateName(out string actualName) {
131      IValueParameter valueParam;
132      ILookupParameter lookupParam;
133      IExecutionContext currentExecutionContext = ExecutionContext;
134
135      actualName = Name;
136      while (currentExecutionContext != null) {
137        valueParam = currentExecutionContext.Parameters[actualName] as IValueParameter;
138        lookupParam = currentExecutionContext.Parameters[actualName] as ILookupParameter;
139
140        if ((valueParam == null) && (lookupParam == null))
141          throw new InvalidOperationException(
142            string.Format("Parameter look-up chain broken. Parameter \"{0}\" is not an \"{1}\" or an \"{2}\".",
143                          actualName, typeof(IValueParameter).GetPrettyName(), typeof(ILookupParameter).GetPrettyName())
144          );
145
146        if (valueParam != null) {
147          if (valueParam.Value != null) return valueParam;
148          else if (lookupParam == null) return valueParam;
149        }
150        if (lookupParam != null) actualName = lookupParam.ActualName;
151
152        currentExecutionContext = currentExecutionContext.Parent;
153        while ((currentExecutionContext != null) && !currentExecutionContext.Parameters.ContainsKey(actualName))
154          currentExecutionContext = currentExecutionContext.Parent;
155      }
156      return null;
157    }
158    private IVariable LookupVariable(string name) {
159      IScope scope = ExecutionContext.Scope;
160      while ((scope != null) && !scope.Variables.ContainsKey(name))
161        scope = scope.Parent;
162      return scope != null ? scope.Variables[name] : null;
163    }
164    protected override IItem GetActualValue() {
165      if (CachedActualValue != null) return CachedActualValue;
166      string name;
167      // try to get value from context stack
168      IValueParameter param = GetValueParameterAndTranslateName(out name);
169      if (param != null) return param.Value;
170
171      // try to get variable from scope
172      IVariable var = LookupVariable(name);
173      if (var != null) {
174        if (!(var.Value is T))
175          throw new InvalidOperationException(
176            string.Format("Type mismatch. Variable \"{0}\" does not contain a \"{1}\".",
177                          name,
178                          typeof(T).GetPrettyName())
179          );
180        cachedActualValues.Value.Value = var.Value;
181        return var.Value;
182      }
183      return null;
184    }
185    protected override void SetActualValue(IItem value) {
186      if (!(value is T))
187        throw new InvalidOperationException(
188          string.Format("Type mismatch. Value is not a \"{0}\".",
189                        typeof(T).GetPrettyName())
190        );
191      cachedActualValues.Value.Value = value;
192
193      // try to set value in context stack
194      string name;
195      IValueParameter param = GetValueParameterAndTranslateName(out name);
196      if (param != null) {
197        param.Value = value;
198        return;
199      }
200
201      // try to set value in scope
202      IVariable var = LookupVariable(name);
203      if (var != null) {
204        var.Value = value;
205        return;
206      }
207
208      // create new variable
209      ExecutionContext.Scope.Variables.Add(new Variable(name, value));
210    }
211
212    public virtual void InitializeState() {
213    }
214    public virtual void ClearState() {
215      if (cachedActualValues.IsValueCreated) {
216        cachedActualValues.Value.Dispose();
217        cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
218      }
219      if (executionContexts.IsValueCreated) {
220        executionContexts.Value.Dispose();
221        executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
222      }
223    }
224
225    public event EventHandler ActualNameChanged;
226    protected virtual void OnActualNameChanged() {
227      EventHandler handler = ActualNameChanged;
228      if (handler != null) handler(this, EventArgs.Empty);
229      OnToStringChanged();
230    }
231  }
232}
Note: See TracBrowser for help on using the repository browser.