Index: /trunk/sources/HeuristicLab 3.3.sln
===================================================================
--- /trunk/sources/HeuristicLab 3.3.sln	(revision 2772)
+++ /trunk/sources/HeuristicLab 3.3.sln	(revision 2773)
@@ -68,4 +68,5 @@
 		{DC3D7072-7999-4719-B65D-3997744D5DC1} = {DC3D7072-7999-4719-B65D-3997744D5DC1}
 		{BF7D9494-A586-457B-8DF9-ED599F9E6A71} = {BF7D9494-A586-457B-8DF9-ED599F9E6A71}
+		{F4539FB6-4708-40C9-BE64-0A1390AEA197} = {F4539FB6-4708-40C9-BE64-0A1390AEA197}
 		{958B43BC-CC5C-4FA2-8628-2B3B01D890B6} = {958B43BC-CC5C-4FA2-8628-2B3B01D890B6}
 		{AB687BBE-1BFE-476B-906D-44237135431D} = {AB687BBE-1BFE-476B-906D-44237135431D}
Index: /trunk/sources/HeuristicLab.Core/3.3/Engine.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Engine.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Core/3.3/Engine.cs	(revision 2773)
@@ -93,9 +93,9 @@
     /// </summary>
     [Storable]
-    private Stack<IExecutionContext> executionStack;
+    private Stack<IExecutionSequence> executionStack;
     /// <summary>
     /// Gets the current execution stack.
     /// </summary>
-    protected Stack<IExecutionContext> ExecutionStack {
+    protected Stack<IExecutionSequence> ExecutionStack {
       get { return executionStack; }
     }
@@ -135,5 +135,5 @@
     protected Engine() {
       globalScope = new Scope("Global");
-      executionStack = new Stack<IExecutionContext>();
+      executionStack = new Stack<IExecutionSequence>();
       OperatorGraph = new OperatorGraph();
     }
@@ -151,7 +151,7 @@
       clone.globalScope = (Scope)cloner.Clone(globalScope);
       clone.executionTime = executionTime;
-      IExecutionContext[] contexts = executionStack.ToArray();
+      IExecutionSequence[] contexts = executionStack.ToArray();
       for (int i = contexts.Length - 1; i >= 0; i--)
-        clone.executionStack.Push((IExecutionContext)cloner.Clone(contexts[i]));
+        clone.executionStack.Push((IExecutionSequence)cloner.Clone(contexts[i]));
       clone.running = running;
       clone.canceled = canceled;
Index: /trunk/sources/HeuristicLab.Core/3.3/ExecutionContext.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/ExecutionContext.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Core/3.3/ExecutionContext.cs	(revision 2773)
@@ -26,5 +26,5 @@
 
 namespace HeuristicLab.Core {
-  public class ExecutionContext : DeepCloneable, IExecutionContext {
+  public class ExecutionContext : DeepCloneable, IExecutionSequence {
     [Storable]
     private ExecutionContext parent;
Index: /trunk/sources/HeuristicLab.Core/3.3/ExecutionContextCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/ExecutionContextCollection.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Core/3.3/ExecutionContextCollection.cs	(revision 2773)
@@ -28,7 +28,7 @@
 
 namespace HeuristicLab.Core {
-  public class ExecutionContextCollection : DeepCloneable, IList<IExecutionContext>, IExecutionContext {
+  public class ExecutionContextCollection : DeepCloneable, IList<IExecutionSequence>, IExecutionSequence {
     [Storable]
-    private IList<IExecutionContext> contexts;
+    private IList<IExecutionSequence> contexts;
 
     [Storable]
@@ -40,13 +40,13 @@
 
     public ExecutionContextCollection() {
-      contexts = new List<IExecutionContext>();
+      contexts = new List<IExecutionSequence>();
       parallel = false;
     }
-    public ExecutionContextCollection(IEnumerable<IExecutionContext> collection) {
-      contexts = new List<IExecutionContext>(collection.Where(e => e != null));
+    public ExecutionContextCollection(IEnumerable<IExecutionSequence> collection) {
+      contexts = new List<IExecutionSequence>(collection.Where(e => e != null));
       parallel = false;
     }
-    public ExecutionContextCollection(params IExecutionContext[] list) {
-      contexts = new List<IExecutionContext>(list.Where(e => e != null));
+    public ExecutionContextCollection(params IExecutionSequence[] list) {
+      contexts = new List<IExecutionSequence>(list.Where(e => e != null));
       parallel = false;
     }
@@ -57,13 +57,13 @@
       clone.parallel = parallel;
       for (int i = 0; i < contexts.Count; i++)
-        clone.contexts.Add((IExecutionContext)cloner.Clone(contexts[i]));
+        clone.contexts.Add((IExecutionSequence)cloner.Clone(contexts[i]));
       return clone;
     }
 
     #region IList<IExecutionContext> Members
-    public int IndexOf(IExecutionContext item) {
+    public int IndexOf(IExecutionSequence item) {
       return contexts.IndexOf(item);
     }
-    public void Insert(int index, IExecutionContext item) {
+    public void Insert(int index, IExecutionSequence item) {
       if (item != null) contexts.Insert(index, item);
     }
@@ -71,5 +71,5 @@
       contexts.RemoveAt(index);
     }
-    public IExecutionContext this[int index] {
+    public IExecutionSequence this[int index] {
       get { return contexts[index]; }
       set { if (value != null) contexts[index] = value; }
@@ -78,5 +78,5 @@
 
     #region ICollection<IExecutionContext> Members
-    public void Add(IExecutionContext item) {
+    public void Add(IExecutionSequence item) {
       if (item != null) contexts.Add(item);
     }
@@ -84,8 +84,8 @@
       contexts.Clear();
     }
-    public bool Contains(IExecutionContext item) {
+    public bool Contains(IExecutionSequence item) {
       return contexts.Contains(item);
     }
-    public void CopyTo(IExecutionContext[] array, int arrayIndex) {
+    public void CopyTo(IExecutionSequence[] array, int arrayIndex) {
       contexts.CopyTo(array, arrayIndex);
     }
@@ -96,5 +96,5 @@
       get { return contexts.IsReadOnly; }
     }
-    public bool Remove(IExecutionContext item) {
+    public bool Remove(IExecutionSequence item) {
       return contexts.Remove(item);
     }
@@ -102,5 +102,5 @@
 
     #region IEnumerable<IExecutionContext> Members
-    public IEnumerator<IExecutionContext> GetEnumerator() {
+    public IEnumerator<IExecutionSequence> GetEnumerator() {
       return contexts.GetEnumerator();
     }
Index: /trunk/sources/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 2772)
+++ /trunk/sources/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 2773)
@@ -104,5 +104,5 @@
     <Compile Include="ChangedEventArgs.cs" />
     <None Include="HeuristicLabCorePlugin.cs.frame" />
-    <Compile Include="Interfaces\IExecutionContext.cs" />
+    <Compile Include="Interfaces\IExecutionSequence.cs" />
     <Compile Include="Interfaces\IValueLookupParameter.cs" />
     <Compile Include="Interfaces\IValueParameter.cs" />
Index: unk/sources/HeuristicLab.Core/3.3/Interfaces/IExecutionContext.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IExecutionContext.cs	(revision 2772)
+++ 	(revision )
@@ -1,33 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Text;
-using System.Drawing;
-
-namespace HeuristicLab.Core {
-  /// <summary>
-  /// Interface which represents an execution context.
-  /// </summary>
-  public interface IExecutionContext : IDeepCloneable { }
-}
Index: /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IExecutionSequence.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IExecutionSequence.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IExecutionSequence.cs	(revision 2773)
@@ -0,0 +1,33 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Text;
+using System.Drawing;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface which represents an execution context.
+  /// </summary>
+  public interface IExecutionSequence : IDeepCloneable { }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IOperator.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IOperator.cs	(revision 2773)
@@ -44,5 +44,5 @@
     /// <param name="scope">The scope where to execute the current instance.</param>
     /// <returns>The next operation.</returns>
-    IExecutionContext Execute(ExecutionContext context);
+    IExecutionSequence Execute(ExecutionContext context);
     /// <summary>
     /// Aborts the current operator.
Index: /trunk/sources/HeuristicLab.Operators.Views/3.3/HeuristicLab.Operators.Views-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Operators.Views/3.3/HeuristicLab.Operators.Views-3.3.csproj	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators.Views/3.3/HeuristicLab.Operators.Views-3.3.csproj	(revision 2773)
@@ -58,9 +58,15 @@
     </Compile>
     <None Include="HeuristicLabOperatorsViewsPlugin.cs.frame" />
-    <Compile Include="MultipleSuccessorsOperatorView.cs">
+    <Compile Include="MultipleCallsOperatorView.cs">
       <SubType>UserControl</SubType>
     </Compile>
-    <Compile Include="MultipleSuccessorsOperatorView.Designer.cs">
-      <DependentUpon>MultipleSuccessorsOperatorView.cs</DependentUpon>
+    <Compile Include="MultipleCallsOperatorView.Designer.cs">
+      <DependentUpon>MultipleCallsOperatorView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="ValuesCollectorView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="ValuesCollectorView.Designer.cs">
+      <DependentUpon>ValuesCollectorView.cs</DependentUpon>
     </Compile>
     <Compile Include="HeuristicLabOperatorsViewsPlugin.cs" />
Index: /trunk/sources/HeuristicLab.Operators.Views/3.3/MultipleCallsOperatorView.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators.Views/3.3/MultipleCallsOperatorView.Designer.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Operators.Views/3.3/MultipleCallsOperatorView.Designer.cs	(revision 2773)
@@ -0,0 +1,158 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace HeuristicLab.Operators.Views {
+  partial class MultipleCallsOperatorView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing) {
+        if (components != null) components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.tabControl = new System.Windows.Forms.TabControl();
+      this.operatorsTabPage = new System.Windows.Forms.TabPage();
+      this.operatorListView = new HeuristicLab.Core.Views.OperatorListView();
+      this.parametersTabPage = new System.Windows.Forms.TabPage();
+      this.parameterCollectionView = new HeuristicLab.Core.Views.ParameterCollectionView();
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
+      this.tabControl.SuspendLayout();
+      this.operatorsTabPage.SuspendLayout();
+      this.parametersTabPage.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // nameTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.errorProvider.SetIconPadding(this.nameTextBox, 2);
+      this.nameTextBox.Size = new System.Drawing.Size(414, 20);
+      // 
+      // descriptionTextBox
+      // 
+      this.descriptionTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.descriptionTextBox.Size = new System.Drawing.Size(414, 86);
+      // 
+      // tabControl
+      // 
+      this.tabControl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.tabControl.Controls.Add(this.operatorsTabPage);
+      this.tabControl.Controls.Add(this.parametersTabPage);
+      this.tabControl.Location = new System.Drawing.Point(0, 118);
+      this.tabControl.Name = "tabControl";
+      this.tabControl.SelectedIndex = 0;
+      this.tabControl.Size = new System.Drawing.Size(486, 364);
+      this.tabControl.TabIndex = 4;
+      // 
+      // operatorsTabPage
+      // 
+      this.operatorsTabPage.Controls.Add(this.operatorListView);
+      this.operatorsTabPage.Location = new System.Drawing.Point(4, 22);
+      this.operatorsTabPage.Name = "operatorsTabPage";
+      this.operatorsTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.operatorsTabPage.Size = new System.Drawing.Size(478, 338);
+      this.operatorsTabPage.TabIndex = 0;
+      this.operatorsTabPage.Text = "Operators";
+      this.operatorsTabPage.UseVisualStyleBackColor = true;
+      // 
+      // operatorListView
+      // 
+      this.operatorListView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.operatorListView.Caption = "Operator List";
+      this.operatorListView.Content = null;
+      this.operatorListView.Location = new System.Drawing.Point(6, 6);
+      this.operatorListView.Name = "operatorListView";
+      this.operatorListView.Size = new System.Drawing.Size(466, 326);
+      this.operatorListView.TabIndex = 0;
+      // 
+      // parametersTabPage
+      // 
+      this.parametersTabPage.Controls.Add(this.parameterCollectionView);
+      this.parametersTabPage.Location = new System.Drawing.Point(4, 22);
+      this.parametersTabPage.Name = "parametersTabPage";
+      this.parametersTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.parametersTabPage.Size = new System.Drawing.Size(478, 338);
+      this.parametersTabPage.TabIndex = 1;
+      this.parametersTabPage.Text = "Parameters";
+      this.parametersTabPage.UseVisualStyleBackColor = true;
+      // 
+      // parameterCollectionView
+      // 
+      this.parameterCollectionView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.parameterCollectionView.Caption = "ParameterCollection";
+      this.parameterCollectionView.Content = null;
+      this.parameterCollectionView.Location = new System.Drawing.Point(6, 6);
+      this.parameterCollectionView.Name = "parameterCollectionView";
+      this.parameterCollectionView.Size = new System.Drawing.Size(466, 326);
+      this.parameterCollectionView.TabIndex = 0;
+      // 
+      // MultipleCallsOperatorView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.tabControl);
+      this.Name = "MultipleCallsOperatorView";
+      this.Size = new System.Drawing.Size(486, 482);
+      this.Controls.SetChildIndex(this.tabControl, 0);
+      this.Controls.SetChildIndex(this.nameLabel, 0);
+      this.Controls.SetChildIndex(this.descriptionLabel, 0);
+      this.Controls.SetChildIndex(this.nameTextBox, 0);
+      this.Controls.SetChildIndex(this.descriptionTextBox, 0);
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
+      this.tabControl.ResumeLayout(false);
+      this.operatorsTabPage.ResumeLayout(false);
+      this.parametersTabPage.ResumeLayout(false);
+      this.ResumeLayout(false);
+      this.PerformLayout();
+
+    }
+
+    #endregion
+
+    protected System.Windows.Forms.TabControl tabControl;
+    protected System.Windows.Forms.TabPage operatorsTabPage;
+    protected System.Windows.Forms.TabPage parametersTabPage;
+    private HeuristicLab.Core.Views.ParameterCollectionView parameterCollectionView;
+    private HeuristicLab.Core.Views.OperatorListView operatorListView;
+  }
+}
Index: /trunk/sources/HeuristicLab.Operators.Views/3.3/MultipleCallsOperatorView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators.Views/3.3/MultipleCallsOperatorView.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Operators.Views/3.3/MultipleCallsOperatorView.cs	(revision 2773)
@@ -0,0 +1,72 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Text;
+using System.Windows.Forms;
+using HeuristicLab.Core;
+using HeuristicLab.Core.Views;
+using HeuristicLab.MainForm;
+
+namespace HeuristicLab.Operators.Views { 
+  /// <summary>
+  /// The base class for visual representations of items.
+  /// </summary>
+  [Content(typeof(MultipleCallsOperator), true)]
+  public partial class MultipleCallsOperatorView : NamedItemView {
+    public new MultipleCallsOperator Content {
+      get { return (MultipleCallsOperator)base.Content; }
+      set { base.Content = value; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ItemBaseView"/>.
+    /// </summary>
+    public MultipleCallsOperatorView() {
+      InitializeComponent();
+    }
+    /// <summary>
+    /// Intializes a new instance of <see cref="ItemBaseView"/> with the given <paramref name="item"/>.
+    /// </summary>
+    /// <param name="item">The item that should be displayed.</param>
+    public MultipleCallsOperatorView(MultipleCallsOperator content)
+      : this() {
+      Content = content;
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content == null) {
+        operatorListView.Content = null;
+        parameterCollectionView.Content = null;
+        tabControl.Enabled = false;
+      } else {
+        operatorListView.Content = Content.Operators;
+        parameterCollectionView.Content = ((IOperator)Content).Parameters;
+        tabControl.Enabled = true;
+      }
+    }
+  }
+}
Index: unk/sources/HeuristicLab.Operators.Views/3.3/MultipleSuccessorsOperatorView.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators.Views/3.3/MultipleSuccessorsOperatorView.Designer.cs	(revision 2772)
+++ 	(revision )
@@ -1,158 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-namespace HeuristicLab.Operators.Views {
-  partial class MultipleSuccessorsOperatorView {
-    /// <summary> 
-    /// Required designer variable.
-    /// </summary>
-    private System.ComponentModel.IContainer components = null;
-
-    /// <summary> 
-    /// Clean up any resources being used.
-    /// </summary>
-    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-    protected override void Dispose(bool disposing) {
-      if (disposing) {
-        if (components != null) components.Dispose();
-      }
-      base.Dispose(disposing);
-    }
-
-    #region Component Designer generated code
-
-    /// <summary> 
-    /// Required method for Designer support - do not modify 
-    /// the contents of this method with the code editor.
-    /// </summary>
-    private void InitializeComponent() {
-      this.tabControl = new System.Windows.Forms.TabControl();
-      this.successorsTabPage = new System.Windows.Forms.TabPage();
-      this.successorsListView = new HeuristicLab.Core.Views.OperatorListView();
-      this.parametersTabPage = new System.Windows.Forms.TabPage();
-      this.parameterCollectionView = new HeuristicLab.Core.Views.ParameterCollectionView();
-      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
-      this.tabControl.SuspendLayout();
-      this.successorsTabPage.SuspendLayout();
-      this.parametersTabPage.SuspendLayout();
-      this.SuspendLayout();
-      // 
-      // nameTextBox
-      // 
-      this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
-      this.errorProvider.SetIconPadding(this.nameTextBox, 2);
-      this.nameTextBox.Size = new System.Drawing.Size(414, 20);
-      // 
-      // descriptionTextBox
-      // 
-      this.descriptionTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-                  | System.Windows.Forms.AnchorStyles.Right)));
-      this.descriptionTextBox.Size = new System.Drawing.Size(414, 86);
-      // 
-      // tabControl
-      // 
-      this.tabControl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
-                  | System.Windows.Forms.AnchorStyles.Left)
-                  | System.Windows.Forms.AnchorStyles.Right)));
-      this.tabControl.Controls.Add(this.successorsTabPage);
-      this.tabControl.Controls.Add(this.parametersTabPage);
-      this.tabControl.Location = new System.Drawing.Point(0, 118);
-      this.tabControl.Name = "tabControl";
-      this.tabControl.SelectedIndex = 0;
-      this.tabControl.Size = new System.Drawing.Size(486, 364);
-      this.tabControl.TabIndex = 4;
-      // 
-      // successorsTabPage
-      // 
-      this.successorsTabPage.Controls.Add(this.successorsListView);
-      this.successorsTabPage.Location = new System.Drawing.Point(4, 22);
-      this.successorsTabPage.Name = "successorsTabPage";
-      this.successorsTabPage.Padding = new System.Windows.Forms.Padding(3);
-      this.successorsTabPage.Size = new System.Drawing.Size(478, 338);
-      this.successorsTabPage.TabIndex = 0;
-      this.successorsTabPage.Text = "Successors";
-      this.successorsTabPage.UseVisualStyleBackColor = true;
-      // 
-      // successorsListView
-      // 
-      this.successorsListView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
-                  | System.Windows.Forms.AnchorStyles.Left)
-                  | System.Windows.Forms.AnchorStyles.Right)));
-      this.successorsListView.Caption = "Operator List";
-      this.successorsListView.Content = null;
-      this.successorsListView.Location = new System.Drawing.Point(6, 6);
-      this.successorsListView.Name = "successorsListView";
-      this.successorsListView.Size = new System.Drawing.Size(466, 326);
-      this.successorsListView.TabIndex = 0;
-      // 
-      // parametersTabPage
-      // 
-      this.parametersTabPage.Controls.Add(this.parameterCollectionView);
-      this.parametersTabPage.Location = new System.Drawing.Point(4, 22);
-      this.parametersTabPage.Name = "parametersTabPage";
-      this.parametersTabPage.Padding = new System.Windows.Forms.Padding(3);
-      this.parametersTabPage.Size = new System.Drawing.Size(478, 338);
-      this.parametersTabPage.TabIndex = 1;
-      this.parametersTabPage.Text = "Parameters";
-      this.parametersTabPage.UseVisualStyleBackColor = true;
-      // 
-      // parameterCollectionView
-      // 
-      this.parameterCollectionView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
-                  | System.Windows.Forms.AnchorStyles.Left)
-                  | System.Windows.Forms.AnchorStyles.Right)));
-      this.parameterCollectionView.Caption = "ParameterCollection";
-      this.parameterCollectionView.Content = null;
-      this.parameterCollectionView.Location = new System.Drawing.Point(6, 6);
-      this.parameterCollectionView.Name = "parameterCollectionView";
-      this.parameterCollectionView.Size = new System.Drawing.Size(466, 326);
-      this.parameterCollectionView.TabIndex = 0;
-      // 
-      // MultipleSuccessorsOperatorView
-      // 
-      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-      this.Controls.Add(this.tabControl);
-      this.Name = "MultipleSuccessorsOperatorView";
-      this.Size = new System.Drawing.Size(486, 482);
-      this.Controls.SetChildIndex(this.tabControl, 0);
-      this.Controls.SetChildIndex(this.nameLabel, 0);
-      this.Controls.SetChildIndex(this.descriptionLabel, 0);
-      this.Controls.SetChildIndex(this.nameTextBox, 0);
-      this.Controls.SetChildIndex(this.descriptionTextBox, 0);
-      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
-      this.tabControl.ResumeLayout(false);
-      this.successorsTabPage.ResumeLayout(false);
-      this.parametersTabPage.ResumeLayout(false);
-      this.ResumeLayout(false);
-      this.PerformLayout();
-
-    }
-
-    #endregion
-
-    protected System.Windows.Forms.TabControl tabControl;
-    protected System.Windows.Forms.TabPage successorsTabPage;
-    protected System.Windows.Forms.TabPage parametersTabPage;
-    private HeuristicLab.Core.Views.ParameterCollectionView parameterCollectionView;
-    private HeuristicLab.Core.Views.OperatorListView successorsListView;
-  }
-}
Index: unk/sources/HeuristicLab.Operators.Views/3.3/MultipleSuccessorsOperatorView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators.Views/3.3/MultipleSuccessorsOperatorView.cs	(revision 2772)
+++ 	(revision )
@@ -1,72 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Drawing;
-using System.Data;
-using System.Text;
-using System.Windows.Forms;
-using HeuristicLab.Core;
-using HeuristicLab.Core.Views;
-using HeuristicLab.MainForm;
-
-namespace HeuristicLab.Operators.Views { 
-  /// <summary>
-  /// The base class for visual representations of items.
-  /// </summary>
-  [Content(typeof(MultipleSuccessorsOperator), true)]
-  public partial class MultipleSuccessorsOperatorView : NamedItemView {
-    public new MultipleSuccessorsOperator Content {
-      get { return (MultipleSuccessorsOperator)base.Content; }
-      set { base.Content = value; }
-    }
-
-    /// <summary>
-    /// Initializes a new instance of <see cref="ItemBaseView"/>.
-    /// </summary>
-    public MultipleSuccessorsOperatorView() {
-      InitializeComponent();
-    }
-    /// <summary>
-    /// Intializes a new instance of <see cref="ItemBaseView"/> with the given <paramref name="item"/>.
-    /// </summary>
-    /// <param name="item">The item that should be displayed.</param>
-    public MultipleSuccessorsOperatorView(MultipleSuccessorsOperator content)
-      : this() {
-      Content = content;
-    }
-
-    protected override void OnContentChanged() {
-      base.OnContentChanged();
-      if (Content == null) {
-        successorsListView.Content = null;
-        parameterCollectionView.Content = null;
-        tabControl.Enabled = false;
-      } else {
-        successorsListView.Content = Content.Successors;
-        parameterCollectionView.Content = ((IOperator)Content).Parameters;
-        tabControl.Enabled = true;
-      }
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.Operators.Views/3.3/ValuesCollectorView.Designer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators.Views/3.3/ValuesCollectorView.Designer.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Operators.Views/3.3/ValuesCollectorView.Designer.cs	(revision 2773)
@@ -0,0 +1,159 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace HeuristicLab.Operators.Views {
+  partial class ValuesCollectorView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing) {
+        if (components != null) components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.tabControl = new System.Windows.Forms.TabControl();
+      this.collectedValuesTabPage = new System.Windows.Forms.TabPage();
+      this.collectedValuesView = new HeuristicLab.Core.Views.ParameterCollectionView();
+      this.parametersTabPage = new System.Windows.Forms.TabPage();
+      this.parameterCollectionView = new HeuristicLab.Core.Views.ParameterCollectionView();
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
+      this.tabControl.SuspendLayout();
+      this.collectedValuesTabPage.SuspendLayout();
+      this.parametersTabPage.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // nameTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.errorProvider.SetIconPadding(this.nameTextBox, 2);
+      this.nameTextBox.Size = new System.Drawing.Size(414, 20);
+      // 
+      // descriptionTextBox
+      // 
+      this.descriptionTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.descriptionTextBox.Size = new System.Drawing.Size(414, 86);
+      // 
+      // tabControl
+      // 
+      this.tabControl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.tabControl.Controls.Add(this.collectedValuesTabPage);
+      this.tabControl.Controls.Add(this.parametersTabPage);
+      this.tabControl.Location = new System.Drawing.Point(0, 118);
+      this.tabControl.Name = "tabControl";
+      this.tabControl.SelectedIndex = 0;
+      this.tabControl.Size = new System.Drawing.Size(486, 364);
+      this.tabControl.TabIndex = 4;
+      // 
+      // collectedValuesTabPage
+      // 
+      this.collectedValuesTabPage.Controls.Add(this.collectedValuesView);
+      this.collectedValuesTabPage.Location = new System.Drawing.Point(4, 22);
+      this.collectedValuesTabPage.Name = "collectedValuesTabPage";
+      this.collectedValuesTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.collectedValuesTabPage.Size = new System.Drawing.Size(478, 338);
+      this.collectedValuesTabPage.TabIndex = 0;
+      this.collectedValuesTabPage.Text = "Collected Values";
+      this.collectedValuesTabPage.UseVisualStyleBackColor = true;
+      // 
+      // collectedValuesView
+      // 
+      this.collectedValuesView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.collectedValuesView.Caption = "ParameterCollection";
+      this.collectedValuesView.Content = null;
+      this.collectedValuesView.Location = new System.Drawing.Point(6, 6);
+      this.collectedValuesView.Name = "collectedValuesView";
+      this.collectedValuesView.Size = new System.Drawing.Size(466, 326);
+      this.collectedValuesView.TabIndex = 0;
+      // 
+      // parametersTabPage
+      // 
+      this.parametersTabPage.Controls.Add(this.parameterCollectionView);
+      this.parametersTabPage.Location = new System.Drawing.Point(4, 22);
+      this.parametersTabPage.Name = "parametersTabPage";
+      this.parametersTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.parametersTabPage.Size = new System.Drawing.Size(478, 338);
+      this.parametersTabPage.TabIndex = 1;
+      this.parametersTabPage.Text = "Parameters";
+      this.parametersTabPage.UseVisualStyleBackColor = true;
+      // 
+      // parameterCollectionView
+      // 
+      this.parameterCollectionView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.parameterCollectionView.Caption = "ParameterCollection";
+      this.parameterCollectionView.Content = null;
+      this.parameterCollectionView.Location = new System.Drawing.Point(6, 6);
+      this.parameterCollectionView.Name = "parameterCollectionView";
+      this.parameterCollectionView.Size = new System.Drawing.Size(466, 326);
+      this.parameterCollectionView.TabIndex = 0;
+      // 
+      // ValuesCollectorView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.tabControl);
+      this.Name = "ValuesCollectorView";
+      this.Size = new System.Drawing.Size(486, 482);
+      this.Controls.SetChildIndex(this.tabControl, 0);
+      this.Controls.SetChildIndex(this.nameLabel, 0);
+      this.Controls.SetChildIndex(this.descriptionLabel, 0);
+      this.Controls.SetChildIndex(this.nameTextBox, 0);
+      this.Controls.SetChildIndex(this.descriptionTextBox, 0);
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
+      this.tabControl.ResumeLayout(false);
+      this.collectedValuesTabPage.ResumeLayout(false);
+      this.parametersTabPage.ResumeLayout(false);
+      this.ResumeLayout(false);
+      this.PerformLayout();
+
+    }
+
+    #endregion
+
+    protected System.Windows.Forms.TabControl tabControl;
+    protected System.Windows.Forms.TabPage collectedValuesTabPage;
+    protected System.Windows.Forms.TabPage parametersTabPage;
+    protected HeuristicLab.Core.Views.ParameterCollectionView parameterCollectionView;
+    protected HeuristicLab.Core.Views.ParameterCollectionView collectedValuesView;
+
+  }
+}
Index: /trunk/sources/HeuristicLab.Operators.Views/3.3/ValuesCollectorView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators.Views/3.3/ValuesCollectorView.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Operators.Views/3.3/ValuesCollectorView.cs	(revision 2773)
@@ -0,0 +1,72 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Text;
+using System.Windows.Forms;
+using HeuristicLab.Core;
+using HeuristicLab.Core.Views;
+using HeuristicLab.MainForm;
+
+namespace HeuristicLab.Operators.Views { 
+  /// <summary>
+  /// The base class for visual representations of items.
+  /// </summary>
+  [Content(typeof(ValuesCollector), true)]
+  public partial class ValuesCollectorView : NamedItemView {
+    public new ValuesCollector Content {
+      get { return (ValuesCollector)base.Content; }
+      set { base.Content = value; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="ItemBaseView"/>.
+    /// </summary>
+    public ValuesCollectorView() {
+      InitializeComponent();
+    }
+    /// <summary>
+    /// Intializes a new instance of <see cref="ItemBaseView"/> with the given <paramref name="item"/>.
+    /// </summary>
+    /// <param name="item">The item that should be displayed.</param>
+    public ValuesCollectorView(ValuesCollector content)
+      : this() {
+      Content = content;
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content == null) {
+        collectedValuesView.Content = null;
+        parameterCollectionView.Content = null;
+        tabControl.Enabled = false;
+      } else {
+        collectedValuesView.Content = Content.CollectedValues;
+        parameterCollectionView.Content = ((IOperator)Content).Parameters;
+        tabControl.Enabled = true;
+      }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Operators/3.3/Assigner.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/Assigner.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Operators/3.3/Assigner.cs	(revision 2773)
@@ -0,0 +1,56 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Operators {
+  /// <summary>
+  /// An operator which clones and assigns the value of one parameter to another parameter.
+  /// </summary>
+  [Item("Assigner", "An operator which clones and assigns the value of one parameter to another parameter.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public sealed class Assigner : SingleSuccessorOperator {
+    public LookupParameter<IItem> LeftSideParameter {
+      get { return (LookupParameter<IItem>)Parameters["LeftSide"]; }
+    }
+    public ValueLookupParameter<IItem> RightSideParameter {
+      get { return (ValueLookupParameter<IItem>)Parameters["RightSide"]; }
+    }
+
+    public Assigner()
+      : base() {
+      Parameters.Add(new LookupParameter<IItem>("LeftSide", "The parameter whose value gets assigned with a clone of the other parameter's value."));
+      Parameters.Add(new ValueLookupParameter<IItem>("RightSide", "The parameter whose value is cloned and assigned to the value of the other parameter."));
+    }
+
+    public override IExecutionSequence Apply() {
+      LeftSideParameter.ActualValue = (IItem)RightSideParameter.ActualValue.Clone();
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Operators/3.3/CombinedOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/CombinedOperator.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/CombinedOperator.cs	(revision 2773)
@@ -68,5 +68,5 @@
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       ExecutionContextCollection next = new ExecutionContextCollection(base.Apply());
       if (operatorGraph.InitialOperator != null)
Index: /trunk/sources/HeuristicLab.Operators/3.3/Comparator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/Comparator.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/Comparator.cs	(revision 2773)
@@ -61,5 +61,5 @@
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       IItem left = LeftSideParameter.ActualValue;
       IItem right = RightSideParameter.ActualValue;
Index: /trunk/sources/HeuristicLab.Operators/3.3/ConditionalBranch.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/ConditionalBranch.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/ConditionalBranch.cs	(revision 2773)
@@ -62,5 +62,5 @@
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       ExecutionContextCollection next = new ExecutionContextCollection(base.Apply());
       if (ConditionParameter.ActualValue.Value) {
Index: unk/sources/HeuristicLab.Operators/3.3/Counter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/Counter.cs	(revision 2772)
+++ 	(revision )
@@ -1,61 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Operators {
-  /// <summary>
-  /// Operator which increments an integer variable.
-  /// </summary>
-  [Item("Counter", "An operator which increments an integer variable.")]
-  [EmptyStorableClass]
-  [Creatable("Test")]
-  public sealed class Counter : SingleSuccessorOperator {
-    public LookupParameter<IntData> ValueParameter {
-      get { return (LookupParameter<IntData>)Parameters["Value"]; }
-    }
-    public ValueLookupParameter<IntData> IncrementParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["Increment"]; }
-    }
-    public IntData Increment {
-      get { return IncrementParameter.Value; }
-      set { IncrementParameter.Value = value; }
-    }
-
-    public Counter()
-      : base() {
-      Parameters.Add(new LookupParameter<IntData>("Value", "The value which should be incremented."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Increment", "The increment which is added to the value.", new IntData(1)));
-    }
-
-    public override IExecutionContext Apply() {
-      if (ValueParameter.ActualValue == null) ValueParameter.ActualValue = new IntData();
-      ValueParameter.ActualValue.Value += IncrementParameter.ActualValue.Value;
-      return base.Apply();
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.Operators/3.3/DoubleCounter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/DoubleCounter.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/DoubleCounter.cs	(revision 2773)
@@ -30,5 +30,5 @@
 namespace HeuristicLab.Operators {
   /// <summary>
-  /// Operator which increments a double variable.
+  /// An operator which increments a double variable.
   /// </summary>
   [Item("DoubleCounter", "An operator which increments a double variable.")]
@@ -53,5 +53,5 @@
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       if (ValueParameter.ActualValue == null) ValueParameter.ActualValue = new DoubleData();
       ValueParameter.ActualValue.Value += IncrementParameter.ActualValue.Value;
Index: /trunk/sources/HeuristicLab.Operators/3.3/HeuristicLab.Operators-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/HeuristicLab.Operators-3.3.csproj	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/HeuristicLab.Operators-3.3.csproj	(revision 2773)
@@ -89,14 +89,18 @@
     <Compile Include="ConditionalBranch.cs" />
     <Compile Include="Comparator.cs" />
+    <Compile Include="Assigner.cs" />
+    <Compile Include="MultipleCallsOperator.cs" />
+    <Compile Include="ParallelSubScopesProcessor.cs" />
+    <Compile Include="Placeholder.cs" />
+    <Compile Include="SingleCallOperator.cs" />
+    <Compile Include="IntCounter.cs" />
     <Compile Include="ScopeCleaner.cs" />
+    <Compile Include="SequentialSubScopesProcessor.cs" />
+    <Compile Include="StochasticBranch.cs" />
     <Compile Include="SubScopesRemover.cs" />
     <Compile Include="SubScopesSorter.cs" />
     <Compile Include="DoubleCounter.cs" />
-    <Compile Include="ParallelProcessor.cs" />
     <Compile Include="UniformParallelSubScopesProcessor.cs" />
     <Compile Include="UniformSequentialSubScopesProcessor.cs" />
-    <Compile Include="ValueCollector.cs" />
-    <Compile Include="MultipleSuccessorsOperator.cs" />
-    <Compile Include="Counter.cs" />
     <Compile Include="EmptyOperator.cs">
       <SubType>Code</SubType>
@@ -105,7 +109,7 @@
     <Compile Include="Operator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="SequentialProcessor.cs" />
     <Compile Include="SingleSuccessorOperator.cs" />
     <Compile Include="SubScopesCreater.cs" />
+    <Compile Include="ValuesCollector.cs" />
     <Compile Include="VariableInjector.cs">
       <SubType>Code</SubType>
Index: /trunk/sources/HeuristicLab.Operators/3.3/IntCounter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/IntCounter.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Operators/3.3/IntCounter.cs	(revision 2773)
@@ -0,0 +1,61 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Operators {
+  /// <summary>
+  /// An operator which increments an integer variable.
+  /// </summary>
+  [Item("IntCounter", "An operator which increments an integer variable.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public sealed class IntCounter : SingleSuccessorOperator {
+    public LookupParameter<IntData> ValueParameter {
+      get { return (LookupParameter<IntData>)Parameters["Value"]; }
+    }
+    public ValueLookupParameter<IntData> IncrementParameter {
+      get { return (ValueLookupParameter<IntData>)Parameters["Increment"]; }
+    }
+    public IntData Increment {
+      get { return IncrementParameter.Value; }
+      set { IncrementParameter.Value = value; }
+    }
+
+    public IntCounter()
+      : base() {
+      Parameters.Add(new LookupParameter<IntData>("Value", "The value which should be incremented."));
+      Parameters.Add(new ValueLookupParameter<IntData>("Increment", "The increment which is added to the value.", new IntData(1)));
+    }
+
+    public override IExecutionSequence Apply() {
+      if (ValueParameter.ActualValue == null) ValueParameter.ActualValue = new IntData();
+      ValueParameter.ActualValue.Value += IncrementParameter.ActualValue.Value;
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Operators/3.3/MultipleCallsOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/MultipleCallsOperator.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Operators/3.3/MultipleCallsOperator.cs	(revision 2773)
@@ -0,0 +1,119 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Operators {
+  /// <summary>
+  /// An operator which applies multiple operators sequentially on the current scope.
+  /// </summary>
+  [Item("MultipleCallsOperator", "An operator which applies multiple operators sequentially on the current scope.")]
+  [Creatable("Test")]
+  public class MultipleCallsOperator : SingleSuccessorOperator {
+    protected IValueParameter<IOperator>[] OperatorParameters {
+      get {
+        return (from p in Parameters
+                where p is IValueParameter<IOperator>
+                where Operators.Contains(((IValueParameter<IOperator>)p).Value)
+                orderby p.Name ascending
+                select (IValueParameter<IOperator>)p).ToArray();
+      }
+    }
+
+    private OperatorList operators;
+    [Storable]
+    public OperatorList Operators {
+      get { return operators; }
+      private set {
+        operators = value;
+        operators.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(operators_ItemsAdded);
+        operators.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(operators_ItemsRemoved);
+        operators.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(operators_ItemsReplaced);
+        operators.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(operators_ItemsMoved);
+        operators.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(operators_CollectionReset);
+        var opParams = OperatorParameters;
+        foreach (IValueParameter<IOperator> opParam in opParams)
+          opParam.ValueChanged += new EventHandler(opParam_ValueChanged);
+      }
+    }
+
+    public MultipleCallsOperator()
+      : base() {
+      Operators = new OperatorList();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      MultipleCallsOperator clone = (MultipleCallsOperator)base.Clone(cloner);
+      clone.Operators = (OperatorList)cloner.Clone(operators);
+      return clone;
+    }
+
+    private void UpdateOperatorParameters() {
+      var opParams = OperatorParameters;
+      foreach (IValueParameter<IOperator> opParam in opParams) {
+        opParam.ValueChanged -= new EventHandler(opParam_ValueChanged);
+        Parameters.Remove(opParam.Name);
+      }
+      for (int i = 0; i < Operators.Count; i++) {
+        IValueParameter<IOperator> opParam = new OperatorParameter(i.ToString(), string.Empty, Operators[i]);
+        opParam.ValueChanged += new EventHandler(opParam_ValueChanged);
+        Parameters.Add(opParam);
+      }
+    }
+    private void operators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOperator>> e) {
+      UpdateOperatorParameters();
+    }
+    private void operators_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOperator>> e) {
+      UpdateOperatorParameters();
+    }
+    private void operators_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOperator>> e) {
+      foreach (IndexedItem<IOperator> item in e.Items)
+        ((IValueParameter<IOperator>)Parameters[item.Index.ToString()]).Value = item.Value;
+    }
+    private void operators_ItemsMoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOperator>> e) {
+      foreach (IndexedItem<IOperator> item in e.Items)
+        ((IValueParameter<IOperator>)Parameters[item.Index.ToString()]).Value = item.Value;
+    }
+    private void operators_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOperator>> e) {
+      UpdateOperatorParameters();
+    }
+    private void opParam_ValueChanged(object sender, EventArgs e) {
+      IValueParameter<IOperator> opParam = (IValueParameter<IOperator>)sender;
+      int index = int.Parse(opParam.Name);
+      operators[index] = opParam.Value;
+    }
+
+    public override IExecutionSequence Apply() {
+      ExecutionContextCollection next = new ExecutionContextCollection(base.Apply());
+      for (int i = Operators.Count - 1; i >= 0; i--)
+        next.Insert(0, new ExecutionContext(ExecutionContext.Parent, Operators[i], ExecutionContext.Scope));
+      return next;
+    }
+  }
+}
Index: unk/sources/HeuristicLab.Operators/3.3/MultipleSuccessorsOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/MultipleSuccessorsOperator.cs	(revision 2772)
+++ 	(revision )
@@ -1,109 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Xml;
-using HeuristicLab.Collections;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Operators {
-  /// <summary>
-  /// A base class for operators which have multiple successors.
-  /// </summary>
-  [Item("MultipleSuccessorsOperator", "A base class for operators which have multiple successors.")]
-  [Creatable("Test")]
-  [EmptyStorableClass]
-  public abstract class MultipleSuccessorsOperator : Operator {
-    protected IValueParameter<IOperator>[] SuccessorParameters {
-      get {
-        return (from p in Parameters
-                where p is IValueParameter<IOperator>
-                orderby p.Name ascending
-                select (IValueParameter<IOperator>)p).ToArray();
-      }
-    }
-
-    private OperatorList successors;
-    public OperatorList Successors {
-      get {
-        if (successors == null) {
-          successors = new OperatorList();
-          var opParams = SuccessorParameters;
-          foreach (IValueParameter<IOperator> opParam in opParams) {
-            opParam.ValueChanged += new EventHandler(opParam_ValueChanged);
-            successors.Add(opParam.Value);
-          }
-          successors.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(successors_ItemsAdded);
-          successors.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(successors_ItemsRemoved);
-          successors.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(successors_ItemsReplaced);
-          successors.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(successors_ItemsMoved);
-          successors.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<IOperator>>(successors_CollectionReset);
-        }
-        return successors;
-      }
-    }
-
-    public MultipleSuccessorsOperator()
-      : base() {
-    }
-
-    private void UpdateOperatorParameters() {
-      var opParams = SuccessorParameters;
-      foreach (IValueParameter<IOperator> opParam in opParams) {
-        opParam.ValueChanged -= new EventHandler(opParam_ValueChanged);
-        Parameters.Remove(opParam.Name);
-      }
-      for (int i = 0; i < Successors.Count; i++) {
-        IValueParameter<IOperator> opParam = new OperatorParameter(i.ToString(), string.Empty, Successors[i]);
-        opParam.ValueChanged += new EventHandler(opParam_ValueChanged);
-        Parameters.Add(opParam);
-      }
-    }
-
-    private void successors_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOperator>> e) {
-      UpdateOperatorParameters();
-    }
-    private void successors_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOperator>> e) {
-      UpdateOperatorParameters();
-    }
-    private void successors_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOperator>> e) {
-      foreach (IndexedItem<IOperator> item in e.Items)
-        ((IValueParameter<IOperator>)Parameters[item.Index.ToString()]).Value = item.Value;
-    }
-    private void successors_ItemsMoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOperator>> e) {
-      foreach (IndexedItem<IOperator> item in e.Items)
-        ((IValueParameter<IOperator>)Parameters[item.Index.ToString()]).Value = item.Value;
-    }
-    private void successors_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<IOperator>> e) {
-      UpdateOperatorParameters();
-    }
-    private void opParam_ValueChanged(object sender, EventArgs e) {
-      IValueParameter<IOperator> opParam = (IValueParameter<IOperator>)sender;
-      int index = int.Parse(opParam.Name);
-      successors[index] = opParam.Value;
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.Operators/3.3/Operator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/Operator.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/Operator.cs	(revision 2773)
@@ -130,5 +130,5 @@
 
     /// <inheritdoc/>
-    public virtual IExecutionContext Execute(ExecutionContext context) {
+    public virtual IExecutionSequence Execute(ExecutionContext context) {
       try {
         Canceled = false;
@@ -136,5 +136,5 @@
         foreach (IParameter param in Parameters)
           param.ExecutionContext = context;
-        IExecutionContext next = Apply();
+        IExecutionSequence next = Apply();
         OnExecuted();
         return next;
@@ -156,5 +156,5 @@
     /// <param name="scope">The scope where to execute the operator</param>
     /// <returns><c>null</c>.</returns>
-    public abstract IExecutionContext Apply();
+    public abstract IExecutionSequence Apply();
 
     protected virtual void OnExecutionContextChanged() { }
Index: unk/sources/HeuristicLab.Operators/3.3/OperatorExtractor.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/OperatorExtractor.cs	(revision 2772)
+++ 	(revision )
@@ -1,62 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Operators {
-  /// <summary>
-  /// Retrieves an operator from a specified scope and returns a successor operation with this operation
-  /// and scope.
-  /// </summary>
-  public class OperatorExtractor : OperatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"An operator extractor retrievs an operator from the scope it is applied on and returns a successor operation containing this operator and the current scope. Lookup for the operator is done recursively.
-
-Operator extractors can be used to get those operators again that have been injected by combined operators."; }
-    }
-
-    /// <summary>
-    /// Initializes a new instance of <see cref="OperatorExtractor"/> with 
-    /// one variable info (<c>Operator</c>).
-    /// </summary>
-    public OperatorExtractor()
-      : base() {
-      AddVariableInfo(new VariableInfo("Operator", "Extracted operator", typeof(IOperator), VariableKind.In));
-    }
-
-    /// <summary>
-    /// Gets an operator from the specified <paramref name="scope"/> and returns an 
-    /// <see cref="AtomicOperation"/> containing this operator and scope.
-    /// </summary>
-    /// <param name="scope">The scope where to apply the operator on.</param>
-    /// <returns>A new <see cref="AtomicOperation"/> containing the operator and the given
-    /// <paramref name="scope"/>.</returns>
-    public override IOperation Apply(IScope scope) {
-      IOperator op = GetVariableValue<IOperator>("Operator", scope, true, true);
-      return new AtomicOperation(op, scope);
-    }
-  }
-}
Index: unk/sources/HeuristicLab.Operators/3.3/ParallelProcessor.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/ParallelProcessor.cs	(revision 2772)
+++ 	(revision )
@@ -1,53 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Xml;
-using HeuristicLab.Collections;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Operators {
-  /// <summary>
-  /// Operator which executes multiple operators in parallel.
-  /// </summary>
-  [Item("ParallelProcessor", "An operator which executes multiple operators in parallel.")]
-  [Creatable("Test")]
-  [EmptyStorableClass]
-  public sealed class ParallelProcessor : MultipleSuccessorsOperator {
-    public ParallelProcessor()
-      : base() {
-    }
-
-    public override IExecutionContext Apply() {
-      ExecutionContextCollection next = new ExecutionContextCollection();
-      for (int i = 0; i < Successors.Count; i++) {
-        if (Successors[i] != null)
-          next.Add(new ExecutionContext(ExecutionContext.Parent, Successors[i], ExecutionContext.Scope));
-      }
-      next.Parallel = true;
-      return next;
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.Operators/3.3/ParallelSubScopesProcessor.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/ParallelSubScopesProcessor.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/ParallelSubScopesProcessor.cs	(revision 2773)
@@ -22,29 +22,32 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
+using System.Xml;
+using HeuristicLab.Collections;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Operators {
   /// <summary>
-  /// Performs <c>n</c> operators on <c>n</c> subscopes, operations can be executed in parallel.
+  /// An operator which contains multiple operators of which each is applied in parallel on one sub-scope of the current scope. The first operator is applied on the first sub-scope, the second on the second, and so on.
   /// </summary>
-  public class ParallelSubScopesProcessor : OperatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
+  [Item("ParallelSubScopesProcessor", "An operator which contains multiple operators of which each is applied in parallel on one sub-scope of the current scope. The first operator is applied on the first sub-scope, the second on the second, and so on.")]
+  [Creatable("Test")]
+  public sealed class ParallelSubScopesProcessor : MultipleCallsOperator {
+    public ParallelSubScopesProcessor()
+      : base() {
     }
 
-    /// <summary>
-    /// Applies <c>n</c> operators on all the <c>n</c> sub scopes of the given <paramref name="scope"/>.
-    /// </summary>
-    /// <param name="scope">The scope on whose sub scopes the operators are applied.</param>
-    /// <returns>A new <see cref="CompositeOperation"/> with the <c>i</c>th operator applied
-    /// on the <c>i</c>th sub scope, the <c>ExecuteInParallel</c> flag set to <c>true</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      CompositeOperation next = new CompositeOperation();
-      next.ExecuteInParallel = true;
-      for (int i = 0; i < scope.SubScopes.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[i], scope.SubScopes[i]));
+    public override IExecutionSequence Apply() {
+      ExecutionContextCollection next = new ExecutionContextCollection(base.Apply());
+      if (Operators.Count > 0) {
+        ExecutionContextCollection inner = new ExecutionContextCollection();
+        inner.Parallel = true;
+        for (int i = 0; (i < ExecutionContext.Scope.SubScopes.Count) && (i < Operators.Count); i++)
+          inner.Add(new ExecutionContext(ExecutionContext.Parent, Operators[i], ExecutionContext.Scope.SubScopes[i]));
+        next.Insert(0, inner);
+      }
       return next;
     }
Index: /trunk/sources/HeuristicLab.Operators/3.3/Placeholder.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/Placeholder.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Operators/3.3/Placeholder.cs	(revision 2773)
@@ -0,0 +1,55 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Xml;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Operators {
+  /// <summary>
+  /// An operator which acts as a placeholder for another operator retrieved from the scope or a parent execution context.
+  /// </summary>
+  [Item("Placeholder", "An operator which acts as a placeholder for another operator retrieved from the scope or a parent execution context.")]
+  [Creatable("Test")]
+  [EmptyStorableClass]
+  public sealed class Placeholder : SingleSuccessorOperator {
+    public LookupParameter<IOperator> OperatorParameter {
+      get { return (LookupParameter<IOperator>)Parameters["Operator"]; }
+    }
+
+    public Placeholder()
+      : base() {
+      Parameters.Add(new LookupParameter<IOperator>("Operator", "The operator which is retrieved from the scope or a parent execution context and applied on the current scope."));
+    }
+
+    public override IExecutionSequence Apply() {
+      ExecutionContextCollection next = new ExecutionContextCollection(base.Apply());
+      IOperator op = OperatorParameter.ActualValue;
+      if (op != null)
+        next.Insert(0, new ExecutionContext(ExecutionContext.Parent, op, ExecutionContext.Scope));
+      return next;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Operators/3.3/ScopeCleaner.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/ScopeCleaner.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/ScopeCleaner.cs	(revision 2773)
@@ -47,5 +47,5 @@
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       CurrentScope.Variables.Clear();
       CurrentScope.SubScopes.Clear();
Index: unk/sources/HeuristicLab.Operators/3.3/SequentialProcessor.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/SequentialProcessor.cs	(revision 2772)
+++ 	(revision )
@@ -1,52 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Xml;
-using HeuristicLab.Collections;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Operators {
-  /// <summary>
-  /// Operator which executes multiple operators sequentially.
-  /// </summary>
-  [Item("SequentialProcessor", "An operator which executes multiple operators sequentially.")]
-  [Creatable("Test")]
-  [EmptyStorableClass]
-  public sealed class SequentialProcessor : MultipleSuccessorsOperator {
-    public SequentialProcessor()
-      : base() {
-    }
-
-    public override IExecutionContext Apply() {
-      ExecutionContextCollection next = new ExecutionContextCollection();
-      for (int i = 0; i < Successors.Count; i++) {
-        if (Successors[i] != null)
-          next.Add(new ExecutionContext(ExecutionContext.Parent, Successors[i], ExecutionContext.Scope));
-      }
-      return next;
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.Operators/3.3/SequentialSubScopesProcessor.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/SequentialSubScopesProcessor.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/SequentialSubScopesProcessor.cs	(revision 2773)
@@ -22,28 +22,31 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
+using System.Xml;
+using HeuristicLab.Collections;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Operators {
   /// <summary>
-  /// Performs <c>n</c> operators on <c>n</c> subscopes, operations must be executed sequentially.
+  /// An operator which contains multiple operators of which each is applied sequentially on one sub-scope of the current scope. The first operator is applied on the first sub-scope, the second on the second, and so on.
   /// </summary>
-  public class SequentialSubScopesProcessor : OperatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
+  [Item("SequentialSubScopesProcessor", "An operator which contains multiple operators of which each is applied sequentially on one sub-scope of the current scope. The first operator is applied on the first sub-scope, the second on the second, and so on.")]
+  [Creatable("Test")]
+  public sealed class SequentialSubScopesProcessor : MultipleCallsOperator {
+    public SequentialSubScopesProcessor()
+      : base() {
     }
 
-    /// <summary>
-    /// Applies <c>n</c> operators on all the <c>n</c> sub scopes of the given <paramref name="scope"/>.
-    /// </summary>
-    /// <param name="scope">The scope on whose sub scopes the operators are applied.</param>
-    /// <returns>A new <see cref="CompositeOperation"/> with the <c>i</c>th operator applied
-    /// on the <c>i</c>th sub scope.</returns>
-    public override IOperation Apply(IScope scope) {
-      CompositeOperation next = new CompositeOperation();
-      for (int i = 0; i < scope.SubScopes.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[i], scope.SubScopes[i]));
+    public override IExecutionSequence Apply() {
+      ExecutionContextCollection next = new ExecutionContextCollection(base.Apply());
+      if (Operators.Count > 0) {
+        ExecutionContextCollection inner = new ExecutionContextCollection();
+        for (int i = 0; (i < ExecutionContext.Scope.SubScopes.Count) && (i < Operators.Count); i++)
+          inner.Add(new ExecutionContext(ExecutionContext.Parent, Operators[i], ExecutionContext.Scope.SubScopes[i]));
+        next.Insert(0, inner);
+      }
       return next;
     }
Index: /trunk/sources/HeuristicLab.Operators/3.3/SingleCallOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/SingleCallOperator.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Operators/3.3/SingleCallOperator.cs	(revision 2773)
@@ -0,0 +1,58 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Xml;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Operators {
+  /// <summary>
+  /// An operator which applies a specified operator on the current scope.
+  /// </summary>
+  [Item("SingleCallOperator", "An operator which applies a specified operator on the current scope.")]
+  [Creatable("Test")]
+  [EmptyStorableClass]
+  public class SingleCallOperator : SingleSuccessorOperator {
+    protected OperatorParameter OperatorParameter {
+      get { return (OperatorParameter)Parameters["Operator"]; }
+    }
+    public IOperator Operator {
+      get { return OperatorParameter.Value; }
+      set { OperatorParameter.Value = value; }
+    }
+
+    public SingleCallOperator()
+      : base() {
+      Parameters.Add(new OperatorParameter("Operator", "The operator which should be applied on the current scope."));
+    }
+
+    public override IExecutionSequence Apply() {
+      ExecutionContextCollection next = new ExecutionContextCollection(base.Apply());
+      if (Operator != null)
+        next.Insert(0, new ExecutionContext(ExecutionContext.Parent, Operator, ExecutionContext.Scope));
+      return next;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Operators/3.3/SingleSuccessorOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/SingleSuccessorOperator.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/SingleSuccessorOperator.cs	(revision 2773)
@@ -49,5 +49,5 @@
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       if (Successor != null)
         return new ExecutionContext(ExecutionContext.Parent, Successor, ExecutionContext.Scope);
Index: /trunk/sources/HeuristicLab.Operators/3.3/StochasticBranch.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/StochasticBranch.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/StochasticBranch.cs	(revision 2773)
@@ -23,44 +23,55 @@
 using System.Collections.Generic;
 using System.Text;
+using System.Xml;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Operators {
   /// <summary>
-  /// Branch of (one or) two operators that have different probabilities to get executed.
+  /// A branch of two operators which are executed with a specified probability.
   /// </summary>
-  public class StochasticBranch : OperatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
+  [Item("StochasticBranch", "A branch of two operators which are executed with a specified probability.")]
+  [Creatable("Test")]
+  [EmptyStorableClass]
+  public class StochasticBranch : SingleSuccessorOperator {
+    public LookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ValueLookupParameter<DoubleData> ProbabilityParameter {
+      get { return (ValueLookupParameter<DoubleData>)Parameters["Probability"]; }
+    }
+    protected OperatorParameter FirstBranchParameter {
+      get { return (OperatorParameter)Parameters["FirstBranch"]; }
+    }
+    protected OperatorParameter SecondBranchParameter {
+      get { return (OperatorParameter)Parameters["SecondBranch"]; }
+    }
+    public IOperator FirstBranch {
+      get { return FirstBranchParameter.Value; }
+      set { FirstBranchParameter.Value = value; }
+    }
+    public IOperator SecondBranch {
+      get { return SecondBranchParameter.Value; }
+      set { SecondBranchParameter.Value = value; }
     }
 
-    /// <summary>
-    /// Initializes a new instance of <see cref="StochasticBranch"/> with two variable infos
-    /// (<c>Random</c> and <c>Probability</c>).
-    /// </summary>
     public StochasticBranch()
       : base() {
-      AddVariableInfo(new VariableInfo("Random", "Pseudo random number generator", typeof(IRandom), VariableKind.In));
-      AddVariableInfo(new VariableInfo("Probability", "Probability to choose first branch", typeof(DoubleData), VariableKind.In));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "A pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<DoubleData>("Probability", "The probability to execute the first branch."));
+      Parameters.Add(new OperatorParameter("FirstBranch", "The operator which is executed with the given probability."));
+      Parameters.Add(new OperatorParameter("SecondBranch", "The operator which is executed if the first branch is not executed."));
     }
 
-    /// <summary>
-    /// Applies the operator of branch one with a specific probability on the given 
-    /// <paramref name="scope"/>, or - if existent - with another probability operator of branch two.  
-    /// </summary>
-    /// <param name="scope">The scope to apply the operators on.</param>
-    /// <returns>A new <see cref="AtomicOperation"/> with either operator 1 or operator 2 applied
-    /// to the given <paramref name="scope"/> or <c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      IRandom random = GetVariableValue<IRandom>("Random", scope, true);
-      DoubleData probability = GetVariableValue<DoubleData>("Probability", scope, true);
-
-      bool result = random.NextDouble() < probability.Data;
-      if ((result) && (SubOperators.Count > 0) && (SubOperators[0] != null))
-        return new AtomicOperation(SubOperators[0], scope);
-      else if ((!result) && (SubOperators.Count > 1) && (SubOperators[1] != null))
-        return new AtomicOperation(SubOperators[1], scope);
-      return null;
+    public override IExecutionSequence Apply() {
+      ExecutionContextCollection next = new ExecutionContextCollection(base.Apply());
+      if (RandomParameter.ActualValue.NextDouble() < ProbabilityParameter.ActualValue.Value) {
+        if (FirstBranch != null) next.Insert(0, new ExecutionContext(ExecutionContext.Parent, FirstBranch, ExecutionContext.Scope));
+      } else {
+        if (SecondBranch != null) next.Insert(0, new ExecutionContext(ExecutionContext.Parent, SecondBranch, ExecutionContext.Scope));
+      }
+      return next;
     }
   }
Index: /trunk/sources/HeuristicLab.Operators/3.3/SubScopesCreater.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/SubScopesCreater.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/SubScopesCreater.cs	(revision 2773)
@@ -52,5 +52,5 @@
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       int n = NumberOfSubScopesParameter.ActualValue.Value;
       for (int i = 0; i < n; i++)
Index: /trunk/sources/HeuristicLab.Operators/3.3/SubScopesRemover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/SubScopesRemover.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/SubScopesRemover.cs	(revision 2773)
@@ -52,5 +52,5 @@
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       IntData index = SubScopeIndexParameter.ActualValue;
       if (index != null)
Index: /trunk/sources/HeuristicLab.Operators/3.3/SubScopesSorter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/SubScopesSorter.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/SubScopesSorter.cs	(revision 2773)
@@ -59,5 +59,5 @@
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       descending = DescendingParameter.ActualValue.Value;
       actualName = LookupParameter<DoubleData>.TranslateName(ValueParameter.Name, ExecutionContext);
Index: /trunk/sources/HeuristicLab.Operators/3.3/UniformParallelSubScopesProcessor.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/UniformParallelSubScopesProcessor.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/UniformParallelSubScopesProcessor.cs	(revision 2773)
@@ -35,19 +35,12 @@
   [Creatable("Test")]
   [EmptyStorableClass]
-  public sealed class UniformParallelSubScopesProcessor : SingleSuccessorOperator {
-    private OperatorParameter OperatorParameter {
-      get { return (OperatorParameter)Parameters["Operator"]; }
-    }
-    public IOperator Operator {
-      get { return OperatorParameter.Value; }
-      set { OperatorParameter.Value = value; }
-    }
-
+  public sealed class UniformParallelSubScopesProcessor : SingleCallOperator {
     public UniformParallelSubScopesProcessor()
       : base() {
+      Parameters.Remove("Operator");
       Parameters.Add(new OperatorParameter("Operator", "The operator which should be applied on all sub-scopes of the current scope in parallel."));
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       ExecutionContextCollection next = new ExecutionContextCollection(base.Apply());
       if (Operator != null) {
Index: /trunk/sources/HeuristicLab.Operators/3.3/UniformSequentialSubScopesProcessor.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/UniformSequentialSubScopesProcessor.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/UniformSequentialSubScopesProcessor.cs	(revision 2773)
@@ -35,19 +35,12 @@
   [Creatable("Test")]
   [EmptyStorableClass]
-  public sealed class UniformSequentialSubScopesProcessor : SingleSuccessorOperator {
-    private OperatorParameter OperatorParameter {
-      get { return (OperatorParameter)Parameters["Operator"]; }
-    }
-    public IOperator Operator {
-      get { return OperatorParameter.Value; }
-      set { OperatorParameter.Value = value; }
-    }
-
+  public sealed class UniformSequentialSubScopesProcessor : SingleCallOperator {
     public UniformSequentialSubScopesProcessor()
       : base() {
+      Parameters.Remove("Operator");
       Parameters.Add(new OperatorParameter("Operator", "The operator which should be applied sequentially on all sub-scopes of the current scope."));
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       ExecutionContextCollection next = new ExecutionContextCollection(base.Apply());
       if (Operator != null) {
Index: unk/sources/HeuristicLab.Operators/3.3/ValueCollector.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/ValueCollector.cs	(revision 2772)
+++ 	(revision )
@@ -1,56 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Xml;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Operators {
-  /// <summary>
-  /// An operator which collects the actual values of parameters.
-  /// </summary>
-  [Item("ValueCollector", "An operator which collects the actual values of parameters.")]
-  [EmptyStorableClass]
-  [Creatable("Test")]
-  public abstract class ValueCollector : SingleSuccessorOperator, IOperator {
-    protected ValueParameter<ParameterCollection> CollectedValuesParameter {
-      get { return (ValueParameter<ParameterCollection>)Parameters["CollectedValues"]; }
-    }
-    public ParameterCollection CollectedValues {
-      get { return CollectedValuesParameter.Value; }
-      set { CollectedValuesParameter.Value = value; }
-    }
-
-    public ValueCollector()
-      : base() {
-      Parameters.Add(new ValueParameter<ParameterCollection>("CollectedValues", "The parameters whose actual values are collected.", new ParameterCollection()));
-    }
-
-    protected override void OnExecutionContextChanged() {
-      foreach (IParameter param in CollectedValues)
-        param.ExecutionContext = ExecutionContext;
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.Operators/3.3/ValuesCollector.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/ValuesCollector.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Operators/3.3/ValuesCollector.cs	(revision 2773)
@@ -0,0 +1,77 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Xml;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Operators {
+  /// <summary>
+  /// An operator which collects the actual values of parameters.
+  /// </summary>
+  [Item("ValuesCollector", "An operator which collects the actual values of parameters.")]
+  [Creatable("Test")]
+  public abstract class ValuesCollector : SingleSuccessorOperator, IOperator {
+    private ParameterCollection collectedValues;
+    [Storable]
+    public ParameterCollection CollectedValues {
+      get { return collectedValues; }
+      private set {
+        collectedValues = value;
+        collectedValues.ItemsAdded += new CollectionItemsChangedEventHandler<IParameter>(collectedValues_ItemsAdded);
+        collectedValues.ItemsRemoved += new CollectionItemsChangedEventHandler<IParameter>(collectedValues_ItemsRemoved);
+        collectedValues.CollectionReset += new CollectionItemsChangedEventHandler<IParameter>(collectedValues_CollectionReset);
+      }
+    }
+
+    public ValuesCollector()
+      : base() {
+      CollectedValues = new ParameterCollection();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      ValuesCollector clone = (ValuesCollector)base.Clone(cloner);
+      clone.CollectedValues = (ParameterCollection)cloner.Clone(collectedValues);
+      return clone;
+    }
+
+    private void collectedValues_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
+      Parameters.AddRange(e.Items);
+    }
+    private void collectedValues_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
+      Parameters.RemoveRange(e.Items);
+    }
+    #region NOTE
+    // NOTE: The ItemsReplaced event has not to be handled here as it is only fired when the name (i.e. key) of a parameter
+    // changes. As the same parameter is also contained in the Parameters collection of the operator, the Parameters collection
+    // will react on this name change on its own.
+    #endregion
+    private void collectedValues_CollectionReset(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
+      Parameters.RemoveRange(e.OldItems);
+      Parameters.AddRange(e.Items);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Operators/3.3/VariableInjector.cs
===================================================================
--- /trunk/sources/HeuristicLab.Operators/3.3/VariableInjector.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Operators/3.3/VariableInjector.cs	(revision 2773)
@@ -37,5 +37,5 @@
   [Creatable("Test")]
   [EmptyStorableClass]
-  public class VariableInjector : ValueCollector {
+  public class VariableInjector : ValuesCollector {
     protected ScopeParameter CurrentScopeParameter {
       get { return (ScopeParameter)Parameters["CurrentScope"]; }
@@ -50,5 +50,5 @@
     }
 
-    public override IExecutionContext Apply() {
+    public override IExecutionSequence Apply() {
       IVariable var;
       foreach (IParameter param in CollectedValues) {
Index: /trunk/sources/HeuristicLab.Parameters/3.3/LookupParameter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Parameters/3.3/LookupParameter.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Parameters/3.3/LookupParameter.cs	(revision 2773)
@@ -74,4 +74,35 @@
     }
 
+    private IValueParameter<T> GetParameter(out string name) {
+      IValueParameter<T> valueParam = this as IValueParameter<T>;
+      ILookupParameter<T> lookupParam = this as ILookupParameter<T>;
+      ExecutionContext current = ExecutionContext;
+
+      name = Name;
+      while ((valueParam != null) && (lookupParam != null)) {
+        if ((valueParam != null) && (valueParam.Value != null)) return valueParam;
+        if (lookupParam != null) name = lookupParam.ActualName;
+
+        current = current.Parent;
+        while ((current != null) && !current.Operator.Parameters.ContainsKey(name))
+          current = current.Parent;
+
+        if (current != null) {
+          valueParam = current.Operator.Parameters[name] as IValueParameter<T>;
+          lookupParam = current.Operator.Parameters[name] as ILookupParameter<T>;
+          if ((valueParam == null) && (lookupParam == null))
+            throw new InvalidOperationException(
+              string.Format("Parameter look-up chain broken. Parameter \"{0}\" is not an \"{1}\" or an \"{2}\".",
+                            name,
+                            typeof(IValueParameter<T>).GetPrettyName(),
+                            typeof(ILookupParameter<T>).GetPrettyName())
+            );
+        } else {
+          valueParam = null;
+          lookupParam = null;
+        }
+      }
+      return null;
+    }
     private IVariable LookupVariable(string name) {
       IScope scope = ExecutionContext.Scope;
@@ -81,15 +112,20 @@
     }
     protected override IItem GetActualValue() {
-      string name = TranslateName(Name, ExecutionContext);
-      IVariable var = LookupVariable(name);
-      if (var != null) {
-        T value = var.Value as T;
-        if (value == null)
-          throw new InvalidOperationException(
-            string.Format("Type mismatch. Variable \"{0}\" does not contain a \"{1}\".",
-                          name,
-                          typeof(T).GetPrettyName())
-          );
-        return value;
+      string name;
+      // try to get local value from context stack
+      IValueParameter<T> param = GetParameter(out name);
+      if (param != null) return param.Value;
+      else {  // try to get variable from scope
+        IVariable var = LookupVariable(name);
+        if (var != null) {
+          T value = var.Value as T;
+          if (value == null)
+            throw new InvalidOperationException(
+              string.Format("Type mismatch. Variable \"{0}\" does not contain a \"{1}\".",
+                            name,
+                            typeof(T).GetPrettyName())
+            );
+          return value;
+        }
       }
       return null;
@@ -102,8 +138,13 @@
                         typeof(T).GetPrettyName())
         );
-      string name = TranslateName(Name, ExecutionContext);
-      IVariable var = LookupVariable(name);
-      if (var != null) var.Value = val;
-      else ExecutionContext.Scope.Variables.Add(new Variable(name, val));
+      // try to get local value from context stack
+      string name;
+      IValueParameter<T> param = GetParameter(out name);
+      if (param != null) param.Value = val;
+      else {  // try to get variable from scope
+        IVariable var = LookupVariable(name);
+        if (var != null) var.Value = val;
+        else ExecutionContext.Scope.Variables.Add(new Variable(name, value));
+      }
     }
 
Index: /trunk/sources/HeuristicLab.Parameters/3.3/ValueLookupParameter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Parameters/3.3/ValueLookupParameter.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Parameters/3.3/ValueLookupParameter.cs	(revision 2773)
@@ -33,18 +33,5 @@
   /// </summary>
   [Item("ValueLookupParameter<T>", "A parameter whose value is either defined it the parameter itself or is retrieved from or written to a scope.")]
-  public class ValueLookupParameter<T> : Parameter, IValueLookupParameter<T> where T : class, IItem {
-    [Storable]
-    private string actualName;
-    public string ActualName {
-      get { return actualName; }
-      set {
-        if (value == null) throw new ArgumentNullException();
-        if (!actualName.Equals(value)) {
-          actualName = value;
-          OnActualNameChanged();
-        }
-      }
-    }
-
+  public class ValueLookupParameter<T> : LookupParameter<T>, IValueLookupParameter<T> where T : class, IItem {
     private T value;
     [Storable]
@@ -61,29 +48,19 @@
     }
 
-    public new T ActualValue {
-      get { return (T)GetActualValue(); }
-      set { SetActualValue(value); }
-    }
-
     public ValueLookupParameter()
-      : base("Anonymous", typeof(T)) {
-      actualName = Name;
+      : base() {
     }
     public ValueLookupParameter(string name)
-      : base(name, typeof(T)) {
-      actualName = Name;
+      : base(name) {
     }
     public ValueLookupParameter(string name, T value)
-      : base(name, typeof(T)) {
-      actualName = Name;
+      : base(name) {
       Value = value;
     }
     public ValueLookupParameter(string name, string description)
-      : base(name, description, typeof(T)) {
-      actualName = Name;
+      : base(name, description) {
     }
     public ValueLookupParameter(string name, string description, T value)
-      : base(name, description, typeof(T)) {
-      actualName = Name;
+      : base(name, description) {
       Value = value;
     }
@@ -91,5 +68,4 @@
     public override IDeepCloneable Clone(Cloner cloner) {
       ValueLookupParameter<T> clone = (ValueLookupParameter<T>)base.Clone(cloner);
-      clone.actualName = actualName;
       clone.Value = (T)cloner.Clone(value);
       return clone;
@@ -100,85 +76,4 @@
     }
 
-    private IValueParameter<T> GetParameter(out string name) {
-      IValueParameter<T> valueParam = this;
-      ILookupParameter<T> lookupParam = this;
-      ExecutionContext current = ExecutionContext;
-
-      name = Name;
-      while ((valueParam != null) && (lookupParam != null)) {
-        if ((valueParam != null) && (valueParam.Value != null)) return valueParam;
-        if (lookupParam != null) name = lookupParam.ActualName;
-
-        current = current.Parent;
-        while ((current != null) && !current.Operator.Parameters.ContainsKey(name))
-          current = current.Parent;
-
-        if (current != null) {
-          valueParam = current.Operator.Parameters[name] as IValueParameter<T>;
-          lookupParam = current.Operator.Parameters[name] as ILookupParameter<T>;
-          if ((valueParam == null) && (lookupParam == null))
-            throw new InvalidOperationException(
-              string.Format("Parameter look-up chain broken. Parameter \"{0}\" is not an \"{1}\" or an \"{2}\".",
-                            name,
-                            typeof(IValueParameter<T>).GetPrettyName(),
-                            typeof(ILookupParameter<T>).GetPrettyName())
-            );
-        } else {
-          valueParam = null;
-          lookupParam = null;
-        }
-      }
-      return null;
-    }
-    private IVariable LookupVariable(string name) {
-      IScope scope = ExecutionContext.Scope;
-      while ((scope != null) && !scope.Variables.ContainsKey(name))
-        scope = scope.Parent;
-      return scope != null ? scope.Variables[actualName] : null;
-    }
-    protected override IItem GetActualValue() {
-      string name;
-      // try to get local value from context stack
-      IValueParameter<T> param = GetParameter(out name);
-      if (param != null) return param.Value;
-      else {  // try to get variable from scope
-        IVariable var = LookupVariable(name);
-        if (var != null) {
-          T value = var.Value as T;
-          if (value == null)
-            throw new InvalidOperationException(
-              string.Format("Type mismatch. Variable \"{0}\" does not contain a \"{1}\".",
-                            name,
-                            typeof(T).GetPrettyName())
-            );
-          return value;
-        }
-      }
-      return null;
-    }
-    protected override void SetActualValue(IItem value) {
-      T val = value as T;
-      if (val == null)
-        throw new InvalidOperationException(
-          string.Format("Type mismatch. Value is not a \"{0}\".",
-                        typeof(T).GetPrettyName())
-        );
-      // try to get local value from context stack
-      string name;
-      IValueParameter<T> param = GetParameter(out name);
-      if (param != null) param.Value = val;
-      else {  // try to get variable from scope
-        IVariable var = LookupVariable(name);
-        if (var != null) var.Value = val;
-        else ExecutionContext.Scope.Variables.Add(new Variable(name, value));
-      }
-    }
-
-    public event EventHandler ActualNameChanged;
-    private void OnActualNameChanged() {
-      if (ActualNameChanged != null)
-        ActualNameChanged(this, new EventArgs());
-      OnChanged();
-    }
     public event EventHandler ValueChanged;
     private void OnValueChanged() {
Index: /trunk/sources/HeuristicLab.Random/3.3/HeuristicLab.Random-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Random/3.3/HeuristicLab.Random-3.3.csproj	(revision 2772)
+++ /trunk/sources/HeuristicLab.Random/3.3/HeuristicLab.Random-3.3.csproj	(revision 2773)
@@ -85,15 +85,20 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="UniformRandomAdder.cs" />
-    <Compile Include="NormalRandomAdder.cs" />
+    <None Include="HeuristicLabRandomPlugin.cs.frame" />
+    <Compile Include="RandomInitializer.cs" />
     <Compile Include="HeuristicLabRandomPlugin.cs" />
-    <Compile Include="MersenneTwister.cs" />
-    <Compile Include="NormalDistributedRandom.cs" />
-    <Compile Include="NormalRandomizer.cs" />
+    <Compile Include="MersenneTwister.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="NormalDistributedRandom.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="RandomInjector.cs" />
-    <Compile Include="UniformRandomizer.cs" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
       <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
@@ -107,4 +112,8 @@
       <Project>{23DA7FF4-D5B8-41B6-AA96-F0561D24F3EE}</Project>
       <Name>HeuristicLab.Operators-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
+      <Project>{56F9106A-079F-4C61-92F6-86A84C2D84B7}</Project>
+      <Name>HeuristicLab.Parameters-3.3</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
@@ -135,5 +144,6 @@
 set Outdir=$(Outdir)
 
-call PreBuildEvent.cmd</PreBuildEvent>
+call PreBuildEvent.cmd
+SubWCRev "%25ProjectDir%25\" "%25ProjectDir%25\HeuristicLabRandomPlugin.cs.frame" "%25ProjectDir%25\HeuristicLabRandomPlugin.cs"</PreBuildEvent>
   </PropertyGroup>
 </Project>
Index: unk/sources/HeuristicLab.Random/3.3/HeuristicLabRandomPlugin.cs
===================================================================
--- /trunk/sources/HeuristicLab.Random/3.3/HeuristicLabRandomPlugin.cs	(revision 2772)
+++ 	(revision )
@@ -1,39 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using HeuristicLab.PluginInfrastructure;
-
-namespace HeuristicLab.Random {
-  /// <summary>
-  /// Plugin class for HeuristicLab.Random plugin.
-  /// </summary>
-  [ClassInfo(Name = "HeuristicLab.Random-3.3")]
-  [PluginFile(Filename = "HeuristicLab.Random-3.3.dll", Filetype = PluginFileType.Assembly)]
-  [Dependency(Dependency = "HeuristicLab.Core-3.3")]
-  [Dependency(Dependency = "HeuristicLab.Data-3.3")]
-  [Dependency(Dependency = "HeuristicLab.Operators-3.3")]
-  [Dependency(Dependency = "HeuristicLab.Persistence-3.3")]
-  public class HeuristicLabRandomPlugin : PluginBase {
-  }
-}
Index: /trunk/sources/HeuristicLab.Random/3.3/HeuristicLabRandomPlugin.cs.frame
===================================================================
--- /trunk/sources/HeuristicLab.Random/3.3/HeuristicLabRandomPlugin.cs.frame	(revision 2773)
+++ /trunk/sources/HeuristicLab.Random/3.3/HeuristicLabRandomPlugin.cs.frame	(revision 2773)
@@ -0,0 +1,41 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Random {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Random plugin.
+  /// </summary>
+  [Plugin("HeuristicLab.Random-3.3", "3.3.0.$WCREV$")]
+  [PluginFile("HeuristicLab.Random-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  public class HeuristicLabRandomPlugin : PluginBase {
+  }
+}
Index: /trunk/sources/HeuristicLab.Random/3.3/MersenneTwister.cs
===================================================================
--- /trunk/sources/HeuristicLab.Random/3.3/MersenneTwister.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Random/3.3/MersenneTwister.cs	(revision 2773)
@@ -43,5 +43,6 @@
   /// A 623-Dimensionally Equidistributed Uniform Pseudo-Random Number Generator.
   /// </summary>
-  public class MersenneTwister : ItemBase, IRandom {
+  [Item("MersenneTwister", "A high-quality pseudo random number generator which creates uniformly distributed random numbers.")]
+  public class MersenneTwister : Item, IRandom {
     private const int n = 624, m = 397;
 
@@ -84,5 +85,5 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="MersenneTwister"/>.</returns>
-    public override IItem Clone(ICloner cloner) {
+    public override IDeepCloneable Clone(Cloner cloner) {
       MersenneTwister clone = new MersenneTwister();
       cloner.RegisterClonedObject(this, clone);
Index: /trunk/sources/HeuristicLab.Random/3.3/NormalDistributedRandom.cs
===================================================================
--- /trunk/sources/HeuristicLab.Random/3.3/NormalDistributedRandom.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.Random/3.3/NormalDistributedRandom.cs	(revision 2773)
@@ -23,7 +23,7 @@
 using System.Collections.Generic;
 using System.Text;
-using HeuristicLab.Core;
 using System.Xml;
 using System.Globalization;
+using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -35,6 +35,6 @@
   /// See "The Ziggurat Method for Generating Random Variables" (G. Marsaglia and W.W. Tsang 2000).
   /// </summary>
-  public class NormalDistributedRandom : ItemBase, IRandom {
-
+  [Item("NormalDistributedRandom", "A pseudo random number generator which uses the Ziggurat method to create normally distributed random numbers.")]
+  public class NormalDistributedRandom : Item, IRandom {
     [Storable]
     private double mu;
@@ -487,28 +487,22 @@
 
     /// <summary>
-    /// TODO: The method is not implemented.
-    /// </summary>
-    /// <returns>TODO</returns>
+    /// This method is not implemented.
+    /// </summary>
     public int Next() {
-      throw new Exception("The method or operation is not implemented.");
-    }
-
-    /// <summary>
-    /// TODO: The method is not implemented.
-    /// </summary>
-    /// <param name="maxVal">TODO</param>
-    /// <returns>TODO</returns>
+      throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// This method is not implemented.
+    /// </summary>
     public int Next(int maxVal) {
-      throw new Exception("The method or operation is not implemented.");
-    }
-
-    /// <summary>
-    /// TODO: The method is not implemented.
-    /// </summary>
-    /// <param name="minVal">TODO</param>
-    /// <param name="maxVal">TODO</param>
-    /// <returns>TODO</returns>
+      throw new NotImplementedException();
+    }
+
+    /// <summary>
+    /// This method is not implemented.
+    /// </summary>
     public int Next(int minVal, int maxVal) {
-      throw new Exception("The method or operation is not implemented.");
+      throw new NotImplementedException();
     }
 
@@ -561,5 +555,5 @@
     /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
     /// <returns>The cloned object as <see cref="NormalDistributedRandom"/>.</returns>
-    public override IItem Clone(ICloner cloner) {
+    public override IDeepCloneable Clone(Cloner cloner) {
       NormalDistributedRandom clone = new NormalDistributedRandom((IRandom)cloner.Clone(uniform), mu, sigma);
       cloner.RegisterClonedObject(this, clone);
Index: /trunk/sources/HeuristicLab.Random/3.3/Properties/AssemblyInfo.frame
===================================================================
--- /trunk/sources/HeuristicLab.Random/3.3/Properties/AssemblyInfo.frame	(revision 2772)
+++ /trunk/sources/HeuristicLab.Random/3.3/Properties/AssemblyInfo.frame	(revision 2773)
@@ -23,5 +23,4 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using HeuristicLab.PluginInfrastructure;
 
 // General Information about an assembly is controlled through the following 
@@ -33,5 +32,5 @@
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("HeuristicLab")]
-[assembly: AssemblyCopyright("(c) 2002-2008 HEAL")]
+[assembly: AssemblyCopyright("(c) 2002-2010 HEAL")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
@@ -54,5 +53,4 @@
 // You can specify all the values or you can default the Revision and Build Numbers 
 // by using the '*' as shown below:
-[assembly: AssemblyVersion("3.3.0.$WCREV$")]
+[assembly: AssemblyVersion("3.3.0.0")]
 [assembly: AssemblyFileVersion("3.3.0.$WCREV$")]
-[assembly: AssemblyBuildDate("$WCNOW$")]
Index: /trunk/sources/HeuristicLab.Random/3.3/RandomInitializer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Random/3.3/RandomInitializer.cs	(revision 2773)
+++ /trunk/sources/HeuristicLab.Random/3.3/RandomInitializer.cs	(revision 2773)
@@ -0,0 +1,76 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Operators {
+  /// <summary>
+  /// An operator which initializes a pseudo random number generator.
+  /// </summary>
+  [Item("RandomInitializer", "An operator which initializes a pseudo random number generator.")]
+  [EmptyStorableClass]
+  [Creatable("Test")]
+  public sealed class RandomInitializer : SingleSuccessorOperator {
+    public ValueLookupParameter<BoolData> SetSeedRandomlyParameter {
+      get { return (ValueLookupParameter<BoolData>)Parameters["SetSeedRandomly"]; }
+    }
+    public ValueLookupParameter<IntData> SeedParameter {
+      get { return (ValueLookupParameter<IntData>)Parameters["Seed"]; }
+    }
+    public LookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public BoolData SetSeedRandomly {
+      get { return SetSeedRandomlyParameter.Value; }
+      set { SetSeedRandomlyParameter.Value = value; }
+    }
+    public IntData Seed {
+      get { return SeedParameter.Value; }
+      set { SeedParameter.Value = value; }
+    }
+
+    public RandomInitializer()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<BoolData>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolData(true)));
+      Parameters.Add(new ValueLookupParameter<IntData>("Seed", "The random seed used to initialize the pseudo random number generator.", new IntData(0)));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be initialized with the given seed."));
+    }
+
+    public override IExecutionSequence Apply() {
+      bool setSeedRandomly = SetSeedRandomlyParameter.ActualValue == null ? true : SetSeedRandomlyParameter.ActualValue.Value;
+      IntData seed = SeedParameter.ActualValue;
+      IRandom random = RandomParameter.ActualValue;
+
+      if (seed == null) seed = new IntData(0);
+      if (setSeedRandomly) seed.Value = new System.Random().Next();
+      RandomParameter.ActualValue = new MersenneTwister((uint)seed.Value);
+
+      return base.Apply();
+    }
+  }
+}
Index: unk/sources/HeuristicLab.Random/3.3/RandomInjector.cs
===================================================================
--- /trunk/sources/HeuristicLab.Random/3.3/RandomInjector.cs	(revision 2772)
+++ 	(revision )
@@ -1,76 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Xml;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-
-namespace HeuristicLab.Random {
-  /// <summary>
-  /// Injects a random variable in a given scope.
-  /// </summary>
-  public class RandomInjector : OperatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
-    }
-
-    /// <summary>
-    /// Initializes a new instance of <see cref="RandomInjector"/> with three variable infos
-    /// (<c>SetSeedRandomly</c>, <c>Seed</c> and <c>Random</c>.)
-    /// </summary>
-    public RandomInjector()
-      : base() {
-      AddVariableInfo(new VariableInfo("SetSeedRandomly", "Initialize random seed randomly", typeof(BoolData), VariableKind.In));
-      GetVariableInfo("SetSeedRandomly").Local = true;
-      AddVariable(new Variable("SetSeedRandomly", new BoolData(true)));
-
-      AddVariableInfo(new VariableInfo("Seed", "Random seed", typeof(IntData), VariableKind.In));
-      GetVariableInfo("Seed").Local = true;
-      System.Random random = new System.Random();
-      AddVariable(new Variable("Seed", new IntData(random.Next())));
-
-      AddVariableInfo(new VariableInfo("Random", "Pseudo random number generator", typeof(IRandom), VariableKind.New));
-    }
-
-    /// <summary>
-    /// Injects a new random variable in the given <paramref name="scope"/> .
-    /// </summary>
-    /// <param name="scope">The scope where to inject the variable.</param>
-    /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      bool setRandomly = GetVariableValue<BoolData>("SetSeedRandomly", scope, true).Data;
-      IntData seed = GetVariableValue<IntData>("Seed", scope, true);
-      if (setRandomly) {
-        System.Random random = new System.Random();
-        seed.Data = random.Next();
-      }
-      MersenneTwister mersenneTwister = new MersenneTwister((uint)seed.Data);
-
-      scope.AddVariable(new Variable(scope.TranslateName("Random"), mersenneTwister));
-      return null;
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.SequentialEngine/3.3/SequentialEngine.cs
===================================================================
--- /trunk/sources/HeuristicLab.SequentialEngine/3.3/SequentialEngine.cs	(revision 2772)
+++ /trunk/sources/HeuristicLab.SequentialEngine/3.3/SequentialEngine.cs	(revision 2773)
@@ -57,5 +57,5 @@
     protected override void ProcessNextOperator() {
       currentOperator = null;
-      IExecutionContext next = ExecutionStack.Pop();
+      IExecutionSequence next = ExecutionStack.Pop();
       ExecutionContextCollection coll = next as ExecutionContextCollection;
       while (coll != null) {
