Index: stable/HeuristicLab.Analysis/3.3/MultiAnalyzer.cs
===================================================================
--- stable/HeuristicLab.Analysis/3.3/MultiAnalyzer.cs	(revision 10505)
+++ stable/HeuristicLab.Analysis/3.3/MultiAnalyzer.cs	(revision 10507)
@@ -69,5 +69,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IntValue interval = UpdateIntervalParameter.ActualValue;
       if (interval == null) interval = new IntValue(1);
@@ -84,8 +84,8 @@
         foreach (IndexedItem<IAnalyzer> item in Operators.CheckedItems)
           next.Add(ExecutionContext.CreateOperation(item.Value));
-        next.Add(base.Apply());
+        next.Add(base.InstrumentedApply());
         return next;
       } else {
-        return base.Apply();
+        return base.InstrumentedApply();
       }
     }
Index: stable/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj
===================================================================
--- stable/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 10505)
+++ stable/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 10507)
@@ -150,4 +150,5 @@
     <Compile Include="Interfaces\ICheckedMultiOperator.cs" />
     <Compile Include="Interfaces\IConstrainedValueParameter.cs" />
+    <Compile Include="Interfaces\IInstrumentedOperator.cs" />
     <Compile Include="Interfaces\IMultiOperator.cs" />
     <Compile Include="Interfaces\IFixedValueParameter.cs" />
Index: stable/HeuristicLab.Core/3.3/Interfaces/IInstrumentedOperator.cs
===================================================================
--- stable/HeuristicLab.Core/3.3/Interfaces/IInstrumentedOperator.cs	(revision 10507)
+++ stable/HeuristicLab.Core/3.3/Interfaces/IInstrumentedOperator.cs	(revision 10507)
@@ -0,0 +1,32 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Collections;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Core {
+  public interface IInstrumentedOperator : IOperator {
+    IEnumerable<IOperator> BeforeExecutionOperators { get; }
+    IEnumerable<IOperator> AfterExecutionOperators { get; }
+  }
+}
Index: stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCreator.cs	(revision 10507)
@@ -34,5 +34,5 @@
   [Item("BinaryVectorCreator", "A base class for operators creating bool-valued vectors.")]
   [StorableClass]
-  public abstract class BinaryVectorCreator : SingleSuccessorOperator, IBinaryVectorCreator, IStochasticOperator {
+  public abstract class BinaryVectorCreator : InstrumentedOperator, IBinaryVectorCreator, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -58,7 +58,7 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       BinaryVectorParameter.ActualValue = Create(RandomParameter.ActualValue, LengthParameter.ActualValue);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCrossover.cs	(revision 10507)
@@ -33,5 +33,5 @@
   [Item("BinaryVectorCrossover", "A base class for operators that perform a crossover of bool-valued vectors.")]
   [StorableClass]
-  public abstract class BinaryVectorCrossover : SingleSuccessorOperator, IBinaryVectorCrossover, IStochasticOperator {
+  public abstract class BinaryVectorCrossover : InstrumentedOperator, IBinaryVectorCrossover, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -59,7 +59,7 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorManipulator.cs	(revision 10507)
@@ -33,5 +33,5 @@
   [Item("BinaryVectorManipulator", "A base class for operators that manipulate bool-valued vectors.")]
   [StorableClass]
-  public abstract class BinaryVectorManipulator : SingleSuccessorOperator, IBinaryVectorManipulator, IStochasticOperator {
+  public abstract class BinaryVectorManipulator : InstrumentedOperator, IBinaryVectorManipulator, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -53,7 +53,7 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       Manipulate(RandomParameter.ActualValue, BinaryVectorParameter.ActualValue);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Crossovers/MultiBinaryVectorCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Crossovers/MultiBinaryVectorCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Crossovers/MultiBinaryVectorCrossover.cs	(revision 10507)
@@ -90,7 +90,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one binary vector crossover to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/MultiIntegerVectorCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/MultiIntegerVectorCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/MultiIntegerVectorCrossover.cs	(revision 10507)
@@ -99,7 +99,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one integer vector crossover to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs	(revision 10507)
@@ -34,5 +34,5 @@
   [Item("IntegerVectorCreator", "A base class for operators creating int-valued vectors.")]
   [StorableClass]
-  public abstract class IntegerVectorCreator : SingleSuccessorOperator, IIntegerVectorCreator, IStochasticOperator {
+  public abstract class IntegerVectorCreator : InstrumentedOperator, IIntegerVectorCreator, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -79,7 +79,7 @@
     #endregion
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       IntegerVectorParameter.ActualValue = Create(RandomParameter.ActualValue, LengthParameter.ActualValue, BoundsParameter.ActualValue);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCrossover.cs	(revision 10507)
@@ -58,7 +58,7 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorManipulator.cs	(revision 10507)
@@ -52,7 +52,7 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       Manipulate(RandomParameter.ActualValue, IntegerVectorParameter.ActualValue);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorOperator.cs
===================================================================
--- stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorOperator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorOperator.cs	(revision 10507)
@@ -29,5 +29,5 @@
   [Item("IntegerVectorOperator", "Base class for integer vectoro operators.")]
   [StorableClass]
-  public abstract class IntegerVectorOperator : SingleSuccessorOperator, IIntegerVectorOperator {
+  public abstract class IntegerVectorOperator : InstrumentedOperator, IIntegerVectorOperator {
 
     [StorableConstructor]
Index: stable/HeuristicLab.Encodings.PermutationEncoding/3.3/Creators/RandomPermutationCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.PermutationEncoding/3.3/Creators/RandomPermutationCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.PermutationEncoding/3.3/Creators/RandomPermutationCreator.cs	(revision 10507)
@@ -34,5 +34,5 @@
   [Item("RandomPermutationCreator", "An operator which creates a new random permutation of integer values.")]
   [StorableClass]
-  public sealed class RandomPermutationCreator : SingleSuccessorOperator, IPermutationCreator, IStochasticOperator {
+  public sealed class RandomPermutationCreator : InstrumentedOperator, IPermutationCreator, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -72,7 +72,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       PermutationParameter.ActualValue = new Permutation(PermutationType, LengthParameter.ActualValue.Value, RandomParameter.ActualValue);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/MultiPermutationCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/MultiPermutationCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/MultiPermutationCrossover.cs	(revision 10507)
@@ -90,7 +90,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one permutation crossover to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Encodings.PermutationEncoding/3.3/Manipulators/MultiPermutationManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.PermutationEncoding/3.3/Manipulators/MultiPermutationManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.PermutationEncoding/3.3/Manipulators/MultiPermutationManipulator.cs	(revision 10507)
@@ -82,7 +82,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one permutation manipulator to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationCrossover.cs	(revision 10507)
@@ -33,5 +33,5 @@
   [Item("PermutationCrossover", "A base class for permutation crossover operators.")]
   [StorableClass]
-  public abstract class PermutationCrossover : SingleSuccessorOperator, IPermutationCrossover, IStochasticOperator {
+  public abstract class PermutationCrossover : InstrumentedOperator, IPermutationCrossover, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -60,7 +60,7 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationManipulator.cs	(revision 10507)
@@ -33,5 +33,5 @@
   [Item("PermutationManipulator", "A base class for permutation manipulation operators.")]
   [StorableClass]
-  public abstract class PermutationManipulator : SingleSuccessorOperator, IPermutationManipulator, IStochasticOperator {
+  public abstract class PermutationManipulator : InstrumentedOperator, IPermutationManipulator, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -54,7 +54,7 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       Manipulate(RandomParameter.ActualValue, PermutationParameter.ActualValue);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/MultiRealVectorCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/MultiRealVectorCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/MultiRealVectorCrossover.cs	(revision 10507)
@@ -97,7 +97,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one real vector crossover to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/MultiRealVectorManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/MultiRealVectorManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/MultiRealVectorManipulator.cs	(revision 10507)
@@ -88,7 +88,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one real vector manipulator to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCreator.cs	(revision 10507)
@@ -34,5 +34,5 @@
   [Item("RealVectorCreator", "A base class for operators creating real-valued vectors.")]
   [StorableClass]
-  public abstract class RealVectorCreator : SingleSuccessorOperator, IRealVectorCreator, IStochasticOperator {
+  public abstract class RealVectorCreator : InstrumentedOperator, IRealVectorCreator, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -63,7 +63,7 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       RealVectorParameter.ActualValue = Create(RandomParameter.ActualValue, LengthParameter.ActualValue, BoundsParameter.ActualValue);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCrossover.cs	(revision 10507)
@@ -35,5 +35,5 @@
   [Item("RealVectorCrossover", "A base class for operators that perform a crossover of real-valued vectors.")]
   [StorableClass]
-  public abstract class RealVectorCrossover : SingleSuccessorOperator, IRealVectorCrossover, IStochasticOperator {
+  public abstract class RealVectorCrossover : InstrumentedOperator, IRealVectorCrossover, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -96,9 +96,9 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       RealVector result = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
       ChildParameter.ActualValue = result;
 
-      IOperation successor = base.Apply();
+      IOperation successor = base.InstrumentedApply();
       if (BoundsChecker != null) {
         IOperation checkerOperation = ExecutionContext.CreateChildOperation(BoundsChecker);
Index: stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorManipulator.cs	(revision 10507)
@@ -35,5 +35,5 @@
   [Item("RealVectorManipulator", "A base class for operators that manipulate real-valued vectors.")]
   [StorableClass]
-  public abstract class RealVectorManipulator : SingleSuccessorOperator, IRealVectorManipulator, IStochasticOperator {
+  public abstract class RealVectorManipulator : InstrumentedOperator, IRealVectorManipulator, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -90,9 +90,9 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       RealVector vector = RealVectorParameter.ActualValue;
       Manipulate(RandomParameter.ActualValue, vector);
 
-      IOperation successor = base.Apply();
+      IOperation successor = base.InstrumentedApply();
       if (BoundsChecker != null) {
         IOperation checkerOperation = ExecutionContext.CreateChildOperation(BoundsChecker);
Index: stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Crossovers/JSMCrossover.cs	(revision 10507)
@@ -40,5 +40,5 @@
     public abstract JSMEncoding Cross(IRandom random, JSMEncoding parent1, JSMEncoding parent2);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var parents = ParentsParameter.ActualValue;
 
@@ -46,5 +46,5 @@
         Cross(RandomParameter.ActualValue, parents[0] as JSMEncoding, parents[1] as JSMEncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/JobSequenceMatrix/Manipulators/JSMManipulator.cs	(revision 10507)
@@ -39,9 +39,9 @@
     protected abstract void Manipulate(IRandom random, IScheduleEncoding individual);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = ScheduleEncodingParameter.ActualValue as JSMEncoding;
       if (solution == null) throw new InvalidOperationException("ScheduleEncoding was not found or is not of type JSMEncoding.");
       Manipulate(RandomParameter.ActualValue, solution);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Crossovers/PWRCrossover.cs	(revision 10507)
@@ -40,5 +40,5 @@
     public abstract PWREncoding Cross(IRandom random, PWREncoding parent1, PWREncoding parent2);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var parents = ParentsParameter.ActualValue;
 
@@ -46,5 +46,5 @@
         Cross(RandomParameter.ActualValue, parents[0] as PWREncoding, parents[1] as PWREncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Manipulators/PWRManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Manipulators/PWRManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PermutationWithRepetition/Manipulators/PWRManipulator.cs	(revision 10507)
@@ -40,9 +40,9 @@
     protected abstract void Manipulate(IRandom random, PWREncoding individual);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = ScheduleEncodingParameter.ActualValue as PWREncoding;
       if (solution == null) throw new InvalidOperationException("ScheduleEncoding was not found or is not of type PWREncoding.");
       Manipulate(RandomParameter.ActualValue, solution);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Crossovers/PRVCrossover.cs	(revision 10507)
@@ -40,9 +40,9 @@
     public abstract PRVEncoding Cross(IRandom random, PRVEncoding parent1, PRVEncoding parent2);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var parents = ParentsParameter.ActualValue;
       ChildParameter.ActualValue =
         Cross(RandomParameter.ActualValue, parents[0] as PRVEncoding, parents[1] as PRVEncoding);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Manipulators/PRVManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Manipulators/PRVManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/PriorityRulesVector/Manipulators/PRVManipulator.cs	(revision 10507)
@@ -39,9 +39,9 @@
     protected abstract void Manipulate(IRandom random, PRVEncoding individual);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = ScheduleEncodingParameter.ActualValue as PRVEncoding;
       if (solution == null) throw new InvalidOperationException("ScheduleEncoding was not found or is not of type PRVEncoding.");
       Manipulate(RandomParameter.ActualValue, solution);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleCreator.cs	(revision 10507)
@@ -29,5 +29,5 @@
   [Item("ScheduleCreator", "Represents the generalized form of creators for Scheduling Problems.")]
   [StorableClass]
-  public abstract class ScheduleCreator : SingleSuccessorOperator, IScheduleCreator {
+  public abstract class ScheduleCreator : InstrumentedOperator, IScheduleCreator {
 
     public ILookupParameter<IScheduleEncoding> ScheduleEncodingParameter {
@@ -43,7 +43,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       ScheduleEncodingParameter.ActualValue = CreateSolution();
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleCrossover.cs	(revision 10507)
@@ -30,5 +30,5 @@
   [Item("ScheduleCrossover", "A scheduling crossover operation.")]
   [StorableClass]
-  public abstract class ScheduleCrossover : SingleSuccessorOperator, IScheduleCrossover, IStochasticOperator {
+  public abstract class ScheduleCrossover : InstrumentedOperator, IScheduleCrossover, IStochasticOperator {
 
     public ILookupParameter<IScheduleEncoding> ChildParameter {
Index: stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Crossovers/DirectScheduleCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Crossovers/DirectScheduleCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Crossovers/DirectScheduleCrossover.cs	(revision 10507)
@@ -45,9 +45,9 @@
     public abstract Schedule Cross(IRandom random, Schedule parent1, Schedule parent2);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var parents = ParentsParameter.ActualValue;
       ChildParameter.ActualValue =
         Cross(RandomParameter.ActualValue, parents[0] as Schedule, parents[1] as Schedule);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Manipulators/DirectScheduleManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Manipulators/DirectScheduleManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleEncoding/Manipulators/DirectScheduleManipulator.cs	(revision 10507)
@@ -40,9 +40,9 @@
     protected abstract void Manipulate(IRandom random, Schedule individual);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var schedule = ScheduleEncodingParameter.ActualValue as Schedule;
       if (schedule == null) throw new InvalidOperationException("ScheduleEncoding was not found or is not of type Schedule.");
       Manipulate(RandomParameter.ActualValue, schedule);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.ScheduleEncoding/3.3/ScheduleManipulator.cs	(revision 10507)
@@ -30,5 +30,5 @@
   [Item("ScheduleManipulator", "A scheduling manipulation operation.")]
   [StorableClass]
-  public abstract class ScheduleManipulator : SingleSuccessorOperator, IScheduleManipulator, IStochasticOperator {
+  public abstract class ScheduleManipulator : InstrumentedOperator, IScheduleManipulator, IStochasticOperator {
 
     public ILookupParameter<IScheduleEncoding> ScheduleEncodingParameter {
Index: stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/FullTreeCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/FullTreeCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/FullTreeCreator.cs	(revision 10507)
@@ -94,5 +94,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (ClonedSymbolicExpressionTreeGrammarParameter.ActualValue == null) {
         SymbolicExpressionTreeGrammarParameter.ActualValue.ReadOnly = true;
@@ -104,5 +104,5 @@
           (ISymbolicExpressionGrammar)SymbolicExpressionTreeGrammarParameter.ActualValue.Clone()));
       }
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/GrowTreeCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/GrowTreeCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/GrowTreeCreator.cs	(revision 10507)
@@ -94,5 +94,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (ClonedSymbolicExpressionTreeGrammarParameter.ActualValue == null) {
         SymbolicExpressionTreeGrammarParameter.ActualValue.ReadOnly = true;
@@ -104,5 +104,5 @@
           (ISymbolicExpressionGrammar)SymbolicExpressionTreeGrammarParameter.ActualValue.Clone()));
       }
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs	(revision 10507)
@@ -87,5 +87,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (ClonedSymbolicExpressionTreeGrammarParameter.ActualValue == null) {
         SymbolicExpressionTreeGrammarParameter.ActualValue.ReadOnly = true;
@@ -96,5 +96,5 @@
         globalScope.Variables.Add(new Variable(ClonedSymbolicExpressionTreeGrammarParameterName, (ISymbolicExpressionGrammar)SymbolicExpressionTreeGrammarParameter.ActualValue.Clone()));
       }
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/RampedHalfAndHalfTreeCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/RampedHalfAndHalfTreeCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/RampedHalfAndHalfTreeCreator.cs	(revision 10507)
@@ -95,5 +95,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (ClonedSymbolicExpressionTreeGrammarParameter.ActualValue == null) {
         SymbolicExpressionTreeGrammarParameter.ActualValue.ReadOnly = true;
@@ -105,5 +105,5 @@
           (ISymbolicExpressionGrammar)SymbolicExpressionTreeGrammarParameter.ActualValue.Clone()));
       }
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/SymbolicExpressionTreeCreator.cs
===================================================================
--- stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/SymbolicExpressionTreeCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/SymbolicExpressionTreeCreator.cs	(revision 10507)
@@ -54,7 +54,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       SymbolicExpressionTree = Create(Random);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs
===================================================================
--- stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs	(revision 10507)
@@ -63,5 +63,5 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       if (Parents.Length != 2)
         throw new ArgumentException("Number of parents must be exactly two for symbolic expression tree crossover operators.");
@@ -70,5 +70,5 @@
 
       Child = result;
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/SymbolicExpressionTreeManipulator.cs
===================================================================
--- stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/SymbolicExpressionTreeManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/SymbolicExpressionTreeManipulator.cs	(revision 10507)
@@ -22,5 +22,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -55,9 +54,9 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       ISymbolicExpressionTree tree = SymbolicExpressionTreeParameter.ActualValue;
       Manipulate(RandomParameter.ActualValue, tree);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeOperator.cs
===================================================================
--- stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeOperator.cs	(revision 10505)
+++ stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeOperator.cs	(revision 10507)
@@ -34,5 +34,5 @@
   [Item("SymbolicExpressionTreeOperator", "A base class for operators for symbolic expression trees.")]
   [StorableClass]
-  public abstract class SymbolicExpressionTreeOperator : SingleSuccessorOperator, IStochasticOperator, ISymbolicExpressionTreeOperator {
+  public abstract class SymbolicExpressionTreeOperator : InstrumentedOperator, IStochasticOperator, ISymbolicExpressionTreeOperator {
     private const string RandomParameterName = "Random";
 
Index: stable/HeuristicLab.Operators/3.3/HeuristicLab.Operators-3.3.csproj
===================================================================
--- stable/HeuristicLab.Operators/3.3/HeuristicLab.Operators-3.3.csproj	(revision 10505)
+++ stable/HeuristicLab.Operators/3.3/HeuristicLab.Operators-3.3.csproj	(revision 10507)
@@ -113,4 +113,5 @@
     <Compile Include="CheckedMultiOperator.cs" />
     <Compile Include="CombinedOperator.cs" />
+    <Compile Include="Operator.InstrumentedOperatorWrapper.cs" />
     <None Include="Plugin.cs.frame" />
     <Compile Include="ConditionalBranch.cs" />
@@ -119,4 +120,5 @@
     <Compile Include="AlgorithmOperator.cs" />
     <Compile Include="DataReducer.cs" />
+    <Compile Include="InstrumentedOperator.cs" />
     <Compile Include="LocalRandomCreator.cs" />
     <Compile Include="MultiOperator.cs" />
@@ -220,5 +222,5 @@
   -->
   <PropertyGroup>
-   <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
 set ProjectDir=$(ProjectDir)
 set SolutionDir=$(SolutionDir)
@@ -227,5 +229,5 @@
 call PreBuildEvent.cmd
 </PreBuildEvent>
-<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
 export ProjectDir=$(ProjectDir)
 export SolutionDir=$(SolutionDir)
Index: stable/HeuristicLab.Operators/3.3/InstrumentedOperator.cs
===================================================================
--- stable/HeuristicLab.Operators/3.3/InstrumentedOperator.cs	(revision 10507)
+++ stable/HeuristicLab.Operators/3.3/InstrumentedOperator.cs	(revision 10507)
@@ -0,0 +1,114 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Operators {
+  [Item("InstrumentedOperator", "A operator that can execute pre- and post actions.")]
+  [StorableClass]
+  public abstract class InstrumentedOperator : SingleSuccessorOperator, IInstrumentedOperator {
+    private const string BeforeExecutionOperatorsParameterName = "BeforeExecutionOperators";
+    private const string AfterExecutionOperatorsParameterName = "AfterExecutionOperators";
+
+    private IFixedValueParameter<OperatorList> BeforeExecutionOperatorsParameter {
+      get { return (IFixedValueParameter<OperatorList>)Parameters[BeforeExecutionOperatorsParameterName]; }
+    }
+    private IFixedValueParameter<OperatorList> AfterExecutionOperatorsParameter {
+      get { return (IFixedValueParameter<OperatorList>)Parameters[AfterExecutionOperatorsParameterName]; }
+    }
+
+
+    IEnumerable<IOperator> IInstrumentedOperator.BeforeExecutionOperators { get { return BeforeExecutionOperators; } }
+    public OperatorList BeforeExecutionOperators {
+      get { return BeforeExecutionOperatorsParameter.Value; }
+    }
+    IEnumerable<IOperator> IInstrumentedOperator.AfterExecutionOperators { get { return AfterExecutionOperators; } }
+    public OperatorList AfterExecutionOperators {
+      get { return AfterExecutionOperatorsParameter.Value; }
+    }
+
+    [StorableConstructor]
+    protected InstrumentedOperator(bool deserializing) : base(deserializing) { }
+    protected InstrumentedOperator(InstrumentedOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    protected InstrumentedOperator()
+      : base() {
+      Parameters.Add(new FixedValueParameter<OperatorList>(BeforeExecutionOperatorsParameterName, "Actions that are executed before the execution of the operator", new OperatorList()));
+      Parameters.Add(new FixedValueParameter<OperatorList>(AfterExecutionOperatorsParameterName, "Actions that are executed after the execution of the operator", new OperatorList()));
+      BeforeExecutionOperatorsParameter.Hidden = true;
+      AfterExecutionOperatorsParameter.Hidden = true;
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // BackwardsCompatibility3.3
+      #region Backwards compatible code, remove with 3.4
+      if (!Parameters.ContainsKey(BeforeExecutionOperatorsParameterName)) {
+        Parameters.Add(new FixedValueParameter<OperatorList>(BeforeExecutionOperatorsParameterName, "Actions that are executed before the execution of the operator", new OperatorList()));
+        BeforeExecutionOperatorsParameter.Hidden = true;
+      }
+      if (!Parameters.ContainsKey(AfterExecutionOperatorsParameterName)) {
+        Parameters.Add(new FixedValueParameter<OperatorList>(AfterExecutionOperatorsParameterName, "Actions that are executed after the execution of the operator", new OperatorList()));
+        AfterExecutionOperatorsParameter.Hidden = true;
+      }
+      #endregion
+    }
+
+    public sealed override IOperation Apply() {
+      //to speed up the execution call instrumented apply directly if no before operators exists
+      if (!BeforeExecutionOperators.Any())
+        return InstrumentedApply();
+
+      //build before operations
+      var opCol = new OperationCollection();
+      foreach (var beforeAction in BeforeExecutionOperators) {
+        var beforeActionOperation = ExecutionContext.CreateChildOperation(beforeAction);
+        opCol.Add(beforeActionOperation);
+      }
+      //build operation for the instrumented apply
+      opCol.Add(CreateInstrumentedOperation(this));
+      return opCol;
+    }
+
+    public virtual IOperation InstrumentedApply() {
+      if (!AfterExecutionOperators.Any()) {
+        if (Successor != null) return ExecutionContext.CreateOperation(Successor);
+        return null;
+      }
+
+      var opCol = new OperationCollection();
+      foreach (var afterAction in AfterExecutionOperators) {
+        var afterActionOperation = ExecutionContext.CreateChildOperation(afterAction);
+        opCol.Add(afterActionOperation);
+      }
+
+      if (Successor != null)
+        opCol.Add(ExecutionContext.CreateOperation(Successor));
+      return opCol;
+    }
+  }
+}
Index: stable/HeuristicLab.Operators/3.3/MultiOperator.cs
===================================================================
--- stable/HeuristicLab.Operators/3.3/MultiOperator.cs	(revision 10505)
+++ stable/HeuristicLab.Operators/3.3/MultiOperator.cs	(revision 10507)
@@ -34,5 +34,5 @@
   [Item("MultiOperator", "A base class for operators which apply arbitrary many other operators of a specific type.")]
   [StorableClass]
-  public abstract class MultiOperator<T> : SingleSuccessorOperator, IMultiOperator<T> where T : class, IOperator {
+  public abstract class MultiOperator<T> : InstrumentedOperator, IMultiOperator<T> where T : class, IOperator {
     private List<IValueParameter<T>> operatorParameters;
     protected IEnumerable<IValueParameter<T>> OperatorParameters { get { return operatorParameters; } }
Index: stable/HeuristicLab.Operators/3.3/Operator.InstrumentedOperatorWrapper.cs
===================================================================
--- stable/HeuristicLab.Operators/3.3/Operator.InstrumentedOperatorWrapper.cs	(revision 10507)
+++ stable/HeuristicLab.Operators/3.3/Operator.InstrumentedOperatorWrapper.cs	(revision 10507)
@@ -0,0 +1,86 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Linq;
+using System.Threading;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using ExecutionContext = HeuristicLab.Core.ExecutionContext;
+
+namespace HeuristicLab.Operators {
+  public abstract partial class Operator {
+    internal static IOperation CreateInstrumentedOperation(InstrumentedOperator instrumentedOperator) {
+      var wrapper = new InstrumentedOperatorWrapper(instrumentedOperator);
+      return instrumentedOperator.ExecutionContext.CreateOperation(wrapper);
+    }
+
+    [StorableClass]
+    [NonDiscoverableType]
+    private class InstrumentedOperatorWrapper : Operator {
+      [Storable]
+      private readonly InstrumentedOperator instrumentedOperator;
+
+      [StorableConstructor]
+      private InstrumentedOperatorWrapper(bool deserializing) : base(deserializing) { }
+
+      private InstrumentedOperatorWrapper(InstrumentedOperatorWrapper original, Cloner cloner)
+        : base(original, cloner) {
+        instrumentedOperator = cloner.Clone(original.instrumentedOperator);
+      }
+
+      public override IDeepCloneable Clone(Cloner cloner) {
+        return new InstrumentedOperatorWrapper(this, cloner);
+      }
+
+      public InstrumentedOperatorWrapper(InstrumentedOperator instrumentedOperator)
+        : base() {
+        this.instrumentedOperator = instrumentedOperator;
+      }
+
+      public override IOperation Apply() {
+        throw new NotSupportedException("InstrumentedOperatorWrapper is not executeable.");
+      }
+
+      public override IOperation Execute(IExecutionContext context, CancellationToken cancellationToken) {
+        try {
+          //create new executionContext for the instrumented operation to account for parameter lookup and name translation
+          var executionContext = new ExecutionContext(context.Parent, instrumentedOperator, context.Scope);
+          instrumentedOperator.ExecutionContext = executionContext;
+          instrumentedOperator.cancellationToken = cancellationToken;
+          foreach (ILookupParameter param in instrumentedOperator.Parameters.OfType<ILookupParameter>())
+            param.ExecutionContext = executionContext;
+          IOperation next = instrumentedOperator.InstrumentedApply();
+          return next;
+        }
+        finally {
+          foreach (ILookupParameter param in instrumentedOperator.Parameters.OfType<ILookupParameter>())
+            param.ExecutionContext = null;
+          instrumentedOperator.ExecutionContext = null;
+        }
+      }
+    }
+  }
+}
Index: stable/HeuristicLab.Operators/3.3/Operator.cs
===================================================================
--- stable/HeuristicLab.Operators/3.3/Operator.cs	(revision 10505)
+++ stable/HeuristicLab.Operators/3.3/Operator.cs	(revision 10507)
@@ -34,5 +34,5 @@
   [Item("Operator", "Base class for operators.")]
   [StorableClass]
-  public abstract class Operator : ParameterizedNamedItem, IOperator, IStatefulItem {
+  public abstract partial class Operator : ParameterizedNamedItem, IOperator, IStatefulItem {
     public static new Image StaticItemImage {
       get { return HeuristicLab.Common.Resources.VSImageLibrary.Method; }
Index: stable/HeuristicLab.Operators/3.3/StochasticMultiBranch.cs
===================================================================
--- stable/HeuristicLab.Operators/3.3/StochasticMultiBranch.cs	(revision 10505)
+++ stable/HeuristicLab.Operators/3.3/StochasticMultiBranch.cs	(revision 10507)
@@ -132,5 +132,5 @@
     /// or all selected operators have zero probabitlity.</exception>
     /// <returns>A new operation with the operator that was selected followed by the current operator's successor.</returns>
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IRandom random = RandomParameter.ActualValue;
       DoubleArray probabilities = ProbabilitiesParameter.ActualValue;
@@ -156,5 +156,5 @@
         }
       }
-      OperationCollection next = new OperationCollection(base.Apply());
+      OperationCollection next = new OperationCollection(base.InstrumentedApply());
       if (successor != null) {
         if (TraceSelectedOperatorParameter.Value.Value)
Index: stable/HeuristicLab.Operators/3.3/SubScopesProcessor.cs
===================================================================
--- stable/HeuristicLab.Operators/3.3/SubScopesProcessor.cs	(revision 10505)
+++ stable/HeuristicLab.Operators/3.3/SubScopesProcessor.cs	(revision 10507)
@@ -67,7 +67,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       List<IScope> scopes = GetScopesOnLevel(ExecutionContext.Scope, Depth.Value).ToList();
-      OperationCollection next = new OperationCollection(base.Apply());
+      OperationCollection next = new OperationCollection(base.InstrumentedApply());
       if (scopes.Count != Operators.Count)
         throw new ArgumentException("The number of operators doesn't match the number of sub-scopes at depth " + Depth.Value);
Index: stable/HeuristicLab.Optimization.Operators/3.3/ParentCopyCrossover.cs
===================================================================
--- stable/HeuristicLab.Optimization.Operators/3.3/ParentCopyCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Optimization.Operators/3.3/ParentCopyCrossover.cs	(revision 10507)
@@ -29,5 +29,5 @@
   [Item("ParentCopyCrossover", "This operator creates an offspring by creating a clone of a randomly chosen parent. It can be used in situations where no crossover should occur after selection.")]
   [StorableClass]
-  public class ParentCopyCrossover : SingleSuccessorOperator, ICrossover, IStochasticOperator {
+  public class ParentCopyCrossover : InstrumentedOperator, ICrossover, IStochasticOperator {
     public ILookupParameter<IRandom> RandomParameter {
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
@@ -43,5 +43,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IScope scope = ExecutionContext.Scope;
       int index = RandomParameter.ActualValue.Next(scope.SubScopes.Count);
@@ -51,5 +51,5 @@
         scope.Variables.Add((IVariable)var.Clone());
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Optimization.Operators/3.3/ShakingOperator.cs
===================================================================
--- stable/HeuristicLab.Optimization.Operators/3.3/ShakingOperator.cs	(revision 10505)
+++ stable/HeuristicLab.Optimization.Operators/3.3/ShakingOperator.cs	(revision 10507)
@@ -56,5 +56,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (NeighborhoodCountParameter.ActualValue == null)
         NeighborhoodCountParameter.ActualValue = new IntValue(Operators.CheckedItems.Count());
@@ -64,5 +64,5 @@
       var shaker = base.Operators.CheckedItems.SingleOrDefault(x => x.Index == index);
 
-      OperationCollection next = new OperationCollection(base.Apply());
+      OperationCollection next = new OperationCollection(base.InstrumentedApply());
       if (shaker.Value != null)
         next.Insert(0, ExecutionContext.CreateChildOperation(shaker.Value));
Index: stable/HeuristicLab.Optimization.Operators/3.3/UserDefinedOperator.cs
===================================================================
--- stable/HeuristicLab.Optimization.Operators/3.3/UserDefinedOperator.cs	(revision 10505)
+++ stable/HeuristicLab.Optimization.Operators/3.3/UserDefinedOperator.cs	(revision 10507)
@@ -35,10 +35,10 @@
     public UserDefinedOperator() : base() { }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       OperationCollection result = new OperationCollection();
       foreach (IOperator op in Operators.CheckedItems.OrderBy(x => x.Index).Select(x => x.Value)) {
         result.Add(ExecutionContext.CreateOperation(op));
       }
-      result.Add(base.Apply());
+      result.Add(base.InstrumentedApply());
       return result;
     }
Index: stable/HeuristicLab.Problems.ArtificialAnt/3.4/Evaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.ArtificialAnt/3.4/Evaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.ArtificialAnt/3.4/Evaluator.cs	(revision 10507)
@@ -32,5 +32,5 @@
   [Item("ArtificialAntEvaluator", "Evaluates an artificial ant solution.")]
   [StorableClass]
-  public class Evaluator : SingleSuccessorOperator, ISingleObjectiveEvaluator {
+  public class Evaluator : InstrumentedOperator, ISingleObjectiveEvaluator {
 
     public ILookupParameter<DoubleValue> QualityParameter {
@@ -60,5 +60,5 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       SymbolicExpressionTree expression = SymbolicExpressionTreeParameter.ActualValue;
       BoolMatrix world = WorldParameter.ActualValue;
@@ -72,5 +72,5 @@
 
       QualityParameter.ActualValue = new DoubleValue(interpreter.FoodEaten);
-      return null;
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 10507)
@@ -44,10 +44,10 @@
     public override IEnumerable<bool> Maximization { get { return new bool[2] { false, false }; } }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows);
       QualitiesParameter.ActualValue = new DoubleArray(qualities);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 10507)
@@ -44,10 +44,10 @@
     public override IEnumerable<bool> Maximization { get { return new bool[2] { true, false }; } }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value);
       QualitiesParameter.ActualValue = new DoubleArray(qualities);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveBoundedMeanSquaredErrorEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveBoundedMeanSquaredErrorEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveBoundedMeanSquaredErrorEvaluator.cs	(revision 10507)
@@ -44,10 +44,10 @@
     public override bool Maximization { get { return false; } }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value);
       QualityParameter.ActualValue = new DoubleValue(quality);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveMeanSquaredErrorEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 10507)
@@ -45,10 +45,10 @@
     public override bool Maximization { get { return false; } }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value);
       QualityParameter.ActualValue = new DoubleValue(quality);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePearsonRSquaredEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePearsonRSquaredEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePearsonRSquaredEvaluator.cs	(revision 10507)
@@ -44,10 +44,10 @@
     public override bool Maximization { get { return true; } }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       double quality = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value);
       QualityParameter.ActualValue = new DoubleValue(quality);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePenaltyScoreEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePenaltyScoreEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePenaltyScoreEvaluator.cs	(revision 10507)
@@ -64,8 +64,8 @@
 
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       double quality = Evaluate(ExecutionContext, SymbolicExpressionTreeParameter.ActualValue, ProblemDataParameter.ActualValue, GenerateRowsToEvaluate());
       QualityParameter.ActualValue = new DoubleValue(quality);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 10507)
@@ -44,10 +44,10 @@
     public override IEnumerable<bool> Maximization { get { return new bool[2] { false, false }; } }
 
-    public override Core.IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value);
       QualitiesParameter.ActualValue = new DoubleArray(qualities);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 10507)
@@ -44,10 +44,10 @@
     public override IEnumerable<bool> Maximization { get { return new bool[2] { true, false }; } }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IEnumerable<int> rows = GenerateRowsToEvaluate();
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value);
       QualitiesParameter.ActualValue = new DoubleArray(qualities);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionConstantOptimizationEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionConstantOptimizationEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionConstantOptimizationEvaluator.cs	(revision 10507)
@@ -102,5 +102,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       double quality;
@@ -121,8 +121,5 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
 
-      if (Successor != null)
-        return ExecutionContext.CreateOperation(Successor);
-      else
-        return null;
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator.cs	(revision 10507)
@@ -42,5 +42,5 @@
     public SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator() : base() { }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       IEnumerable<int> rows = GenerateRowsToEvaluate();
@@ -49,5 +49,5 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanAbsoluteErrorEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanAbsoluteErrorEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanAbsoluteErrorEvaluator.cs	(revision 10507)
@@ -42,5 +42,5 @@
     public SymbolicRegressionSingleObjectiveMeanAbsoluteErrorEvaluator() : base() { }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       IEnumerable<int> rows = GenerateRowsToEvaluate();
@@ -49,5 +49,5 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 10507)
@@ -42,5 +42,5 @@
     public SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator() : base() { }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       IEnumerable<int> rows = GenerateRowsToEvaluate();
@@ -49,5 +49,5 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs	(revision 10507)
@@ -44,5 +44,5 @@
     public override bool Maximization { get { return true; } }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       IEnumerable<int> rows = GenerateRowsToEvaluate();
@@ -51,5 +51,5 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveMeanSquaredErrorEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 10507)
@@ -44,5 +44,5 @@
     public override bool Maximization { get { return false; } }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       IEnumerable<int> rows = GenerateRowsToEvaluate();
@@ -56,5 +56,5 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Creators/MultiSymbolicDataAnalysisExpressionCreator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Creators/MultiSymbolicDataAnalysisExpressionCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Creators/MultiSymbolicDataAnalysisExpressionCreator.cs	(revision 10507)
@@ -95,5 +95,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (ClonedSymbolicExpressionTreeGrammarParameter.ActualValue == null) {
         SymbolicExpressionTreeGrammarParameter.ActualValue.ReadOnly = true;
@@ -104,5 +104,5 @@
         globalScope.Variables.Add(new Core.Variable(ClonedSymbolicExpressionTreeGrammarParameterName, (ISymbolicExpressionGrammar)SymbolicExpressionTreeGrammarParameter.ActualValue.Clone()));
       }
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Evaluators/SymbolicDataAnalysisEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Evaluators/SymbolicDataAnalysisEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Evaluators/SymbolicDataAnalysisEvaluator.cs	(revision 10507)
@@ -35,5 +35,5 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableClass]
-  public abstract class SymbolicDataAnalysisEvaluator<T> : SingleSuccessorOperator,
+  public abstract class SymbolicDataAnalysisEvaluator<T> : InstrumentedOperator,
     ISymbolicDataAnalysisEvaluator<T>, ISymbolicDataAnalysisInterpreterOperator, ISymbolicDataAnalysisBoundedOperator, IStochasticOperator
   where T : class, IDataAnalysisProblemData {
Index: stable/HeuristicLab.Problems.DataAnalysis.Trading/3.4/Symbolic/SingleObjective/ProfitEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Trading/3.4/Symbolic/SingleObjective/ProfitEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Trading/3.4/Symbolic/SingleObjective/ProfitEvaluator.cs	(revision 10507)
@@ -47,5 +47,5 @@
     public override bool Maximization { get { return true; } }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       IEnumerable<int> rows = GenerateRowsToEvaluate();
@@ -54,5 +54,5 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Trading/3.4/Symbolic/SingleObjective/SharpeRatioEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Trading/3.4/Symbolic/SingleObjective/SharpeRatioEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.DataAnalysis.Trading/3.4/Symbolic/SingleObjective/SharpeRatioEvaluator.cs	(revision 10507)
@@ -47,5 +47,5 @@
     public override bool Maximization { get { return true; } }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       IEnumerable<int> rows = GenerateRowsToEvaluate();
@@ -54,5 +54,5 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.Knapsack/3.3/Evaluators/KnapsackEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.Knapsack/3.3/Evaluators/KnapsackEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.Knapsack/3.3/Evaluators/KnapsackEvaluator.cs	(revision 10507)
@@ -35,5 +35,5 @@
   [Item("KnapsackEvaluator", "Evaluates solutions for the Knapsack problem.")]
   [StorableClass]
-  public class KnapsackEvaluator : SingleSuccessorOperator, IKnapsackEvaluator {
+  public class KnapsackEvaluator : InstrumentedOperator, IKnapsackEvaluator {
     public ILookupParameter<DoubleValue> QualityParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
@@ -129,5 +129,5 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       BinaryVector v = BinaryVectorParameter.ActualValue;
 
@@ -143,5 +143,5 @@
       AppliedPenaltyParameter.ActualValue = evaluation.AppliedPenalty;
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.LawnMower/3.3/Evaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.LawnMower/3.3/Evaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.LawnMower/3.3/Evaluator.cs	(revision 10507)
@@ -32,5 +32,5 @@
   [StorableClass]
   [Item("Lawn Mower Evaluator", "Evaluator for the lawn mower demo GP problem.")]
-  public class Evaluator : SingleSuccessorOperator, ISingleObjectiveEvaluator {
+  public class Evaluator : InstrumentedOperator, ISingleObjectiveEvaluator {
 
     private const string QualityParameterName = "Quality";
@@ -72,5 +72,5 @@
       return new Evaluator(this, cloner);
     }
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       int length = LawnLengthParameter.ActualValue.Value;
       int width = LawnWidthParameter.ActualValue.Value;
@@ -88,5 +88,5 @@
 
       QualityParameter.ActualValue = new DoubleValue(numberOfMowedCells);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.LinearAssignment/3.3/LAPEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.LinearAssignment/3.3/LAPEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.LinearAssignment/3.3/LAPEvaluator.cs	(revision 10507)
@@ -32,5 +32,5 @@
   [Item("LAPEvaluator", "Evaluates a solution to the linear assignment problem.")]
   [StorableClass]
-  public class LAPEvaluator : SingleSuccessorOperator, ILAPEvaluator {
+  public class LAPEvaluator : InstrumentedOperator, ILAPEvaluator {
 
     public ILookupParameter<DoubleMatrix> CostsParameter {
@@ -47,5 +47,6 @@
     protected LAPEvaluator(bool deserializing) : base(deserializing) { }
     protected LAPEvaluator(LAPEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public LAPEvaluator() : base() {
+    public LAPEvaluator()
+      : base() {
       Parameters.Add(new LookupParameter<DoubleMatrix>("Costs", LinearAssignmentProblem.CostsDescription));
       Parameters.Add(new LookupParameter<Permutation>("Assignment", "The assignment solution to evaluate."));
@@ -57,5 +58,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var costs = CostsParameter.ActualValue;
       var assignment = AssignmentParameter.ActualValue;
@@ -69,5 +70,5 @@
 
       QualityParameter.ActualValue = new DoubleValue(quality);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.OneMax/3.3/Evaluators/OneMaxEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.OneMax/3.3/Evaluators/OneMaxEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.OneMax/3.3/Evaluators/OneMaxEvaluator.cs	(revision 10507)
@@ -34,5 +34,5 @@
   [Item("OneMaxEvaluator", "Evaluates solutions for the OneMax problem.")]
   [StorableClass]
-  public class OneMaxEvaluator : SingleSuccessorOperator, IOneMaxEvaluator {
+  public class OneMaxEvaluator : InstrumentedOperator, IOneMaxEvaluator {
     public ILookupParameter<DoubleValue> QualityParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
@@ -56,5 +56,5 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       BinaryVector v = BinaryVectorParameter.ActualValue;
 
@@ -67,5 +67,5 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPEvaluator.cs	(revision 10507)
@@ -30,5 +30,5 @@
 namespace HeuristicLab.Problems.QuadraticAssignment {
   [StorableClass]
-  public class QAPEvaluator : SingleSuccessorOperator, IQAPEvaluator {
+  public class QAPEvaluator : InstrumentedOperator, IQAPEvaluator {
 
     public ILookupParameter<Permutation> PermutationParameter {
@@ -78,5 +78,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       Permutation assignment = PermutationParameter.ActualValue;
       DoubleMatrix weights = WeightsParameter.ActualValue;
@@ -86,5 +86,5 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.Scheduling/3.3/Evaluators/ScheduleEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.Scheduling/3.3/Evaluators/ScheduleEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.Scheduling/3.3/Evaluators/ScheduleEvaluator.cs	(revision 10507)
@@ -31,5 +31,5 @@
   [Item("Schedule Evaluator", "Represents a base class for schedule evaluators.")]
   [StorableClass]
-  public abstract class ScheduleEvaluator : SingleSuccessorOperator, IScheduleEvaluator {
+  public abstract class ScheduleEvaluator : InstrumentedOperator, IScheduleEvaluator {
 
     public ILookupParameter<DoubleValue> QualityParameter {
@@ -51,7 +51,7 @@
     protected abstract double Evaluate(Schedule schedule);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       QualityParameter.ActualValue = new DoubleValue(Evaluate(ScheduleParameter.ActualValue));
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.Scheduling/3.3/Evaluators/SchedulingEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.Scheduling/3.3/Evaluators/SchedulingEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.Scheduling/3.3/Evaluators/SchedulingEvaluator.cs	(revision 10507)
@@ -32,8 +32,8 @@
   [Item("SchedulingEvaluator", "First applies the decoder operator to obtain a schedule from an encoding and then applies the evaluator to obtain a quality.")]
   [StorableClass]
-  public class SchedulingEvaluator : SingleSuccessorOperator, ISchedulingEvaluator {
+  public class SchedulingEvaluator : InstrumentedOperator, ISchedulingEvaluator {
 
     public IValueLookupParameter<IScheduleDecoder> ScheduleDecoderParameter {
-      get { return (IValueLookupParameter<IScheduleDecoder>) Parameters["ScheduleDecoder"]; }
+      get { return (IValueLookupParameter<IScheduleDecoder>)Parameters["ScheduleDecoder"]; }
     }
     ILookupParameter<IScheduleDecoder> ISchedulingEvaluator.ScheduleDecoderParameter {
@@ -41,5 +41,5 @@
     }
     public IValueLookupParameter<IScheduleEvaluator> ScheduleEvaluatorParameter {
-      get { return (IValueLookupParameter<IScheduleEvaluator>) Parameters["ScheduleEvaluator"]; }
+      get { return (IValueLookupParameter<IScheduleEvaluator>)Parameters["ScheduleEvaluator"]; }
     }
     ILookupParameter<IScheduleEvaluator> ISchedulingEvaluator.ScheduleEvaluatorParameter {
@@ -65,10 +65,10 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var decoder = ScheduleDecoderParameter.ActualValue;
       var evaluator = ScheduleEvaluatorParameter.ActualValue;
       if (evaluator == null) throw new InvalidOperationException("A ScheduleEvaluator could not be found.");
 
-      var operations = new OperationCollection(base.Apply());
+      var operations = new OperationCollection(base.InstrumentedApply());
       operations.Insert(0, ExecutionContext.CreateChildOperation(evaluator));
       if (decoder != null) // decode before evaluating
Index: stable/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SingleObjectiveTestFunctionProblemEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SingleObjectiveTestFunctionProblemEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SingleObjectiveTestFunctionProblemEvaluator.cs	(revision 10507)
@@ -34,5 +34,5 @@
   [Item("Evaluator", "Base calls for single objective test function evaluators.")]
   [StorableClass]
-  public abstract class SingleObjectiveTestFunctionProblemEvaluator : SingleSuccessorOperator, ISingleObjectiveTestFunctionProblemEvaluator {
+  public abstract class SingleObjectiveTestFunctionProblemEvaluator : InstrumentedOperator, ISingleObjectiveTestFunctionProblemEvaluator {
     /// <summary>
     /// The name of the function
@@ -86,9 +86,9 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       RealVector point = PointParameter.ActualValue;
       double quality = Evaluate(point);
       QualityParameter.ActualValue = new DoubleValue(quality);
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.TravelingSalesman/3.3/Evaluators/TSPCoordinatesPathEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.TravelingSalesman/3.3/Evaluators/TSPCoordinatesPathEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.TravelingSalesman/3.3/Evaluators/TSPCoordinatesPathEvaluator.cs	(revision 10507)
@@ -84,5 +84,5 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       if (UseDistanceMatrixParameter.ActualValue.Value) {
         Permutation p = PermutationParameter.ActualValue;
@@ -120,5 +120,5 @@
         QualityParameter.ActualValue = new DoubleValue(length);
       }
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.TravelingSalesman/3.3/Evaluators/TSPDistanceMatrixEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.TravelingSalesman/3.3/Evaluators/TSPDistanceMatrixEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.TravelingSalesman/3.3/Evaluators/TSPDistanceMatrixEvaluator.cs	(revision 10507)
@@ -69,10 +69,10 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       Permutation p = PermutationParameter.ActualValue;
       DistanceMatrix dm = DistanceMatrixParameter.ActualValue;
 
       QualityParameter.ActualValue = new DoubleValue(Apply(dm, p));
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.TravelingSalesman/3.3/Evaluators/TSPEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.TravelingSalesman/3.3/Evaluators/TSPEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.TravelingSalesman/3.3/Evaluators/TSPEvaluator.cs	(revision 10507)
@@ -33,5 +33,5 @@
   [Item("TSPEvaluator", "A base class for operators which evaluate TSP solutions.")]
   [StorableClass]
-  public abstract class TSPEvaluator : SingleSuccessorOperator, ITSPEvaluator {
+  public abstract class TSPEvaluator : InstrumentedOperator, ITSPEvaluator {
     public override bool CanChangeName {
       get { return false; }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/AlbaCreator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/AlbaCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/AlbaCreator.cs	(revision 10507)
@@ -45,8 +45,8 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       (VRPToursParameter.ActualValue as AlbaEncoding).Repair();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/RandomCreator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/RandomCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Creators/RandomCreator.cs	(revision 10507)
@@ -86,9 +86,9 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       //choose default encoding here
       VRPToursParameter.ActualValue = AlbaEncoding.ConvertFrom(CreateSolution(), ProblemInstance);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Crossovers/AlbaCrossover.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Crossovers/AlbaCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Crossovers/AlbaCrossover.cs	(revision 10507)
@@ -52,5 +52,5 @@
     protected abstract AlbaEncoding Crossover(IRandom random, AlbaEncoding parent1, AlbaEncoding parent2);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
       for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
@@ -69,5 +69,5 @@
       (ChildParameter.ActualValue as AlbaEncoding).Repair();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/LocalImprovement/AlbaLambdaInterchangeLocalImprovementOperator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/LocalImprovement/AlbaLambdaInterchangeLocalImprovementOperator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/LocalImprovement/AlbaLambdaInterchangeLocalImprovementOperator.cs	(revision 10507)
@@ -125,5 +125,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       int maxIterations = MaximumIterationsParameter.ActualValue.Value;
       AlbaEncoding solution = null;
@@ -146,5 +146,5 @@
       QualityParameter.ActualValue.Value = quality;
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Manipulators/AlbaManipulator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Manipulators/AlbaManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Manipulators/AlbaManipulator.cs	(revision 10507)
@@ -62,5 +62,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is AlbaEncoding)) {
@@ -71,5 +71,5 @@
       (VRPToursParameter.ActualValue as AlbaEncoding).Repair();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/AlbaMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/AlbaMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/AlbaMoveGenerator.cs	(revision 10507)
@@ -41,5 +41,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is AlbaEncoding)) {
@@ -47,5 +47,5 @@
       }
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/IntraRouteInversion/AlbaIntraRouteInversionMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/IntraRouteInversion/AlbaIntraRouteInversionMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/IntraRouteInversion/AlbaIntraRouteInversionMoveGenerator.cs	(revision 10507)
@@ -58,6 +58,6 @@
     protected abstract AlbaIntraRouteInversionMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       AlbaEncoding individual = VRPToursParameter.ActualValue as AlbaEncoding;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/LambdaInterchange/AlbaLambdaInterchangeMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/LambdaInterchange/AlbaLambdaInterchangeMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/LambdaInterchange/AlbaLambdaInterchangeMoveGenerator.cs	(revision 10507)
@@ -68,6 +68,6 @@
     protected abstract AlbaLambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       AlbaEncoding individual = VRPToursParameter.ActualValue as AlbaEncoding;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaStochasticTranslocationSingleMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaStochasticTranslocationSingleMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaStochasticTranslocationSingleMoveGenerator.cs	(revision 10507)
@@ -69,6 +69,6 @@
     }
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       IVRPEncoding solution = VRPToursParameter.ActualValue;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveGenerator.cs	(revision 10507)
@@ -93,6 +93,6 @@
     }
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       IVRPEncoding solution = VRPToursParameter.ActualValue;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveHardTabuCriterion.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveHardTabuCriterion.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveHardTabuCriterion.cs	(revision 10507)
@@ -81,6 +81,6 @@
     }
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       IVRPEncoding solution = VRPToursParameter.ActualValue;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveSoftTabuCriterion.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveSoftTabuCriterion.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveSoftTabuCriterion.cs	(revision 10507)
@@ -81,6 +81,6 @@
     }
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       IVRPEncoding solution = VRPToursParameter.ActualValue;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveTabuMaker.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveTabuMaker.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveTabuMaker.cs	(revision 10507)
@@ -81,6 +81,6 @@
     }
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       IVRPEncoding solution = VRPToursParameter.ActualValue;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Crossovers/GVRCrossover.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Crossovers/GVRCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Crossovers/GVRCrossover.cs	(revision 10507)
@@ -103,5 +103,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
       for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
@@ -117,5 +117,5 @@
       ChildParameter.ActualValue = Crossover(RandomParameter.ActualValue, parents[0] as GVREncoding, parents[1] as GVREncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRManipulator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRManipulator.cs	(revision 10507)
@@ -49,5 +49,5 @@
     protected abstract void Manipulate(IRandom random, GVREncoding individual);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is GVREncoding)) {
@@ -57,5 +57,5 @@
       Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as GVREncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Creators/MultiVRPSolutionCreator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Creators/MultiVRPSolutionCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Creators/MultiVRPSolutionCreator.cs	(revision 10507)
@@ -97,7 +97,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one VRP creator to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/BiasedMultiVRPSolutionCrossover.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/BiasedMultiVRPSolutionCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/BiasedMultiVRPSolutionCrossover.cs	(revision 10507)
@@ -21,15 +21,13 @@
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using HeuristicLab.Analysis;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Analysis;
-using HeuristicLab.Parameters;
-using HeuristicLab.Optimization;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.General {
@@ -81,5 +79,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IOperator successor = null;
 
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/MultiVRPSolutionCrossover.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/MultiVRPSolutionCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/MultiVRPSolutionCrossover.cs	(revision 10507)
@@ -106,7 +106,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one permutation crossover to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/RandomParentCloneCrossover.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/RandomParentCloneCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Crossovers/RandomParentCloneCrossover.cs	(revision 10507)
@@ -65,5 +65,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (RandomParameter.ActualValue.Next() < 0.5)
         ChildParameter.ActualValue = ParentsParameter.ActualValue[0].Clone() as IVRPEncoding;
@@ -71,5 +71,5 @@
         ChildParameter.ActualValue = ParentsParameter.ActualValue[1].Clone() as IVRPEncoding;
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/BiasedMultiVRPSolutionManipulator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/BiasedMultiVRPSolutionManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/BiasedMultiVRPSolutionManipulator.cs	(revision 10507)
@@ -21,15 +21,13 @@
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using HeuristicLab.Analysis;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Analysis;
-using HeuristicLab.Parameters;
-using HeuristicLab.Optimization;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.General {
@@ -40,5 +38,5 @@
       get { return (ValueLookupParameter<DoubleArray>)Parameters["ActualProbabilities"]; }
     }
-    
+
     public ValueLookupParameter<StringValue> SuccessProgressAnalyisis {
       get { return (ValueLookupParameter<StringValue>)Parameters["SuccessProgressAnalysis"]; }
@@ -63,5 +61,5 @@
       : base() {
       Parameters.Add(new ValueLookupParameter<DoubleArray>("ActualProbabilities", "The array of relative probabilities for each operator."));
-      Parameters.Add(new ValueLookupParameter<StringValue>("SuccessProgressAnalysis", "The success progress analyisis to be considered", 
+      Parameters.Add(new ValueLookupParameter<StringValue>("SuccessProgressAnalysis", "The success progress analyisis to be considered",
         new StringValue("ExecutedMutationOperator")));
 
@@ -81,5 +79,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IOperator successor = null;
 
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/MultiVRPSolutionManipulator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/MultiVRPSolutionManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Manipulators/MultiVRPSolutionManipulator.cs	(revision 10507)
@@ -97,7 +97,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one permutation manipulator to choose from.");
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveEvaluator.cs	(revision 10507)
@@ -53,5 +53,5 @@
     protected override void EvaluateMove() { }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPMove move = VRPMoveParameter.ActualValue as IVRPMove;
 
@@ -59,5 +59,5 @@
       moveEvaluator.VRPMoveParameter.ActualName = VRPMoveParameter.Name;
 
-      OperationCollection next = new OperationCollection(base.Apply());
+      OperationCollection next = new OperationCollection(base.InstrumentedApply());
       next.Insert(0, ExecutionContext.CreateOperation(moveEvaluator));
 
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveGenerator.cs	(revision 10507)
@@ -153,7 +153,7 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one VRP move generator choose from.");
-      OperationCollection next = new OperationCollection(base.Apply());
+      OperationCollection next = new OperationCollection(base.InstrumentedApply());
 
       for (int i = 0; i < SelectedOperatorsParameter.ActualValue.Value; i++) {
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveEvaluator.cs	(revision 10507)
@@ -76,8 +76,8 @@
     protected abstract void EvaluateMove();
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       EvaluateMove();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveMaker.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveMaker.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveMaker.cs	(revision 10507)
@@ -99,9 +99,9 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       PerformMove();
       UpdateMoveEvaluation();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/IterativeInsertionCreator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/IterativeInsertionCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/IterativeInsertionCreator.cs	(revision 10507)
@@ -140,8 +140,8 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       VRPToursParameter.ActualValue = CreateSolution(ProblemInstance, RandomParameter.ActualValue, AdhereTimeWindowsParameter.Value.Value);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/PushForwardInsertionCreator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/PushForwardInsertionCreator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/PushForwardInsertionCreator.cs	(revision 10507)
@@ -373,10 +373,10 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       VRPToursParameter.ActualValue = CreateSolution(ProblemInstance, RandomParameter.ActualValue,
         Alpha.Value.Value, Beta.Value.Value, Gamma.Value.Value,
         AlphaVariance.Value.Value, BetaVariance.Value.Value, GammaVariance.Value.Value);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinCrossover.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinCrossover.cs	(revision 10507)
@@ -144,5 +144,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
       for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
@@ -160,5 +160,5 @@
       (ChildParameter.ActualValue as PotvinEncoding).Repair();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinManipulator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinManipulator.cs	(revision 10507)
@@ -87,5 +87,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is PotvinEncoding)) {
@@ -96,5 +96,5 @@
       (VRPToursParameter.ActualValue as PotvinEncoding).Repair();
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinVehicleAssignmentManipulator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinVehicleAssignmentManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinVehicleAssignmentManipulator.cs	(revision 10507)
@@ -60,5 +60,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is PotvinEncoding)) {
@@ -66,5 +66,5 @@
       }
 
-      OperationCollection next = new OperationCollection(base.Apply());
+      OperationCollection next = new OperationCollection(base.InstrumentedApply());
 
       VehicleAssignmentParameter.ActualValue = (VRPToursParameter.ActualValue as PotvinEncoding).VehicleAssignment;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/CustomerRelocation/PotvinCustomerRelocationMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/CustomerRelocation/PotvinCustomerRelocationMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/CustomerRelocation/PotvinCustomerRelocationMoveGenerator.cs	(revision 10507)
@@ -57,6 +57,6 @@
     protected abstract PotvinCustomerRelocationMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveGenerator.cs	(revision 10507)
@@ -57,6 +57,6 @@
     protected abstract PotvinPDExchangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveGenerator.cs	(revision 10507)
@@ -57,6 +57,6 @@
     protected abstract PotvinPDRearrangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveGenerator.cs	(revision 10507)
@@ -57,6 +57,6 @@
     protected abstract PotvinPDShiftMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PotvinMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PotvinMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PotvinMoveGenerator.cs	(revision 10507)
@@ -41,5 +41,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is PotvinEncoding)) {
@@ -47,5 +47,5 @@
       }
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/TwoOptStar/PotvinTwoOptStarMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/TwoOptStar/PotvinTwoOptStarMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/TwoOptStar/PotvinTwoOptStarMoveGenerator.cs	(revision 10507)
@@ -57,6 +57,6 @@
     protected abstract PotvinTwoOptStarMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/VehicleAssignment/PotvinVehicleAssignmentMoveGenerator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/VehicleAssignment/PotvinVehicleAssignmentMoveGenerator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/VehicleAssignment/PotvinVehicleAssignmentMoveGenerator.cs	(revision 10507)
@@ -57,6 +57,6 @@
     protected abstract PotvinVehicleAssignmentMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
 
-    public override IOperation Apply() {
-      IOperation next = base.Apply();
+    public override IOperation InstrumentedApply() {
+      IOperation next = base.InstrumentedApply();
 
       PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsCrossover.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsCrossover.cs	(revision 10507)
@@ -51,5 +51,5 @@
     protected abstract PrinsEncoding Crossover(IRandom random, PrinsEncoding parent1, PrinsEncoding parent2);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
       for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
@@ -67,5 +67,5 @@
         Crossover(RandomParameter.ActualValue, parents[0] as PrinsEncoding, parents[1] as PrinsEncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsManipulator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsManipulator.cs	(revision 10507)
@@ -50,5 +50,5 @@
     protected abstract void Manipulate(IRandom random, PrinsEncoding individual);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is PrinsEncoding)) {
@@ -58,5 +58,5 @@
       Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as PrinsEncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/VRPOperator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/VRPOperator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/VRPOperator.cs	(revision 10507)
@@ -30,5 +30,5 @@
   [Item("VRPOperator", "Represents a VRP operator.")]
   [StorableClass]
-  public abstract class VRPOperator : SingleSuccessorOperator, IVRPOperator {
+  public abstract class VRPOperator : InstrumentedOperator, IVRPOperator {
     public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
       get { return (LookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuCrossover.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuCrossover.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuCrossover.cs	(revision 10507)
@@ -50,5 +50,5 @@
     protected abstract ZhuEncoding Crossover(IRandom random, ZhuEncoding parent1, ZhuEncoding parent2);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
       for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
@@ -66,5 +66,5 @@
         Crossover(RandomParameter.ActualValue, parents[0] as ZhuEncoding, parents[1] as ZhuEncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuManipulator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuManipulator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuManipulator.cs	(revision 10507)
@@ -50,5 +50,5 @@
     protected abstract void Manipulate(IRandom random, ZhuEncoding individual);
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is ZhuEncoding)) {
@@ -58,5 +58,5 @@
       Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as ZhuEncoding);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
   }
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/Improver/VRPImprovementOperator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/Improver/VRPImprovementOperator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/Improver/VRPImprovementOperator.cs	(revision 10507)
@@ -75,5 +75,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       var solution = SolutionParameter.ActualValue as IVRPEncoding;
       var potvinSolution = solution is PotvinEncoding ? solution as PotvinEncoding : PotvinEncoding.ConvertFrom(solution, ProblemInstance);
@@ -87,5 +87,5 @@
       LocalEvaluatedSolutions.ActualValue = new IntValue(evaluatedSolutions);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/VRPEvaluator.cs
===================================================================
--- stable/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/VRPEvaluator.cs	(revision 10505)
+++ stable/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/VRPEvaluator.cs	(revision 10507)
@@ -128,5 +128,5 @@
     }
 
-    public override IOperation Apply() {
+    public override IOperation InstrumentedApply() {
       InitResultParameters();
 
@@ -140,5 +140,5 @@
       QualityParameter.ActualValue = new DoubleValue(evaluation.Quality);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
Index: stable/HeuristicLab.Selection/3.3/Selector.cs
===================================================================
--- stable/HeuristicLab.Selection/3.3/Selector.cs	(revision 10505)
+++ stable/HeuristicLab.Selection/3.3/Selector.cs	(revision 10507)
@@ -33,5 +33,5 @@
   [Item("Selector", "A base class for selection operators.")]
   [StorableClass]
-  public abstract class Selector : SingleSuccessorOperator {
+  public abstract class Selector : InstrumentedOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -54,5 +54,5 @@
     }
 
-    public sealed override IOperation Apply() {
+    public sealed override IOperation InstrumentedApply() {
       List<IScope> scopes = new List<IScope>(CurrentScope.SubScopes);
       IScope[] selected = Select(scopes);
@@ -66,5 +66,5 @@
       CurrentScope.SubScopes.Add(selectedScope);
 
-      return base.Apply();
+      return base.InstrumentedApply();
     }
 
