Changeset 2030 for branches/Operator Architecture Refactoring

Timestamp:

06/08/09 02:02:21 (16 years ago)

Author:

swagner

Message:

Refactoring of the Operator Architecture (#95)

Location:

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2

Files:

• Interfaces/IParameter.cs (modified) (2 diffs)
• Parameter.cs (modified) (9 diffs)
• ParameterView.cs (modified) (1 diff)

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Interfaces/IParameter.cs

@@ -27 +27 @@
 namespace HeuristicLab.Core {
   /// <summary>
-  /// Interface to store meta-information about parameters of operators.
+  /// Interface to represent parameters of operators.
   /// </summary>
   public interface IParameter : IItem {
     /// <summary>
-    /// Gets or sets the name of the current instance.
+    /// Gets or sets the actual name of the parameter.
     /// </summary>
-    string Name { get; }
+    string ActualName { get; set; }
     /// <summary>
-    /// Gets the description of the current instance.
+    /// Gets or sets the formal name of the parameter.
     /// </summary>
-    string Description { get; }
+    string FormalName { get; }
+    /// <summary>
+    /// Gets or sets the description of the current instance.
+    /// </summary>
+    string Description { get; set; }
     /// <summary>
     /// Gets the data type of the current instance.
@@ -46 +50 @@
     /// </summary>
     ParameterType Type { get; }
+    /// <summary>
+    /// Gets or sets, if the parameter is constant (only valid for input parameters).
+    /// </summary>
+    bool Constant { get; set; }
+    /// <summary>
+    /// Gets or sets, if the parameter should be cached by operators.
+    /// </summary>
+    bool Cached { get; set; }
+    /// <summary>
+    /// Gets or sets the value of the parameter.
+    /// </summary>
+    IItem Value { get; set; }
+
+    /// <summary>
+    /// Occurs when the actual name of the current instance has been changed.
+    /// </summary>
+    event EventHandler ActualNameChanged;
+    /// <summary>
+    /// Occurs when the description of the current instance has been changed.
+    /// </summary>
+    event EventHandler DescriptionChanged;
+    /// <summary>
+    /// Occurs when the constant flag of the current instance has been changed.
+    /// </summary>
+    event EventHandler ConstantChanged;
+    /// <summary>
+    /// Occurs when the cached flag of the current instance has been changed.
+    /// </summary>
+    event EventHandler CachedChanged;
+    /// <summary>
+    /// Occurs when the value of the current instance has been changed.
+    /// </summary>
+    event EventHandler ValueChanged;
+
+  }
+
+  /// <summary>
+  /// Generic interface to represent parameters of operators.
+  /// </summary>
+  /// <typeparam name="T">The data type of the parameter, which has to be an <see cref="IItem"/>.</typeparam>
+  public interface IParamter<T> : IParameter where T : class, IItem {
+    /// <summary>
+    /// Gets or sets the value of the parameter.
+    /// </summary>
+    T Value { get; set; }
   }
 }

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/Parameter.cs

@@ -27 +27 @@
 namespace HeuristicLab.Core {
   /// <summary>
-  /// Class for storing meta-information about parameters of an operator.
+  /// Represents a parameter of an operator.
   /// </summary>
-  public class Parameter : ItemBase, IParameter {
-    private string myName;
-    /// <summary>
-    /// Gets or sets the name of the current instance.
+  /// <typeparam name="T">The data type of the parameter, which has to be an <see cref="IItem"/>.</typeparam>
+  public class Parameter<T> : ItemBase, IParameter, IParamter<T> where T : class, IItem {
+    private string myActualName;
+    /// <summary>
+    /// Gets or sets the actual name of the current instance.
     /// </summary>
     /// <remarks>Calls <see cref="OnActualNameChanged"/> in the setter.</remarks>
-    public string Name {
-      get { return myName; }
+    public string ActualName {
+      get { return myActualName; }
+      set {
+        if (! myActualName.Equals(value)) {
+          myActualName = value;
+          OnActualNameChanged();
+        }
+      }
+    }
+    private string myFormalName;
+    /// <summary>
+    /// Gets the formal name of the current instance.
+    /// </summary>
+    public string FormalName {
+      get { return myFormalName; }
     }
     private string myDescription;
     /// <summary>
-    /// Gets the description of the current instance.
-    /// </summary>
+    /// Gets or sets the description of the current instance.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnDescriptionChanged"/> in the setter.</remarks>
     public string Description {
       get { return myDescription; }
-    }
-    private Type myDataType;
+      set {
+        if (! myDescription.Equals(value)) {
+          myDescription = value;
+          OnDescriptionChanged();
+        }
+      }
+    }
     /// <summary>
     /// Gets the data type of the parameter.
     /// </summary>
     public Type DataType {
-      get { return myDataType; }
+      get { return typeof(T); }
     }
     private ParameterType myType;
@@ -58 +78 @@
     public ParameterType Type {
       get { return myType; }
+    }
+    private bool myConstant;
+    /// <summary>
+    /// Gets or sets, if the parameter is constant (only valid for input parameters).
+    /// </summary>
+    /// <remarks>Calls <see cref="OnConstantChanged"/> in the setter.</remarks>
+    public bool Constant {
+      get { return myConstant; }
+      set {
+        if (Type != ParameterType.In) throw new InvalidOperationException("only input parameters can be constant");
+        if (myConstant != value) {
+          myConstant = value;
+          OnConstantChanged();
+        }
+      }
+    }
+    private bool myCached;
+    /// <summary>
+    /// Gets or sets, if the parameter should be cached by operators.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnCachedChanged"/> in the setter.</remarks>
+    public bool Cached {
+      get { return myCached; }
+      set {
+        if (myCached != value) {
+          myCached = value;
+          OnCachedChanged();
+        }
+      }
+    }
+    private T myValue;
+    /// <summary>
+    /// Gets or sets the value of the parameter.
+    /// </summary>
+    public T Value {
+      get { return myValue; }
+      set {
+        if (! myValue.Equals(value)) {
+          myValue = value;
+          OnValueChanged();
+        }
+      }
+    }
+    /// <summary>
+    /// Gets or sets the value of the parameter.
+    /// </summary>
+    public IItem IParameter.Value {
+      get { return myValue; }
+      set { Value = (T)value; }
     }
 
@@ -66 +135 @@
     /// </summary>
     public Parameter() {
-      myName = "Anonymous";
+      myActualName = "Anonymous";
+      myFormalName = "Anonymous";
       myDescription = "";
-      myDataType = null;
       myType = ParameterType.In;
+      myConstant = false;
+      myCached = false;
+      myValue = null;
     }
     /// <summary>
     /// Initializes a new instance of <see cref="Parameter"/> with the given parameters.
     /// </summary>
-    /// <remarks>Calls <see cref="Parameter()"/>.</remarks>
-    /// <param name="name">The name of the current instance.</param>
+    /// <remarks>Calls <see cref="Parameter()"/>.<br/>
+    /// The formal name is assigned to the actual name, too.</remarks>
+    /// <param name="formalName">The formal name of the current instance.</param>
     /// <param name="description">The description of the current instance.</param>
-    /// <param name="dataType">The data type of the parameter.</param>
-    /// <param name="type">The type of the parameter.</param>
-    public Parameter(string name, string description, Type dataType, ParameterType type)
+    /// <param name="kind">The type of the parameter.</param>
+    public Parameter(string formalName, string description, ParameterType type, bool constant, bool cached)
       : this() {
-      myName = name;
+      myActualName = formalName;
+      myFormalName = formalName;
       myDescription = description;
-      myDataType = dataType;
       myType = type;
+      myConstant = constant;
+      myCached = cached;
     }
 
@@ -102 +176 @@
     /// <returns>The cloned object as <see cref="Parameter"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      Parameter clone = new Parameter();
+      Parameter<T> clone = (Parameter<T>)base.Clone(clonedObjects);
       clonedObjects.Add(Guid, clone);
-      clone.myName = Name;
+      clone.myActualName = ActualName;
+      clone.myFormalName = FormalName;
       clone.myDescription = Description;
-      clone.myDataType = DataType;
       clone.myType = Type;
+      clone.myConstant = Constant;
+      clone.myCached = Cached;
+      clone.myValue = (T)Auxiliary.Clone(Value, clonedObjects);
       return clone;
+    }
+
+    /// <inheritdoc/>
+    public event EventHandler ActualNameChanged;
+    /// <summary>
+    /// Fires a new <c>ActualNameChanged</c> event.
+    /// </summary>
+    protected virtual void OnActualNameChanged() {
+      if (ActualNameChanged != null)
+        ActualNameChanged(this, new EventArgs());
+    }
+    /// <inheritdoc />
+    public event EventHandler DescriptionChanged;
+    /// <summary>
+    /// Fires a new <c>DescriptionChanged</c> event.
+    /// </summary>
+    protected virtual void OnDescriptionChanged() {
+      if (DescriptionChanged != null)
+        DescriptionChanged(this, new EventArgs());
+    }
+    public event EventHandler ConstantChanged;
+    /// <summary>
+    /// Fires a new <c>ConstantChanged</c> event.
+    /// </summary>
+    protected virtual void OnConstantChanged() {
+      if (ConstantChanged != null)
+        ConstantChanged(this, new EventArgs());
+    }
+    public event EventHandler CachedChanged;
+    /// <summary>
+    /// Fires a new <c>CachedChanged</c> event.
+    /// </summary>
+    protected virtual void OnCachedChanged() {
+      if (CachedChanged != null)
+        CachedChanged(this, new EventArgs());
+    }
+    public event EventHandler ValueChanged;
+    /// <summary>
+    /// Fires a new <c>ValueChanged</c> event.
+    /// </summary>
+    protected virtual void OnValueChanged() {
+      if (ValueChanged != null)
+        ValueChanged(this, new EventArgs());
     }
 
@@ -119 +239 @@
     /// <list type="bullet">
     /// <item>
-    /// <term>Name: </term>
-    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>Name</c>.</description>
+    /// <term>ActualName: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>ActualName</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>FormalName: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>FormalName</c>.</description>
     /// </item>
     /// <item>
@@ -126 +250 @@
     /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>Description</c>.</description>
     /// </item>
-    /// <item><term>Data type: </term>
-    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>DataType</c>.</description>
-    /// </item>
     /// <item>
     /// <term>Type: </term>
     /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>ParameterType</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Constant: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>Constant</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Cached: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>Cached</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Value: </term>
+    /// <description>Saved as child node with tag name <c>Value</c>.</description>
     /// </item>
     /// </list></remarks>
@@ -140 +273 @@
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
-      XmlAttribute nameAttribute = document.CreateAttribute("Name");
-      nameAttribute.Value = Name;
-      node.Attributes.Append(nameAttribute);
+      XmlAttribute actualNameAttribute = document.CreateAttribute("ActualName");
+      actualNameAttribute.Value = ActualName;
+      node.Attributes.Append(actualNameAttribute);
+
+      XmlAttribute formalNameAttribute = document.CreateAttribute("FormalName");
+      formalNameAttribute.Value = FormalName;
+      node.Attributes.Append(formalNameAttribute);
 
       XmlAttribute descriptionAttribute = document.CreateAttribute("Description");
@@ -148 +285 @@
       node.Attributes.Append(descriptionAttribute);
 
-      XmlAttribute dataTypeAttribute = document.CreateAttribute("DataType");
-      dataTypeAttribute.Value = PersistenceManager.BuildTypeString(DataType);
-      node.Attributes.Append(dataTypeAttribute);
-
       XmlAttribute typeAttribute = document.CreateAttribute("ParameterType");
       typeAttribute.Value = Type.ToString();
       node.Attributes.Append(typeAttribute);
+
+      XmlAttribute constantAttribute = document.CreateAttribute("Constant");
+      constantAttribute.Value = Constant.ToString();
+      node.Attributes.Append(constantAttribute);
+
+      XmlAttribute cachedAttribute = document.CreateAttribute("Cached");
+      cachedAttribute.Value = Cached.ToString();
+      node.Attributes.Append(cachedAttribute);
+
+      if (myValue != null)
+        node.AppendChild(PersistenceManager.Persist("Value", Value, document, persistedObjects));
 
       return node;
@@ -169 +313 @@
     public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
-      myName = node.Attributes["ActualName"].Value;
+      myActualName = node.Attributes["ActualName"].Value;
+      myFormalName = node.Attributes["FormalName"].Value;
       myDescription = node.Attributes["Description"].Value;
-      myDataType = System.Type.GetType(node.Attributes["DataType"].Value, true);
       myType = (ParameterType)Enum.Parse(typeof(ParameterType), node.Attributes["ParameterType"].Value);
+      myConstant = bool.Parse(node.Attributes["Constant"].Value);
+      myCached = bool.Parse(node.Attributes["Cached"].Value);
+
+      XmlNode valueNode = node.SelectSingleNode("Value");
+      if (valueNode != null)
+        myValue = (T)PersistenceManager.Restore(valueNode, restoredObjects);
     }
     #endregion

branches/Operator Architecture Refactoring/HeuristicLab.Core/3.2/ParameterView.cs

@@ -30 +30 @@
 namespace HeuristicLab.Core {
   /// <summary>
-  /// The visual representation of <see cref="IVariableInfo"/>.
+  /// The visual representation of <see cref="IParameter"/>.
   /// </summary>
   public partial class ParameterView : ViewBase {