Index: trunk/sources/HeuristicLab.AdvancedOptimizationFrontend/3.3/MainForm.cs
===================================================================
--- trunk/sources/HeuristicLab.AdvancedOptimizationFrontend/3.3/MainForm.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.AdvancedOptimizationFrontend/3.3/MainForm.cs	(revision 2526)
@@ -43,11 +43,11 @@
     private class Task {
       public string filename;
-      public IStorable storable;
+      public IItem item;
       public IEditor editor;
 
       private Task() { }
-      public Task(string filename, IStorable storable, IEditor editor) {
+      public Task(string filename, IItem item, IEditor editor) {
         this.filename = filename;
-        this.storable = storable;
+        this.item = item;
         this.editor = editor;
       }
@@ -156,5 +156,5 @@
       Task task = (Task)state;
       try {
-        task.storable = PersistenceManager.Load(task.filename);
+        task.item = PersistenceManager.Load(task.filename);
       } catch (FileNotFoundException fileNotFoundEx) {
         MessageBox.Show("Sorry couldn't open file \"" + task.filename + "\".\nThe file or plugin \"" + fileNotFoundEx.FileName + "\" is not available.\nPlease make sure you have all necessary plugins installed.",
@@ -177,6 +177,6 @@
       else {
         IEditor editor = null;
-        if (task.storable != null) {
-          IEditable editable = task.storable as IEditable;
+        if (task.item != null) {
+          IEditable editable = task.item as IEditable;
           if (editable != null)
             editor = (IEditor)MainFormManager.CreateDefaultView(editable);
Index: trunk/sources/HeuristicLab.Core.Views/3.3/OperatorGraphView.cs
===================================================================
--- trunk/sources/HeuristicLab.Core.Views/3.3/OperatorGraphView.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core.Views/3.3/OperatorGraphView.cs	(revision 2526)
@@ -221,5 +221,5 @@
         if (operatorsListView.SelectedItems.Count > 0) {
           foreach (ListViewItem item in operatorsListView.SelectedItems)
-            OperatorGraph.RemoveOperator(((IOperator)item.Tag).Guid);
+            OperatorGraph.RemoveOperator((IOperator)item.Tag);
         }
       }
@@ -261,5 +261,5 @@
       if (operatorsListView.SelectedItems.Count > 0) {
         foreach (ListViewItem item in operatorsListView.SelectedItems)
-          OperatorGraph.RemoveOperator(((IOperator)item.Tag).Guid);
+          OperatorGraph.RemoveOperator((IOperator)item.Tag);
       }
     }
Index: trunk/sources/HeuristicLab.Core/3.3/AtomicOperation.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/AtomicOperation.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/AtomicOperation.cs	(revision 2526)
@@ -69,12 +69,12 @@
     /// </summary>
     /// <remarks>The operator and the scope objects are cloned with the 
-    /// <see cref="HeuristicLab.Core.Auxiliary.Clone"/> method of the <see cref="Auxiliary"/> class.</remarks>
+    /// <see cref="HeuristicLab.Core.cloner.Clone"/> method of the <see cref="Auxiliary"/> class.</remarks>
     /// <param name="clonedObjects">All already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="AtomicOperation"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       AtomicOperation clone = new AtomicOperation();
-      clonedObjects.Add(Guid, clone);
-      clone.myOperator = (IOperator)Auxiliary.Clone(Operator, clonedObjects);
-      clone.myScope = (IScope)Auxiliary.Clone(Scope, clonedObjects);
+      cloner.RegisterClonedObject(this, clone);
+      clone.myOperator = (IOperator)cloner.Clone(Operator);
+      clone.myScope = (IScope)cloner.Clone(Scope);
       return clone;
     }
Index: trunk/sources/HeuristicLab.Core/3.3/Auxiliary.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/Auxiliary.cs	(revision 2525)
+++ 	(revision )
@@ -1,48 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace HeuristicLab.Core {
-  /// <summary>
-  /// Static helper class.
-  /// </summary>
-  public static class Auxiliary {
-    #region Cloning
-    /// <summary>
-    /// Clones the given <paramref name="obj"/> (deep clone).
-    /// </summary>
-    /// <remarks>Checks before clone if object has not already been cloned.</remarks>
-    /// <param name="obj">The object to clone.</param>
-    /// <param name="clonedObjects">A dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
-    /// <returns>The cloned object.</returns>
-    public static object Clone(IStorable obj, IDictionary<Guid, object> clonedObjects) {
-      object clone;
-      if (clonedObjects.TryGetValue(obj.Guid, out clone))
-        return clone;
-      else
-        return obj.Clone(clonedObjects);
-    }
-    #endregion
-  }
-}
Index: trunk/sources/HeuristicLab.Core/3.3/Cloner.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/Cloner.cs	(revision 2526)
+++ trunk/sources/HeuristicLab.Core/3.3/Cloner.cs	(revision 2526)
@@ -0,0 +1,73 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// A helper class which is used to create deep clones of object graphs.
+  /// </summary>
+  public class Cloner : ICloner {
+    private class ReferenceEqualityComparer : IEqualityComparer<IItem> {
+      public bool Equals(IItem x, IItem y) {
+        return object.ReferenceEquals(x, y);
+      }
+
+      public int GetHashCode(IItem item) {
+        if (item == null) return 0;
+        return item.GetHashCode();
+      }
+    }
+
+    private Dictionary<IItem, IItem> mapping;
+
+    /// <summary>
+    /// Creates a new Cloner instance.
+    /// </summary>
+    public Cloner() {
+      mapping = new Dictionary<IItem, IItem>(new ReferenceEqualityComparer());
+    }
+
+    /// <summary>
+    /// Creates a deep clone of a given item.
+    /// </summary>
+    /// <param name="item">The item which should be cloned.</param>
+    /// <returns>A clone of the given item.</returns>
+    public IItem Clone(IItem item) {
+      if (item == null) return null;
+      IItem clone;
+      if (mapping.TryGetValue(item, out clone))
+        return clone;
+      else
+        return item.Clone(this);
+    }
+    /// <summary>
+    /// Registers a new clone for a given item.
+    /// </summary>
+    /// <param name="item">The original item.</param>
+    /// <param name="clone">The clone of the original item.</param>
+    public void RegisterClonedObject(IItem item, IItem clone) {
+      mapping.Add(item, clone);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Core/3.3/CompositeOperation.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/CompositeOperation.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/CompositeOperation.cs	(revision 2526)
@@ -81,13 +81,13 @@
     /// </summary>
     /// <remarks>All operations of the current instance are cloned, too (deep clone), with the 
-    /// <see cref="HeuristicLab.Core.Auxiliary.Clone"/> method of the class <see cref="Auxiliary"/>.</remarks>
+    /// <see cref="HeuristicLab.Core.cloner.Clone"/> method of the class <see cref="Auxiliary"/>.</remarks>
     /// <param name="clonedObjects">A dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned operation as <see cref="CompositeOperation"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       CompositeOperation clone = new CompositeOperation();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       clone.myExecuteInParallel = ExecuteInParallel;
       for (int i = 0; i < Operations.Count; i++)
-        clone.AddOperation((IOperation)Auxiliary.Clone(Operations[i], clonedObjects));
+        clone.AddOperation((IOperation)cloner.Clone(Operations[i]));
       return clone;
     }
Index: trunk/sources/HeuristicLab.Core/3.3/EngineBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/EngineBase.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/EngineBase.cs	(revision 2526)
@@ -127,17 +127,17 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <remarks>Deep clone through <see cref="cloner.Clone"/> method of helper class 
     /// <see cref="Auxiliary"/>.</remarks>
     /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
     /// <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);
+    public override IItem Clone(ICloner cloner) {
+      EngineBase clone = (EngineBase)base.Clone(cloner);
+      clone.myOperatorGraph = (IOperatorGraph)cloner.Clone(OperatorGraph);
+      clone.myGlobalScope = (IScope)cloner.Clone(GlobalScope);
       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.myExecutionStack.Push((IOperation)cloner.Clone(operations[i]));
       clone.myRunning = Running;
       clone.myCanceled = Canceled;
Index: trunk/sources/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 2526)
@@ -98,7 +98,8 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Auxiliary.cs" />
     <Compile Include="AtomicOperation.cs" />
     <Compile Include="CompositeOperation.cs" />
+    <Compile Include="Cloner.cs" />
+    <Compile Include="Interfaces\ICloner.cs" />
     <Compile Include="Interfaces\IEditable.cs" />
     <Compile Include="Interfaces\IOperation.cs" />
@@ -119,10 +120,8 @@
     <Compile Include="Interfaces\IRandom.cs" />
     <Compile Include="OperatorGraph.cs" />
-    <Compile Include="StorableBase.cs" />
     <Compile Include="Scope.cs" />
     <Compile Include="EngineBase.cs" />
     <Compile Include="Interfaces\IEngine.cs" />
     <Compile Include="Interfaces\IOperator.cs" />
-    <Compile Include="Interfaces\IStorable.cs" />
     <Compile Include="PersistenceManager.cs" />
     <Compile Include="HeuristicLabCorePlugin.cs" />
Index: trunk/sources/HeuristicLab.Core/3.3/Interfaces/ICloner.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/Interfaces/ICloner.cs	(revision 2526)
+++ trunk/sources/HeuristicLab.Core/3.3/Interfaces/ICloner.cs	(revision 2526)
@@ -0,0 +1,45 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// An interface describing the signature of helper classes required for creating deep
+  /// clones of object graphs.
+  /// </summary>
+  public interface ICloner {
+    /// <summary>
+    /// Creates a deep clone of a given item.
+    /// </summary>
+    /// <param name="item">The item which should be cloned.</param>
+    /// <returns>A clone of the given item.</returns>
+    IItem Clone(IItem item);
+    /// <summary>
+    /// Registers a new clone for a given item.
+    /// </summary>
+    /// <param name="item">The original item.</param>
+    /// <param name="clone">The clone of the original item.</param>
+    void RegisterClonedObject(IItem item, IItem clone);
+  }
+}
Index: trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItem.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItem.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItem.cs	(revision 2526)
@@ -28,5 +28,13 @@
   /// Interface to represent (almost) every HeuristicLab object (an object, an operator,...).
   /// </summary>
-  public interface IItem : IStorable {
+  public interface IItem : ICloneable {
+    /// <summary>
+    /// Creates a deep clone of this item.
+    /// </summary>
+    /// <param name="cloner">The cloner which is responsible for keeping track of all already
+    /// cloned objects.</param>
+    /// <returns>A clone of this instance.</returns>
+    IItem Clone(ICloner cloner);
+
     /// <summary>
     /// Fires a new <c>Changed</c> event.
Index: trunk/sources/HeuristicLab.Core/3.3/Interfaces/IOperatorGraph.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/Interfaces/IOperatorGraph.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/Interfaces/IOperatorGraph.cs	(revision 2526)
@@ -49,11 +49,5 @@
     /// </summary>
     /// <param name="guid">The unique id of the operator to remove.</param>
-    void RemoveOperator(Guid guid);
-    /// <summary>
-    /// Gets the operator with the specified <paramref name="guid"/>.
-    /// </summary>
-    /// <param name="guid">The unique id of the operator.</param>
-    /// <returns>The searched operator.</returns>
-    IOperator GetOperator(Guid guid);
+    void RemoveOperator(IOperator op);
     /// <summary>
     /// Clears the current instance.
Index: trunk/sources/HeuristicLab.Core/3.3/Interfaces/IOperatorGroup.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/Interfaces/IOperatorGroup.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/Interfaces/IOperatorGroup.cs	(revision 2526)
@@ -29,5 +29,5 @@
   /// Interface to represent a group of operators.
   /// </summary>
-  public interface IOperatorGroup : IStorable {
+  public interface IOperatorGroup : IItem {
     /// <summary>
     /// Gets or sets the name of the current instance.
Index: trunk/sources/HeuristicLab.Core/3.3/Interfaces/IScope.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/Interfaces/IScope.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/Interfaces/IScope.cs	(revision 2526)
@@ -130,10 +130,4 @@
     void ReorderSubScopes(int[] sequence);
     /// <summary>
-    /// Gets the sub scope with the given <paramref name="guid"/>.
-    /// </summary>
-    /// <param name="guid">The unique identifier of the sub scope.</param>
-    /// <returns>The sub scope with the given <paramref name="guid"/>.</returns>
-    IScope GetScope(Guid guid);
-    /// <summary>
     /// Gets the sub scope with the given <paramref name="name"/>.
     /// </summary>
Index: trunk/sources/HeuristicLab.Core/3.3/Interfaces/IStorable.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/Interfaces/IStorable.cs	(revision 2525)
+++ 	(revision )
@@ -1,52 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Xml;
-
-namespace HeuristicLab.Core {
-
-  /// <summary>
-  /// Interface to represent objects that are de- and serializeable.
-  /// </summary>
-  public interface IStorable {
-
-    /// <summary>
-    /// Gets the objects unique identifier.
-    /// </summary>
-    Guid Guid { get; }
-
-    /// <summary>
-    /// Clones the current instance (deep clone).
-    /// </summary>
-    /// <returns>The cloned object.</returns>
-    object Clone();
-
-    /// <summary>
-    /// Clones the current instance, considering already cloned objects.
-    /// </summary>
-    /// <param name="clonedObjects">All already cloned objects. (Needed to avoid cycles.)</param>
-    /// <returns>The cloned object.</returns>
-    object Clone(IDictionary<Guid, object> clonedObjects);
-  }
-}
Index: trunk/sources/HeuristicLab.Core/3.3/ItemBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/ItemBase.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/ItemBase.cs	(revision 2526)
@@ -31,5 +31,30 @@
   /// </summary>
   [EmptyStorableClass]
-  public abstract class ItemBase : StorableBase, IItem {
+  public abstract class ItemBase : IItem {
+    /// <summary>
+    /// Creates a deep clone of this instance.
+    /// </summary>
+    /// <remarks>
+    /// This method is the entry point for creating a deep clone of a whole object graph.
+    /// </remarks>
+    /// <returns>A clone of this instance.</returns>
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    /// <summary>
+    /// Creates a deep clone of this instance.
+    /// </summary>
+    /// <remarks>This method should not be called directly. It is used for creating clones of
+    /// objects which are contained in the object that is currently cloned.</remarks>
+    /// <param name="cloner">The cloner which is responsible for keeping track of all already
+    /// cloned objects.</param>
+    /// <returns>A clone of this instance.</returns>
+    public virtual IItem Clone(ICloner cloner) {
+      ItemBase clone = (ItemBase)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      return clone;
+    }
+
     /// <summary>
     /// Gets the string representation of the current instance.
Index: trunk/sources/HeuristicLab.Core/3.3/OperatorBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/OperatorBase.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/OperatorBase.cs	(revision 2526)
@@ -131,16 +131,16 @@
     /// <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);
+    public override IItem Clone(ICloner cloner) {
+      OperatorBase clone = (OperatorBase)base.Clone(cloner);
       clone.myName = Name;
       clone.mySubOperators.Clear();
       for (int i = 0; i < SubOperators.Count; i++)
-        clone.AddSubOperator((IOperator)Auxiliary.Clone(SubOperators[i], clonedObjects));
+        clone.AddSubOperator((IOperator)cloner.Clone(SubOperators[i]));
       clone.myVariableInfos.Clear();
       foreach (IVariableInfo variableInfo in myVariableInfos.Values)
-        clone.AddVariableInfo((IVariableInfo)Auxiliary.Clone(variableInfo, clonedObjects));
+        clone.AddVariableInfo((IVariableInfo)cloner.Clone(variableInfo));
       clone.myVariables.Clear();
       foreach (IVariable variable in myVariables.Values)
-        clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
+        clone.AddVariable((IVariable)cloner.Clone(variable));
       return clone;
     }
Index: trunk/sources/HeuristicLab.Core/3.3/OperatorGraph.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/OperatorGraph.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/OperatorGraph.cs	(revision 2526)
@@ -34,5 +34,5 @@
 
     [Storable]
-    private IDictionary<Guid, IOperator> myOperators;
+    private IDictionary<IOperator, IOperator> myOperators;
     /// <summary>
     /// Gets all operators of the current instance.
@@ -62,5 +62,5 @@
     /// </summary>
     public OperatorGraph() {
-      myOperators = new Dictionary<Guid, IOperator>();
+      myOperators = new Dictionary<IOperator, IOperator>();
     }
 
@@ -68,15 +68,15 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <remarks>Deep clone through <see cref="cloner.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="OperatorGraph"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       OperatorGraph clone = new OperatorGraph();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       foreach (IOperator op in Operators)
-        clone.AddOperator((IOperator)Auxiliary.Clone(op, clonedObjects));
+        clone.AddOperator((IOperator)cloner.Clone(op));
       if (InitialOperator != null)
-        clone.myInitialOperator = (IOperator)Auxiliary.Clone(InitialOperator, clonedObjects);
+        clone.myInitialOperator = (IOperator)cloner.Clone(InitialOperator);
       return clone;
     }
@@ -85,6 +85,6 @@
     /// <remarks>Calls <see cref="OnOperatorAdded"/>.</remarks>
     public void AddOperator(IOperator op) {
-      if (!myOperators.ContainsKey(op.Guid)) {
-        myOperators.Add(op.Guid, op);
+      if (!myOperators.ContainsKey(op)) {
+        myOperators.Add(op, op);
         OnOperatorAdded(op);
 
@@ -95,7 +95,6 @@
     /// <inheritdoc/>
     /// <remarks>Calls <see cref="OnOperatorRemoved"/>.</remarks>
-    public void RemoveOperator(Guid guid) {
-      IOperator op = GetOperator(guid);
-      if (op != null) {
+    public void RemoveOperator(IOperator op) {
+      if (myOperators.ContainsKey(op)) {
         foreach (IOperator o in Operators) {
           int i = 0;
@@ -109,26 +108,18 @@
         if (InitialOperator == op)
           InitialOperator = null;
-        myOperators.Remove(op.Guid);
+        myOperators.Remove(op);
         OnOperatorRemoved(op);
       }
     }
     /// <inheritdoc/>
-    public IOperator GetOperator(Guid guid) {
-      IOperator op;
-      if (myOperators.TryGetValue(guid, out op))
-        return op;
-      else
-        return null;
-    }
-    /// <inheritdoc/>
     public void Clear() {
-      Guid[] guids = new Guid[Operators.Count];
+      IOperator[] ops = new IOperator[Operators.Count];
       int i = 0;
       foreach (IOperator op in Operators) {
-        guids[i] = op.Guid;
+        ops[i] = op;
         i++;
       }
-      for (int j = 0; j < guids.Length; j++)
-        RemoveOperator(guids[j]);
+      for (int j = 0; j < ops.Length; j++)
+        RemoveOperator(ops[j]);
     }
 
Index: trunk/sources/HeuristicLab.Core/3.3/OperatorGroup.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/OperatorGroup.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/OperatorGroup.cs	(revision 2526)
@@ -30,5 +30,5 @@
   /// Representation of a group of operators (can also include subgroups).
   /// </summary>
-  public class OperatorGroup : StorableBase, IOperatorGroup {
+  public class OperatorGroup : ItemBase, IOperatorGroup {
 
     [Storable]
@@ -80,15 +80,15 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Deep clone with <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <remarks>Deep clone with <see cref="cloner.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="OperatorGroup"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      OperatorGroup clone = (OperatorGroup)base.Clone(clonedObjects);
+    public override IItem Clone(ICloner cloner) {
+      OperatorGroup clone = (OperatorGroup)base.Clone(cloner);
       clone.myName = Name;
       foreach (IOperatorGroup group in SubGroups)
-        clone.AddSubGroup((IOperatorGroup)Auxiliary.Clone(group, clonedObjects));
+        clone.AddSubGroup((IOperatorGroup)cloner.Clone(group));
       foreach (IOperator op in Operators)
-        clone.AddOperator((IOperator)Auxiliary.Clone(op, clonedObjects));
+        clone.AddOperator((IOperator)cloner.Clone(op));
       return clone;
     }
Index: trunk/sources/HeuristicLab.Core/3.3/OperatorLibrary.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/OperatorLibrary.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/OperatorLibrary.cs	(revision 2526)
@@ -51,12 +51,12 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <remarks>Deep clone through <see cref="cloner.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="OperatorLibrary"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       OperatorLibrary clone = new OperatorLibrary();
-      clonedObjects.Add(Guid, clone);
-      clone.myGroup = (IOperatorGroup)Auxiliary.Clone(Group, clonedObjects);
+      cloner.RegisterClonedObject(this, clone);
+      clone.myGroup = (IOperatorGroup)cloner.Clone(Group);
       return clone;
     }
Index: trunk/sources/HeuristicLab.Core/3.3/PersistenceManager.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/PersistenceManager.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/PersistenceManager.cs	(revision 2526)
@@ -41,9 +41,9 @@
     /// <param name="instance">The object that should be saved.</param>
     /// <param name="filename">The name of the file where the <paramref name="object"/> should be saved.</param>
-    public static void Save(IStorable instance, string filename) {
+    public static void Save(IItem instance, string filename) {
       XmlGenerator.Serialize(instance, filename, 0);
     }
 
-    public static void SaveCompressed(IStorable instance, string filename) {
+    public static void SaveCompressed(IItem instance, string filename) {
       XmlGenerator.Serialize(instance, filename, 9);
     }
@@ -55,5 +55,5 @@
     /// <param name="instance">The object that should be saved.</param>
     /// <param name="stream">The (file) stream where the object should be saved.</param>
-    public static void Save(IStorable instance, Stream stream) {
+    public static void Save(IItem instance, Stream stream) {
       XmlGenerator.Serialize(instance, stream, ConfigurationService.Instance.GetConfiguration(new XmlFormat()));      
     }
@@ -65,6 +65,6 @@
     /// <param name="filename">The filename of the file where the data is saved.</param>
     /// <returns>The loaded object.</returns>
-    public static IStorable Load(string filename) {
-      return (IStorable)XmlParser.Deserialize(filename);
+    public static IItem Load(string filename) {
+      return (IItem)XmlParser.Deserialize(filename);
     }
     /// <summary>
@@ -75,6 +75,6 @@
     /// <param name="stream">The stream from where to load the data.</param>
     /// <returns>The loaded object.</returns>
-    public static IStorable Load(Stream stream) {
-      return (IStorable)XmlParser.Deserialize(stream);
+    public static IItem Load(Stream stream) {
+      return (IItem)XmlParser.Deserialize(stream);
     }
 
Index: trunk/sources/HeuristicLab.Core/3.3/Scope.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/Scope.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/Scope.cs	(revision 2526)
@@ -217,15 +217,4 @@
     }
     /// <inheritdoc/>
-    public IScope GetScope(Guid guid) {
-      if (Guid == guid) return this;
-      else {
-        for (int i = 0; i < mySubScopes.Count; i++) {
-          IScope s = mySubScopes[i].GetScope(guid);
-          if (s != null) return s;
-        }
-      }
-      return null;
-    }
-    /// <inheritdoc/>
     public IScope GetScope(string name) {
       if (Name == name) return this;
@@ -260,14 +249,14 @@
 
     /// <inheritdoc/>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      Scope clone = (Scope)base.Clone(clonedObjects);
+    public override IItem Clone(ICloner cloner) {
+      Scope clone = (Scope)base.Clone(cloner);
       clone.myName = Name;
 
       foreach (IVariable variable in myVariables.Values)
-        clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
+        clone.AddVariable((IVariable)cloner.Clone(variable));
       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));
+        clone.AddSubScope((IScope)cloner.Clone(SubScopes[i]));
 
       return clone;
Index: trunk/sources/HeuristicLab.Core/3.3/StorableBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/StorableBase.cs	(revision 2525)
+++ 	(revision )
@@ -1,70 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Xml;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Core {
-  /// <summary>
-  /// The base class for all storable objects.
-  /// </summary>
-  public abstract class StorableBase : IStorable {
-
-    [Storable]
-    private Guid myGuid;
-    /// <summary>
-    /// Gets the Guid of the item.
-    /// </summary>
-    public Guid Guid {
-      get { return myGuid; }
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the class <see cref="StorableBase"/> with a new <see cref="Guid"/>. 
-    /// </summary>
-    protected StorableBase() {
-      myGuid = Guid.NewGuid();
-    }
-
-    /// <summary>
-    /// Clones the current instance (deep clone).
-    /// </summary>
-    /// <remarks>Uses the <see cref="Auxiliary.Clone"/> method of the class <see cref="Auxiliary"/>.</remarks>
-    /// <returns>The clone.</returns>
-    public object Clone() {
-      return Auxiliary.Clone(this, new Dictionary<Guid, object>());
-    }
-    /// <summary>
-    /// Clones the current instance with the <see cref="M:Activator.CreateInstance"/> 
-    /// method of <see cref="Activator"/>.
-    /// </summary>
-    /// <param name="clonedObjects">All already cloned objects.</param>
-    /// <returns>The clone.</returns>
-    public virtual object Clone(IDictionary<Guid, object> clonedObjects) {
-      object clone = Activator.CreateInstance(this.GetType());
-      clonedObjects.Add(Guid, clone);
-      return clone;
-    }
-  }
-}
Index: trunk/sources/HeuristicLab.Core/3.3/Variable.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/Variable.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/Variable.cs	(revision 2526)
@@ -95,10 +95,10 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="Variable"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       Variable clone = new Variable();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       clone.myName = Name;
       if (Value != null)
-        clone.myValue = (IItem)Auxiliary.Clone(Value, clonedObjects);
+        clone.myValue = (IItem)cloner.Clone(Value);
       return clone;
     }
Index: trunk/sources/HeuristicLab.Core/3.3/VariableInfo.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/VariableInfo.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Core/3.3/VariableInfo.cs	(revision 2526)
@@ -136,7 +136,7 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="VariableInfo"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       VariableInfo clone = new VariableInfo();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       clone.myActualName = ActualName;
       clone.myFormalName = FormalName;
Index: trunk/sources/HeuristicLab.Data/3.3/BoolData.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/BoolData.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Data/3.3/BoolData.cs	(revision 2526)
@@ -63,7 +63,7 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects.</param>
     /// <returns>The cloned instance as <see cref="BoolData"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       BoolData clone = new BoolData();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       clone.Data = Data;
       return clone;
Index: trunk/sources/HeuristicLab.Data/3.3/DoubleData.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/DoubleData.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Data/3.3/DoubleData.cs	(revision 2526)
@@ -64,7 +64,7 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects.</param>
     /// <returns>The cloned instance as <see cref="DoubleData"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       DoubleData clone = new DoubleData();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       clone.Data = Data;
       return clone;
Index: trunk/sources/HeuristicLab.Data/3.3/IntData.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/IntData.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Data/3.3/IntData.cs	(revision 2526)
@@ -64,7 +64,7 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects.</param>
     /// <returns>The cloned instance as <see cref="IntData"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       IntData clone = new IntData();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       clone.Data = Data;
       return clone;
Index: trunk/sources/HeuristicLab.Data/3.3/ItemDictionary_T.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/ItemDictionary_T.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Data/3.3/ItemDictionary_T.cs	(revision 2526)
@@ -46,9 +46,9 @@
     /// <param name="clonedObjects">A dictionary of all already cloned objects.</param>
     /// <returns>The cloned instance as <see cref="ItemDictionary&lt;K,V&gt;"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       ItemDictionary<K,V> clone = new ItemDictionary<K,V>();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       foreach (KeyValuePair<K, V> item in dict) {
-        clone.dict.Add((K) Auxiliary.Clone(item.Key, clonedObjects), (V) Auxiliary.Clone(item.Value, clonedObjects));
+        clone.dict.Add((K) cloner.Clone(item.Key), (V) cloner.Clone(item.Value));
       }
       return clone;
@@ -300,5 +300,5 @@
           return ((IObjectData) obj).Data.GetHashCode(); 
         }
-        return obj.Guid.GetHashCode(); 
+        return obj.GetHashCode(); 
       }
     }
Index: trunk/sources/HeuristicLab.Data/3.3/ItemList.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/ItemList.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Data/3.3/ItemList.cs	(revision 2526)
@@ -37,8 +37,8 @@
     /// <param name="clonedObjects">A dictionary of all already cloned objects.</param>
     /// <returns>The cloned instance as <see cref="ItemList"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       ItemList clone = new ItemList();
-      clonedObjects.Add(Guid, clone);
-      base.CloneElements(clone, clonedObjects);
+      cloner.RegisterClonedObject(this, clone);
+      base.CloneElements(cloner, clone);
       return clone;
     }
Index: trunk/sources/HeuristicLab.Data/3.3/ItemList_T.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/ItemList_T.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Data/3.3/ItemList_T.cs	(revision 2526)
@@ -52,8 +52,8 @@
     /// <param name="clonedObjects">A dictionary of all already cloned objects.</param>
     /// <returns>The cloned instance as <see cref="ItemList&lt;T&gt;"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       ItemList<T> clone = new ItemList<T>();
-      clonedObjects.Add(Guid, clone);
-      CloneElements(clone, clonedObjects);
+      cloner.RegisterClonedObject(this, clone);
+      CloneElements(cloner, clone);
       return clone;
     }
@@ -66,7 +66,7 @@
     /// <param name="destination">The <see cref="ItemList&lt;T&gt;"/> where to save the cloned objects.</param>
     /// <param name="clonedObjects">A dictionary of all already cloned objects.</param>
-    protected void CloneElements(ItemList<T> destination, IDictionary<Guid, object> clonedObjects) {
+    protected void CloneElements(ICloner cloner, ItemList<T> destination) {
       for (int i = 0; i < list.Count; i++)
-        destination.list.Add((T) Auxiliary.Clone(list[i], clonedObjects));
+        destination.list.Add((T)cloner.Clone(list[i]));
     }
 
Index: trunk/sources/HeuristicLab.Data/3.3/NullData.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/NullData.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Data/3.3/NullData.cs	(revision 2526)
@@ -55,7 +55,7 @@
     /// <param name="clonedObjects">All already cloned objects.</param>
     /// <returns>The cloned instance as <see cref="NullData"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       NullData clone = new NullData();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       return clone;
     }
Index: trunk/sources/HeuristicLab.Data/3.3/ObjectData.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/ObjectData.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Data/3.3/ObjectData.cs	(revision 2526)
@@ -52,5 +52,5 @@
     /// Clones the current instance.
     /// </summary>
-    /// <remarks>HeuristicLab data items are cloned with the <see cref="HeuristicLab.Core.Auxiliary.Clone"/> method of 
+    /// <remarks>HeuristicLab data items are cloned with the <see cref="HeuristicLab.Core.cloner.Clone"/> method of 
     /// class <see cref="Auxiliary"/> (deep copy), all other items (like basic data types) 
     /// are cloned with their own <c>Clone</c> methods (shadow copy).</remarks>
@@ -58,8 +58,8 @@
     /// <param name="clonedObjects">A dictionary of all already cloned objects.</param>
     /// <returns>The clone instance.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      ObjectData clone = (ObjectData)base.Clone(clonedObjects);
-      if (Data is IStorable)
-        clone.myData = Auxiliary.Clone((IStorable)Data, clonedObjects);
+    public override IItem Clone(ICloner cloner) {
+      ObjectData clone = (ObjectData)base.Clone(cloner);
+      if (Data is IItem)
+        clone.myData = cloner.Clone((IItem)Data);
       else if (Data is ICloneable)
         clone.myData = ((ICloneable)Data).Clone();
Index: trunk/sources/HeuristicLab.Data/3.3/StringData.cs
===================================================================
--- trunk/sources/HeuristicLab.Data/3.3/StringData.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Data/3.3/StringData.cs	(revision 2526)
@@ -64,7 +64,7 @@
     /// <param name="clonedObjects">A dictionary of all already cloned objects.</param>
     /// <returns>The coned instance as <see cref="StringData"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       StringData clone = new StringData();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       clone.Data = Data;
       return clone;
Index: trunk/sources/HeuristicLab.Logging/3.3/Linechart.cs
===================================================================
--- trunk/sources/HeuristicLab.Logging/3.3/Linechart.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Logging/3.3/Linechart.cs	(revision 2526)
@@ -85,12 +85,12 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <remarks>Deep clone through <see cref="cloner.Clone"/> method of helper class 
     /// <see cref="Auxiliary"/>.</remarks>
     /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="Linechart"/>.</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);
+    public override IItem Clone(ICloner cloner) {
+      Linechart clone = (Linechart)base.Clone(cloner);
+      clone.myNumberOfLines = (IntData)cloner.Clone(myNumberOfLines);
+      clone.myValues = (ItemList)cloner.Clone(Values);
       return clone;
     }
Index: trunk/sources/HeuristicLab.Logging/3.3/Log.cs
===================================================================
--- trunk/sources/HeuristicLab.Logging/3.3/Log.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Logging/3.3/Log.cs	(revision 2526)
@@ -59,11 +59,11 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <remarks>Deep clone through <see cref="cloner.Clone"/> method of helper class 
     /// <see cref="Auxiliary"/>.</remarks>
     /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="Log"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      Log clone = (Log)base.Clone(clonedObjects);
-      clone.myItems = (ItemList)Auxiliary.Clone(Items, clonedObjects);
+    public override IItem Clone(ICloner cloner) {
+      Log clone = (Log)base.Clone(cloner);
+      clone.myItems = (ItemList)cloner.Clone(Items);
       return clone;
     }
Index: trunk/sources/HeuristicLab.Logging/3.3/PointXYChart.cs
===================================================================
--- trunk/sources/HeuristicLab.Logging/3.3/PointXYChart.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Logging/3.3/PointXYChart.cs	(revision 2526)
@@ -87,11 +87,11 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <remarks>Deep clone through <see cref="cloner.Clone"/> method of helper class 
     /// <see cref="Auxiliary"/>.</remarks>
     /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="PointXYChart"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      PointXYChart clone = (PointXYChart)base.Clone(clonedObjects);
-      clone.myValues = (ItemList)Auxiliary.Clone(Values, clonedObjects);
+    public override IItem Clone(ICloner cloner) {
+      PointXYChart clone = (PointXYChart)base.Clone(cloner);
+      clone.myValues = (ItemList)cloner.Clone(Values);
       return clone;
     }
Index: trunk/sources/HeuristicLab.Operators.Programmable/3.3/ProgrammableOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators.Programmable/3.3/ProgrammableOperator.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Operators.Programmable/3.3/ProgrammableOperator.cs	(revision 2526)
@@ -149,6 +149,6 @@
     }
 
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      ProgrammableOperator clone = (ProgrammableOperator)base.Clone(clonedObjects);
+    public override IItem Clone(ICloner cloner) {
+      ProgrammableOperator clone = (ProgrammableOperator)base.Clone(cloner);
       clone.myDescription = Description;
       clone.myCode = Code;
Index: trunk/sources/HeuristicLab.Operators/3.3/CombinedOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/CombinedOperator.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Operators/3.3/CombinedOperator.cs	(revision 2526)
@@ -87,12 +87,12 @@
     /// (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 
+    /// Deep clone through <see cref="cloner.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 override object Clone(IDictionary<Guid, object> clonedObjects) {
-      CombinedOperator clone = (CombinedOperator)base.Clone(clonedObjects);
+    public override IItem Clone(ICloner cloner) {
+      CombinedOperator clone = (CombinedOperator)base.Clone(cloner);
       clone.myDescription = Description;
-      clone.myOperatorGraph = (IOperatorGraph)Auxiliary.Clone(OperatorGraph, clonedObjects);
+      clone.myOperatorGraph = (IOperatorGraph)cloner.Clone(OperatorGraph);
       return clone;
     }
Index: trunk/sources/HeuristicLab.Operators/3.3/DelegatingOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/DelegatingOperator.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Operators/3.3/DelegatingOperator.cs	(revision 2526)
@@ -31,4 +31,20 @@
   /// </summary>
   public abstract class DelegatingOperator : OperatorBase {
+    private Guid myGuid;
+    protected Guid Guid {
+      get { return myGuid; }
+    }
+
+    protected DelegatingOperator()
+      : base() {
+      myGuid = Guid.NewGuid();
+    }
+
+    public override IItem Clone(ICloner cloner) {
+      DelegatingOperator clone = (DelegatingOperator)base.Clone(cloner);
+      clone.myGuid = Guid;
+      return clone;
+    }
+
     /// <summary>
     /// Executes the specified operator in the given <paramref name="scope"/>.
Index: trunk/sources/HeuristicLab.Operators/3.3/VariableInjector.cs
===================================================================
--- trunk/sources/HeuristicLab.Operators/3.3/VariableInjector.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Operators/3.3/VariableInjector.cs	(revision 2526)
@@ -53,14 +53,14 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Deep clone performed with <see cref="Auxiliary.Clone"/> of helper class
+    /// <remarks>Deep clone performed with <see cref="cloner.Clone"/> 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="VariableInjector"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       VariableInjector clone = new VariableInjector();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       clone.Name = Name;
       foreach (IVariable variable in Variables)
-        clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
+        clone.AddVariable((IVariable)cloner.Clone(variable));
       return clone;
     }
Index: trunk/sources/HeuristicLab.Permutation/3.3/Permutation.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Permutation.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Permutation.cs	(revision 2526)
@@ -24,4 +24,5 @@
 using System.Text;
 using System.Xml;
+using HeuristicLab.Core;
 using HeuristicLab.Data;
 
@@ -52,7 +53,7 @@
     /// avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="Permutation"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       Permutation clone = new Permutation((int[])Data.Clone());
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       return clone;
     }
Index: trunk/sources/HeuristicLab.Random/3.3/MersenneTwister.cs
===================================================================
--- trunk/sources/HeuristicLab.Random/3.3/MersenneTwister.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Random/3.3/MersenneTwister.cs	(revision 2526)
@@ -84,7 +84,7 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="MersenneTwister"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       MersenneTwister clone = new MersenneTwister();
-      clonedObjects.Add(Guid, clone);
+      cloner.RegisterClonedObject(this, clone);
       clone.state = (uint[])state.Clone();
       clone.p = p;
Index: trunk/sources/HeuristicLab.Random/3.3/NormalDistributedRandom.cs
===================================================================
--- trunk/sources/HeuristicLab.Random/3.3/NormalDistributedRandom.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Random/3.3/NormalDistributedRandom.cs	(revision 2526)
@@ -557,11 +557,11 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <remarks>Deep clone through <see cref="cloner.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="NormalDistributedRandom"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      NormalDistributedRandom clone = new NormalDistributedRandom((IRandom)Auxiliary.Clone(uniform, clonedObjects), mu, sigma);
-      clonedObjects.Add(Guid, clone);
+    public override IItem Clone(ICloner cloner) {
+      NormalDistributedRandom clone = new NormalDistributedRandom((IRandom)cloner.Clone(uniform), mu, sigma);
+      cloner.RegisterClonedObject(this, clone);
       return clone;
     }
Index: trunk/sources/HeuristicLab.Routing.TSP/3.3/TSPTour.cs
===================================================================
--- trunk/sources/HeuristicLab.Routing.TSP/3.3/TSPTour.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.Routing.TSP/3.3/TSPTour.cs	(revision 2526)
@@ -74,11 +74,11 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Uses <see cref="Auxiliary.Clone"/> method of class <see cref="Auxiliary"/> to clone
+    /// <remarks>Uses <see cref="cloner.Clone"/> method of class <see cref="Auxiliary"/> to clone
     /// the coordinates.</remarks>
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="TSPTour"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      TSPTour clone = (TSPTour)base.Clone(clonedObjects);
-      clone.myCoordinates = (DoubleMatrixData)Auxiliary.Clone(Coordinates, clonedObjects);
+    public override IItem Clone(ICloner cloner) {
+      TSPTour clone = (TSPTour)base.Clone(cloner);
+      clone.myCoordinates = (DoubleMatrixData)cloner.Clone(Coordinates);
       clone.myTour = Tour;
       return clone;
Index: trunk/sources/HeuristicLab.SGA/3.3/SGA.cs
===================================================================
--- trunk/sources/HeuristicLab.SGA/3.3/SGA.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.SGA/3.3/SGA.cs	(revision 2526)
@@ -462,5 +462,5 @@
       set {
         value.Name = "ProblemInjector";
-        mySGA.OperatorGraph.RemoveOperator(ProblemInjector.Guid);
+        mySGA.OperatorGraph.RemoveOperator(ProblemInjector);
         mySGA.OperatorGraph.AddOperator(value);
         myVariableInjection.AddSubOperator(value, 0);
@@ -477,5 +477,5 @@
       set {
         value.Name = "SolutionGenerator";
-        mySGA.OperatorGraph.RemoveOperator(SolutionGenerator.Guid);
+        mySGA.OperatorGraph.RemoveOperator(SolutionGenerator);
         mySGA.OperatorGraph.AddOperator(value);
         myPopulationInitialization.AddSubOperator(value, 0);
@@ -490,5 +490,5 @@
       set {
         value.Name = "Evaluator";
-        mySGA.OperatorGraph.RemoveOperator(Evaluator.Guid);
+        mySGA.OperatorGraph.RemoveOperator(Evaluator);
         mySGA.OperatorGraph.AddOperator(value);
         myPopulationInitialization.AddSubOperator(value, 1);
@@ -507,5 +507,5 @@
       set {
         value.Name = "Selector";
-        mySGA.OperatorGraph.RemoveOperator(Selector.Guid);
+        mySGA.OperatorGraph.RemoveOperator(Selector);
         mySGA.OperatorGraph.AddOperator(value);
         mySGAMain.AddSubOperator(value, 0);
@@ -520,5 +520,5 @@
       set {
         value.Name = "Crossover";
-        mySGA.OperatorGraph.RemoveOperator(Crossover.Guid);
+        mySGA.OperatorGraph.RemoveOperator(Crossover);
         mySGA.OperatorGraph.AddOperator(value);
         mySGAMain.AddSubOperator(value, 1);
@@ -533,5 +533,5 @@
       set {
         value.Name = "Mutator";
-        mySGA.OperatorGraph.RemoveOperator(Mutator.Guid);
+        mySGA.OperatorGraph.RemoveOperator(Mutator);
         mySGA.OperatorGraph.AddOperator(value);
         mySGAMain.AddSubOperator(value, 2);
@@ -552,12 +552,12 @@
     /// Clones the current instance (deep clone).
     /// </summary>
-    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
+    /// <remarks>Deep clone through <see cref="cloner.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="SGA"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+    public override IItem Clone(ICloner cloner) {
       SGA clone = new SGA();
-      clonedObjects.Add(Guid, clone);
-      clone.myEngine = (IEngine)Auxiliary.Clone(Engine, clonedObjects);
+      cloner.RegisterClonedObject(this, clone);
+      clone.myEngine = (IEngine)cloner.Clone(Engine);
       return clone;
     }
Index: trunk/sources/HeuristicLab.ThreadParallelEngine/3.3/ThreadParallelEngine.cs
===================================================================
--- trunk/sources/HeuristicLab.ThreadParallelEngine/3.3/ThreadParallelEngine.cs	(revision 2525)
+++ trunk/sources/HeuristicLab.ThreadParallelEngine/3.3/ThreadParallelEngine.cs	(revision 2526)
@@ -73,6 +73,6 @@
     /// <inheritdoc/>
     /// <returns>The cloned object as <see cref="ThreadParallelEngine"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      ThreadParallelEngine clone = (ThreadParallelEngine)base.Clone(clonedObjects);
+    public override IItem Clone(ICloner cloner) {
+      ThreadParallelEngine clone = (ThreadParallelEngine)base.Clone(cloner);
       clone.myWorkers = Workers;
       return clone;
