Index: /branches/CloningRefactorBranch/HeuristicLab.CEDMA.Charting/HeuristicLab.CEDMA.Charting.csproj
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.CEDMA.Charting/HeuristicLab.CEDMA.Charting.csproj	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.CEDMA.Charting/HeuristicLab.CEDMA.Charting.csproj	(revision 887)
@@ -4,5 +4,5 @@
     <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>
Index: /branches/CloningRefactorBranch/HeuristicLab.CEDMA.Core/OperatorLink.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.CEDMA.Core/OperatorLink.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.CEDMA.Core/OperatorLink.cs	(revision 887)
@@ -44,5 +44,5 @@
     }
 
-    public OperatorLink() : base() { } // for cloning and persistence
+    public OperatorLink() { } // for cloning and persistence
 
     public OperatorLink(long id, IOperator op)
@@ -51,4 +51,11 @@
       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,8 +69,5 @@
 
     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);
     }
 
Index: /branches/CloningRefactorBranch/HeuristicLab.Core/OperatorBase.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Core/OperatorBase.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Core/OperatorBase.cs	(revision 887)
@@ -105,7 +105,7 @@
 
     /// <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,4 +130,17 @@
     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);
     }
 
Index: /branches/CloningRefactorBranch/HeuristicLab.DataAnalysis/Dataset.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.DataAnalysis/Dataset.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.DataAnalysis/Dataset.cs	(revision 887)
@@ -105,4 +105,28 @@
     }
 
+    /// <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,18 +143,12 @@
     }
 
+    /// <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);
     }
 
Index: /branches/CloningRefactorBranch/HeuristicLab.DistributedEngine/DistributedEngine.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.DistributedEngine/DistributedEngine.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.DistributedEngine/DistributedEngine.cs	(revision 887)
@@ -47,8 +47,34 @@
       }
     }
+
+    /// <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,4 +339,5 @@
     }
 
+
     #region Persistence Methods
     public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
Index: /branches/CloningRefactorBranch/HeuristicLab.ES/ES.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.ES/ES.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.ES/ES.cs	(revision 887)
@@ -548,4 +548,10 @@
     }
 
+    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,8 +562,5 @@
 
     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);
     }
 
Index: /branches/CloningRefactorBranch/HeuristicLab.Logging/Linechart.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Logging/Linechart.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Logging/Linechart.cs	(revision 887)
@@ -59,10 +59,31 @@
     }
 
+    /// <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);
     }
 
Index: /branches/CloningRefactorBranch/HeuristicLab.Logging/Log.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Logging/Log.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Logging/Log.cs	(revision 887)
@@ -41,9 +41,28 @@
     }
 
+    /// <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);
     }
 
Index: /branches/CloningRefactorBranch/HeuristicLab.Logging/PointXYChart.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Logging/PointXYChart.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Logging/PointXYChart.cs	(revision 887)
@@ -61,8 +61,28 @@
     }
 
+    /// <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);
     }
 
Index: /branches/CloningRefactorBranch/HeuristicLab.Operators.Programmable/HeuristicLabOperatorsProgrammablePlugin.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Operators.Programmable/HeuristicLabOperatorsProgrammablePlugin.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Operators.Programmable/HeuristicLabOperatorsProgrammablePlugin.cs	(revision 887)
@@ -25,5 +25,5 @@
 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)]
Index: /branches/CloningRefactorBranch/HeuristicLab.Operators.Programmable/ProgrammableOperator.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Operators.Programmable/ProgrammableOperator.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Operators.Programmable/ProgrammableOperator.cs	(revision 887)
@@ -55,4 +55,7 @@
     }
 
+    /// <summary>
+    /// Default constructor.
+    /// </summary>
     public ProgrammableOperator() {
       myCode = "Result.Data = true;";
@@ -60,4 +63,22 @@
       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,12 +164,4 @@
     }
 
-    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,4 +209,14 @@
     }
 
+
+    /// <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) {
Index: /branches/CloningRefactorBranch/HeuristicLab.Operators.Stopwatch/Stopwatch.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Operators.Stopwatch/Stopwatch.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Operators.Stopwatch/Stopwatch.cs	(revision 887)
@@ -40,4 +40,20 @@
     }
 
+    /// <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,12 +74,15 @@
     }
 
+    /// <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,9 +94,9 @@
       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);
     }
Index: /branches/CloningRefactorBranch/HeuristicLab.Operators/CombinedOperator.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Operators/CombinedOperator.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Operators/CombinedOperator.cs	(revision 887)
@@ -61,4 +61,20 @@
 
     /// <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,16 +95,11 @@
     /// 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);
     }
 
Index: /branches/CloningRefactorBranch/HeuristicLab.Operators/DelegatingOperator.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Operators/DelegatingOperator.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Operators/DelegatingOperator.cs	(revision 887)
@@ -31,4 +31,13 @@
   /// </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,5 +51,5 @@
       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()));
Index: /branches/CloningRefactorBranch/HeuristicLab.Permutation/Permutation.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Permutation/Permutation.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Permutation/Permutation.cs	(revision 887)
@@ -35,8 +35,12 @@
     }
 
+    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);
     }
   }
Index: /branches/CloningRefactorBranch/HeuristicLab.Random/MersenneTwister.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Random/MersenneTwister.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Random/MersenneTwister.cs	(revision 887)
@@ -59,12 +59,29 @@
       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);
     }
 
Index: /branches/CloningRefactorBranch/HeuristicLab.Random/NormalDistributedRandom.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.Random/NormalDistributedRandom.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.Random/NormalDistributedRandom.cs	(revision 887)
@@ -452,4 +452,21 @@
     }
 
+    /// <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,4 +528,13 @@
     #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,10 +562,4 @@
     }
 
-    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
   }
Index: /branches/CloningRefactorBranch/HeuristicLab.SGA/SGA.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.SGA/SGA.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.SGA/SGA.cs	(revision 887)
@@ -458,4 +458,9 @@
       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,8 +472,5 @@
 
     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);
     }
 
Index: /branches/CloningRefactorBranch/HeuristicLab.SequentialEngine/SequentialEngine.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.SequentialEngine/SequentialEngine.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.SequentialEngine/SequentialEngine.cs	(revision 887)
@@ -30,4 +30,21 @@
     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,5 +73,5 @@
           myExecutionStack.Push(atomicOperation);
           Abort();
-          ThreadPool.QueueUserWorkItem(delegate(object state) { OnExceptionOccurred(ex);});
+          ThreadPool.QueueUserWorkItem(delegate(object state) { OnExceptionOccurred(ex); });
         }
         if (next != null)
@@ -68,4 +85,14 @@
       }
     }
+
+    /// <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);
+    }
   }
 }
Index: /branches/CloningRefactorBranch/HeuristicLab.ThreadParallelEngine/ThreadParallelEngine.cs
===================================================================
--- /branches/CloningRefactorBranch/HeuristicLab.ThreadParallelEngine/ThreadParallelEngine.cs	(revision 886)
+++ /branches/CloningRefactorBranch/HeuristicLab.ThreadParallelEngine/ThreadParallelEngine.cs	(revision 887)
@@ -58,9 +58,12 @@
     }
 
+    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);
     }
 
