Changeset 887 for branches

Timestamp:

12/02/08 21:10:17 (15 years ago)

Author:

gkronber

Message:

Refactored cloning in all plugins except: HL.Communication, HL.Hive, HL.GP, HL.Routing, HL.Scheduling, HL.SimOpt, HL.Visualization

#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.CEDMA.Charting/HeuristicLab.CEDMA.Charting.csproj (modified) (1 diff)
• HeuristicLab.CEDMA.Core/OperatorLink.cs (modified) (3 diffs)
• HeuristicLab.Core/OperatorBase.cs (modified) (2 diffs)
• HeuristicLab.DataAnalysis/Dataset.cs (modified) (2 diffs)
• HeuristicLab.DistributedEngine/DistributedEngine.cs (modified) (2 diffs)
• HeuristicLab.ES/ES.cs (modified) (2 diffs)
• HeuristicLab.Logging/Linechart.cs (modified) (1 diff)
• HeuristicLab.Logging/Log.cs (modified) (1 diff)
• HeuristicLab.Logging/PointXYChart.cs (modified) (1 diff)
• HeuristicLab.Operators.Programmable/HeuristicLabOperatorsProgrammablePlugin.cs (modified) (1 diff)
• HeuristicLab.Operators.Programmable/ProgrammableOperator.cs (modified) (4 diffs)
• HeuristicLab.Operators.Stopwatch/Stopwatch.cs (modified) (3 diffs)
• HeuristicLab.Operators/CombinedOperator.cs (modified) (2 diffs)
• HeuristicLab.Operators/DelegatingOperator.cs (modified) (2 diffs)
• HeuristicLab.Permutation/Permutation.cs (modified) (1 diff)
• HeuristicLab.Random/MersenneTwister.cs (modified) (1 diff)
• HeuristicLab.Random/NormalDistributedRandom.cs (modified) (3 diffs)
• HeuristicLab.SGA/SGA.cs (modified) (2 diffs)
• HeuristicLab.SequentialEngine/SequentialEngine.cs (modified) (3 diffs)
• HeuristicLab.ThreadParallelEngine/ThreadParallelEngine.cs (modified) (1 diff)

branches/CloningRefactorBranch/HeuristicLab.CEDMA.Charting/HeuristicLab.CEDMA.Charting.csproj

@@ -4 +4 @@
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.21022</ProductVersion>
+    <ProductVersion>9.0.30729</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{1BF17271-5350-476A-8F6D-FC74FA3E82CA}</ProjectGuid>

branches/CloningRefactorBranch/HeuristicLab.CEDMA.Core/OperatorLink.cs

@@ -44 +44 @@
     }
 
-    public OperatorLink() : base() { } // for cloning and persistence
+    public OperatorLink() { } // for cloning and persistence
 
     public OperatorLink(long id, IOperator op)
@@ -51 +51 @@
       this.myOperator = op;
       Name = myOperator.Name;
+    }
+
+    public OperatorLink(OperatorLink original) : this(original, new Dictionary<Guid, object>()) { }
+    protected OperatorLink(OperatorLink original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.id = original.id;
+      this.myOperator = (IOperator)Auxiliary.Clone(Operator, clonedObjects);
     }
 
@@ -62 +69 @@
 
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      OperatorLink clone = (OperatorLink)base.Clone(clonedObjects);
-      clone.id = id;
-      clone.myOperator = Operator;
-      return clone;
+      return new OperatorLink(this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.Core/OperatorBase.cs

@@ -105 +105 @@
 
     /// <summary>
-    /// Copy constructor.
-    /// </summary>
-    /// <param name="original">The original instance to be cloned</param>
+    /// Copy constructor to create deep clones reusing already cloned object references.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
     /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
     protected OperatorBase(OperatorBase original, IDictionary<Guid, object> clonedObjects)
@@ -130 +130 @@
     public override IView CreateView() {
       return new OperatorBaseView(this);
+    }
+
+    /// <summary>
+    /// Creates a deep clone with the copy constructor reusing already cloned
+    /// object references.
+    /// </summary>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    /// <returns>The cloned instance.</returns>
+    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+      // override clone for all classes inheriting from OperatorBase, so
+      // we don't need to implement Clone() and the copy constructors in
+      // every single operator.
+      return Activator.CreateInstance(this.GetType(), this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.DataAnalysis/Dataset.cs

@@ -105 +105 @@
     }
 
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    public Dataset(Dataset original) : this(original, new Dictionary<Guid, object>()) { }
+    /// <summary>
+    /// Copy constructor to create deep clones reusing already cloned object references.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    protected Dataset(Dataset original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      double[] cloneSamples = new double[original.rows * original.columns];
+      Array.Copy(original.samples, cloneSamples, original.samples.Length);
+      this.rows = original.rows;
+      this.columns = original.columns;
+      this.Samples = cloneSamples;
+      this.Name = original.Name;
+      this.VariableNames = new string[original.VariableNames.Length];
+      Array.Copy(original.VariableNames, this.VariableNames, original.VariableNames.Length);
+      Array.Copy(original.scalingFactor, this.scalingFactor, original.columns);
+      Array.Copy(original.scalingOffset, this.scalingOffset, original.columns);
+    }
+
     private void CreateDictionaries() {
       // keep a means and ranges dictionary for each column (possible target variable) of the dataset.
@@ -119 +143 @@
     }
 
+    /// <summary>
+    /// Creates a deep clone with the copy constructor reusing already cloned
+    /// object references.
+    /// </summary>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    /// <returns>The cloned instance.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      Dataset clone = new Dataset();
-      clonedObjects.Add(Guid, clone);
-      double[] cloneSamples = new double[rows * columns];
-      Array.Copy(samples, cloneSamples, samples.Length);
-      clone.rows = rows;
-      clone.columns = columns;
-      clone.Samples = cloneSamples;
-      clone.Name = Name;
-      clone.VariableNames = new string[VariableNames.Length];
-      Array.Copy(VariableNames, clone.VariableNames, VariableNames.Length);
-      Array.Copy(scalingFactor, clone.scalingFactor, columns);
-      Array.Copy(scalingOffset, clone.scalingOffset, columns);
-      return clone;
+      return new Dataset(this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.DistributedEngine/DistributedEngine.cs

@@ -47 +47 @@
       }
     }
+
+    /// <summary>
+    /// Default constructor
+    /// </summary>
+    public DistributedEngine() { }
+
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    public DistributedEngine(DistributedEngine original) : this(original, new Dictionary<Guid, object>()) { }
+
+    /// <summary>
+    /// Copy constructor for DistributedEngine clones (deep clone) reusing already cloned object references
+    /// </summary>
+    /// <remarks>Calls the copy constructor of the base class <see cref="EngineBase"/></remarks>
+    /// <param name="original">Instance to be cloned</param>
+    /// <param name="clonedObjects">Already cloned object reference</param>
+    protected DistributedEngine(DistributedEngine original, IDictionary<Guid, object> clonedObjects) 
+      : base(original, clonedObjects) {
+      this.ServerAddress = original.ServerAddress;
+    }
+    /// <summary>
+    /// Creates a deep clone with the copy constructor reusing already cloned
+    /// object references.
+    /// </summary>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    /// <returns>The cloned instance.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      DistributedEngine clone = (DistributedEngine)base.Clone(clonedObjects);
-      clone.ServerAddress = serverAddress;
-      return clone;
+      return new DistributedEngine(this, clonedObjects);
     }
 
@@ -313 +339 @@
     }
 
+
     #region Persistence Methods
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {

branches/CloningRefactorBranch/HeuristicLab.ES/ES.cs

@@ -548 +548 @@
     }
 
+    public ES(ES original) : this(original, new Dictionary<Guid, object>()) { }
+    protected ES(ES original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myEngine = (IEngine)Auxiliary.Clone(original.Engine, clonedObjects);
+    }
+
     public override IView CreateView() {
       return new ESEditor(this);
@@ -556 +562 @@
 
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      ES clone = new ES();
-      clonedObjects.Add(Guid, clone);
-      clone.myEngine = (IEngine)Auxiliary.Clone(Engine, clonedObjects);
-      return clone;
+      return new ES(this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.Logging/Linechart.cs

@@ -59 +59 @@
     }
 
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    public Linechart(Linechart original) : this(original, new Dictionary<Guid, object>()) { }
 
+
+    /// <summary>
+    /// Copy constructor for DistributedEngine clones (deep clone) reusing already cloned object references
+    /// </summary>
+    /// <remarks>Calls the copy constructor of the base class <see cref="EngineBase"/></remarks>
+    /// <param name="original">Instance to be cloned</param>
+    /// <param name="clonedObjects">Already cloned object reference</param>
+    protected Linechart(Linechart original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myNumberOfLines = (IntData)Auxiliary.Clone(original.myNumberOfLines,clonedObjects);
+      this.myValues = (ItemList)Auxiliary.Clone(original.Values, clonedObjects);
+    }
+
+    /// <summary>
+    /// Creates a deep clone with the copy constructor reusing already cloned
+    /// object references.
+    /// </summary>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    /// <returns>The cloned instance.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      Linechart clone = (Linechart)base.Clone(clonedObjects);
-      clone.myNumberOfLines = (IntData)Auxiliary.Clone(myNumberOfLines, clonedObjects);
-      clone.myValues = (ItemList)Auxiliary.Clone(Values, clonedObjects);
-      return clone;
+      return new Linechart(this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.Logging/Log.cs

@@ -41 +41 @@
     }
 
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    public Log(Log original) : this(original, new Dictionary<Guid, object>()) { }
+    /// <summary>
+    /// Copy constructor for DistributedEngine clones (deep clone) reusing already cloned object references
+    /// </summary>
+    /// <remarks>Calls the copy constructor of the base class <see cref="EngineBase"/></remarks>
+    /// <param name="original">Instance to be cloned</param>
+    /// <param name="clonedObjects">Already cloned object reference</param>
+    protected Log(Log original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myItems = (ItemList)Auxiliary.Clone(original.Items, clonedObjects);
+    }
 
+    /// <summary>
+    /// Creates a deep clone with the copy constructor reusing already cloned
+    /// object references.
+    /// </summary>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    /// <returns>The cloned instance.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      Log clone = (Log)base.Clone(clonedObjects);
-      clone.myItems = (ItemList)Auxiliary.Clone(Items, clonedObjects);
-      return clone;
+      return new Log(this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.Logging/PointXYChart.cs

@@ -61 +61 @@
     }
 
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    public PointXYChart(PointXYChart original) : this(original, new Dictionary<Guid, object>()) { }
+    /// <summary>
+    /// Copy constructor for DistributedEngine clones (deep clone) reusing already cloned object references
+    /// </summary>
+    /// <remarks>Calls the copy constructor of the base class <see cref="EngineBase"/></remarks>
+    /// <param name="original">Instance to be cloned</param>
+    /// <param name="clonedObjects">Already cloned object reference</param>
+    protected PointXYChart(PointXYChart original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myValues = (ItemList)Auxiliary.Clone(original.Values, clonedObjects);
+    }
+
+    /// <summary>
+    /// Creates a deep clone with the copy constructor reusing already cloned
+    /// object references.
+    /// </summary>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    /// <returns>The cloned instance.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      PointXYChart clone = (PointXYChart)base.Clone(clonedObjects);
-      clone.myValues = (ItemList)Auxiliary.Clone(Values, clonedObjects);
-      return clone;
+      return new PointXYChart(this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.Operators.Programmable/HeuristicLabOperatorsProgrammablePlugin.cs

@@ -25 +25 @@
 using HeuristicLab.PluginInfrastructure;
 
-namespace HeuristicLab.Operators {
+namespace HeuristicLab.Operators.Programmable {
   [ClassInfo(Name = "HeuristicLab.Operators.Programmable-3.2")]
   [PluginFile(Filename = "HeuristicLab.Operators.Programmable-3.2.dll", Filetype = PluginFileType.Assembly)]

branches/CloningRefactorBranch/HeuristicLab.Operators.Programmable/ProgrammableOperator.cs

@@ -55 +55 @@
     }
 
+    /// <summary>
+    /// Default constructor.
+    /// </summary>
     public ProgrammableOperator() {
       myCode = "Result.Data = true;";
@@ -60 +63 @@
       AddVariableInfo(new VariableInfo("Result", "A computed variable", typeof(BoolData), VariableKind.New | VariableKind.Out));
       executeMethod = null;
+    }
+
+
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    public ProgrammableOperator(ProgrammableOperator original) : this(original, new Dictionary<Guid, object>()) { }
+    /// <summary>
+    /// Copy constructor to create a deep clone of an ProgrammableOperator instance.
+    /// </summary>
+    /// <param name="original">The original instance to be cloned.</param>
+    /// <param name="clonedObjects">Already cloned object references.</param>
+    protected ProgrammableOperator(ProgrammableOperator original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myDescription = original.Description;
+      this.myCode = original.Code;
+      this.executeMethod = original.executeMethod;
     }
 
@@ -143 +164 @@
     }
 
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      ProgrammableOperator clone = (ProgrammableOperator)base.Clone(clonedObjects);
-      clone.myDescription = Description;
-      clone.myCode = Code;
-      clone.executeMethod = executeMethod;
-      return clone;
-    }
-
     public override IOperation Apply(IScope scope) {
       if (executeMethod == null) {
@@ -196 +209 @@
     }
 
+
+    /// <summary>
+    /// Creates a deep clone with the copy constructor reusing already cloned
+    /// object references.
+    /// </summary>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    /// <returns>The cloned instance.</returns>
+    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+      return new ProgrammableOperator(this, clonedObjects);
+    }
     #region Persistence Methods
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {

branches/CloningRefactorBranch/HeuristicLab.Operators.Stopwatch/Stopwatch.cs

@@ -40 +40 @@
     }
 
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    public Stopwatch(Stopwatch original) : this(original, new Dictionary<Guid, object>()) { }
+    /// <summary>
+    /// Copy constructor to create deep clones reusing already cloned object references.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    protected Stopwatch(Stopwatch original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      elapsedTime = original.elapsedTime;
+      if (original.running) this.Start();
+    }
+
     public void Start() {
       stopwatch.Start();
@@ -58 +74 @@
     }
 
+    /// <summary>
+    /// Creates a deep clone with the copy constructor reusing already cloned
+    /// object references.
+    /// </summary>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    /// <returns>The cloned instance.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      Stopwatch clone = (Stopwatch)base.Clone(clonedObjects);
-      if(running) clone.Start();
-      clone.elapsedTime = elapsedTime;
-      return clone;
+      return new Stopwatch(this, clonedObjects);
     }
 
-    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 runningAttr = document.CreateAttribute("Running");
@@ -75 +94 @@
       return node;
     }
-    public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       long elapsedTicks = long.Parse(node.Attributes["ElapsedTicks"].Value);
       elapsedTime = TimeSpan.FromTicks(elapsedTicks);
       running = bool.Parse(node.Attributes["Running"].Value);
-      if(running) stopwatch.Start();
+      if (running) stopwatch.Start();
       base.Populate(node, restoredObjects);
     }

branches/CloningRefactorBranch/HeuristicLab.Operators/CombinedOperator.cs

@@ -61 +61 @@
 
     /// <summary>
+    /// Copy constructor for CombinedOperators (deep clone).
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBase
+    /// (System.Collections.Generic.IDictionary&lt;System.Guid, object&gt;)"/> 
+    /// of base class <see cref="DelegatingOperator"/>.<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="CombinedOperator"/>.</returns>
+    public CombinedOperator(CombinedOperator original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myDescription = original.Description;
+      this.myOperatorGraph = (IOperatorGraph)Auxiliary.Clone(original.OperatorGraph, clonedObjects);
+    }
+
+    /// <summary>
     /// Sets the description of the current instance.
     /// </summary>
@@ -79 +95 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Calls <see cref="OperatorBase.Clone
-    /// (System.Collections.Generic.IDictionary&lt;System.Guid, object&gt;)"/> 
-    /// of base class <see cref="DelegatingOperator"/>.<br/>
-    /// Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
-    /// <see cref="Auxiliary"/>.</remarks>
+    /// <remarks>Calls the copy constructor <see cref="CombinedOperator
+    /// (System.Collections.Generic.IDictionary&lt;System.Guid, object&gt;)"/> .<br/>
+    ///</remarks>
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="CombinedOperator"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      CombinedOperator clone = (CombinedOperator)base.Clone(clonedObjects);
-      clone.myDescription = Description;
-      clone.myOperatorGraph = (IOperatorGraph)Auxiliary.Clone(OperatorGraph, clonedObjects);
-      return clone;
+      return new CombinedOperator(this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.Operators/DelegatingOperator.cs

@@ -31 +31 @@
   /// </summary>
   public abstract class DelegatingOperator : OperatorBase {
+
+    /// <summary>
+    ///  Default constructor for DelegatingOperator
+    /// </summary>
+    public DelegatingOperator() { }
+
+    public DelegatingOperator(DelegatingOperator original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) { }
+
     /// <summary>
     /// Executes the specified operator in the given <paramref name="scope"/>.
@@ -42 +51 @@
       myCanceled = false;
 
-      if(scope.GetVariable(Guid.ToString()) == null) { // contained operator not yet executed
+      if (scope.GetVariable(Guid.ToString()) == null) { // contained operator not yet executed
         // add marker
         scope.AddVariable(new Variable(Guid.ToString(), new NullData()));

branches/CloningRefactorBranch/HeuristicLab.Permutation/Permutation.cs

@@ -35 +35 @@
     }
 
+    public Permutation(Permutation original) : this(original, new Dictionary<Guid, object>()) { }
+    protected Permutation(Permutation original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.Data = (int[])original.Data.Clone();
+    }
+
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      Permutation clone = new Permutation((int[])Data.Clone());
-      clonedObjects.Add(Guid, clone);
-      return clone;
+      return new Permutation(this, clonedObjects);
     }
   }

branches/CloningRefactorBranch/HeuristicLab.Random/MersenneTwister.cs

@@ -59 +59 @@
       init = true;
     }
-
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    public MersenneTwister(MersenneTwister original) : this(original, new Dictionary<Guid, object>()) { }
+    /// <summary>
+    /// Copy constructor to create deep clones reusing already cloned object references.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    protected MersenneTwister(MersenneTwister original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.state = (uint[])original.state.Clone();
+      this.p = original.p;
+      this.init = original.init;
+    }
+
+    /// <summary>
+    /// Creates a deep clone with the copy constructor reusing already cloned
+    /// object references.
+    /// </summary>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    /// <returns>The cloned instance.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      MersenneTwister clone = new MersenneTwister();
-      clonedObjects.Add(Guid, clone);
-      clone.state = (uint[])state.Clone();
-      clone.p = p;
-      clone.init = init;
-      return clone;
+      return new MersenneTwister(this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.Random/NormalDistributedRandom.cs

@@ -452 +452 @@
     }
 
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    public NormalDistributedRandom(NormalDistributedRandom original) : this(original, new Dictionary<Guid, object>()) { }
+    /// <summary>
+    /// Copy constructor to create deep clones reusing already cloned object references.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    protected NormalDistributedRandom(NormalDistributedRandom original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.uniform = (IRandom)Auxiliary.Clone(original.uniform, clonedObjects);
+      this.mu = original.mu;
+      this.sigma = original.sigma;
+    }
+
     #region IRandom Members
 
@@ -511 +528 @@
     #endregion
 
+    /// <summary>
+    /// Creates a deep clone with the copy constructor reusing already cloned
+    /// object references.
+    /// </summary>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    /// <returns>The cloned instance.</returns>
+    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+      return new NormalDistributedRandom(this, clonedObjects);
+    }
     #region persistence
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
@@ -536 +562 @@
     }
 
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      NormalDistributedRandom clone = new NormalDistributedRandom((IRandom)Auxiliary.Clone(uniform, clonedObjects), mu, sigma);
-      clonedObjects.Add(Guid, clone);
-      return clone;
-    }
-
     #endregion
   }

branches/CloningRefactorBranch/HeuristicLab.SGA/SGA.cs

@@ -458 +458 @@
       SetReferences();
     }
+    public SGA(SGA original) : this(original, new Dictionary<Guid, object>()) { }
+    protected SGA(SGA original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myEngine = (IEngine)Auxiliary.Clone(original.Engine, clonedObjects);
+    }
 
     public override IView CreateView() {
@@ -467 +472 @@
 
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      SGA clone = new SGA();
-      clonedObjects.Add(Guid, clone);
-      clone.myEngine = (IEngine)Auxiliary.Clone(Engine, clonedObjects);
-      return clone;
+      return new SGA(this, clonedObjects);
     }
 

branches/CloningRefactorBranch/HeuristicLab.SequentialEngine/SequentialEngine.cs

@@ -30 +30 @@
     private IOperator currentOperator;
 
+    /// <summary>
+    /// Default constructor
+    /// </summary>
+    public SequentialEngine() { }
+
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    public SequentialEngine(SequentialEngine original) : this(original, new Dictionary<Guid, object>()) { }
+    /// <summary>
+    /// Copy constructor to create deep clones reusing already cloned object references.
+    /// </summary>
+    /// <param name="original">The instance to be cloned.</param>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    protected SequentialEngine(SequentialEngine original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) { }
     public override IView CreateView() {
       return new SequentialEngineEditor(this);
@@ -56 +73 @@
           myExecutionStack.Push(atomicOperation);
           Abort();
-          ThreadPool.QueueUserWorkItem(delegate(object state) { OnExceptionOccurred(ex);});
+          ThreadPool.QueueUserWorkItem(delegate(object state) { OnExceptionOccurred(ex); });
         }
         if (next != null)
@@ -68 +85 @@
       }
     }
+
+    /// <summary>
+    /// Creates a deep clone with the copy constructor reusing already cloned
+    /// object references.
+    /// </summary>
+    /// <param name="clonedObjects">Already cloned objects (for referential integrity).</param>
+    /// <returns>The cloned instance.</returns>
+    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+      return new SequentialEngine(this, clonedObjects);
+    }
   }
 }

branches/CloningRefactorBranch/HeuristicLab.ThreadParallelEngine/ThreadParallelEngine.cs

@@ -58 +58 @@
     }
 
+    public ThreadParallelEngine(ThreadParallelEngine original) : this(original, new Dictionary<Guid, object>()) { }
+    protected ThreadParallelEngine(ThreadParallelEngine original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myWorkers = original.Workers;
+    }
 
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      ThreadParallelEngine clone = (ThreadParallelEngine)base.Clone(clonedObjects);
-      clone.myWorkers = Workers;
-      return clone;
+      return new ThreadParallelEngine(this, clonedObjects);
     }