Changeset 2027 for branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjector.cs

Timestamp:

06/06/09 02:09:35 (15 years ago)

Author:

swagner

Message:

Refactoring of the operator architecture (#95)

File:

• branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjector.cs (modified) (6 diffs)

branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjector.cs

@@ -30 +30 @@
   /// Class to inject local variables into the scope.
   /// </summary>
-  public class VariableInjector : OperatorBase {
-    private Dictionary<IVariable, IVariableInfo> variableVariableInfoTable;
-    private Dictionary<IVariableInfo, IVariable> variableInfoVariableTable;
+  public class VariableInjector : OperatorBase, IVariablesContainer {
+    private Dictionary<string, IVariable> myVariables;
+    /// <summary>
+    /// Gets a collection of all variables of the current operator.
+    /// </summary>
+    public virtual ICollection<IVariable> Variables {
+      get { return myVariables.Values; }
+    }
 
     /// <inheritdoc select="summary"/>
     public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
+      get { return @"Injects new variable into a scope."; }
+    }
+
+    /// <summary>
+    /// Overrides the Parameters property so that a parameter is returned for each injected variable.
+    /// </summary>
+    public override ICollection<IParameter> Parameters {
+      get {
+        List<IParameter> parameters = new List<IParameter>();
+        foreach (IVariable variable in Variables)
+          parameters.Add(new Parameter(variable.Name, "Injected variable.", variable.Value.GetType(), ParameterType.Out));
+        return parameters;
+      }
     }
 
@@ -44 +61 @@
     public VariableInjector()
       : base() {
-      variableVariableInfoTable = new Dictionary<IVariable, IVariableInfo>();
-      variableInfoVariableTable = new Dictionary<IVariableInfo, IVariable>();
+      myVariables = new Dictionary<string, IVariable>();
     }
 
@@ -56 +72 @@
     /// <returns>The cloned object as <see cref="VariableInjector"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      VariableInjector clone = new VariableInjector();
-      clonedObjects.Add(Guid, clone);
-      clone.Name = Name;
+      VariableInjector clone = (VariableInjector)base.Clone(clonedObjects);
       foreach (IVariable variable in Variables)
         clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
@@ -65 +79 @@
 
     /// <summary>
-    /// Adds the specified <paramref name="variable"/> to the current instance to get injected.
-    /// </summary>
-    /// <param name="variable">The variable to add.</param>
-    /// <remarks>Calls private method <see cref="CreateVariableInfo"/> and <see cref="OperatorBase.AddVariable"/>
-    /// of base class <see cref="OperatorBase"/>.</remarks>
-    public override void AddVariable(IVariable variable) {
-      base.AddVariable(variable);
-      CreateVariableInfo(variable);
-    }
-
-    /// <summary>
-    /// Removes a variable with the specified <paramref name="name"/> from the current injector.
-    /// </summary>
-    /// <remarks>Calls private method <see cref="DeleteVariableInfo"/> and <see cref="OperatorBase.RemoveVariable"/>
-    /// of base class <see cref="OperatorBase"/>.</remarks>
-    /// <param name="name">The name of the </param>
-    public override void RemoveVariable(string name) {
-      DeleteVariableInfo(name);
-      base.RemoveVariable(name);
-    }
-
-    /// <summary>
     /// Adds the specified variables to the given <paramref name="scope"/> (and removes them first,
     /// if they already exist in the current scope).
@@ -92 +84 @@
     /// <param name="scope">The scope where to inject the variables.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       foreach (IVariable variable in Variables) {
         if (scope.GetVariable(variable.Name) != null)
@@ -109 +101 @@
     }
 
-    private void CreateVariableInfo(IVariable variable) {
-      IVariableInfo info = new VariableInfo(Guid.NewGuid().ToString(), "Injected variable", variable.Value.GetType(), VariableKind.New);
-      info.ActualName = variable.Name;
-      AddVariableInfo(info);
-      variableVariableInfoTable.Add(variable, info);
-      variableInfoVariableTable.Add(info, variable);
-      info.ActualNameChanged += new EventHandler(VariableInfo_ActualNameChanged);
+    /// <summary>
+    /// Gets a variable with the given <paramref name="name"/>.
+    /// </summary>
+    /// <param name="name">The name of the variable.</param>
+    /// <returns>The variable with the specified name.</returns>
+    public virtual IVariable GetVariable(string name) {
+      IVariable variable;
+      if (myVariables.TryGetValue(name, out variable))
+        return variable;
+      else
+        return null;
+    }
+    /// <summary>
+    /// Adds the specified <paramref name="variable"/> to the current instance.
+    /// </summary>
+    /// <param name="variable">The variable to add.</param>
+    public virtual void AddVariable(IVariable variable) {
+      myVariables.Add(variable.Name, variable);
+      variable.NameChanging += new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
       variable.NameChanged += new EventHandler(Variable_NameChanged);
-    }
-    private void DeleteVariableInfo(string name) {
-      IVariable variable = GetVariable(name);
-      if (variable != null) {
-        IVariableInfo info = variableVariableInfoTable[variable];
-        RemoveVariableInfo(info.FormalName);
-        variableVariableInfoTable.Remove(variable);
-        variableInfoVariableTable.Remove(info);
-        info.ActualNameChanged -= new EventHandler(VariableInfo_ActualNameChanged);
+      OnVariableAdded(variable);
+    }
+    /// <summary>
+    /// Deletes the variable with the specified <paramref name="name"/>.
+    /// </summary>
+    /// <param name="name">The name of the variable to delete.</param>
+    public virtual void RemoveVariable(string name) {
+      IVariable variable;
+      if (myVariables.TryGetValue(name, out variable)) {
+        variable.NameChanging -= new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
         variable.NameChanged -= new EventHandler(Variable_NameChanged);
-      }
-    }
-
-    #region VariableInfo and Variable Events
-    private void VariableInfo_ActualNameChanged(object sender, EventArgs e) {
-      IVariableInfo info = (IVariableInfo)sender;
-      IVariable variable = variableInfoVariableTable[info];
-      variable.Name = info.ActualName;
+        myVariables.Remove(name);
+        OnVariableRemoved(variable);
+      }
+    }
+    private void Variable_NameChanging(object sender, NameChangingEventArgs e) {
+      e.Cancel = myVariables.ContainsKey(e.Name);
     }
     private void Variable_NameChanged(object sender, EventArgs e) {
       IVariable variable = (IVariable)sender;
-      IVariableInfo info = variableVariableInfoTable[variable];
-      info.ActualName = variable.Name;
-    }
-    #endregion
+      string oldName = null;
+      foreach (KeyValuePair<string, IVariable> element in myVariables) {
+        if (element.Value == variable)
+          oldName = element.Key;
+      }
+      myVariables.Remove(oldName);
+      myVariables.Add(variable.Name, variable);
+    }
+
+    /// <summary>
+    /// Occurs when a variable has been added.
+    /// </summary>
+    public event EventHandler<VariableEventArgs> VariableAdded;
+    /// <summary>
+    /// Fires a new <c>VariableAdded</c> event.
+    /// </summary>
+    /// <param name="variable">The variable that has been added.</param>
+    protected virtual void OnVariableAdded(IVariable variable) {
+      if (VariableAdded != null)
+        VariableAdded(this, new VariableEventArgs(variable));
+    }
+    /// <summary>
+    /// Occurs when a variable has been deleted.
+    /// </summary>
+    public event EventHandler<VariableEventArgs> VariableRemoved;
+    /// <summary>
+    /// Fires a new <c>VariableRemoved</c> event.
+    /// </summary>
+    /// <param name="variable">The variable that has been removed</param>
+    protected virtual void OnVariableRemoved(IVariable variable) {
+      if (VariableRemoved != null)
+        VariableRemoved(this, new VariableEventArgs(variable));
+    }
 
     #region Persistence Methods
     /// <summary>
     /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
-    /// <note type="caution"> Variable infos are not persisted!</note>
-    /// </summary>
-    /// <remarks>Calls <see cref="OperatorBase.GetXmlNode"/> of base class <see cref="OperatorBase"/>.</remarks>
+    /// </summary>
+    /// <remarks>
+    /// Calls <see cref="OperatorBase.GetXmlNode"/> of base class <see cref="OperatorBase"/>.
+    /// <br/>A quick overview how the single elements of the current instance are saved:
+    /// <list type="bullet">
+    /// <item>
+    /// <term>Variables: </term>
+    /// <description>Saved as child node with tag name <c>Variables</c>. All variables are themselves
+    /// saved as child nodes.</description>
+    /// </item> 
+    /// </list>
+    /// </remarks>
     /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
     /// <param name="document">The <see cref="XmlDocument"/> where to save the data.</param>
     /// <param name="persistedObjects">The dictionary of all already persisted objects. (Needed to avoid cycles.)</param>
     /// <returns>The saved <see cref="XmlNode"/>.</returns>
-    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
+    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
-      // variable infos should not be persisted
-      XmlNode infosNode = node.SelectSingleNode("VariableInfos");
-      infosNode.RemoveAll();
+      XmlNode variablesNode = document.CreateNode(XmlNodeType.Element, "Variables", null);
+      foreach (IVariable variable in myVariables.Values)
+        variablesNode.AppendChild(PersistenceManager.Persist(variable, document, persistedObjects));
+      node.AppendChild(variablesNode);
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted variable injector from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBase.Populate"/> of base class 
+    /// <see cref="OperatorBase"/>.
+    /// For informations how the different elements must be saved please see <see cref="GetXmlNode"/>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the operation is saved.</param>
+    /// <param name="restoredObjects">A dictionary of all already restored objects. (Needed to avoid cycles.)</param>
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
+      base.Populate(node, restoredObjects);
+      XmlNode variablesNode = node.SelectSingleNode("Variables");
+      foreach (XmlNode variableNode in variablesNode.ChildNodes)
+        AddVariable((IVariable)PersistenceManager.Restore(variableNode, restoredObjects));
     }
     #endregion