Index: trunk/sources/HeuristicLab.Core/3.3/OperationCollection.cs
===================================================================
--- trunk/sources/HeuristicLab.Core/3.3/ExecutionContextCollection.cs	(revision 2790)
+++ trunk/sources/HeuristicLab.Core/3.3/OperationCollection.cs	(revision 2834)
@@ -20,15 +20,12 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Xml;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Core {
-  public class ExecutionContextCollection : DeepCloneable, IList<IExecutionSequence>, IExecutionSequence {
+  public class OperationCollection : DeepCloneable, IList<IOperation>, IOperation {
     [Storable]
-    private IList<IExecutionSequence> contexts;
+    private IList<IOperation> operations;
 
     [Storable]
@@ -39,69 +36,67 @@
     }
 
-    public ExecutionContextCollection() {
-      contexts = new List<IExecutionSequence>();
+    public OperationCollection() {
+      operations = new List<IOperation>();
       parallel = false;
     }
-    public ExecutionContextCollection(IEnumerable<IExecutionSequence> collection) {
-      contexts = new List<IExecutionSequence>(collection.Where(e => e != null));
+    public OperationCollection(IEnumerable<IOperation> collection) {
+      operations = new List<IOperation>(collection.Where(e => e != null));
       parallel = false;
     }
-    public ExecutionContextCollection(params IExecutionSequence[] list) {
-      contexts = new List<IExecutionSequence>(list.Where(e => e != null));
+    public OperationCollection(params IOperation[] list) {
+      operations = new List<IOperation>(list.Where(e => e != null));
       parallel = false;
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      ExecutionContextCollection clone = new ExecutionContextCollection();
+      OperationCollection clone = new OperationCollection(this.Select(x => (IOperation)cloner.Clone(x)));
       cloner.RegisterClonedObject(this, clone);
       clone.parallel = parallel;
-      for (int i = 0; i < contexts.Count; i++)
-        clone.contexts.Add((IExecutionSequence)cloner.Clone(contexts[i]));
       return clone;
     }
 
-    #region IList<IExecutionContext> Members
-    public int IndexOf(IExecutionSequence item) {
-      return contexts.IndexOf(item);
+    #region IList<IOperation> Members
+    public int IndexOf(IOperation item) {
+      return operations.IndexOf(item);
     }
-    public void Insert(int index, IExecutionSequence item) {
-      if (item != null) contexts.Insert(index, item);
+    public void Insert(int index, IOperation item) {
+      if (item != null) operations.Insert(index, item);
     }
     public void RemoveAt(int index) {
-      contexts.RemoveAt(index);
+      operations.RemoveAt(index);
     }
-    public IExecutionSequence this[int index] {
-      get { return contexts[index]; }
-      set { if (value != null) contexts[index] = value; }
+    public IOperation this[int index] {
+      get { return operations[index]; }
+      set { if (value != null) operations[index] = value; }
     }
     #endregion
 
-    #region ICollection<IExecutionContext> Members
-    public void Add(IExecutionSequence item) {
-      if (item != null) contexts.Add(item);
+    #region ICollection<IOperation> Members
+    public void Add(IOperation item) {
+      if (item != null) operations.Add(item);
     }
     public void Clear() {
-      contexts.Clear();
+      operations.Clear();
     }
-    public bool Contains(IExecutionSequence item) {
-      return contexts.Contains(item);
+    public bool Contains(IOperation item) {
+      return operations.Contains(item);
     }
-    public void CopyTo(IExecutionSequence[] array, int arrayIndex) {
-      contexts.CopyTo(array, arrayIndex);
+    public void CopyTo(IOperation[] array, int arrayIndex) {
+      operations.CopyTo(array, arrayIndex);
     }
     public int Count {
-      get { return contexts.Count; }
+      get { return operations.Count; }
     }
     public bool IsReadOnly {
-      get { return contexts.IsReadOnly; }
+      get { return operations.IsReadOnly; }
     }
-    public bool Remove(IExecutionSequence item) {
-      return contexts.Remove(item);
+    public bool Remove(IOperation item) {
+      return operations.Remove(item);
     }
     #endregion
 
-    #region IEnumerable<IExecutionContext> Members
-    public IEnumerator<IExecutionSequence> GetEnumerator() {
-      return contexts.GetEnumerator();
+    #region IEnumerable<IOperation> Members
+    public IEnumerator<IOperation> GetEnumerator() {
+      return operations.GetEnumerator();
     }
     #endregion
@@ -109,5 +104,5 @@
     #region IEnumerable Members
     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
-      return contexts.GetEnumerator();
+      return operations.GetEnumerator();
     }
     #endregion
