Index: branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/HeuristicLab.Analysis.SolutionCaching-3.3.csproj
===================================================================
--- branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/HeuristicLab.Analysis.SolutionCaching-3.3.csproj	(revision 10113)
+++ branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/HeuristicLab.Analysis.SolutionCaching-3.3.csproj	(revision 10114)
@@ -38,15 +38,7 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="ALGLIB-3.7.0, Version=3.7.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+    <Reference Include="HeuristicLab.Clients.Hive-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\ALGLIB-3.7.0.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Algorithms.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Algorithms.DataAnalysis-3.4.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Analysis-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Clients.Hive-3.3.dll</HintPath>
       <Private>False</Private>
     </Reference>
@@ -57,7 +49,4 @@
     <Reference Include="HeuristicLab.Common-3.3">
       <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <Private>False</Private>
     </Reference>
@@ -90,10 +79,4 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Optimization.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Optimization.Views-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
     <Reference Include="HeuristicLab.Parameters-3.3">
       <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
@@ -107,23 +90,7 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis-3.4.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Problems.Instances-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Drawing" />
-    <Reference Include="System.Windows.Forms" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
@@ -154,4 +121,6 @@
     <Compile Include="RealVectorEncoding\RealVectorSolutionCacheCollector.cs" />
     <Compile Include="RealVectorEncoding\RealVectorSolutionInformation.cs" />
+    <Compile Include="RunCollectionModifiers\RunCollectionModifierExecutable.cs" />
+    <Compile Include="RunCollectionModifiers\RunCollectionModifierHiveTask.cs" />
     <Compile Include="RunCollectionModifiers\RunCollectionModifierTask.cs" />
     <Compile Include="SolutionCache.cs" />
Index: branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/Plugin.cs.frame
===================================================================
--- branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/Plugin.cs.frame	(revision 10113)
+++ branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/Plugin.cs.frame	(revision 10114)
@@ -26,6 +26,7 @@
   [PluginFile("HeuristicLab.Analysis.SolutionCaching-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Clients.Hive", "3.3")]
+  [PluginDependency("HeuristicLab.Hive", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
-  [PluginDependency("HeuristicLab.Analysis", "3.3")]
   [PluginDependency("HeuristicLab.Core", "3.3")]
   [PluginDependency("HeuristicLab.Data", "3.3")]
@@ -34,5 +35,4 @@
   [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Optimization", "3.3")]
-  [PluginDependency("HeuristicLab.Optimization.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
Index: branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/RunCollectionModifiers/RunCollectionModifierExecutable.cs
===================================================================
--- branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/RunCollectionModifiers/RunCollectionModifierExecutable.cs	(revision 10114)
+++ branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/RunCollectionModifiers/RunCollectionModifierExecutable.cs	(revision 10114)
@@ -0,0 +1,227 @@
+﻿#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.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Analysis.SolutionCaching {
+  [Item("RunCollectionModifierExecutable", "An executable that runs RunCollectionModifiers on RunCollections.")]
+  [StorableClass]
+  public class RunCollectionModifierExecutable : ParameterizedNamedItem, IExecutable {
+    [Storable]
+    protected ExecutionState executionState;
+    public ExecutionState ExecutionState {
+      get { return executionState; }
+      set {
+        if (value != executionState) {
+          executionState = value;
+          OnExecutionStateChanged();
+        }
+      }
+    }
+
+    [Storable]
+    protected TimeSpan executionTime;
+    public TimeSpan ExecutionTime {
+      get { return executionTime; }
+      set {
+        if (value != executionTime) {
+          executionTime = value;
+          OnExecutionTimeChanged();
+        }
+      }
+    }
+
+    public ValueParameter<ItemList<IRunCollectionModifier>> RunCollectionModifiersParameter {
+      get { return (ValueParameter<ItemList<IRunCollectionModifier>>)Parameters["RunCollectionModifiers"]; }
+    }
+    public ItemList<IRunCollectionModifier> RunCollectionModifiers {
+      get { return RunCollectionModifiersParameter.Value; }
+    }
+
+    [Storable]
+    protected RunCollection runCollection;
+    public RunCollection RunCollection {
+      get { return runCollection; }
+    }
+
+    [Storable]
+    protected Stack<IRunCollectionModifier> executionStack;
+    protected Stack<IRunCollectionModifier> ExecutionStack {
+      get { return executionStack; }
+    }
+
+    [Storable]
+    protected ILog log;
+    public ILog Log {
+      get { return log; }
+    }
+
+    protected CancellationTokenSource cancellationTokenSource;
+    protected bool stopPending;
+
+    #region Constructors and Cloning
+    public RunCollectionModifierExecutable() {
+      Parameters.Add(new ValueParameter<ItemList<IRunCollectionModifier>>("RunCollectionModifiers", "List of RunCollectionModifiers that are executed. ", new ItemList<IRunCollectionModifier>()));
+      executionStack = new Stack<IRunCollectionModifier>();
+      runCollection = new RunCollection();
+      log = new Log();
+    }
+    [StorableConstructor]
+    protected RunCollectionModifierExecutable(bool deserializing) : base(deserializing) { }
+    protected RunCollectionModifierExecutable(RunCollectionModifierExecutable original, Cloner cloner)
+      : base(original, cloner) {
+      executionTime = original.executionTime;
+      executionState = original.executionState;
+      runCollection = (RunCollection)original.runCollection.Clone(cloner);
+      executionStack = new Stack<IRunCollectionModifier>();
+      foreach (var runCollectionModifier in original.executionStack) {
+        executionStack.Push(runCollectionModifier);
+      }
+      log = (ILog)original.log.Clone(cloner);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RunCollectionModifierExecutable(this, cloner);
+    }
+    #endregion
+
+    public void Pause() {
+      cancellationTokenSource.Cancel();
+    }
+
+    public void Prepare() {
+      executionStack.Clear();
+      foreach (var runCollectionModifier in RunCollectionModifiers) {
+        executionStack.Push(runCollectionModifier);
+      }
+    }
+
+    public void Start() {
+      cancellationTokenSource = new CancellationTokenSource();
+
+      Task task = Task.Factory.StartNew(RunModifiers, cancellationTokenSource.Token, cancellationTokenSource.Token);
+      task.ContinueWith(t => {
+        try {
+          t.Wait();
+        }
+        catch (AggregateException ex) {
+          try {
+            ex.Flatten().Handle(x => x is OperationCanceledException);
+          }
+          catch (AggregateException remaining) {
+            if (remaining.InnerExceptions.Count == 1) OnExceptionOccuted(remaining.InnerExceptions[0]);
+            else OnExceptionOccuted(remaining);
+          }
+        }
+        cancellationTokenSource.Dispose();
+        cancellationTokenSource = null;
+        if (stopPending) executionStack.Clear();
+        if (executionStack.Count == 0) OnStopped();
+        else OnPaused();
+      });
+    }
+
+    public void Stop() {
+      if (ExecutionState == ExecutionState.Paused) {
+        executionStack.Clear();
+        OnStopped();
+      } else {
+        stopPending = true;
+        cancellationTokenSource.Cancel();
+      }
+    }
+
+    public virtual void AddRunCollectionModifiers(IRunCollectionModifier modifier) {
+      RunCollectionModifiers.Add(modifier);
+    }
+
+    protected virtual void RunModifiers(object state) {
+      CancellationToken ct = (CancellationToken)state;
+      OnStarted();
+
+      IRunCollectionModifier next;
+      while (executionStack.Count > 0) {
+        next = executionStack.Pop();
+        try {
+          ct.ThrowIfCancellationRequested();
+          next.Modify(runCollection.ToList());
+        }
+        catch (Exception ex) {
+          executionStack.Push(next);
+          if (ex is OperationCanceledException) throw ex;
+          else throw new Exception("IRunCollectionModifier " + next + "threw an exception.", ex);
+        }
+      }
+    }
+
+    #region Events
+    public event EventHandler Prepared;
+    protected virtual void OnPrepared() {
+      ExecutionState = ExecutionState.Prepared;
+      EventHandler handler = Prepared;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Started;
+    protected virtual void OnStarted() {
+      executionState = ExecutionState.Started;
+      EventHandler handler = Started;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Stopped;
+    protected virtual void OnStopped() {
+      executionState = ExecutionState.Stopped;
+      EventHandler handler = Stopped;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Paused;
+    protected virtual void OnPaused() {
+      executionState = ExecutionState.Paused;
+      EventHandler handler = Paused;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler<EventArgs<Exception>> ExceptionOccurred;
+    protected virtual void OnExceptionOccuted(Exception e) {
+      var eventArgs = new EventArgs<Exception>(e);
+      Log.LogException(e);
+      EventHandler<EventArgs<Exception>> handler = ExceptionOccurred;
+      if (handler != null) handler(this, eventArgs);
+    }
+    public event EventHandler ExecutionTimeChanged;
+    protected virtual void OnExecutionTimeChanged() {
+      EventHandler handler = ExecutionTimeChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ExecutionStateChanged;
+    protected virtual void OnExecutionStateChanged() {
+      EventHandler handler = ExecutionStateChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    #endregion
+  }
+}
Index: branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/RunCollectionModifiers/RunCollectionModifierHiveTask.cs
===================================================================
--- branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/RunCollectionModifiers/RunCollectionModifierHiveTask.cs	(revision 10114)
+++ branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/RunCollectionModifiers/RunCollectionModifierHiveTask.cs	(revision 10114)
@@ -0,0 +1,43 @@
+﻿#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 HeuristicLab.Clients.Hive;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Analysis.SolutionCaching {
+  public class RunCollectionModifierHiveTask : HiveTask<RunCollectionModifierTask> {
+    #region Constructors and Cloning
+    public RunCollectionModifierHiveTask(RunCollectionModifierTask task)
+      : base() {
+      ItemTask = task;
+    }
+    public RunCollectionModifierHiveTask(RunCollectionModifierExecutable executable)
+      : base() {
+      ItemTask = new RunCollectionModifierTask(executable);
+    }
+    protected RunCollectionModifierHiveTask(RunCollectionModifierHiveTask original, Cloner cloner)
+      : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RunCollectionModifierHiveTask(this, cloner);
+    }
+    #endregion
+  }
+}
Index: branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/RunCollectionModifiers/RunCollectionModifierTask.cs
===================================================================
--- branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/RunCollectionModifiers/RunCollectionModifierTask.cs	(revision 10113)
+++ branches/HeuristicLab.Analysis.AlgorithmBehavior/HeuristicLab.Analysis.SolutionCaching/3.3/RunCollectionModifiers/RunCollectionModifierTask.cs	(revision 10114)
@@ -21,102 +21,31 @@
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
+using HeuristicLab.Clients.Hive;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Hive;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Analysis.SolutionCaching.RunCollectionModifiers {
-  [Item("RunCollectionModifierTask", "An item that runs RunCollectionModifiers on RunCollections with Hive support.")]
+namespace HeuristicLab.Analysis.SolutionCaching {
+  [Item("RunCollectionModifierTask", "Represents task which executes a RunCollectionModifierExecutable.")]
   [StorableClass]
-  public class RunCollectionModifierTask : ParameterizedNamedItem, ITask {
-    public virtual bool IsParallelizable {
+  public class RunCollectionModifierTask : ItemTask {
+    public override bool IsParallelizable {
       get { return false; }
     }
 
-    public virtual bool ComputeInParallel {
-      get { return false; }
-      set {
-        throw new NotSupportedException("Parallelization is not supported for RunCollectionModifierTasks.");
-      }
+    public new RunCollectionModifierExecutable Item {
+      get { return (RunCollectionModifierExecutable)base.Item; }
+      set { base.Item = value; }
     }
 
-    [Storable]
-    protected ExecutionState executionState;
-    public ExecutionState ExecutionState {
-      get { return executionState; }
-      set {
-        if (value != executionState) {
-          executionState = value;
-          OnExecutionStateChanged();
-        }
-      }
-    }
-
-    [Storable]
-    protected TimeSpan executionTime;
-    public TimeSpan ExecutionTime {
-      get { return executionTime; }
-      set {
-        if (value != executionTime) {
-          executionTime = value;
-          OnExecutionTimeChanged();
-        }
-      }
-    }
-
-    public ValueParameter<ItemList<IRunCollectionModifier>> RunCollectionModifiersParameter {
-      get { return (ValueParameter<ItemList<IRunCollectionModifier>>)Parameters["RunCollectionModifiers"]; }
-    }
-    public ItemList<IRunCollectionModifier> RunCollectionModifiers {
-      get { return RunCollectionModifiersParameter.Value; }
-    }
-
-    [Storable]
-    protected RunCollection runCollection;
-    public RunCollection RunCollection {
-      get { return runCollection; }
-    }
-
-    [Storable]
-    protected Stack<IRunCollectionModifier> executionStack;
-    protected Stack<IRunCollectionModifier> ExecutionStack {
-      get { return executionStack; }
-    }
-
-    [Storable]
-    protected ILog log;
-    public ILog Log {
-      get { return log; }
-    }
-
-    protected CancellationTokenSource cancellationTokenSource;
-    protected bool stopPending;
-
     #region Constructors and Cloning
-    public RunCollectionModifierTask() {
-      Parameters.Add(new ValueParameter<ItemList<IRunCollectionModifier>>("RunCollectionModifiers", "List of RunCollectionModifiers that are executed. ", new ItemList<IRunCollectionModifier>()));
-      executionStack = new Stack<IRunCollectionModifier>();
-      runCollection = new RunCollection();
-      log = new Log();
+    public RunCollectionModifierTask(RunCollectionModifierExecutable executable)
+      : base() {
+      Item = executable;
     }
     [StorableConstructor]
-    protected RunCollectionModifierTask(bool deserializing) : base(deserializing) { }
+    protected RunCollectionModifierTask(bool deserializing) { }
     protected RunCollectionModifierTask(RunCollectionModifierTask original, Cloner cloner)
       : base(original, cloner) {
-      executionTime = original.executionTime;
-      executionState = original.executionState;
-      runCollection = (RunCollection)original.runCollection.Clone(cloner);
-      executionStack = new Stack<IRunCollectionModifier>();
-      foreach (var runCollectionModifier in original.executionStack) {
-        executionStack.Push(runCollectionModifier);
-      }
-      log = (ILog)original.log.Clone(cloner);
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -125,119 +54,127 @@
     #endregion
 
-    public void Pause() {
-      cancellationTokenSource.Cancel();
-    }
-
-    public void Prepare() {
-      executionStack.Clear();
-      foreach (var runCollectionModifier in RunCollectionModifiers) {
-        executionStack.Push(runCollectionModifier);
-      }
-
-      executionState = ExecutionState.Prepared;
-    }
-
-    public void Start() {
-      cancellationTokenSource = new CancellationTokenSource();
-
-      Task task = Task.Factory.StartNew(RunModifiers, cancellationTokenSource.Token, cancellationTokenSource.Token);
-      task.ContinueWith(t => {
-        try {
-          t.Wait();
-        }
-        catch (AggregateException ex) {
-          try {
-            ex.Flatten().Handle(x => x is OperationCanceledException);
-          }
-          catch (AggregateException remaining) {
-            if (remaining.InnerExceptions.Count == 1) OnTaskFailed(remaining.InnerExceptions[0]);
-            else OnTaskFailed(remaining);
-          }
-        }
-        cancellationTokenSource.Dispose();
-        cancellationTokenSource = null;
-        if (stopPending) executionStack.Clear();
-        if (executionStack.Count == 0) OnTaskStopped();
-        else OnTaskPaused();
-      });
-    }
-
-    public void Stop() {
-      if (ExecutionState == ExecutionState.Paused) {
-        executionStack.Clear();
-        OnTaskStopped();
-      } else {
-        stopPending = true;
-        cancellationTokenSource.Cancel();
+    public override bool CanChangeDescription {
+      get {
+        if (Item == null)
+          return false;
+        else
+          return Item.CanChangeDescription;
       }
     }
 
-    public virtual void AddRunCollectionModifiers(IRunCollectionModifier modifier) {
-      RunCollectionModifiers.Add(modifier);
-    }
-
-    protected virtual void RunModifiers(object state) {
-      CancellationToken ct = (CancellationToken)state;
-      OnTaskStarted();
-
-      IRunCollectionModifier next;
-      while (executionStack.Count > 0) {
-        next = executionStack.Pop();
-        try {
-          ct.ThrowIfCancellationRequested();
-          next.Modify(runCollection.ToList());
-        }
-        catch (Exception ex) {
-          executionStack.Push(next);
-          if (ex is OperationCanceledException) throw ex;
-          else throw new Exception("IRunCollectionModifier " + next + "threw an exception.", ex);
-        }
+    public override bool CanChangeName {
+      get {
+        if (Item == null)
+          return false;
+        else
+          return Item.CanChangeName;
       }
     }
 
-    #region Events
-    public event EventHandler TaskStarted;
-    protected virtual void OnTaskStarted() {
-      executionState = ExecutionState.Started;
-      EventHandler handler = TaskStarted;
-      if (handler != null) handler(this, EventArgs.Empty);
+    public override string Description {
+      get {
+        if (Item == null)
+          return string.Empty;
+        else
+          return Item.Description;
+      }
+      set { Item.Description = value; }
     }
 
-    public event EventHandler TaskStopped;
-    protected virtual void OnTaskStopped() {
-      executionState = ExecutionState.Stopped;
-      EventHandler handler = TaskStopped;
-      if (handler != null) handler(this, EventArgs.Empty);
+    public override string Name {
+      get {
+        if (Item == null)
+          return "RunCollectionModifierTask";
+        else
+          return Item.Name;
+      }
+      set { Item.Name = value; }
     }
 
-    public event EventHandler TaskPaused;
-    protected virtual void OnTaskPaused() {
-      executionState = ExecutionState.Paused;
-      EventHandler handler = TaskPaused;
-      if (handler != null) handler(this, EventArgs.Empty);
+    public override ExecutionState ExecutionState {
+      get { return Item.ExecutionState; }
     }
 
-    public event EventHandler TaskFailed;
-    protected virtual void OnTaskFailed(Exception e) {
-      var eventArgs = new EventArgs<Exception>(e);
-      Log.LogException(e);
-      EventHandler handler = TaskFailed;
-      if (handler != null) handler(this, eventArgs);
+    public override TimeSpan ExecutionTime {
+      get { return Item.ExecutionTime; }
     }
 
-    public event EventHandler ExecutionTimeChanged;
-    protected virtual void OnExecutionTimeChanged() {
-      EventHandler handler = ExecutionTimeChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
+    public override void Pause() {
+      Item.Pause();
     }
 
-    public event EventHandler ExecutionStateChanged;
-    protected virtual void OnExecutionStateChanged() {
-      EventHandler handler = ExecutionStateChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
+    public override void Prepare() {
+      Item.Prepare();
     }
 
-    public event EventHandler ComputeInParallelChanged; //not needed
-    #endregion
+    public override void Start() {
+      Item.Start();
+    }
+
+    public override void Stop() {
+      Item.Stop();
+    }
+
+    protected override void RegisterItemEvents() {
+      base.RegisterItemEvents();
+      Item.Stopped += new EventHandler(executable_Stopped);
+      Item.Paused += new EventHandler(executable_Paused);
+      Item.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(executable_ExceptionOccurred);
+      Item.DescriptionChanged += new EventHandler(executable_DescriptionChanged);
+      Item.NameChanged += new EventHandler(executable_NameChanged);
+      Item.NameChanging += new EventHandler<CancelEventArgs<string>>(executable_NameChanging);
+      Item.ExecutionStateChanged += new EventHandler(executable_ExecutionStateChanged);
+      Item.ExecutionTimeChanged += new EventHandler(executable_ExecutionTimeChanged);
+      Item.Started += new EventHandler(executable_Started);
+    }
+
+    protected virtual void DeregisterOptimizerEvents() {
+      Item.Stopped -= new EventHandler(executable_Stopped);
+      Item.Paused -= new EventHandler(executable_Paused);
+      Item.ExceptionOccurred -= new EventHandler<EventArgs<Exception>>(executable_ExceptionOccurred);
+      Item.DescriptionChanged -= new EventHandler(executable_DescriptionChanged);
+      Item.NameChanged -= new EventHandler(executable_NameChanged);
+      Item.NameChanging -= new EventHandler<CancelEventArgs<string>>(executable_NameChanging);
+      Item.ExecutionStateChanged -= new EventHandler(executable_ExecutionStateChanged);
+      Item.ExecutionTimeChanged -= new EventHandler(executable_ExecutionTimeChanged);
+      Item.Started -= new EventHandler(executable_Started);
+      base.DeregisterItemEvents();
+    }
+
+    protected void executable_NameChanging(object sender, CancelEventArgs<string> e) {
+      OnNameChanging(new CancelEventArgs<string>(e.Value, e.Cancel));
+    }
+
+    protected void executable_NameChanged(object sender, EventArgs e) {
+      this.OnNameChanged();
+    }
+
+    protected void executable_DescriptionChanged(object sender, EventArgs e) {
+      OnDescriptionChanged();
+    }
+
+    protected virtual void executable_ExceptionOccurred(object sender, EventArgs<Exception> e) {
+      OnTaskFailed(e);
+    }
+
+    protected virtual void executable_Started(object sender, EventArgs e) {
+      OnTaskStarted();
+    }
+
+    protected virtual void executable_Stopped(object sender, EventArgs e) {
+      OnTaskStopped();
+    }
+
+    protected virtual void executable_Paused(object sender, EventArgs e) {
+      OnTaskPaused();
+    }
+
+    protected virtual void executable_ExecutionTimeChanged(object sender, EventArgs e) {
+      OnExecutionTimeChanged();
+    }
+
+    protected virtual void executable_ExecutionStateChanged(object sender, EventArgs e) {
+      OnExecutionStateChanged();
+    }
   }
 }
