Changeset 836 for branches/CloningRefactorBranch

Timestamp:

11/27/08 00:52:23 (16 years ago)

Author:

gkronber

Message:

worked on #285 (Cloning could be improved by creating objects at the bottom of the cloning chain with 'new' instead of the top with Activator.CreateInstance())

Location:

branches/CloningRefactorBranch

Files:

• HeuristicLab.Core/AtomicOperation.cs (modified) (1 diff)
• HeuristicLab.Core/ConstrainedItemBase.cs (modified) (4 diffs)
• HeuristicLab.Core/EngineBase.cs (modified) (2 diffs)
• HeuristicLab.Core/ItemBase.cs (modified) (1 diff)
• HeuristicLab.Core/OperatorBase.cs (modified) (3 diffs)
• HeuristicLab.Core/OperatorGroup.cs (modified) (2 diffs)
• HeuristicLab.Core/Scope.cs (modified) (6 diffs)
• HeuristicLab.Core/StorableBase.cs (modified) (4 diffs)
• HeuristicLab.Data/ConstrainedDoubleData.cs (modified) (2 diffs)
• HeuristicLab.Data/ConstrainedIntData.cs (modified) (2 diffs)

branches/CloningRefactorBranch/HeuristicLab.Core/AtomicOperation.cs

@@ -47 +47 @@
     /// <summary>
     /// Initializes a new instance of <see cref="AtomicOperation"/>.
+    /// Empty constructor is needed for the persistence mechanism.
     /// </summary>
     public AtomicOperation() { }

branches/CloningRefactorBranch/HeuristicLab.Core/ConstrainedItemBase.cs

@@ -47 +47 @@
 
     /// <summary>
-    /// Clones the current instance (deep clone).
+    /// Copy constructor for deep cloning.
     /// </summary>
-    /// <remarks>Calls <see cref="StorableBase.Clone
-    /// (System.Collections.Generic.IDictionary&lt;System.Guid, object&gt;)"/> 
-    /// of base class <see cref="ItemBase"/>.<br/>
-    /// Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
-    /// <see cref="Auxiliary"/>.</remarks>
-    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
-    /// <returns>The cloned object as <see cref="ConstrainedItemBase"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      ConstrainedItemBase clone = (ConstrainedItemBase)base.Clone(clonedObjects);
-      clone.myConstraints.Clear();
-      foreach (IConstraint constraint in Constraints)
-        clone.AddConstraint((IConstraint)Auxiliary.Clone(constraint, clonedObjects));
-      return clone;
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected ConstrainedItemBase(ConstrainedItemBase original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      myConstraints = new List<IConstraint>();
+      foreach (IConstraint constraint in original.myConstraints)
+        AddConstraint((IConstraint)Auxiliary.Clone(constraint, clonedObjects));
     }
 
@@ -145 +139 @@
     }
 
-    #region Persistence Methods  
+    #region Persistence Methods
     /// <summary>
     /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
@@ -157 +151 @@
     /// (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);
       if (Constraints.Count > 0) {
@@ -176 +170 @@
     /// <param name="restoredObjects">The dictionary of all already restored objects. 
     /// (Needed to avoid cycles.)</param>
-    public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
       XmlNode constraintsNode = node.SelectSingleNode("Constraints");

branches/CloningRefactorBranch/HeuristicLab.Core/EngineBase.cs

@@ -118 +118 @@
 
     /// <summary>
+    /// Copy constructor.
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected EngineBase(EngineBase original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myOperatorGraph = (IOperatorGraph)Auxiliary.Clone(original.OperatorGraph, clonedObjects);
+      this.myGlobalScope = (IScope)Auxiliary.Clone(original.GlobalScope, clonedObjects);
+      this.myExecutionTime = original.ExecutionTime;
+      IOperation[] operations = new IOperation[original.ExecutionStack.Count];
+      original.ExecutionStack.CopyTo(operations, 0);
+      for (int i = operations.Length - 1; i >= 0; i--)
+        this.myExecutionStack.Push((IOperation)Auxiliary.Clone(operations[i], clonedObjects));
+      this.myRunning = original.Running;
+      this.myCanceled = original.Canceled;
+    }
+
+    /// <summary>
     /// Clones the current instance (deep clone).
     /// </summary>
@@ -125 +143 @@
     /// <returns>The cloned object as <see cref="EngineBase"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      EngineBase clone = (EngineBase)base.Clone(clonedObjects);
-      clone.myOperatorGraph = (IOperatorGraph)Auxiliary.Clone(OperatorGraph, clonedObjects);
-      clone.myGlobalScope = (IScope)Auxiliary.Clone(GlobalScope, clonedObjects);
-      clone.myExecutionTime = ExecutionTime;
-      IOperation[] operations = new IOperation[ExecutionStack.Count];
-      ExecutionStack.CopyTo(operations, 0);
-      for (int i = operations.Length - 1; i >= 0; i--)
-        clone.myExecutionStack.Push((IOperation)Auxiliary.Clone(operations[i], clonedObjects));
-      clone.myRunning = Running;
-      clone.myCanceled = Canceled;
-      return clone;
-      
+      return new EngineBase(this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.Core/ItemBase.cs

@@ -30 +30 @@
   /// </summary>
   public abstract class ItemBase : StorableBase, IItem {
+    /// <summary>
+    /// Creates an instance of an ItemBase.
+    /// </summary>
+    protected ItemBase() { }
+
+    /// <summary>
+    /// Copy constructor for deep cloning of items.
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected ItemBase(ItemBase original, IDictionary<Guid, object> clonedObjects) : base(original, clonedObjects) { }
+
     /// <summary>
     /// Creates a new instance of <see cref="ItemBaseView"/> for 

branches/CloningRefactorBranch/HeuristicLab.Core/OperatorBase.cs

@@ -105 +105 @@
 
     /// <summary>
-    /// Clones the current instance (deep clone).
-    /// </summary>
-    /// <remarks>Clones also sub operators, variables and variable infos.</remarks>
-    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
-    /// <returns>The cloned object as <see cref="OperatorBase"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      OperatorBase clone = (OperatorBase)base.Clone(clonedObjects);
-      clone.myName = Name;
-      clone.mySubOperators.Clear();
-      for (int i = 0; i < SubOperators.Count; i++)
-        clone.AddSubOperator((IOperator)Auxiliary.Clone(SubOperators[i], clonedObjects));
-      clone.myVariableInfos.Clear();
-      foreach (IVariableInfo variableInfo in myVariableInfos.Values)
-        clone.AddVariableInfo((IVariableInfo)Auxiliary.Clone(variableInfo, clonedObjects));
-      clone.myVariables.Clear();
-      foreach (IVariable variable in myVariables.Values)
-        clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
-      return clone;
+    /// Copy constructor
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected OperatorBase(OperatorBase original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myName = original.Name;
+      this.mySubOperators = new List<IOperator>();
+      for (int i = 0; i < original.SubOperators.Count; i++)
+        AddSubOperator((IOperator)Auxiliary.Clone(original.SubOperators[i], clonedObjects));
+      this.myVariableInfos = new Dictionary<string, IVariableInfo>();
+      foreach (IVariableInfo variableInfo in original.myVariableInfos.Values)
+        AddVariableInfo((IVariableInfo)Auxiliary.Clone(variableInfo, clonedObjects));
+      this.myVariables = new Dictionary<string, IVariable>();
+      foreach (IVariable variable in original.myVariables.Values)
+        AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
     }
 
@@ -628 +626 @@
     /// <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);
       XmlAttribute nameAttribute = document.CreateAttribute("Name");
@@ -660 +658 @@
     /// <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) {
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
       myName = node.Attributes["Name"].Value;

branches/CloningRefactorBranch/HeuristicLab.Core/OperatorGroup.cs

@@ -71 +71 @@
 
     /// <summary>
+    /// Copy constructor for deep cloning
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected OperatorGroup(OperatorGroup original, IDictionary<Guid, object> clonedObjects) : base(original, clonedObjects) {
+      this.myName = original.myName;
+      mySubGroups = new List<IOperatorGroup>();
+      myOperators = new List<IOperator>();
+      foreach (IOperatorGroup group in original.SubGroups)
+        AddSubGroup((IOperatorGroup)Auxiliary.Clone(group, clonedObjects));
+      foreach (IOperator op in original.Operators)
+        AddOperator((IOperator)Auxiliary.Clone(op, clonedObjects));
+    }
+
+    /// <summary>
     /// Clones the current instance (deep clone).
     /// </summary>
@@ -78 +93 @@
     /// <returns>The cloned object as <see cref="OperatorGroup"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      OperatorGroup clone = (OperatorGroup)base.Clone(clonedObjects);
-      clone.myName = Name;
-      foreach (IOperatorGroup group in SubGroups)
-        clone.AddSubGroup((IOperatorGroup)Auxiliary.Clone(group, clonedObjects));
-      foreach (IOperator op in Operators)
-        clone.AddOperator((IOperator)Auxiliary.Clone(op, clonedObjects));
+      OperatorGroup clone = new OperatorGroup(this, clonedObjects);
       return clone;
     }

branches/CloningRefactorBranch/HeuristicLab.Core/Scope.cs

@@ -32 +32 @@
     private IScope parent;
 
-    private string myName; 
+    private string myName;
     /// <summary>
     /// Gets the name of the current scope.
@@ -75 +75 @@
       : this() {
       if (name != null) myName = name;
+    }
+
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected Scope(Scope original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myName = original.Name;
+      foreach (IVariable variable in original.myVariables.Values)
+        AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
+      foreach (KeyValuePair<string, string> alias in original.myAliases)
+        AddAlias(alias.Key, alias.Value);
+      for (int i = 0; i < original.SubScopes.Count; i++)
+        AddSubScope((IScope)Auxiliary.Clone(original.SubScopes[i], clonedObjects));
     }
 
@@ -238 +254 @@
         RemoveVariable(variableNames[j]);
 
-      KeyValuePair<string, string>[] aliases = new KeyValuePair<string,string>[myAliases.Count];
+      KeyValuePair<string, string>[] aliases = new KeyValuePair<string, string>[myAliases.Count];
       myAliases.CopyTo(aliases, 0);
       for (int j = 0; j < aliases.Length; j++)
@@ -249 +265 @@
     /// <inheritdoc/>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      Scope clone = (Scope)base.Clone(clonedObjects);
-      clone.myName = Name;
-
-      foreach (IVariable variable in myVariables.Values)
-        clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
-      foreach (KeyValuePair<string, string> alias in myAliases)
-        clone.AddAlias(alias.Key, alias.Value);
-      for (int i = 0; i < SubScopes.Count; i++)
-        clone.AddSubScope((IScope)Auxiliary.Clone(SubScopes[i], clonedObjects));
-
-      return clone;
+      return new Scope(this, clonedObjects);
     }
 
@@ -369 +375 @@
     /// <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);
       XmlAttribute nameAttribute = document.CreateAttribute("Name");
@@ -409 +415 @@
     /// <param name="restoredObjects">The dictionary of all already restored objects. 
     /// (Needed to avoid cycles.)</param>
-    public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
       myName = node.Attributes["Name"].Value;

branches/CloningRefactorBranch/HeuristicLab.Core/StorableBase.cs

@@ -46 +46 @@
 
     /// <summary>
+    ///  Copy constructor to create a deep clone of the original object
+    /// </summary>
+    /// <param name="original">The object to be cloned</param>
+    protected StorableBase(StorableBase original, IDictionary<Guid, object> clonedObjects) : this() {
+      clonedObjects.Add(myGuid, this);
+    }
+
+    /// <summary>
     /// Clones the current instance (deep clone).
     /// </summary>
@@ -54 +62 @@
     }
     /// <summary>
-    /// Clones the current instance with the <see cref="M:Activator.CreateInstance"/> 
-    /// method of <see cref="Activator"/>.
+    /// Default implementation of clone throws NotSupportedException. 
+    /// All actually cloneable objects must override this method.
     /// </summary>
     /// <param name="clonedObjects">All already cloned objects.</param>
-    /// <returns>The clone.</returns>
+    /// <returns>Nothing</returns>
     public virtual object Clone(IDictionary<Guid, object> clonedObjects) {
-      object clone = Activator.CreateInstance(this.GetType());
-      clonedObjects.Add(Guid, clone);
-      return clone;
+      throw new NotSupportedException("Can't clone abstract type StorableBase.");
     }
 
@@ -74 +80 @@
     /// <param name="persistedObjects">The dictionary of all already persisted objects. (Needed to avoid cycles.)</param>
     /// <returns>The saved <see cref="XmlNode"/>.</returns>
-    public virtual XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
+    public virtual XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = document.CreateNode(XmlNodeType.Element, name, null);
       XmlAttribute typeAttribute = document.CreateAttribute("Type");
@@ -91 +97 @@
     /// <param name="restoredObjects">The dictionary of all already restored objects. 
     /// (Needed to avoid cycles.)</param>
-    public virtual void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
+    public virtual void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       myGuid = new Guid(node.Attributes["GUID"].Value);
     }

branches/CloningRefactorBranch/HeuristicLab.Data/ConstrainedDoubleData.cs

@@ -56 +56 @@
     }
 
+    /// <summary>
+    /// Copy constructor for deep cloning of ConstrainedDoubleData items.
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected ConstrainedDoubleData(ConstrainedDoubleData original, IDictionary<Guid, object> clonedObjects) : base(original, clonedObjects) { }
+
     /// <inheritdoc cref="ConstrainedObjectData.TrySetData(object)"/>
     public virtual bool TrySetData(double data) {
@@ -80 +87 @@
     /// <returns>The cloned instance as <see cref="ConstrainedDoubleData"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      ConstrainedDoubleData clone = (ConstrainedDoubleData)base.Clone(clonedObjects);
-      return clone;
+      return new ConstrainedDoubleData(this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.Data/ConstrainedIntData.cs

@@ -56 +56 @@
     }
 
+    /// <summary>
+    /// Copy constructor for deep cloning of ConstrainedDoubleData items.
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected ConstrainedIntData(ConstrainedIntData original, IDictionary<Guid, object> clonedObjects) : base(original, clonedObjects) { }
+
     /// <inheritdoc cref="ConstrainedObjectData.TrySetData(object)"/>
     public virtual bool TrySetData(int data) {
@@ -80 +87 @@
     /// <returns>The clone instance as <see cref="ConstrainedIntData"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      ConstrainedIntData clone = (ConstrainedIntData)base.Clone(clonedObjects);
-      return clone;
+      return new ConstrainedIntData(this, clonedObjects);
     }