Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
06/06/09 02:09:35 (15 years ago)
Author:
swagner
Message:

Refactoring of the operator architecture (#95)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/OperatorBase.cs

    r1851 r2027  
    2929  /// The base class for all operators.
    3030  /// </summary>
    31   public abstract class OperatorBase : ConstrainedItemBase, IOperator {
     31  public abstract class OperatorBase : ItemBase, IOperator {
    3232    private string myName;
    3333    /// <summary>
    … …  
    8080      get { return mySubOperators.AsReadOnly(); }
    8181    }
    82     private Dictionary<string, IVariableInfo> myVariableInfos;
    83     /// <inheritdoc/>
    84     public virtual ICollection<IVariableInfo> VariableInfos {
    85       get { return myVariableInfos.Values; }
    86     }
    87     private Dictionary<string, IVariable> myVariables;
    88     /// <inheritdoc/>
    89     public virtual ICollection<IVariable> Variables {
    90       get { return myVariables.Values; }
     82    private Dictionary<string, IParameter> myParameters;
     83    /// <inheritdoc/>
     84    public virtual ICollection<IParameter> Parameters {
     85      get { return myParameters.Values; }
    9186    }
    9287
    … …  
    10095      myBreakpoint = false;
    10196      mySubOperators = new List<IOperator>();
    102       myVariableInfos = new Dictionary<string, IVariableInfo>();
    103       myVariables = new Dictionary<string, IVariable>();
     97      myParameters = new Dictionary<string, IParameter>();
    10498    }
    10599
    … …  
    116110      for (int i = 0; i < SubOperators.Count; i++)
    117111        clone.AddSubOperator((IOperator)Auxiliary.Clone(SubOperators[i], clonedObjects));
    118       clone.myVariableInfos.Clear();
    119       foreach (IVariableInfo variableInfo in myVariableInfos.Values)
    120         clone.AddVariableInfo((IVariableInfo)Auxiliary.Clone(variableInfo, clonedObjects));
    121       clone.myVariables.Clear();
    122       foreach (IVariable variable in myVariables.Values)
    123         clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
     112      clone.myParameters.Clear();
     113      foreach (IParameter parameter in myParameters.Values)
     114        clone.AddParameter((IParameter)Auxiliary.Clone(parameter, clonedObjects));
    124115      return clone;
    125116    }
    … …  
    142133      OnSubOperatorAdded(subOperator, mySubOperators.Count - 1);
    143134    }
    144     /// <inheritdoc cref="IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator)"/>
    145     /// <param name="subOperator">The sub operator to add.</param>
    146     /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
    147     public virtual bool TryAddSubOperator(IOperator subOperator) {
    148       mySubOperators.Add(subOperator);
    149       if (IsValid()) {
    150         OnSubOperatorAdded(subOperator, mySubOperators.Count - 1);
    151         return true;
    152       } else {
    153         mySubOperators.RemoveAt(mySubOperators.Count - 1);
    154         return false;
    155       }
    156     }
    157     /// <inheritdoc cref="HeuristicLab.Core.IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator,
    158     /// out System.Collections.Generic.ICollection&lt;HeuristicLab.Core.IConstraint&gt;)"/>
    159     /// <param name="subOperator">The sub operator to add.</param>
    160     /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
    161     public virtual bool TryAddSubOperator(IOperator subOperator, out ICollection<IConstraint> violatedConstraints) {
    162       mySubOperators.Add(subOperator);
    163       if (IsValid(out violatedConstraints)) {
    164         OnSubOperatorAdded(subOperator, mySubOperators.Count - 1);
    165         return true;
    166       } else {
    167         mySubOperators.RemoveAt(mySubOperators.Count - 1);
    168         return false;
    169       }
    170     }
    171135    /// <inheritdoc cref="HeuristicLab.Core.IOperator.AddSubOperator(HeuristicLab.Core.IOperator, int)"/>
    172136    /// <param name="subOperator">The sub operator to add.</param>
    … …  
    176140      OnSubOperatorAdded(subOperator, index);
    177141    }
    178     /// <inheritdoc cref="IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator, int)"/>
    179     /// <param name="subOperator">The sub operator to add.</param>
    180     /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
    181     public virtual bool TryAddSubOperator(IOperator subOperator, int index) {
    182       mySubOperators.Insert(index, subOperator);
    183       if (IsValid()) {
    184         OnSubOperatorAdded(subOperator, index);
    185         return true;
    186       } else {
    187         mySubOperators.RemoveAt(index);
    188         return false;
    189       }
    190     }
    191     /// <inheritdoc cref="IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator, int, out
    192     /// System.Collections.Generic.ICollection&lt;HeuristicLab.Core.IConstraint&gt;)"/>
    193     /// <param name="subOperator">The sub operator to add.</param>
    194     /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
    195     public virtual bool TryAddSubOperator(IOperator subOperator, int index, out ICollection<IConstraint> violatedConstraints) {
    196       mySubOperators.Insert(index, subOperator);
    197       if (IsValid(out violatedConstraints)) {
    198         OnSubOperatorAdded(subOperator, index);
    199         return true;
    200       } else {
    201         mySubOperators.RemoveAt(index);
    202         return false;
    203       }
    204     }
    205142    /// <inheritdoc/>
    206143    /// <remarks>Calls <see cref="OnSubOperatorRemoved"/>.</remarks>
    … …  
    210147      OnSubOperatorRemoved(op, index);
    211148    }
    212     /// <inheritdoc/>
    213     /// <remarks>Calls <see cref="OnSubOperatorRemoved"/>.</remarks>
    214     public virtual bool TryRemoveSubOperator(int index) {
    215       IOperator op = mySubOperators[index];
    216       mySubOperators.RemoveAt(index);
    217       if (IsValid()) {
    218         OnSubOperatorRemoved(op, index);
    219         return true;
    220       } else {
    221         mySubOperators.Insert(index, op);
    222         return false;
    223       }
    224     }
    225     /// <inheritdoc/>
    226     /// <remarks>Calls <see cref="OnSubOperatorRemoved"/>.</remarks>
    227     public virtual bool TryRemoveSubOperator(int index, out ICollection<IConstraint> violatedConstraints) {
    228       IOperator op = mySubOperators[index];
    229       mySubOperators.RemoveAt(index);
    230       if (IsValid(out violatedConstraints)) {
    231         OnSubOperatorRemoved(op, index);
    232         return true;
    233       } else {
    234         mySubOperators.Insert(index, op);
    235         return false;
    236       }
    237     }
    238149    #endregion
    239150
    240     #region VariableInfo Methods
    241     /// <inheritdoc/>
    242     public virtual IVariableInfo GetVariableInfo(string formalName) {
    243       IVariableInfo info;
    244       if (myVariableInfos.TryGetValue(formalName, out info))
     151    #region Parameter Methods
     152    /// <inheritdoc/>
     153    public virtual IParameter GetParameter(string name) {
     154      IParameter info;
     155      if (myParameters.TryGetValue(name, out info))
    245156        return info;
    246157      else
    … …  
    249160    /// <inheritdoc/>
    250161    /// <remarks>Calls <see cref="OnVariableInfoAdded"/>.</remarks>
    251     public virtual void AddVariableInfo(IVariableInfo variableInfo) {
    252       myVariableInfos.Add(variableInfo.FormalName, variableInfo);
    253       OnVariableInfoAdded(variableInfo);
    254     }
    255     /// <inheritdoc/>
    256     /// <remarks>Calls <see cref="OnVariableInfoAdded"/>.</remarks>
    257     public virtual bool TryAddVariableInfo(IVariableInfo variableInfo) {
    258       myVariableInfos.Add(variableInfo.FormalName, variableInfo);
    259       if (IsValid()) {
    260         OnVariableInfoAdded(variableInfo);
    261         return true;
    262       } else {
    263         myVariableInfos.Remove(variableInfo.FormalName);
    264         return false;
    265       }
    266     }
    267     /// <inheritdoc/>
    268     /// <remarks>Calls <see cref="OnVariableInfoAdded"/>.</remarks>
    269     public virtual bool TryAddVariableInfo(IVariableInfo variableInfo, out ICollection<IConstraint> violatedConstraints) {
    270       myVariableInfos.Add(variableInfo.FormalName, variableInfo);
    271       if (IsValid(out violatedConstraints)) {
    272         OnVariableInfoAdded(variableInfo);
    273         return true;
    274       } else {
    275         myVariableInfos.Remove(variableInfo.FormalName);
    276         return false;
    277       }
     162    public virtual void AddParameter(IParameter parameter) {
     163      myParameters.Add(parameter.Name, parameter);
     164      OnParameterAdded(parameter);
    278165    }
    279166    /// <inheritdoc/>
    280167    /// <remarks>Calls <see cref="OnVariableInfoRemoved"/>.</remarks>
    281     public virtual void RemoveVariableInfo(string formalName) {
    282       IVariableInfo variableInfo;
    283       if (myVariableInfos.TryGetValue(formalName, out variableInfo)) {
    284         myVariableInfos.Remove(formalName);
    285         OnVariableInfoRemoved(variableInfo);
    286       }
    287     }
    288     /// <inheritdoc/>
    289     /// <remarks>Calls <see cref="OnVariableInfoRemoved"/>.</remarks>
    290     public virtual bool TryRemoveVariableInfo(string formalName) {
    291       IVariableInfo variableInfo;
    292       if (myVariableInfos.TryGetValue(formalName, out variableInfo)) {
    293         myVariableInfos.Remove(formalName);
    294         if (IsValid()) {
    295           OnVariableInfoRemoved(variableInfo);
    296           return true;
    297         } else {
    298           myVariableInfos.Add(formalName, variableInfo);
    299           return false;
    300         }
    301       }
    302       return true;
    303     }
    304     /// <inheritdoc/>
    305     /// <remarks>Calls <see cref="OnVariableInfoRemoved"/>.</remarks>
    306     public virtual bool TryRemoveVariableInfo(string formalName, out ICollection<IConstraint> violatedConstraints) {
    307       IVariableInfo variableInfo;
    308       if (myVariableInfos.TryGetValue(formalName, out variableInfo)) {
    309         myVariableInfos.Remove(formalName);
    310         if (IsValid(out violatedConstraints)) {
    311           OnVariableInfoRemoved(variableInfo);
    312           return true;
    313         } else {
    314           myVariableInfos.Add(formalName, variableInfo);
    315           return false;
    316         }
    317       }
    318       violatedConstraints = new List<IConstraint>();
    319       return true;
     168    public virtual void RemoveParameter(string name) {
     169      IParameter parameter;
     170      if (myParameters.TryGetValue(name, out parameter)) {
     171        myParameters.Remove(name);
     172        OnParameterRemoved(parameter);
     173      }
    320174    }
    321175    #endregion
    322176
    323     #region Variable Methods
    324     /// <inheritdoc/>
    325     public virtual IVariable GetVariable(string name) {
    326       IVariable variable;
    327       if (myVariables.TryGetValue(name, out variable))
    328         return variable;
    329       else
    330         return null;
    331     }
    332     /// <inheritdoc/>
    333     /// <remarks>Calls <see cref="OnVariableAdded"/> and adds <c>NameChanging</c> and <c>NameChanged</c>
    334     /// event handlers.</remarks>
    335     public virtual void AddVariable(IVariable variable) {
    336       myVariables.Add(variable.Name, variable);
    337       variable.NameChanging += new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
    338       variable.NameChanged += new EventHandler(Variable_NameChanged);
    339       OnVariableAdded(variable);
    340     }
    341     /// <inheritdoc/>
    342     /// <remarks>Calls <see cref="OnVariableAdded"/> and adds <c>NameChanging</c> and <c>NameChanged</c>
    343     /// event handlers.</remarks>
    344     public virtual bool TryAddVariable(IVariable variable) {
    345       myVariables.Add(variable.Name, variable);
    346       if (IsValid()) {
    347         variable.NameChanging += new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
    348         variable.NameChanged += new EventHandler(Variable_NameChanged);
    349         OnVariableAdded(variable);
    350         return true;
    351       } else {
    352         myVariableInfos.Remove(variable.Name);
    353         return false;
    354       }
    355     }
    356     /// <inheritdoc/>
    357     /// <remarks>Calls <see cref="OnVariableAdded"/> and adds <c>NameChanging</c> and <c>NameChanged</c>
    358     /// event handlers.</remarks>
    359     public virtual bool TryAddVariable(IVariable variable, out ICollection<IConstraint> violatedConstraints) {
    360       myVariables.Add(variable.Name, variable);
    361       if (IsValid(out violatedConstraints)) {
    362         variable.NameChanging += new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
    363         variable.NameChanged += new EventHandler(Variable_NameChanged);
    364         OnVariableAdded(variable);
    365         return true;
    366       } else {
    367         myVariableInfos.Remove(variable.Name);
    368         return false;
    369       }
    370     }
    371     /// <inheritdoc/>
    372     /// <remarks>Calls <see cref="OnVariableRemoved"/> and removes <c>NameChanging</c> and <c>NameChanged</c>
    373     /// event handlers.</remarks>
    374     public virtual void RemoveVariable(string name) {
    375       IVariable variable;
    376       if (myVariables.TryGetValue(name, out variable)) {
    377         variable.NameChanging -= new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
    378         variable.NameChanged -= new EventHandler(Variable_NameChanged);
    379         myVariables.Remove(name);
    380         OnVariableRemoved(variable);
    381       }
    382     }
    383     /// <inheritdoc/>
    384     /// <remarks>Calls <see cref="OnVariableRemoved"/> and removes <c>NameChanging</c> and <c>NameChanged</c>
    385     /// event handlers.</remarks>
    386     public virtual bool TryRemoveVariable(string name) {
    387       IVariable variable;
    388       if (myVariables.TryGetValue(name, out variable)) {
    389         myVariables.Remove(name);
    390         if (IsValid()) {
    391           variable.NameChanging -= new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
    392           variable.NameChanged -= new EventHandler(Variable_NameChanged);
    393           OnVariableRemoved(variable);
    394           return true;
    395         } else {
    396           myVariables.Add(name, variable);
    397           return false;
    398         }
    399       }
    400       return true;
    401     }
    402     /// <inheritdoc/>
    403     /// <remarks>Calls <see cref="OnVariableRemoved"/> and removes <c>NameChanging</c> and <c>NameChanged</c>
    404     /// event handlers.</remarks>
    405     public virtual bool TryRemoveVariable(string name, out ICollection<IConstraint> violatedConstraints) {
    406       IVariable variable;
    407       if (myVariables.TryGetValue(name, out variable)) {
    408         myVariables.Remove(name);
    409         if (IsValid(out violatedConstraints)) {
    410           variable.NameChanging -= new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
    411           variable.NameChanged -= new EventHandler(Variable_NameChanged);
    412           OnVariableRemoved(variable);
    413           return true;
    414         } else {
    415           myVariables.Add(name, variable);
    416           return false;
    417         }
    418       }
    419       violatedConstraints = new List<IConstraint>();
    420       return true;
    421     }
    422     private void Variable_NameChanging(object sender, NameChangingEventArgs e) {
    423       e.Cancel = myVariables.ContainsKey(e.Name);
    424     }
    425     private void Variable_NameChanged(object sender, EventArgs e) {
    426       IVariable variable = (IVariable)sender;
    427       string oldName = null;
    428       foreach (KeyValuePair<string, IVariable> element in myVariables) {
    429         if (element.Value == variable)
    430           oldName = element.Key;
    431       }
    432       myVariables.Remove(oldName);
    433       myVariables.Add(variable.Name, variable);
    434     }
    435     /// <inheritdoc cref="IOperator.GetVariableValue&lt;T&gt;(string, HeuristicLab.Core.IScope, bool)"/>
    436     ///  <remarks>Calls <see cref="GetVariableValue&lt;T&gt;(string, HeuristicLab.Core.IScope, bool, bool)"/>
    437     /// with <c>throwOnError</c> set to <c>false</c>.</remarks>
    438     public T GetVariableValue<T>(string formalName, IScope scope, bool recursiveLookup) where T : class, IItem {
    439       return GetVariableValue<T>(formalName, scope, recursiveLookup, true);
    440     }
    441     /// <inheritdoc cref="IOperator.GetVariableValue&lt;T&gt;(string, HeuristicLab.Core.IScope, bool, bool)"/>
    442     /// <remarks>Calls
    443     /// <see cref="GetVariableValue(string, HeuristicLab.Core.IScope, bool, bool)"/>.</remarks>
    444     public T GetVariableValue<T>(string formalName, IScope scope, bool recursiveLookup, bool throwOnError) where T : class, IItem {
    445       return (T)GetVariableValue(formalName, scope, recursiveLookup, throwOnError);
    446     }
    447     /// <inheritdoc cref="IOperator.GetVariableValue(string, HeuristicLab.Core.IScope, bool)"/>
    448     /// <remarks>Calls <see cref="GetVariableValue(string, HeuristicLab.Core.IScope, bool, bool)"/>
    449     /// with <c>throwOnError</c> set to <c>false</c>.</remarks>
    450     public IItem GetVariableValue(string formalName, IScope scope, bool recursiveLookup) {
    451       return GetVariableValue(formalName, scope, recursiveLookup, true);
    452     }
    453     /// <inheritdoc cref="IOperator.GetVariableValue(string, HeuristicLab.Core.IScope, bool, bool)"/>
    454     public virtual IItem GetVariableValue(string formalName, IScope scope, bool recursiveLookup, bool throwOnError) {
    455       IVariableInfo info = GetVariableInfo(formalName);
    456       if (info.Local) {
    457         IVariable variable;
    458         if (myVariables.TryGetValue(info.ActualName, out variable))
    459           return variable.Value;
    460         else {
    461           if (throwOnError)
    462             throw new ArgumentException("Variable " + info.ActualName + " not found");
    463           else
    464             return null;
    465         }
    466       } else {
    467         return scope.GetVariableValue(formalName, recursiveLookup, throwOnError);
    468       }
    469     }
    470     #endregion
    471     /// <inheritdoc/>
    472     public virtual IOperation Execute(IScope scope) {
     177    /// <inheritdoc/>
     178    public virtual IOperation Execute(IEnvironment env, IScope scope) {
    473179      myCanceled = false;
    474180
    475       foreach (IVariableInfo variableInfo in VariableInfos)
    476         scope.AddAlias(variableInfo.FormalName, variableInfo.ActualName);
    477 
    478       IOperation next = Apply(scope);
    479 
    480       foreach (IVariableInfo variableInfo in VariableInfos)
    481         scope.RemoveAlias(variableInfo.FormalName);
     181      IOperation next = Apply(env, scope);
    482182
    483183      OnExecuted();
    … …  
    494194    /// <param name="scope">The scope where to execute the operator</param>
    495195    /// <returns><c>null</c>.</returns>
    496     public virtual IOperation Apply(IScope scope) {
     196    public virtual IOperation Apply(IEnvironment env, IScope scope) {
    497197      return null;
    498198    }
    … …  
    540240    }
    541241    /// <inheritdoc/>
    542     public event EventHandler<VariableInfoEventArgs> VariableInfoAdded;
    543     /// <summary>
    544     /// Fires a new <c>VariableInfoAdded</c> event.
    545     /// </summary>
    546     /// <param name="variableInfo">The variable info that has been added.</param>
    547     protected virtual void OnVariableInfoAdded(IVariableInfo variableInfo) {
    548       if (VariableInfoAdded != null)
    549         VariableInfoAdded(this, new VariableInfoEventArgs(variableInfo));
    550     }
    551     /// <inheritdoc/>
    552     public event EventHandler<VariableInfoEventArgs> VariableInfoRemoved;
    553     /// <summary>
    554     /// Fires a new <c>VariableInfoRemoved</c> event.
    555     /// </summary>
    556     /// <param name="variableInfo">The variable info that has been removed.</param>
    557     protected virtual void OnVariableInfoRemoved(IVariableInfo variableInfo) {
    558       if (VariableInfoRemoved != null)
    559         VariableInfoRemoved(this, new VariableInfoEventArgs(variableInfo));
    560     }
    561     /// <inheritdoc/>
    562     public event EventHandler<VariableEventArgs> VariableAdded;
    563     /// <summary>
    564     /// Fires a new <c>VariableAdded</c> event.
    565     /// </summary>
    566     /// <param name="variable">The variable that has been added.</param>
    567     protected virtual void OnVariableAdded(IVariable variable) {
    568       if (VariableAdded != null)
    569         VariableAdded(this, new VariableEventArgs(variable));
    570     }
    571     /// <inheritdoc/>
    572     public event EventHandler<VariableEventArgs> VariableRemoved;
    573     /// <summary>
    574     /// Fires a new <c>VariableRemoved</c> event.
    575     /// </summary>
    576     /// <param name="variable">The variable that has been removed</param>
    577     protected virtual void OnVariableRemoved(IVariable variable) {
    578       if (VariableRemoved != null)
    579         VariableRemoved(this, new VariableEventArgs(variable));
     242    public event EventHandler<ParameterEventArgs> ParameterAdded;
     243    /// <summary>
     244    /// Fires a new <c>ParameterAdded</c> event.
     245    /// </summary>
     246    /// <param name="parameter">The parameter that has been added.</param>
     247    protected virtual void OnParameterAdded(IParameter parameter) {
     248      if (ParameterAdded != null)
     249        ParameterAdded(this, new ParameterEventArgs(parameter));
     250    }
     251    /// <inheritdoc/>
     252    public event EventHandler<ParameterEventArgs> ParameterRemoved;
     253    /// <summary>
     254    /// Fires a new <c>ParameterRemoved</c> event.
     255    /// </summary>
     256    /// <param name="parameter">The parameter that has been removed.</param>
     257    protected virtual void OnParameterRemoved(IParameter parameter) {
     258      if (ParameterRemoved != null)
     259        ParameterRemoved(this, new ParameterEventArgs(parameter));
    580260    }
    581261    /// <inheritdoc/>
    … …  
    642322        subOperatorsNode.AppendChild(PersistenceManager.Persist(SubOperators[i], document, persistedObjects));
    643323      node.AppendChild(subOperatorsNode);
    644       XmlNode infosNode = document.CreateNode(XmlNodeType.Element, "VariableInfos", null);
    645       foreach (IVariableInfo info in myVariableInfos.Values)
    646         infosNode.AppendChild(PersistenceManager.Persist(info, document, persistedObjects));
    647       node.AppendChild(infosNode);
    648       XmlNode variablesNode = document.CreateNode(XmlNodeType.Element, "Variables", null);
    649       foreach (IVariable variable in myVariables.Values)
    650         variablesNode.AppendChild(PersistenceManager.Persist(variable, document, persistedObjects));
    651       node.AppendChild(variablesNode);
     324      XmlNode parametersNode = document.CreateNode(XmlNodeType.Element, "Parameters", null);
     325      foreach (IParameter parameter in myParameters.Values)
     326        parametersNode.AppendChild(PersistenceManager.Persist(parameter, document, persistedObjects));
     327      node.AppendChild(parametersNode);
    652328      return node;
    653329    }
    … …  
    668344      for (int i = 0; i < subOperatorsNode.ChildNodes.Count; i++)
    669345        AddSubOperator((IOperator)PersistenceManager.Restore(subOperatorsNode.ChildNodes[i], restoredObjects));
    670       XmlNode infosNode = node.SelectSingleNode("VariableInfos");
    671       myVariableInfos.Clear();
    672       foreach (XmlNode infoNode in infosNode.ChildNodes)
    673         AddVariableInfo((IVariableInfo)PersistenceManager.Restore(infoNode, restoredObjects));
    674       XmlNode variablesNode = node.SelectSingleNode("Variables");
    675       myVariables.Clear();
    676       foreach (XmlNode variableNode in variablesNode.ChildNodes)
    677         AddVariable((IVariable)PersistenceManager.Restore(variableNode, restoredObjects));
     346      XmlNode parametersNode = node.SelectSingleNode("Parameters");
     347      myParameters.Clear();
     348      foreach (XmlNode parameterNode in parametersNode.ChildNodes)
     349        AddParameter((IParameter)PersistenceManager.Restore(parameterNode, restoredObjects));
    678350    }
    679351    #endregion
Note: See TracChangeset for help on using the changeset viewer.