Changeset 4662 for branches/CloningRefactoring/HeuristicLab.Operators

Timestamp:

10/29/10 15:59:12 (14 years ago)

Author:

abeham

Message:

#922

• Refactored HeuristicLab.Data
• Refactored HeuristicLab.Operators

Location:

branches/CloningRefactoring/HeuristicLab.Operators/3.3

Files:

• AlgorithmOperator.cs (modified) (1 diff)
• Assigner.cs (modified) (2 diffs)
• CheckedMultiOperator.cs (modified) (3 diffs)
• CombinedOperator.cs (modified) (1 diff)
• Comparator.cs (modified) (3 diffs)
• ConditionalBranch.cs (modified) (3 diffs)
• DoubleCounter.cs (modified) (2 diffs)
• EmptyOperator.cs (modified) (2 diffs)
• IntCounter.cs (modified) (2 diffs)
• MultiOperator.cs (modified) (3 diffs)
• Operator.cs (modified) (2 diffs)
• Placeholder.cs (modified) (2 diffs)
• ScopeCleaner.cs (modified) (2 diffs)
• SingleSuccessorOperator.cs (modified) (2 diffs)
• StochasticBranch.cs (modified) (3 diffs)
• StochasticMultiBranch.cs (modified) (3 diffs)
• SubScopesCreator.cs (modified) (2 diffs)
• SubScopesMixer.cs (modified) (3 diffs)
• SubScopesProcessor.cs (modified) (2 diffs)
• SubScopesRemover.cs (modified) (3 diffs)
• SubScopesSorter.cs (modified) (3 diffs)
• UniformSubScopesProcessor.cs (modified) (3 diffs)
• ValuesCollector.cs (modified) (2 diffs)
• VariableCreator.cs (modified) (2 diffs)

branches/CloningRefactoring/HeuristicLab.Operators/3.3/AlgorithmOperator.cs

@@ -44 +44 @@
     }
 
+    [StorableConstructor]
+    protected AlgorithmOperator(bool deserializing) : base(deserializing) { }
+    protected AlgorithmOperator(AlgorithmOperator original, Cloner cloner)
+      : base(original, cloner) {
+      this.operatorGraph = cloner.Clone<OperatorGraph>(original.operatorGraph);
+    }
     protected AlgorithmOperator()
       : base() {
       operatorGraph = new OperatorGraph();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      AlgorithmOperator clone = (AlgorithmOperator)base.Clone(cloner);
-      clone.operatorGraph = (OperatorGraph)cloner.Clone(operatorGraph);
-      return clone;
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/Assigner.cs

@@ -23 +23 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -38 +39 @@
     }
 
+    [StorableConstructor]
+    private Assigner(bool deserializing) : base(deserializing) { }
+    private Assigner(Assigner original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public Assigner()
       : base() {
       Parameters.Add(new LookupParameter<IItem>("LeftSide", "The parameter whose value gets assigned with a clone of the other parameter's value."));
       Parameters.Add(new ValueLookupParameter<IItem>("RightSide", "The parameter whose value is cloned and assigned to the value of the other parameter."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Assigner(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/CheckedMultiOperator.cs

@@ -22 +22 @@
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -37 +38 @@
       protected set { base.Operators = value; }
     }
+
+    [StorableConstructor]
+    protected CheckedMultiOperator(bool deserializing) : base(deserializing) { }
+    protected CheckedMultiOperator(CheckedMultiOperator<T> original, Cloner cloner)
+      : base(original, cloner) {
+    }
     /// <summary>
     /// Creates a new instance of CheckedMultiOperator
@@ -44 +51 @@
       Operators = new CheckedItemList<T>();
     }
-    [StorableConstructor]
-    protected CheckedMultiOperator(bool deserializing) : base(deserializing) { }
   }
 }

branches/CloningRefactoring/HeuristicLab.Operators/3.3/CombinedOperator.cs

@@ -43 +43 @@
     }
 
+    [StorableConstructor]
+    private CombinedOperator(bool deserializing) : base(deserializing) { }
+    private CombinedOperator(CombinedOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public CombinedOperator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CombinedOperator(this, cloner);
+    }
   }
 }

branches/CloningRefactoring/HeuristicLab.Operators/3.3/Comparator.cs

@@ -25 +25 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -50 +51 @@
     }
 
+    [StorableConstructor]
+    private Comparator(bool deserializing) : base(deserializing) { }
+    private Comparator(Comparator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public Comparator()
       : base() {
@@ -56 +62 @@
       Parameters.Add(new ValueParameter<Comparison>("Comparison", "The type of comparison.", new Comparison(Data.ComparisonType.Equal)));
       Parameters.Add(new LookupParameter<BoolValue>("Result", "The result of the comparison."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Comparator(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/ConditionalBranch.cs

@@ -24 +24 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -50 +51 @@
     }
 
+    [StorableConstructor]
+    protected ConditionalBranch(bool deserializing) : base(deserializing) { }
+    protected ConditionalBranch(ConditionalBranch original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public ConditionalBranch()
       : base() {
@@ -55 +61 @@
       Parameters.Add(new OperatorParameter("TrueBranch", "The operator which is executed if the condition is true."));
       Parameters.Add(new OperatorParameter("FalseBranch", "The operator which is executed if the condition is false."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ConditionalBranch(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/DoubleCounter.cs

@@ -24 +24 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -43 +44 @@
     }
 
+    [StorableConstructor]
+    private DoubleCounter(bool deserializing) : base(deserializing) { }
+    private DoubleCounter(DoubleCounter original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public DoubleCounter()
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Value", "The value which should be incremented."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>("Increment", "The increment which is added to the value.", new DoubleValue(1)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DoubleCounter(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/EmptyOperator.cs

@@ -22 +22 @@
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -30 +31 @@
   [StorableClass]
   public sealed class EmptyOperator : SingleSuccessorOperator {
+    [StorableConstructor]
+    private EmptyOperator(bool deserializing) : base(deserializing) { }
+    private EmptyOperator(EmptyOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public EmptyOperator()
       : base() {
     }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EmptyOperator(this, cloner);
+    }
   }
 }

branches/CloningRefactoring/HeuristicLab.Operators/3.3/IntCounter.cs

@@ -24 +24 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -43 +44 @@
     }
 
+    [StorableConstructor]
+    private IntCounter(bool deserializing) : base(deserializing) { }
+    private IntCounter(IntCounter original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public IntCounter()
       : base() {
       Parameters.Add(new LookupParameter<IntValue>("Value", "The value which should be incremented."));
       Parameters.Add(new ValueLookupParameter<IntValue>("Increment", "The increment which is added to the value.", new IntValue(1)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntCounter(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/MultiOperator.cs

@@ -51 +51 @@
     }
 
+    [StorableConstructor]
+    protected MultiOperator(bool deserializing) : base(deserializing) { }
+    protected MultiOperator(MultiOperator<T> original, Cloner cloner)
+      : base(original, cloner) {
+      this.operators = cloner.Clone<IItemList<T>>(original.operators);
+      Initialize();
+    }
     public MultiOperator()
       : base() {
@@ -57 +64 @@
     }
 
-    [StorableConstructor]
-    protected MultiOperator(bool deserializing) : base(deserializing) { }
-
     [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+    
     private void Initialize() {
       if (operators != null) RegisterOperatorsEvents();
@@ -69 +77 @@
         opParam.ValueChanged += new EventHandler(opParam_ValueChanged);
       }
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      MultiOperator<T> clone = (MultiOperator<T>)base.Clone(cloner);
-      clone.operators = (IItemList<T>)cloner.Clone(operators);
-      clone.Initialize();
-      return clone;
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/Operator.cs

@@ -85 +85 @@
     }
 
+    [StorableConstructor]
+    protected Operator(bool deserializing) : base(deserializing) { }
+    protected Operator(Operator original, Cloner cloner)
+      : base(original, cloner) {
+      this.canceled = original.canceled;
+      this.breakpoint = original.breakpoint;
+      this.executionContext = cloner.Clone<IExecutionContext>(original.executionContext);
+    }
     /// <summary>
     /// Initializes a new instance of <see cref="OperatorBase"/> setting the breakpoint flag and 
@@ -113 +121 @@
       canceled = false;
       breakpoint = false;
-    }
-    [StorableConstructor]
-    protected Operator(bool deserializing) : base(deserializing) { }
-
-    /// <summary>
-    /// Clones the current instance (deep clone).
-    /// </summary>
-    /// <remarks>Clones also sub operators, variables and variable infos.</remarks>
-    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
-    /// <returns>The cloned object as <see cref="OperatorBase"/>.</returns>
-    public override IDeepCloneable Clone(Cloner cloner) {
-      Operator clone = (Operator)base.Clone(cloner);
-      clone.canceled = canceled;
-      clone.breakpoint = breakpoint;
-      clone.executionContext = (IExecutionContext)cloner.Clone(executionContext);
-      return clone;
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/Placeholder.cs

@@ -23 +23 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -35 +36 @@
     }
 
+    [StorableConstructor]
+    private Placeholder(bool deserializing) : base(deserializing) { }
+    private Placeholder(Placeholder original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public Placeholder()
       : base() {
       Parameters.Add(new LookupParameter<IOperator>("Operator", "The operator which is retrieved from the scope or a parent execution context and applied on the current scope."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Placeholder(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/ScopeCleaner.cs

@@ -23 +23 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -38 +39 @@
     }
 
+    [StorableConstructor]
+    private ScopeCleaner(bool deserializing) : base(deserializing) { }
+    private ScopeCleaner(ScopeCleaner original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public ScopeCleaner()
       : base() {
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope whose variables and sub-scopes should be removed."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ScopeCleaner(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/SingleSuccessorOperator.cs

@@ -23 +23 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -39 +40 @@
     }
 
+    [StorableConstructor]
+    protected SingleSuccessorOperator(bool deserializing) : base(deserializing) { }
+    protected SingleSuccessorOperator(SingleSuccessorOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public SingleSuccessorOperator()
       : base() {
       Parameters.Add(new OperatorParameter("Successor", "Operator which is executed next."));
     }
-    [StorableConstructor]
-    protected SingleSuccessorOperator(bool deserializing) : base(deserializing) { }
-
+    
     public override IOperation Apply() {
       if (Successor != null)

branches/CloningRefactoring/HeuristicLab.Operators/3.3/StochasticBranch.cs

@@ -24 +24 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -53 +54 @@
     }
 
+    [StorableConstructor]
+    protected StochasticBranch(bool deserializing) : base(deserializing) { }
+    protected StochasticBranch(StochasticBranch original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public StochasticBranch()
       : base() {
@@ -59 +65 @@
       Parameters.Add(new OperatorParameter("FirstBranch", "The operator which is executed with the given probability."));
       Parameters.Add(new OperatorParameter("SecondBranch", "The operator which is executed if the first branch is not executed."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticBranch(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/StochasticMultiBranch.cs

@@ -28 +28 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -56 +57 @@
     [StorableConstructor]
     protected StochasticMultiBranch(bool deserializing) : base(deserializing) { }
+    protected StochasticMultiBranch(StochasticMultiBranch<T> original, Cloner cloner)
+      : base(original, cloner) {
+    }
     /// <summary>
     /// Initializes a new instance of <see cref="StochasticMultiOperator"/> with two parameters
@@ -143 +147 @@
   [StorableClass]
   public class StochasticMultiBranch : StochasticMultiBranch<IOperator> {
+    [StorableConstructor]
+    protected StochasticMultiBranch(bool deserializing) : base(deserializing) { }
+    protected StochasticMultiBranch(StochasticMultiBranch original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public StochasticMultiBranch() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticMultiBranch(this, cloner);
+    }
+
     protected override bool CreateChildOperation {
       get { return false; }

branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesCreator.cs

@@ -24 +24 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -42 +43 @@
     }
 
+    [StorableConstructor]
+    protected SubScopesCreator(bool deserializing) : base(deserializing) { }
+    protected SubScopesCreator(SubScopesCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public SubScopesCreator()
       : base() {
       Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfSubScopes", "The number of new and empty sub-scopes which should be added to the current scope."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope to which the new and empty sub-scopes are added."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SubScopesCreator(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesMixer.cs

@@ -25 +25 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -42 +43 @@
     }
 
+    [StorableConstructor]
+    protected SubScopesMixer(bool deserializing) : base(deserializing) { }
+    protected SubScopesMixer(SubScopesMixer original, Cloner cloner)
+      : base(original, cloner) {
+    }
     /// <summary>
     /// Initializes a new instance of <see cref="SubScopesMixer"/> with one variable infos 
@@ -49 +55 @@
       : base() {
       Parameters.Add(new ValueParameter<IntValue>("Partitions", "The number of equal-sized partitions.", new IntValue(2)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SubScopesMixer(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesProcessor.cs

@@ -27 +27 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -51 +52 @@
     }
 
+    [StorableConstructor]
+    private SubScopesProcessor(bool deserializing) : base(deserializing) { }
+    private SubScopesProcessor(SubScopesProcessor original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public SubScopesProcessor()
       : base() {
       Parameters.Add(new ValueLookupParameter<BoolValue>("Parallel", "True if the operators should be applied in parallel on the sub-scopes, otherwise false.", new BoolValue(false)));
       Parameters.Add(new ValueParameter<IntValue>("Depth", "The number of steps to descend in the scope tree before applying operator.", new IntValue(1)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SubScopesProcessor(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesRemover.cs

@@ -24 +24 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -50 +51 @@
     }
 
+    [StorableConstructor]
+    private SubScopesRemover(bool deserializing) : base(deserializing) { }
+    private SubScopesRemover(SubScopesRemover original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public SubScopesRemover()
       : base() {
@@ -55 +61 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("SubScopeIndex", "The index of the sub-scope which should be removed. This parameter is ignored, if RemoveAllSubScopes is true."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which one or all sub-scopes should be removed."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SubScopesRemover(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/SubScopesSorter.cs

@@ -24 +24 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -48 +49 @@
     }
 
+    [StorableConstructor]
+    private SubScopesSorter(bool deserializing) : base(deserializing) { }
+    private SubScopesSorter(SubScopesSorter original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public SubScopesSorter()
       : base() {
@@ -53 +59 @@
       Parameters.Add(new ValueLookupParameter<BoolValue>("Descending", "True if the sub-scopes should be sorted in descending order, otherwise false."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope whose sub-scopes are sorted."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SubScopesSorter(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/UniformSubScopesProcessor.cs

@@ -26 +26 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -57 +58 @@
     }
 
+    [StorableConstructor]
+    private UniformSubScopesProcessor(bool deserializing) : base(deserializing) { }
+    private UniformSubScopesProcessor(UniformSubScopesProcessor original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public UniformSubScopesProcessor()
       : base() {
@@ -62 +68 @@
       Parameters.Add(new ValueLookupParameter<BoolValue>("Parallel", "True if the operator should be applied in parallel on all sub-scopes, otherwise false.", new BoolValue(false)));
       Parameters.Add(new ValueParameter<IntValue>("Depth", "The number of steps to descend in the scope tree before applying operator.", new IntValue(1)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformSubScopesProcessor(this, cloner);
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/ValuesCollector.cs

@@ -38 +38 @@
     }
 
+    [StorableConstructor]
+    protected ValuesCollector(bool deserializing) : base(deserializing) { }
+    protected ValuesCollector(ValuesCollector original, Cloner cloner)
+      : base(original, cloner) {
+      this.collectedValues = cloner.Clone<ParameterCollection>(original.collectedValues);
+      Initialize();
+    }
     public ValuesCollector()
       : base() {
@@ -43 +50 @@
       Initialize();
     }
-    [StorableConstructor]
-    protected ValuesCollector(bool deserializing) : base(deserializing) { }
 
     [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+
     private void Initialize() {
       collectedValues.ItemsAdded += new CollectionItemsChangedEventHandler<IParameter>(collectedValues_ItemsAdded);
       collectedValues.ItemsRemoved += new CollectionItemsChangedEventHandler<IParameter>(collectedValues_ItemsRemoved);
       collectedValues.CollectionReset += new CollectionItemsChangedEventHandler<IParameter>(collectedValues_CollectionReset);
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      ValuesCollector clone = (ValuesCollector)base.Clone(cloner);
-      clone.collectedValues = (ParameterCollection)cloner.Clone(collectedValues);
-      clone.Initialize();
-      return clone;
     }
 

branches/CloningRefactoring/HeuristicLab.Operators/3.3/VariableCreator.cs

@@ -23 +23 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
 
 namespace HeuristicLab.Operators {
@@ -38 +39 @@
     }
 
+    [StorableConstructor]
+    protected VariableCreator(bool deserializing) : base(deserializing) { }
+    protected VariableCreator(VariableCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
     public VariableCreator()
       : base() {
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope into which the parameter values are cloned."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableCreator(this, cloner);
     }