Free cookie consent management tool by TermsFeed Policy Generator

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

Last change on this file since 17231 was 17181, checked in by swagner, 5 years ago

#2875: Merged r17180 from trunk to stable

File size: 10.2 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 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 HEAL.Attic;
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  [StorableType("84FE5F33-94B8-4E30-B1CB-CD15314FB83B")]
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 = Name;
53        GetValueParameterAndTranslateName(ExecutionContext, ref 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    protected IItem CachedActualValue {
64      get { return cachedActualValues.Value.Value; }
65      set { cachedActualValues.Value.Value = value; }
66    }
67
68    private Lazy<ThreadLocal<IExecutionContext>> executionContexts;
69    public IExecutionContext ExecutionContext {
70      get { return executionContexts.Value.Value; }
71      set {
72        if (value != executionContexts.Value.Value) {
73          executionContexts.Value.Value = value;
74          cachedActualValues.Value.Value = null;
75        }
76      }
77    }
78
79    [StorableConstructor]
80    protected LookupParameter(StorableConstructorFlag _) : base(_) {
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    protected static IValueParameter GetValueParameterAndTranslateName(IExecutionContext executionContext, ref string translatedName) {
131      IValueParameter valueParam;
132      ILookupParameter lookupParam;
133      IExecutionContext currentExecutionContext = executionContext;
134
135      while (currentExecutionContext != null) {
136        IParameter param = null;
137        while (currentExecutionContext != null && !currentExecutionContext.Parameters.TryGetValue(translatedName, out param))
138          currentExecutionContext = currentExecutionContext.Parent;
139        if (currentExecutionContext == null) break;
140
141        valueParam = param as IValueParameter;
142        lookupParam = param as ILookupParameter;
143
144        if ((valueParam == null) && (lookupParam == null))
145          throw new InvalidOperationException(
146            string.Format("Parameter look-up chain broken. Parameter \"{0}\" is not an \"{1}\" or an \"{2}\".",
147                          translatedName, typeof(IValueParameter).GetPrettyName(), typeof(ILookupParameter).GetPrettyName())
148          );
149
150        if (valueParam != null) {
151          if (valueParam.Value != null) return valueParam;
152          else if (lookupParam == null) return valueParam;
153        }
154        translatedName = lookupParam.ActualName;
155
156        currentExecutionContext = currentExecutionContext.Parent;
157      }
158      return null;
159    }
160    protected static IVariable LookupVariable(IScope scope, string name) {
161      IVariable variable = null;
162      while (scope != null && !scope.Variables.TryGetValue(name, out variable))
163        scope = scope.Parent;
164      return scope != null ? variable : null;
165    }
166
167    protected override IItem GetActualValue() {
168      if (CachedActualValue != null) return CachedActualValue;
169
170      string translatedName = Name;
171      var value = GetValue(ExecutionContext, ref translatedName);
172      if (value != null && !(value is T))
173        throw new InvalidOperationException(
174          string.Format("Type mismatch. Variable \"{0}\" does not contain a \"{1}\".",
175                        translatedName,
176                        typeof(T).GetPrettyName())
177        );
178      CachedActualValue = value;
179      return value;
180    }
181
182    protected static IItem GetValue(IExecutionContext executionContext, ref string name) {
183      // try to get value from context stack
184      IValueParameter param = GetValueParameterAndTranslateName(executionContext, ref name);
185      if (param != null) return param.Value;
186
187      // try to get variable from scope
188      IVariable var = LookupVariable(executionContext.Scope, name);
189      return var != null ? var.Value : null;
190    }
191
192    protected override void SetActualValue(IItem value) {
193      if (!(value is T))
194        throw new InvalidOperationException(
195          string.Format("Type mismatch. Value is not a \"{0}\".",
196                        typeof(T).GetPrettyName())
197        );
198      CachedActualValue = value;
199
200      string translatedName = Name;
201      SetValue(ExecutionContext, ref translatedName, value);
202    }
203
204    protected static void SetValue(IExecutionContext executionContext, ref string name, IItem value) {
205      // try to set value in context stack
206      IValueParameter param = GetValueParameterAndTranslateName(executionContext, ref name);
207      if (param != null) {
208        param.Value = value;
209        return;
210      }
211
212      // try to set value in scope
213      IVariable var = LookupVariable(executionContext.Scope, name);
214      if (var != null) {
215        var.Value = value;
216        return;
217      }
218
219      // create new variable
220      executionContext.Scope.Variables.Add(new Variable(name, value));
221    }
222
223    public virtual void InitializeState() {
224    }
225    public virtual void ClearState() {
226      if (cachedActualValues.IsValueCreated) {
227        cachedActualValues.Value.Dispose();
228        cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
229      }
230      if (executionContexts.IsValueCreated) {
231        executionContexts.Value.Dispose();
232        executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
233      }
234    }
235
236    public event EventHandler ActualNameChanged;
237    protected virtual void OnActualNameChanged() {
238      EventHandler handler = ActualNameChanged;
239      if (handler != null) handler(this, EventArgs.Empty);
240      OnToStringChanged();
241    }
242  }
243}
Note: See TracBrowser for help on using the repository browser.