Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Attributes/CreatableAttribute.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Attributes/CreatableAttribute.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Attributes/CreatableAttribute.cs	(revision 9191)
@@ -0,0 +1,56 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+
+namespace HeuristicLab.Core {
+  [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+  public sealed class CreatableAttribute : Attribute {
+    private string category;
+    public string Category {
+      get {
+        return category;
+      }
+      set {
+        if (value == null) throw new ArgumentNullException("Category", "CreataleAttribute.Category must not be null");
+        category = value;
+      }
+    }
+
+    public CreatableAttribute() {
+      Category = "Other Items";
+    }
+    public CreatableAttribute(string category)
+      : this() {
+      Category = category;
+    }
+
+    public static bool IsCreatable(Type type) {
+      object[] attribs = type.GetCustomAttributes(typeof(CreatableAttribute), false);
+      return attribs.Length > 0;
+    }
+    public static string GetCategory(Type type) {
+      object[] attribs = type.GetCustomAttributes(typeof(CreatableAttribute), false);
+      if (attribs.Length > 0) return ((CreatableAttribute)attribs[0]).Category;
+      else return null;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Attributes/ItemAttribute.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Attributes/ItemAttribute.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Attributes/ItemAttribute.cs	(revision 9191)
@@ -0,0 +1,90 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using System.Linq;
+using System.Reflection;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Core {
+  [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+  public sealed class ItemAttribute : Attribute {
+    private string name;
+    public string Name {
+      get { return name; }
+      set { name = value == null ? string.Empty : value; }
+    }
+    private string description;
+    public string Description {
+      get { return description; }
+      set { description = value == null ? string.Empty : value; }
+    }
+
+    public ItemAttribute() {
+      Name = string.Empty;
+      Description = string.Empty;
+    }
+    public ItemAttribute(string name, string description) {
+      Name = name;
+      Description = description;
+    }
+
+    public static string GetName(Type type) {
+      object[] attribs = type.GetCustomAttributes(typeof(ItemAttribute), false);
+      if (attribs.Length > 0) {
+        string name = ((ItemAttribute)attribs[0]).Name;
+        if (type.IsGenericType) {
+          name += "<";
+          Type[] typeParams = type.GetGenericArguments();
+          if (typeParams.Length > 0) {
+            name += GetName(typeParams[0]);
+            for (int i = 1; i < typeParams.Length; i++)
+              name += ", " + GetName(typeParams[i]);
+          }
+          name += ">";
+        }
+        return name;
+      } else {
+        return type.GetPrettyName();
+      }
+    }
+    public static string GetDescription(Type type) {
+      object[] attribs = type.GetCustomAttributes(typeof(ItemAttribute), false);
+      if (attribs.Length > 0) return ((ItemAttribute)attribs[0]).Description;
+      else return string.Empty;
+    }
+    public static Version GetVersion(Type type) {
+      Assembly assembly = Assembly.GetAssembly(type);
+      AssemblyFileVersionAttribute version = assembly.GetCustomAttributes(typeof(AssemblyFileVersionAttribute), true).
+                                             Cast<AssemblyFileVersionAttribute>().FirstOrDefault();
+      if (version != null) {
+        return new Version(version.Version);
+      } else {
+        return assembly.GetName().Version;
+      }
+    }
+    public static Image GetImage(Type type) {
+      var staticItemImageProperty = type.GetProperty("StaticItemImage", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
+      return staticItemImageProperty == null ? null : (Image)staticItemImageProperty.GetValue(null, null);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/CheckedItemCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/CheckedItemCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/CheckedItemCollection.cs	(revision 9191)
@@ -0,0 +1,191 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents a collection of checked items.
+  /// </summary>
+  /// <typeparam name="T">The element type (base type IItem)</typeparam>
+  [StorableClass]
+  [Item("CheckedItemCollection", "Represents a collection of items that can be checked or unchecked.")]
+  public class CheckedItemCollection<T> : ItemCollection<T>, ICheckedItemCollection<T> where T : class, IItem {
+    [Storable]
+    private Dictionary<T, bool> checkedState;
+
+    /// <summary>
+    /// Gets an enumerable of checked items
+    /// </summary>
+    public IEnumerable<T> CheckedItems {
+      get { return from pair in checkedState where pair.Value select pair.Key; }
+    }
+
+    /// <summary>
+    /// Instantiates an empty CheckedItemCollection for deserialization.
+    /// </summary>
+    /// <param name="deserializing"></param>
+    [StorableConstructor]
+    protected CheckedItemCollection(bool deserializing) : base(deserializing) { }
+    protected CheckedItemCollection(CheckedItemCollection<T> original, Cloner cloner)
+      : base(original, cloner) {
+      list = new List<T>(original.Select(x => cloner.Clone(x)));
+      checkedState = new Dictionary<T, bool>();
+      foreach (var pair in original.checkedState)
+        checkedState.Add(cloner.Clone(pair.Key), pair.Value);
+    }
+    /// <summary>
+    /// Instantiates a new CheckedItemCollection.
+    /// </summary>
+    public CheckedItemCollection()
+      : base() {
+      checkedState = new Dictionary<T, bool>();
+    }
+    /// <summary>
+    /// Instantiates a new CheckedItemCollection with a predefined capacity.
+    /// </summary>
+    /// <param name="capacity">Initial capacity.</param>
+    public CheckedItemCollection(int capacity)
+      : base(capacity) {
+      checkedState = new Dictionary<T, bool>(capacity);
+    }
+    /// <summary>
+    /// Instantiates a new CheckedItemCollection containing the elements of <paramref name="collection"/>.
+    /// </summary>
+    /// <param name="collection">Initial element collection.</param>
+    public CheckedItemCollection(IEnumerable<T> collection)
+      : base(collection) {
+      checkedState = new Dictionary<T, bool>();
+      foreach (var item in list)
+        if (!checkedState.ContainsKey(item))
+          checkedState.Add(item, true);
+    }
+
+    /// <summary>
+    /// Gets the checked state of <paramref name="item"/>.
+    /// </summary>
+    /// <param name="item">The element to get the checked state for.</param>
+    /// <returns>Checked state of <paramref name="item"/></returns>
+    public bool ItemChecked(T item) {
+      return checkedState[item];
+    }
+
+    /// <summary>
+    /// Sets the checked state <paramref name="checkedState"/> of <paramref name="item"/>.
+    /// </summary>
+    /// <param name="item">The element to set the checked state for.</param>
+    /// <param name="checkedState">The new checked state of the item</param>
+    public void SetItemCheckedState(T item, bool checkedState) {
+      if (!this.checkedState.ContainsKey(item)) throw new ArgumentException();
+      if (this.checkedState[item] != checkedState) {
+        this.checkedState[item] = checkedState;
+        OnCheckedItemsChanged(new T[] { item });
+      }
+    }
+
+    /// <summary>
+    /// Adds a new <paramref name="item"/> with the given <paramref name="checkedState"/>.
+    /// </summary>
+    /// <param name="item">The item to add.</param>
+    /// <param name="checkedState">The checked state of the item to add.</param>
+    public void Add(T item, bool checkedState) {
+      Add(item);
+      SetItemCheckedState(item, checkedState);
+    }
+
+    /// <summary>
+    /// Creates a ReadOnlyCheckedItemCollection containing the same elements.
+    /// </summary>
+    /// <returns>A new ReadOnlyCheckedItemCollection containing the same elements.</returns>
+    public new ReadOnlyCheckedItemCollection<T> AsReadOnly() {
+      return new ReadOnlyCheckedItemCollection<T>(this);
+    }
+
+    /// <summary>
+    /// Raised when the collection of items is reset.
+    /// </summary>
+    /// <param name="items">Empty</param>
+    /// <param name="oldItems">The elements in the collection before the reset.</param>
+    protected override void OnCollectionReset(IEnumerable<T> items, IEnumerable<T> oldItems) {
+      foreach (var oldItem in oldItems)
+        if (!list.Contains(oldItem))
+          checkedState.Remove(oldItem);
+      foreach (var item in items)
+        if (!checkedState.ContainsKey(item))
+          checkedState.Add(item, true);
+      base.OnCollectionReset(items, oldItems);
+    }
+
+    /// <summary>
+    /// Raised when new items are added to the collection.
+    /// </summary>
+    /// <param name="items">The elements that are added to the collection.</param>
+    protected override void OnItemsAdded(IEnumerable<T> items) {
+      foreach (var item in items)
+        if (!checkedState.ContainsKey(item))
+          checkedState.Add(item, true);
+      base.OnItemsAdded(items);
+    }
+
+    /// <summary>
+    /// Raised when items are removed from the collection.
+    /// </summary>
+    /// <param name="items">The items that are removed.</param>
+    protected override void OnItemsRemoved(IEnumerable<T> items) {
+      foreach (var item in items) {
+        if (!list.Contains(item))
+          checkedState.Remove(item);
+      }
+      base.OnItemsRemoved(items);
+    }
+
+    /// <summary>
+    /// Raised when the checked state of items is changed.
+    /// </summary>
+    /// <param name="items">The item whose check state is changed.</param>
+    protected virtual void OnCheckedItemsChanged(IEnumerable<T> items) {
+      RaiseCheckedItemsChanged(new CollectionItemsChangedEventArgs<T>(items));
+    }
+
+    /// <summary>
+    /// Raised after the checked state of items has been changed.
+    /// </summary>
+    public event CollectionItemsChangedEventHandler<T> CheckedItemsChanged;
+    private void RaiseCheckedItemsChanged(CollectionItemsChangedEventArgs<T> e) {
+      var handler = CheckedItemsChanged;
+      if (handler != null) handler(this, e);
+    }
+
+    /// <summary>
+    /// Creates a deep clone of the CheckedItemCollection.
+    /// </summary>
+    /// <param name="cloner"></param>
+    /// <returns>A clone of the CheckedItemCollection</returns>
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CheckedItemCollection<T>(this, cloner);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/CheckedItemList.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/CheckedItemList.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/CheckedItemList.cs	(revision 9191)
@@ -0,0 +1,241 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents a list of checked items.
+  /// </summary>
+  /// <typeparam name="T">The element type (base type is IItem)</typeparam>
+  [StorableClass]
+  [Item("CheckedItemList", "Represents a list of items that can be checked or unchecked.")]
+  public class CheckedItemList<T> : ItemList<T>, ICheckedItemList<T> where T : class, IItem {
+    [Storable]
+    private Dictionary<T, bool> checkedState;
+
+    /// <summary>
+    /// Gets an enumerable of checked items.
+    /// </summary>
+    public IEnumerable<IndexedItem<T>> CheckedItems {
+      get {
+        return from i in Enumerable.Range(0, list.Count)
+               where ItemChecked(i)
+               select new IndexedItem<T>(i, list[i]);
+      }
+    }
+
+    /// <summary>
+    /// Instantiates a new CheckedItemList for deserialization.
+    /// </summary>
+    /// <param name="deserializing"></param>
+    [StorableConstructor]
+    protected CheckedItemList(bool deserializing) : base(deserializing) { }
+    protected CheckedItemList(CheckedItemList<T> original, Cloner cloner)
+      : base(original, cloner) {
+      list = new List<T>(original.Select(x => (T)cloner.Clone(x)));
+      checkedState = new Dictionary<T, bool>();
+      foreach (var pair in original.checkedState)
+        checkedState.Add(cloner.Clone(pair.Key), pair.Value);
+    }
+    /// <summary>
+    /// Instantiates an empty CheckedItemList.
+    /// </summary>
+    public CheckedItemList()
+      : base() {
+      checkedState = new Dictionary<T, bool>();
+    }
+    /// <summary>
+    /// Instantiates an empty CheckedItemList with a given initial <paramref name="capacity"/>.
+    /// </summary>
+    /// <param name="capacity">The initial capacity.</param>
+    public CheckedItemList(int capacity)
+      : base(capacity) {
+      checkedState = new Dictionary<T, bool>();
+    }
+    /// <summary>
+    /// Instantiates an CheckedItemList initially filled with the elements of <paramref name="collection"/>.
+    /// </summary>
+    /// <param name="collection">Collection of elements.</param>
+    public CheckedItemList(IEnumerable<T> collection)
+      : base(collection) {
+      checkedState = new Dictionary<T, bool>();
+      foreach (var item in list) {
+        if (!checkedState.ContainsKey(item))
+          checkedState.Add(item, true);
+      }
+    }
+
+    /// <summary>
+    /// Gets the checked state of <paramref name="item"/>.
+    /// </summary>
+    /// <param name="item">The element to get the checked state for.</param>
+    /// <returns>The checked state of <paramref name="item"/></returns>
+    public bool ItemChecked(T item) {
+      return checkedState[item];
+    }
+
+    /// <summary>
+    /// Gets the checked state of item with <paramref name="index"/>.
+    /// </summary>
+    /// <param name="itemIndex">The index of the element to get the checked state for.</param>
+    /// <returns>The checked state of the element at <paramref name="itemIndex"/>.</returns>
+    public bool ItemChecked(int itemIndex) {
+      return ItemChecked(this[itemIndex]);
+    }
+
+    /// <summary>
+    /// Sets the checked state of <paramref name="item"/> to <paramref name="checkedState"/>.
+    /// </summary>
+    /// <param name="item">The item to set the checked state for.</param>
+    /// <param name="checkedState">The new checked state of <paramref name="item"/></param>
+    public void SetItemCheckedState(T item, bool checkedState) {
+      if (!this.checkedState.ContainsKey(item)) throw new ArgumentException();
+      if (this.checkedState[item] != checkedState) {
+        this.checkedState[item] = checkedState;
+        OnCheckedItemsChanged(new IndexedItem<T>[] { new IndexedItem<T>(IndexOf(item), item) });
+      }
+    }
+
+    /// <summary>
+    /// Sets the checked state of the element with <paramref name="itemIndex"/> to <paramref name="checkedState"/>.
+    /// </summary>
+    /// <param name="itemIndex">The index of the item to set the checked state for.</param>
+    /// <param name="checkedState">The new checked state of the item.</param>
+    public void SetItemCheckedState(int itemIndex, bool checkedState) {
+      SetItemCheckedState(this[itemIndex], checkedState);
+    }
+
+    /// <summary>
+    /// Adds a new <paramref name="item"/> with <paramref name="checkedState"/> to the list.
+    /// </summary>
+    /// <param name="item">The item to add to the list.</param>
+    /// <param name="checkedState">The checked state of the item added to the list.</param>
+    public void Add(T item, bool checkedState) {
+      Add(item);
+      SetItemCheckedState(item, checkedState);
+    }
+
+    /// <summary>
+    /// Inserts a new <paramref name="item"/> at <paramref name="index"/> with <paramref name="checkedState"/> into the list.
+    /// </summary>
+    /// <param name="index">The insertion index of the new element.</param>
+    /// <param name="item">The element that is inserted into the list.</param>
+    /// <param name="checkedState">The checked state of the inserted element.</param>
+    public void Insert(int index, T item, bool checkedState) {
+      Insert(index, item);
+      SetItemCheckedState(item, checkedState);
+    }
+
+    /// <summary>
+    /// Creates a ReadOnlyCheckedItemList containing the same elements.
+    /// </summary>
+    /// <returns>A new ReadOnlyCheckedItemList containing the same elements.</returns>
+    public new ReadOnlyCheckedItemList<T> AsReadOnly() {
+      return new ReadOnlyCheckedItemList<T>(this);
+    }
+
+    /// <summary>
+    /// Raised after the list has been reset.
+    /// </summary>
+    /// <param name="items">Empty</param>
+    /// <param name="oldItems">The elements of the list before it has been reset.</param>
+    protected override void OnCollectionReset(IEnumerable<IndexedItem<T>> items, IEnumerable<IndexedItem<T>> oldItems) {
+      foreach (var oldIndexedItem in oldItems) {
+        if (!list.Contains(oldIndexedItem.Value))
+          checkedState.Remove(oldIndexedItem.Value);
+      }
+      foreach (var indexedItem in items) {
+        if (!checkedState.ContainsKey(indexedItem.Value))
+          checkedState.Add(indexedItem.Value, true);
+      }
+      base.OnCollectionReset(items, oldItems);
+    }
+
+    /// <summary>
+    /// Raised when new items are added to the list.
+    /// </summary>
+    /// <param name="items">The items that are added.</param>
+    protected override void OnItemsAdded(IEnumerable<IndexedItem<T>> items) {
+      foreach (var indexedItem in items)
+        if (!checkedState.ContainsKey(indexedItem.Value))
+          checkedState.Add(indexedItem.Value, true);
+      base.OnItemsAdded(items);
+    }
+
+    /// <summary>
+    /// Raised when items are removed from the list.
+    /// </summary>
+    /// <param name="items">Items that are removed.</param>
+    protected override void OnItemsRemoved(IEnumerable<IndexedItem<T>> items) {
+      foreach (var indexedItem in items)
+        if (!list.Contains(indexedItem.Value))
+          checkedState.Remove(indexedItem.Value);
+      base.OnItemsRemoved(items);
+    }
+
+    /// <summary>
+    /// Raised when items are replaced.
+    /// </summary>
+    /// <param name="items">The items which replace <paramref name="oldItems"/></param>
+    /// <param name="oldItems">The items that are replaced by <paramref name="items"/></param>
+    protected override void OnItemsReplaced(IEnumerable<IndexedItem<T>> items, IEnumerable<IndexedItem<T>> oldItems) {
+      foreach (var oldIndexedItem in oldItems)
+        if (!list.Contains(oldIndexedItem.Value))
+          checkedState.Remove(oldIndexedItem.Value);
+      foreach (var indexedItem in items)
+        if (!checkedState.ContainsKey(indexedItem.Value))
+          checkedState.Add(indexedItem.Value, true);
+      base.OnItemsReplaced(items, oldItems);
+    }
+
+    /// <summary>
+    /// Raised after the checked state of items has been changed.
+    /// </summary>
+    /// <param name="items">The items whose check state has been changed.</param>
+    protected virtual void OnCheckedItemsChanged(IEnumerable<IndexedItem<T>> items) {
+      RaiseCheckedItemsChanged(new CollectionItemsChangedEventArgs<IndexedItem<T>>(items));
+    }
+
+    /// <summary>
+    /// Raised after the checked state of items has been changed.
+    /// </summary>
+    public event CollectionItemsChangedEventHandler<IndexedItem<T>> CheckedItemsChanged;
+    private void RaiseCheckedItemsChanged(CollectionItemsChangedEventArgs<IndexedItem<T>> e) {
+      var handler = CheckedItemsChanged;
+      if (handler != null) handler(this, e);
+    }
+
+    /// <summary>
+    /// Creates a new deep clone of the CheckedItemList.
+    /// </summary>
+    /// <param name="cloner"></param>
+    /// <returns>A deep clone of the CheckedItemList</returns>
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CheckedItemList<T>(this, cloner);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ConstraintCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ConstraintCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ConstraintCollection.cs	(revision 9191)
@@ -0,0 +1,39 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ConstraintCollection", "Represents a collection of constraints.")]
+  public class ConstraintCollection : ItemCollection<IConstraint> {
+    [StorableConstructor]
+    protected ConstraintCollection(bool deserializing) : base(deserializing) { }
+    protected ConstraintCollection(ConstraintCollection original, Cloner cloner) : base(original, cloner) { }
+    public ConstraintCollection() : base() { }
+    public ConstraintCollection(int capacity) : base(capacity) { }
+    public ConstraintCollection(IEnumerable<IConstraint> collection) : base(collection) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new ConstraintCollection(this, cloner); }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemArray.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemArray.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemArray.cs	(revision 9191)
@@ -0,0 +1,87 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using System.Linq;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ItemArray", "Represents an array of items.")]
+  public class ItemArray<T> : ObservableArray<T>, IItemArray<T> where T : class, IItem {
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected ItemArray(bool deserializing) : base(deserializing) { }
+    protected ItemArray(ItemArray<T> original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      array = original.Select(x => cloner.Clone(x)).ToArray();
+    }
+    public ItemArray() : base() { }
+    public ItemArray(int length) : base(length) { }
+    public ItemArray(T[] array) : base(array) { }
+    public ItemArray(IEnumerable<T> collection) : base(collection) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new ItemArray<T>(this, cloner);
+    }
+
+    public new ReadOnlyItemArray<T> AsReadOnly() {
+      return new ReadOnlyItemArray<T>(this);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemCollection.cs	(revision 9191)
@@ -0,0 +1,86 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using System.Linq;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ItemCollection", "Represents a collection of items.")]
+  public class ItemCollection<T> : ObservableCollection<T>, IItemCollection<T> where T : class, IItem {
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected ItemCollection(bool deserializing) : base(deserializing) { }
+    protected ItemCollection(ItemCollection<T> original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      list = new List<T>(original.Select(x => cloner.Clone(x)));
+    }
+    public ItemCollection() : base() { }
+    public ItemCollection(int capacity) : base(capacity) { }
+    public ItemCollection(IEnumerable<T> collection) : base(collection) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new ItemCollection<T>(this, cloner);
+    }
+
+    public new ReadOnlyItemCollection<T> AsReadOnly() {
+      return new ReadOnlyItemCollection<T>(this);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemDictionary.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemDictionary.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemDictionary.cs	(revision 9191)
@@ -0,0 +1,89 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ItemDictionary", "Represents a dictionary of items.")]
+  public class ItemDictionary<TKey, TValue> : ObservableDictionary<TKey, TValue>, IItemDictionary<TKey, TValue>
+    where TKey : class, IItem
+    where TValue : class, IItem {
+
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected ItemDictionary(bool deserializing) : base(deserializing) { }
+    protected ItemDictionary(ItemDictionary<TKey, TValue> original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      foreach (TKey key in original.dict.Keys)
+        dict.Add(cloner.Clone(key), cloner.Clone(original.dict[key]));
+    }
+    public ItemDictionary() : base() { }
+    public ItemDictionary(int capacity) : base(capacity) { }
+    public ItemDictionary(IDictionary<TKey, TValue> dictionary) : base(dictionary) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new ItemDictionary<TKey, TValue>(this, cloner);
+    }
+
+    public new ReadOnlyItemDictionary<TKey, TValue> AsReadOnly() {
+      return new ReadOnlyItemDictionary<TKey, TValue>(this);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemList.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemList.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemList.cs	(revision 9191)
@@ -0,0 +1,86 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using System.Linq;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ItemList", "Represents a list of items.")]
+  public class ItemList<T> : ObservableList<T>, IItemList<T> where T : class, IItem {
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected ItemList(bool deserializing) : base(deserializing) { }
+    protected ItemList(ItemList<T> original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      list = new List<T>(original.Select(x => cloner.Clone(x)));
+    }
+    public ItemList() : base() { }
+    public ItemList(int capacity) : base(capacity) { }
+    public ItemList(IEnumerable<T> collection) : base(collection) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new ItemList<T>(this, cloner);
+    }
+
+    public new ReadOnlyItemList<T> AsReadOnly() {
+      return new ReadOnlyItemList<T>(this);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemSet.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemSet.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemSet.cs	(revision 9191)
@@ -0,0 +1,87 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using System.Linq;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ItemSet", "Represents a set of items.")]
+  public class ItemSet<T> : ObservableSet<T>, IItemSet<T> where T : class, IItem {
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected ItemSet(bool deserializing) : base(deserializing) { }
+    protected ItemSet(ItemSet<T> original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      set = new HashSet<T>(original.Select(x => cloner.Clone(x)));
+    }
+    public ItemSet() : base() { }
+    public ItemSet(IEnumerable<T> collection) : base(collection) { }
+    public ItemSet(IEqualityComparer<T> comparer) : base(comparer) { }
+    public ItemSet(IEnumerable<T> collection, IEqualityComparer<T> comparer) : base(collection, comparer) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new ItemSet<T>(this, cloner);
+    }
+
+    public new ReadOnlyItemSet<T> AsReadOnly() {
+      return new ReadOnlyItemSet<T>(this);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/KeyedItemCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/KeyedItemCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/KeyedItemCollection.cs	(revision 9191)
@@ -0,0 +1,86 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [Item("KeyedItemCollection", "Represents a keyed collection of items.")]
+  [StorableClass]
+  public abstract class KeyedItemCollection<TKey, TItem> : ObservableKeyedCollection<TKey, TItem>, IKeyedItemCollection<TKey, TItem> where TItem : class, IItem {
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected KeyedItemCollection(bool deserializing) : base(deserializing) { }
+    protected KeyedItemCollection(KeyedItemCollection<TKey, TItem> original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      foreach (TItem item in original.dict.Values) {
+        TItem clonedItem = cloner.Clone(item);
+        dict.Add(GetKeyForItem(clonedItem), clonedItem);
+      }
+    }
+    protected KeyedItemCollection() : base() { }
+    protected KeyedItemCollection(int capacity) : base(capacity) { }
+    protected KeyedItemCollection(IEnumerable<TItem> collection) : base(collection) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public abstract IDeepCloneable Clone(Cloner cloner);
+
+    public new ReadOnlyKeyedItemCollection<TKey, TItem> AsReadOnly() {
+      return new ReadOnlyKeyedItemCollection<TKey, TItem>(this);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/NamedItemCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/NamedItemCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/NamedItemCollection.cs	(revision 9191)
@@ -0,0 +1,102 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [Item("NamedItemCollection", "Represents a collection of named items.")]
+  [StorableClass]
+  public class NamedItemCollection<T> : KeyedItemCollection<string, T> where T : class, INamedItem {
+    [StorableConstructor]
+    protected NamedItemCollection(bool deserializing) : base(deserializing) { }
+    protected NamedItemCollection(NamedItemCollection<T> original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterItemEvents(this);
+    }
+    public NamedItemCollection() : base() { }
+    public NamedItemCollection(int capacity) : base(capacity) { }
+    public NamedItemCollection(IEnumerable<T> collection)
+      : base(collection) {
+      RegisterItemEvents(this);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterItemEvents(this);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NamedItemCollection<T>(this, cloner);
+    }
+
+    protected override string GetKeyForItem(T item) {
+      return item.Name;
+    }
+
+    protected override void OnItemsAdded(IEnumerable<T> items) {
+      RegisterItemEvents(items);
+      base.OnItemsAdded(items);
+    }
+    protected override void OnItemsRemoved(IEnumerable<T> items) {
+      DeregisterItemEvents(items);
+      base.OnItemsRemoved(items);
+    }
+    #region NOTE
+    // NOTE: OnItemsReplaced is not overridden as ItemsReplaced is only fired
+    // by ObservableKeyedCollection when the key of an item has changed. The items stays
+    // in the collection and therefore the NameChanging, NameChanged and Changed event handler
+    // do not have to be removed and added again.
+    #endregion
+    protected override void OnCollectionReset(IEnumerable<T> items, IEnumerable<T> oldItems) {
+      DeregisterItemEvents(oldItems);
+      RegisterItemEvents(items);
+      base.OnCollectionReset(items, oldItems);
+    }
+
+    protected void RegisterItemEvents(IEnumerable<T> items) {
+      foreach (T item in items) {
+        if (item != null) {
+          item.NameChanging += new EventHandler<CancelEventArgs<string>>(Item_NameChanging);
+          item.NameChanged += new EventHandler(Item_NameChanged);
+        }
+      }
+    }
+    private void DeregisterItemEvents(IEnumerable<T> items) {
+      foreach (T item in items) {
+        if (item != null) {
+          item.NameChanging -= new EventHandler<CancelEventArgs<string>>(Item_NameChanging);
+          item.NameChanged -= new EventHandler(Item_NameChanged);
+        }
+      }
+    }
+
+    private void Item_NameChanging(object sender, CancelEventArgs<string> e) {
+      e.Cancel = e.Cancel || this.ContainsKey(e.Value);
+    }
+    private void Item_NameChanged(object sender, EventArgs e) {
+      T item = (T)sender;
+      UpdateItemKey(item);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperationCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperationCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperationCollection.cs	(revision 9191)
@@ -0,0 +1,116 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  public sealed class OperationCollection : DeepCloneable, IList<IOperation>, IOperation {
+    [Storable]
+    private IList<IOperation> operations;
+
+    [Storable]
+    private bool parallel;
+    public bool Parallel {
+      get { return parallel; }
+      set { parallel = value; }
+    }
+
+    [StorableConstructor]
+    private OperationCollection(bool deserializing) { }
+    private OperationCollection(OperationCollection original, Cloner cloner)
+      : base(original, cloner) {
+      operations = new List<IOperation>(original.Select(x => cloner.Clone(x)));
+      parallel = original.parallel;
+    }
+    public OperationCollection() {
+      operations = new List<IOperation>();
+      parallel = false;
+    }
+    public OperationCollection(IEnumerable<IOperation> collection) {
+      operations = new List<IOperation>(collection.Where(e => e != null));
+      parallel = false;
+    }
+    public OperationCollection(params IOperation[] list) {
+      operations = new List<IOperation>(list.Where(e => e != null));
+      parallel = false;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new OperationCollection(this, cloner);
+    }
+
+    #region IList<IOperation> Members
+    public int IndexOf(IOperation item) {
+      return operations.IndexOf(item);
+    }
+    public void Insert(int index, IOperation item) {
+      if (item != null) operations.Insert(index, item);
+    }
+    public void RemoveAt(int index) {
+      operations.RemoveAt(index);
+    }
+    public IOperation this[int index] {
+      get { return operations[index]; }
+      set { if (value != null) operations[index] = value; }
+    }
+    #endregion
+
+    #region ICollection<IOperation> Members
+    public void Add(IOperation item) {
+      if (item != null) operations.Add(item);
+    }
+    public void Clear() {
+      operations.Clear();
+    }
+    public bool Contains(IOperation item) {
+      return operations.Contains(item);
+    }
+    public void CopyTo(IOperation[] array, int arrayIndex) {
+      operations.CopyTo(array, arrayIndex);
+    }
+    public int Count {
+      get { return operations.Count; }
+    }
+    public bool IsReadOnly {
+      get { return operations.IsReadOnly; }
+    }
+    public bool Remove(IOperation item) {
+      return operations.Remove(item);
+    }
+    #endregion
+
+    #region IEnumerable<IOperation> Members
+    public IEnumerator<IOperation> GetEnumerator() {
+      return operations.GetEnumerator();
+    }
+    #endregion
+
+    #region IEnumerable Members
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
+      return operations.GetEnumerator();
+    }
+    #endregion
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperatorCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperatorCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperatorCollection.cs	(revision 9191)
@@ -0,0 +1,38 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("Operator Collection", "Represents a collection of operators.")]
+  public class OperatorCollection : ItemCollection<IOperator> {
+    [StorableConstructor]
+    protected OperatorCollection(bool deserializing) : base(deserializing) { }
+    protected OperatorCollection(OperatorCollection original, Cloner cloner) : base(original, cloner) { }
+    public OperatorCollection() : base() { }
+    public OperatorCollection(IEnumerable<IOperator> collection) : base(collection) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new OperatorCollection(this, cloner); }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperatorList.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperatorList.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperatorList.cs	(revision 9191)
@@ -0,0 +1,39 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("OperatorList", "Represents a list of operators.")]
+  public class OperatorList : ItemList<IOperator> {
+    [StorableConstructor]
+    protected OperatorList(bool deserializing) : base(deserializing) { }
+    protected OperatorList(OperatorList original, Cloner cloner) : base(original, cloner) { }
+    public OperatorList() : base() { }
+    public OperatorList(int capacity) : base(capacity) { }
+    public OperatorList(IEnumerable<IOperator> collection) : base(collection) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new OperatorList(this, cloner); }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperatorSet.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperatorSet.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/OperatorSet.cs	(revision 9191)
@@ -0,0 +1,38 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("OperatorSet", "Represents a set of operators.")]
+  public class OperatorSet : ItemSet<IOperator> {
+    [StorableConstructor]
+    protected OperatorSet(bool deserializing) : base(deserializing) { }
+    protected OperatorSet(OperatorSet original, Cloner cloner) : base(original, cloner) { }
+    public OperatorSet() : base() { }
+    public OperatorSet(IEnumerable<IOperator> collection) : base(collection) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new OperatorSet(this, cloner); }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ParameterCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ParameterCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ParameterCollection.cs	(revision 9191)
@@ -0,0 +1,39 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ParameterCollection", "Represents a collection of parameters.")]
+  public class ParameterCollection : NamedItemCollection<IParameter> {
+    [StorableConstructor]
+    protected ParameterCollection(bool deserializing) : base(deserializing) { }
+    protected ParameterCollection(ParameterCollection original, Cloner cloner) : base(original, cloner) { }
+    public ParameterCollection() : base() { }
+    public ParameterCollection(int capacity) : base(capacity) { }
+    public ParameterCollection(IEnumerable<IParameter> collection) : base(collection) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new ParameterCollection(this, cloner); }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyCheckedItemCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyCheckedItemCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyCheckedItemCollection.cs	(revision 9191)
@@ -0,0 +1,82 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyCheckedItemCollection", "Represents a read-only collection of checked items.")]
+  public class ReadOnlyCheckedItemCollection<T> : ReadOnlyItemCollection<T>, ICheckedItemCollection<T> where T : class, IItem {
+    private CheckedItemCollection<T> CheckedItemCollection {
+      get { return (CheckedItemCollection<T>)base.collection; }
+    }
+
+    [StorableConstructor]
+    protected ReadOnlyCheckedItemCollection(bool deserializing) : base(deserializing) { }
+    protected ReadOnlyCheckedItemCollection(ReadOnlyCheckedItemCollection<T> original, Cloner cloner)
+      : base(original, cloner) {
+      CheckedItemCollection.CheckedItemsChanged += new CollectionItemsChangedEventHandler<T>(collection_CheckedItemsChanged);
+    }
+    public ReadOnlyCheckedItemCollection() : base(new CheckedItemCollection<T>()) { }
+    public ReadOnlyCheckedItemCollection(ICheckedItemCollection<T> collection)
+      : base(collection) {
+      CheckedItemCollection.CheckedItemsChanged += new CollectionItemsChangedEventHandler<T>(collection_CheckedItemsChanged);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      CheckedItemCollection.CheckedItemsChanged += new CollectionItemsChangedEventHandler<T>(collection_CheckedItemsChanged);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ReadOnlyCheckedItemCollection<T>(this, cloner);
+    }
+
+    #region ReadOnlyCheckedItemCollection<T> Members
+    public event CollectionItemsChangedEventHandler<T> CheckedItemsChanged;
+    protected virtual void collection_CheckedItemsChanged(object sender, CollectionItemsChangedEventArgs<T> e) {
+      var handler = CheckedItemsChanged;
+      if (handler != null)
+        handler(this, e);
+    }
+
+    public IEnumerable<T> CheckedItems {
+      get { return CheckedItemCollection.CheckedItems; }
+    }
+
+    public bool ItemChecked(T item) {
+      return CheckedItemCollection.ItemChecked(item);
+    }
+
+    public void SetItemCheckedState(T item, bool checkedState) {
+      CheckedItemCollection.SetItemCheckedState(item, checkedState);
+    }
+
+    public void Add(T item, bool checkedState) {
+      throw new NotSupportedException();
+    }
+    #endregion
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyCheckedItemList.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyCheckedItemList.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyCheckedItemList.cs	(revision 9191)
@@ -0,0 +1,88 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyCheckedItemList", "Represents a read-only list of checked items.")]
+  public class ReadOnlyCheckedItemList<T> : ReadOnlyItemList<T>, ICheckedItemList<T> where T : class, IItem {
+    private CheckedItemList<T> CheckedItemList {
+      get { return (CheckedItemList<T>)base.list; }
+    }
+
+    [StorableConstructor]
+    protected ReadOnlyCheckedItemList(bool deserializing) : base(deserializing) { }
+    protected ReadOnlyCheckedItemList(ReadOnlyCheckedItemList<T> original, Cloner cloner)
+      : base(original, cloner) {
+      CheckedItemList.CheckedItemsChanged += new CollectionItemsChangedEventHandler<IndexedItem<T>>(list_CheckedItemsChanged);
+    }
+    public ReadOnlyCheckedItemList() : base(new CheckedItemList<T>()) { }
+    public ReadOnlyCheckedItemList(ICheckedItemList<T> list)
+      : base(list) {
+      CheckedItemList.CheckedItemsChanged += new CollectionItemsChangedEventHandler<IndexedItem<T>>(list_CheckedItemsChanged);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      CheckedItemList.CheckedItemsChanged += new CollectionItemsChangedEventHandler<IndexedItem<T>>(list_CheckedItemsChanged);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ReadOnlyCheckedItemList<T>(this, cloner);
+    }
+
+
+    #region ICheckedItemList<T> Members
+    public event CollectionItemsChangedEventHandler<IndexedItem<T>> CheckedItemsChanged;
+    protected virtual void list_CheckedItemsChanged(object sender, CollectionItemsChangedEventArgs<IndexedItem<T>> e) {
+      var handler = CheckedItemsChanged;
+      if (handler != null)
+        handler(this, e);
+    }
+
+    public IEnumerable<IndexedItem<T>> CheckedItems {
+      get { return CheckedItemList.CheckedItems; }
+    }
+
+    public bool ItemChecked(T item) {
+      return CheckedItemList.ItemChecked(item);
+    }
+
+    public void SetItemCheckedState(T item, bool checkedState) {
+      CheckedItemList.SetItemCheckedState(item, checkedState);
+    }
+
+    public void Add(T item, bool checkedState) {
+      throw new NotSupportedException();
+    }
+
+    public void Insert(int index, T item, bool checkedState) {
+      throw new NotSupportedException();
+    }
+
+    #endregion
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemArray.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemArray.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemArray.cs	(revision 9191)
@@ -0,0 +1,80 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyItemArray", "Represents a read-only array of items.")]
+  public class ReadOnlyItemArray<T> : ReadOnlyObservableArray<T>, IItemArray<T> where T : class, IItem {
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected ReadOnlyItemArray(bool deserializing) : base(deserializing) { }
+    protected ReadOnlyItemArray(ReadOnlyItemArray<T> original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      array = cloner.Clone((IItemArray<T>)original.array);
+      RegisterEvents();
+    }
+    public ReadOnlyItemArray() : base(new ItemArray<T>()) { }
+    public ReadOnlyItemArray(IItemArray<T> array) : base(array) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new ReadOnlyItemArray<T>(this, cloner);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemCollection.cs	(revision 9191)
@@ -0,0 +1,80 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyItemCollection", "Represents a read-only collection of items.")]
+  public class ReadOnlyItemCollection<T> : ReadOnlyObservableCollection<T>, IItemCollection<T> where T : class, IItem {
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected ReadOnlyItemCollection(bool deserializing) : base(deserializing) { }
+    protected ReadOnlyItemCollection(ReadOnlyItemCollection<T> original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      collection = cloner.Clone((IItemCollection<T>)original.collection);
+      RegisterEvents();
+    }
+    public ReadOnlyItemCollection() : base(new ItemCollection<T>()) { }
+    public ReadOnlyItemCollection(IItemCollection<T> collection) : base(collection) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new ReadOnlyItemCollection<T>(this, cloner);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemDictionary.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemDictionary.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemDictionary.cs	(revision 9191)
@@ -0,0 +1,83 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyItemDictionary", "Represents a read-only dictionary of items.")]
+  public class ReadOnlyItemDictionary<TKey, TValue> : ReadOnlyObservableDictionary<TKey, TValue>, IItemDictionary<TKey, TValue>
+    where TKey : class, IItem
+    where TValue : class, IItem {
+
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected ReadOnlyItemDictionary(bool deserializing) : base(deserializing) { }
+    protected ReadOnlyItemDictionary(ReadOnlyItemDictionary<TKey, TValue> original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      dict = cloner.Clone((IItemDictionary<TKey, TValue>)original.dict);
+      RegisterEvents();
+    }
+    public ReadOnlyItemDictionary() : base(new ItemDictionary<TKey, TValue>()) { }
+    public ReadOnlyItemDictionary(IItemDictionary<TKey, TValue> dictionary) : base(dictionary) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new ReadOnlyItemDictionary<TKey, TValue>(this, cloner);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemList.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemList.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemList.cs	(revision 9191)
@@ -0,0 +1,79 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyItemList", "Represents a read-only list of items.")]
+  public class ReadOnlyItemList<T> : ReadOnlyObservableList<T>, IItemList<T> where T : class, IItem {
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected ReadOnlyItemList(bool deserializing) : base(deserializing) { }
+    protected ReadOnlyItemList(ReadOnlyItemList<T> original, Cloner cloner)
+      : base(cloner.Clone((IItemList<T>)original.list)) {
+      cloner.RegisterClonedObject(original, this);
+    }
+    public ReadOnlyItemList() : base(new ItemList<T>()) { }
+    public ReadOnlyItemList(IItemList<T> list) : base(list) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new ReadOnlyItemList<T>(this, cloner);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemSet.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemSet.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyItemSet.cs	(revision 9191)
@@ -0,0 +1,80 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyItemSet", "Represents a read-only set of items.")]
+  public class ReadOnlyItemSet<T> : ReadOnlyObservableSet<T>, IItemSet<T> where T : class, IItem {
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected ReadOnlyItemSet(bool deserializing) : base(deserializing) { }
+    protected ReadOnlyItemSet(ReadOnlyItemSet<T> original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      set = cloner.Clone((IItemSet<T>)original.set);
+      RegisterEvents();
+    }
+    public ReadOnlyItemSet() : base(new ItemSet<T>()) { }
+    public ReadOnlyItemSet(IItemSet<T> set) : base(set) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new ReadOnlyItemSet<T>(this, cloner);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyKeyedItemCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyKeyedItemCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ReadOnlyKeyedItemCollection.cs	(revision 9191)
@@ -0,0 +1,80 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyKeyedItemCollection", "Represents a read-only keyed collection of items.")]
+  public class ReadOnlyKeyedItemCollection<TKey, TItem> : ReadOnlyObservableKeyedCollection<TKey, TItem>, IKeyedItemCollection<TKey, TItem> where TItem : class, IItem {
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected ReadOnlyKeyedItemCollection(bool deserializing) : base(deserializing) { }
+    protected ReadOnlyKeyedItemCollection(ReadOnlyKeyedItemCollection<TKey, TItem> original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      collection = cloner.Clone((IKeyedItemCollection<TKey, TItem>)original.collection);
+      RegisterEvents();
+    }
+    protected ReadOnlyKeyedItemCollection() : base() { }
+    public ReadOnlyKeyedItemCollection(IKeyedItemCollection<TKey, TItem> collection) : base(collection) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new ReadOnlyKeyedItemCollection<TKey, TItem>(this, cloner);
+    }
+
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ScopeList.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ScopeList.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ScopeList.cs	(revision 9191)
@@ -0,0 +1,45 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ScopeList", "Represents a list of scopes.")]
+  public sealed class ScopeList : ItemList<IScope> {
+    [StorableConstructor]
+    private ScopeList(bool deserializing) : base(deserializing) { }
+    private ScopeList(ScopeList original, Cloner cloner)
+      : base(original, cloner) {
+      list = new List<IScope>(original.Select(x => cloner.Clone(x)));
+    }
+    public ScopeList() : base() { }
+    public ScopeList(int capacity) : base(capacity) { }
+    public ScopeList(IEnumerable<IScope> collection) : base(collection) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ScopeList(this, cloner);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ValueParameterCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ValueParameterCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ValueParameterCollection.cs	(revision 9191)
@@ -0,0 +1,39 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ValueParameterCollection", "Represents a collection of value parameters.")]
+  public class ValueParameterCollection : NamedItemCollection<IValueParameter> {
+    [StorableConstructor]
+    protected ValueParameterCollection(bool deserializing) : base(deserializing) { }
+    protected ValueParameterCollection(ValueParameterCollection original, Cloner cloner) : base(original, cloner) { }
+    public ValueParameterCollection() : base() { }
+    public ValueParameterCollection(int capacity) : base(capacity) { }
+    public ValueParameterCollection(IEnumerable<IValueParameter> collection) : base(collection) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) { return new ValueParameterCollection(this, cloner); }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/VariableCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/VariableCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/VariableCollection.cs	(revision 9191)
@@ -0,0 +1,41 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("VariableCollection", "Represents a collection of variables.")]
+  public sealed class VariableCollection : NamedItemCollection<IVariable> {
+    [StorableConstructor]
+    private VariableCollection(bool deserializing) : base(deserializing) { }
+    private VariableCollection(VariableCollection original, Cloner cloner) : base(original, cloner) { }
+    public VariableCollection() : base() { }
+    public VariableCollection(int capacity) : base(capacity) { }
+    public VariableCollection(IEnumerable<IVariable> collection) : base(collection) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableCollection(this, cloner);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/ComparisonConstraint.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/ComparisonConstraint.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/ComparisonConstraint.cs	(revision 9191)
@@ -0,0 +1,86 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ComparisonConstraint", "A constraint which checks for specified compare operation.")]
+  public class ComparisonConstraint : Constraint {
+    [StorableConstructor]
+    protected ComparisonConstraint(bool deserializing) : base(deserializing) { }
+    protected ComparisonConstraint(ComparisonConstraint original, Cloner cloner) : base(original, cloner) { }
+    public ComparisonConstraint() : base() { }
+    public ComparisonConstraint(IItem constrainedValue, ConstraintOperation comparisonOperation, object comparisonValue)
+      : base(constrainedValue, comparisonOperation, comparisonValue) {
+    }
+    public ComparisonConstraint(IItem constrainedValue, ConstraintOperation comparisonOperation, object comparisonValue, bool active)
+      : base(constrainedValue, comparisonOperation, comparisonOperation, active) {
+    }
+
+    public override IEnumerable<ConstraintOperation> AllowedConstraintOperations {
+      get { return new ConstraintOperation[6] { ConstraintOperation.Less, ConstraintOperation.LessOrEqual, ConstraintOperation.Equal, ConstraintOperation.GreaterOrEqual, ConstraintOperation.Greater, ConstraintOperation.NotEqual }; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ComparisonConstraint(this, cloner);
+    }
+
+    protected override bool Check(object constrainedMember) {
+      if (constrainedMember == null)
+        return false;
+
+      IComparable comparableMember = constrainedMember as IComparable;
+      if (comparableMember == null)
+        throw new InvalidOperationException("Constrained member must be of type IComparable to be used with ComparisonConstraint.");
+
+      int compareResult = comparableMember.CompareTo(this.ConstraintData);
+      bool result = false;
+      if (this.ConstraintOperation == ConstraintOperation.Less)
+        result = compareResult < 0;
+      else if (this.ConstraintOperation == ConstraintOperation.LessOrEqual)
+        result = compareResult <= 0;
+      else if (this.ConstraintOperation == ConstraintOperation.Equal)
+        result = compareResult == 0;
+      else if (this.ConstraintOperation == ConstraintOperation.GreaterOrEqual)
+        result = compareResult >= 0;
+      else if (this.ConstraintOperation == ConstraintOperation.Greater)
+        result = compareResult > 0;
+      else if (this.ConstraintOperation == ConstraintOperation.NotEqual)
+        result = compareResult != 0;
+      else
+        throw new InvalidOperationException("Constraint operation " + this.ConstraintOperation + " is not defined for ComparisonConstraint.");
+
+      return result;
+    }
+
+    protected override bool Check(object constrainedMember, out string errorMessage) {
+      bool result = Check(constrainedMember);
+      errorMessage = string.Empty;
+      if (!result)
+        errorMessage = constrainedMember.ToString() + " must be " + ConstraintOperation.ToString() + " than " + ConstraintData.ToString() + ".";
+      return result;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/Constraint.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/Constraint.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/Constraint.cs	(revision 9191)
@@ -0,0 +1,196 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  public abstract class Constraint : Item, IConstraint {
+    [StorableConstructor]
+    protected Constraint(bool deserializing) : base(deserializing) { }
+    protected Constraint(Constraint original, Cloner cloner)
+      : base(original, cloner) {
+      constrainedValue = null;  //mkommend: intentionally set to null;
+
+      IDeepCloneable constraintDataDeepCloneable = original.constraintData as IDeepCloneable;
+      ICloneable constraintDataCloneable = original.constraintData as ICloneable;
+      if (constraintDataDeepCloneable != null)
+        constraintData = cloner.Clone(constraintDataDeepCloneable);
+      else if (constraintDataCloneable != null)
+        constraintData = constraintDataCloneable.Clone();
+      else
+        constraintData = original.constraintData;
+
+      constraintOperation = original.constraintOperation;
+    }
+    protected Constraint() {
+      this.Active = false;
+      if (AllowedConstraintOperations != null && AllowedConstraintOperations.Any())
+        this.ConstraintOperation = AllowedConstraintOperations.ElementAt(0);
+    }
+    protected Constraint(IItem constrainedValue, ConstraintOperation constraintOperation, object constraintData)
+      : this() {
+      this.ConstrainedValue = constrainedValue;
+      this.ConstraintOperation = constraintOperation;
+      this.ConstraintData = constraintData;
+    }
+    protected Constraint(IItem constrainedValue, ConstraintOperation constraintOperation, object constraintData, bool active) {
+      this.ConstrainedValue = constrainedValue;
+      this.ConstraintOperation = constraintOperation;
+      this.ConstraintData = constraintData;
+      this.Active = active;
+    }
+
+    [Storable]
+    private bool active;
+    public bool Active {
+      get { return this.active; }
+      set {
+        if (this.active != value) {
+          this.active = value;
+          this.OnActiveChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private IItem constrainedValue;
+    public IItem ConstrainedValue {
+      get { return this.constrainedValue; }
+      set {
+        if (value == null)
+          throw new ArgumentNullException("Constraint value cannot be null.");
+        if (this.constrainedValue != value) {
+          this.constrainedValue = value;
+          this.OnConstrainedValueChanged();
+          this.OnToStringChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private object constraintData;
+    public object ConstraintData {
+      get { return this.constraintData; }
+      set {
+        if (this.constraintData != value) {
+          this.constraintData = value;
+          this.OnConstraintDataChanged();
+          this.OnToStringChanged();
+        }
+      }
+    }
+
+    public abstract IEnumerable<ConstraintOperation> AllowedConstraintOperations { get; }
+    [Storable]
+    private ConstraintOperation constraintOperation;
+    public ConstraintOperation ConstraintOperation {
+      get { return this.constraintOperation; }
+      set {
+        if (value == null)
+          throw new ArgumentNullException("Comparison operation cannot be null.");
+        if (!AllowedConstraintOperations.Contains(value))
+          throw new ArgumentException("Comparison operation is not contained in the allowed ComparisonOperations.");
+        if (this.constraintOperation != value) {
+          this.constraintOperation = value;
+          this.OnConstraintOperationChanged();
+          this.OnToStringChanged();
+        }
+      }
+    }
+
+    /// <summary>
+    /// This method is called to determine which member of the constrained value should be compared.
+    /// </summary>
+    /// <returns></returns>
+    protected virtual IItem GetConstrainedMember() {
+      return this.constrainedValue;
+    }
+    protected abstract bool Check(object constrainedMember);
+    protected abstract bool Check(object constrainedMember, out string errorMessage);
+
+    public bool Check() {
+      if (!Active)
+        return true;
+
+      IItem constrainedMember = this.GetConstrainedMember();
+      return this.Check(constrainedMember);
+    }
+    public bool Check(out string errorMessage) {
+      errorMessage = string.Empty;
+      if (!Active)
+        return true;
+
+      IItem constrainedMember = this.GetConstrainedMember();
+      return this.Check(constrainedMember, out errorMessage);
+    }
+
+    #region events
+    public event EventHandler ActiveChanged;
+    protected virtual void OnActiveChanged() {
+      EventHandler handler = ActiveChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ConstrainedValueChanged;
+    protected virtual void OnConstrainedValueChanged() {
+      EventHandler handler = ConstrainedValueChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ConstraintDataChanged;
+    protected virtual void OnConstraintDataChanged() {
+      EventHandler handler = ConstraintDataChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ConstraintOperationChanged;
+    protected virtual void OnConstraintOperationChanged() {
+      EventHandler handler = ConstraintOperationChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    #endregion
+
+    #region overriden item methods
+    public override string ToString() {
+      IItem constrainedMember = GetConstrainedMember();
+      string s = string.Empty;
+      if (constrainedMember != null)
+        s += constrainedMember.ToString() + " ";
+
+      if (constraintOperation != null)
+        s += ConstraintOperation.ToString() + " ";
+
+      if (constraintData != null)
+        s += constraintData.ToString();
+      else
+        s += "null";
+
+      s += ".";
+      return s;
+    }
+    #endregion
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/ConstraintOperation.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/ConstraintOperation.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/ConstraintOperation.cs	(revision 9191)
@@ -0,0 +1,73 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+namespace HeuristicLab.Core {
+  [StorableClass]
+  public class ConstraintOperation {
+    public static readonly ConstraintOperation Equal = new ConstraintOperation(0, "Equal");
+    public static readonly ConstraintOperation NotEqual = new ConstraintOperation(1, "Not equal");
+    public static readonly ConstraintOperation Less = new ConstraintOperation(2, "Less than");
+    public static readonly ConstraintOperation LessOrEqual = new ConstraintOperation(3, "Less than or equal");
+    public static readonly ConstraintOperation Greater = new ConstraintOperation(4, "Greater than");
+    public static readonly ConstraintOperation GreaterOrEqual = new ConstraintOperation(5, "Greater than or equal");
+    public static readonly ConstraintOperation IsTypeCompatible = new ConstraintOperation(6, "Is type compatible to");
+    public static readonly ConstraintOperation IsTypeNotCompatible = new ConstraintOperation(7, "Is type not compatible to");
+
+    [Storable]
+    private int value;
+    [Storable]
+    private string name;
+
+    [StorableConstructor]
+    protected ConstraintOperation(bool deserializing) { }
+    protected ConstraintOperation(int value, string name) {
+      this.value = value;
+      this.name = name;
+    }
+
+    public override string ToString() {
+      return name;
+    }
+
+    public override bool Equals(object obj) {
+      if (obj is ConstraintOperation)
+        return this == (ConstraintOperation)obj;
+
+      return false;
+    }
+    public override int GetHashCode() {
+      return value;
+    }
+    public static bool operator ==(ConstraintOperation co1, ConstraintOperation co2) {
+      if (object.ReferenceEquals(co1, co2))
+        return true;
+
+      if ((object)co1 == null || (object)co2 == null)
+        return false;
+
+      return co1.value == co2.value;
+    }
+    public static bool operator !=(ConstraintOperation co1, ConstraintOperation co2) {
+      return !(co1 == co2);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/EqualityConstraint.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/EqualityConstraint.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/EqualityConstraint.cs	(revision 9191)
@@ -0,0 +1,80 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("EqualityConstraint", "A constraint which checks for equality.")]
+  public class EqualityConstraint : Constraint {
+    [StorableConstructor]
+    protected EqualityConstraint(bool deserializing) : base(deserializing) { }
+    protected EqualityConstraint(EqualityConstraint original, Cloner cloner) : base(original, cloner) { }
+    public EqualityConstraint() : base() { }
+    public EqualityConstraint(IItem constrainedValue, ConstraintOperation constraintOperation, object constraintData)
+      : base(constrainedValue, constraintOperation, constraintData) {
+    }
+    public EqualityConstraint(IItem constrainedValue, ConstraintOperation constraintOperation, object constraintData, bool active)
+      : base(constrainedValue, constraintOperation, constraintData, active) {
+    }
+
+    public override IEnumerable<ConstraintOperation> AllowedConstraintOperations {
+      get { return new ConstraintOperation[2] { ConstraintOperation.Equal, ConstraintOperation.NotEqual }; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EqualityConstraint(this, cloner);
+    }
+
+    protected override bool Check(object constrainedMember) {
+      if (constrainedMember == null)
+        return false;
+
+      IComparable comparableMember = constrainedMember as IComparable;
+      bool compareValue;
+      if (comparableMember != null && this.ConstraintData != null)
+        compareValue = comparableMember.CompareTo(this.ConstraintData) == 0;
+      else
+        compareValue = constrainedMember.Equals(this.ConstraintData);
+
+      bool result;
+      if (ConstraintOperation == ConstraintOperation.Equal)
+        result = compareValue;
+      else if (ConstraintOperation == ConstraintOperation.NotEqual)
+        result = !compareValue;
+      else
+        throw new InvalidOperationException("Constraint operation " + this.ConstraintOperation + " is not defined for TypeConstraint.");
+
+      return result;
+    }
+
+    protected override bool Check(object constrainedMember, out string errorMessage) {
+      bool result = Check(constrainedMember);
+      errorMessage = string.Empty;
+      if (!result)
+        errorMessage = constrainedMember.ToString() + " must be " + ConstraintOperation.ToString() + " to " + ConstraintData.ToString() + ".";
+      return result;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/IConstraint.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/IConstraint.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/IConstraint.cs	(revision 9191)
@@ -0,0 +1,40 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+
+namespace HeuristicLab.Core {
+  public interface IConstraint : IItem {
+    bool Active { get; set; }
+    IItem ConstrainedValue { get; set; }
+    ConstraintOperation ConstraintOperation { get; set; }
+    IEnumerable<ConstraintOperation> AllowedConstraintOperations { get; }
+    object ConstraintData { get; set; }
+    bool Check();
+    bool Check(out string errorMessage);
+
+    event EventHandler ActiveChanged;
+    event EventHandler ConstrainedValueChanged;
+    event EventHandler ConstraintDataChanged;
+    event EventHandler ConstraintOperationChanged;
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/TypeCompatibilityConstraint.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/TypeCompatibilityConstraint.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Constraints/TypeCompatibilityConstraint.cs	(revision 9191)
@@ -0,0 +1,80 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("TypeCompatibilityConstraint", "A constraint that checks for compatible types.")]
+  public class TypeCompatibilityConstraint : Constraint {
+    [StorableConstructor]
+    protected TypeCompatibilityConstraint(bool deserializing) : base(deserializing) { }
+    protected TypeCompatibilityConstraint(TypeCompatibilityConstraint original, Cloner cloner) : base(original, cloner) { }
+    public TypeCompatibilityConstraint() : base() { }
+    public TypeCompatibilityConstraint(IItem constrainedValue, ConstraintOperation constraintOperation, Type constraintData)
+      : base(constrainedValue, constraintOperation, constraintData) {
+    }
+    public TypeCompatibilityConstraint(IItem constrainedValue, ConstraintOperation constraintOperation, Type constraintData, bool active)
+      : base(constrainedValue, constraintOperation, constraintData, active) {
+    }
+
+    public new Type ConstraintData {
+      get { return (Type)base.ConstraintData; }
+      set { base.ConstraintData = value; }
+    }
+
+    public override IEnumerable<ConstraintOperation> AllowedConstraintOperations {
+      get { return new ConstraintOperation[2] { ConstraintOperation.IsTypeCompatible, ConstraintOperation.IsTypeNotCompatible }; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TypeCompatibilityConstraint(this, cloner);
+    }
+
+    protected override bool Check(object constrainedMember) {
+      if (constrainedMember == null)
+        return false;
+
+      Type constrainedMemberType = constrainedMember.GetType();
+      bool compareValue = ConstraintData.IsAssignableFrom(constrainedMemberType);
+      bool result;
+      if (ConstraintOperation == ConstraintOperation.IsTypeCompatible)
+        result = compareValue;
+      else if (ConstraintOperation == ConstraintOperation.IsTypeNotCompatible)
+        result = !compareValue;
+      else
+        throw new InvalidOperationException("Constraint operation " + this.ConstraintOperation + " is not defined for TypeCompatibilityConstraint.");
+
+      return result;
+    }
+
+    protected override bool Check(object constrainedMember, out string errorMessage) {
+      bool result = Check(constrainedMember);
+      errorMessage = string.Empty;
+      if (!result)
+        errorMessage = "The type of " + constrainedMember.ToString() + " must be " + ConstraintOperation.ToString() + " compatible to " + ConstraintData.ToString() + ".";
+      return result;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Engine.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Engine.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Engine.cs	(revision 9191)
@@ -0,0 +1,174 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Threading;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [Item("Engine", "A base class for engines.")]
+  [StorableClass]
+  public abstract class Engine : Executable, IEngine {
+    [Storable]
+    protected ILog log;
+    public ILog Log {
+      get { return log; }
+    }
+
+    [Storable]
+    private Stack<IOperation> executionStack;
+    protected Stack<IOperation> ExecutionStack {
+      get { return executionStack; }
+    }
+
+    #region Variables for communication between threads
+    private CancellationTokenSource cancellationTokenSource;
+    private bool stopPending;
+    private DateTime lastUpdateTime;
+    #endregion
+
+    [StorableConstructor]
+    protected Engine(bool deserializing) : base(deserializing) { }
+    protected Engine(Engine original, Cloner cloner)
+      : base(original, cloner) {
+      log = cloner.Clone(original.log);
+      executionStack = new Stack<IOperation>();
+      IOperation[] contexts = original.executionStack.ToArray();
+      for (int i = contexts.Length - 1; i >= 0; i--)
+        executionStack.Push(cloner.Clone(contexts[i]));
+    }
+    protected Engine()
+      : base() {
+      log = new Log();
+      executionStack = new Stack<IOperation>();
+    }
+
+    public sealed override void Prepare() {
+      base.Prepare();
+      executionStack.Clear();
+      OnPrepared();
+    }
+    public void Prepare(IOperation initialOperation) {
+      base.Prepare();
+      executionStack.Clear();
+      if (initialOperation != null)
+        executionStack.Push(initialOperation);
+      OnPrepared();
+    }
+    protected override void OnPrepared() {
+      Log.LogMessage("Engine prepared");
+      base.OnPrepared();
+    }
+
+    public override void Start() {
+      base.Start();
+      cancellationTokenSource = new CancellationTokenSource();
+      stopPending = false;
+      Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token);
+      task.ContinueWith(t => {
+        try {
+          t.Wait();
+        }
+        catch (AggregateException ex) {
+          try {
+            ex.Flatten().Handle(x => x is OperationCanceledException);
+          }
+          catch (AggregateException remaining) {
+            if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]);
+            else OnExceptionOccurred(remaining);
+          }
+        }
+        cancellationTokenSource.Dispose();
+        cancellationTokenSource = null;
+        if (stopPending) executionStack.Clear();
+        if (executionStack.Count == 0) OnStopped();
+        else OnPaused();
+      });
+    }
+    protected override void OnStarted() {
+      Log.LogMessage("Engine started");
+      base.OnStarted();
+    }
+
+    public override void Pause() {
+      base.Pause();
+      cancellationTokenSource.Cancel();
+    }
+    protected override void OnPaused() {
+      Log.LogMessage("Engine paused");
+      base.OnPaused();
+    }
+
+    public override void Stop() {
+      base.Stop();
+      if (ExecutionState == ExecutionState.Paused) {
+        executionStack.Clear();
+        OnStopped();
+      } else {
+        stopPending = true;
+        cancellationTokenSource.Cancel();
+      }
+    }
+    protected override void OnStopped() {
+      Log.LogMessage("Engine stopped");
+      base.OnStopped();
+    }
+
+    protected override void OnExceptionOccurred(Exception exception) {
+      Log.LogException(exception);
+      base.OnExceptionOccurred(exception);
+    }
+
+    private void Run(object state) {
+      CancellationToken cancellationToken = (CancellationToken)state;
+
+      OnStarted();
+      lastUpdateTime = DateTime.Now;
+      System.Timers.Timer timer = new System.Timers.Timer(250);
+      timer.AutoReset = true;
+      timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
+      timer.Start();
+      try {
+        Run(cancellationToken);
+      }
+      finally {
+        timer.Elapsed -= new System.Timers.ElapsedEventHandler(timer_Elapsed);
+        timer.Stop();
+        ExecutionTime += DateTime.Now - lastUpdateTime;
+      }
+
+      cancellationToken.ThrowIfCancellationRequested();
+    }
+    protected abstract void Run(CancellationToken cancellationToken);
+
+    private void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) {
+      System.Timers.Timer timer = (System.Timers.Timer)sender;
+      timer.Enabled = false;
+      DateTime now = DateTime.Now;
+      ExecutionTime += now - lastUpdateTime;
+      lastUpdateTime = now;
+      timer.Enabled = true;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Executable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Executable.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Executable.cs	(revision 9191)
@@ -0,0 +1,137 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [Item("Executable", "A base class for executables.")]
+  [StorableClass]
+  public abstract class Executable : Item, IExecutable {
+    public static new Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Event; }
+    }
+    public override Image ItemImage {
+      get {
+        if (ExecutionState == ExecutionState.Prepared) return HeuristicLab.Common.Resources.VSImageLibrary.ExecutablePrepared;
+        else if (ExecutionState == ExecutionState.Started) return HeuristicLab.Common.Resources.VSImageLibrary.ExecutableStarted;
+        else if (ExecutionState == ExecutionState.Paused) return HeuristicLab.Common.Resources.VSImageLibrary.ExecutablePaused;
+        else if (ExecutionState == ExecutionState.Stopped) return HeuristicLab.Common.Resources.VSImageLibrary.ExecutableStopped;
+        else return base.ItemImage;
+      }
+    }
+
+    [Storable]
+    private ExecutionState executionState;
+    public ExecutionState ExecutionState {
+      get { return executionState; }
+      private set {
+        if (executionState != value) {
+          executionState = value;
+          OnExecutionStateChanged();
+          OnItemImageChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private TimeSpan executionTime;
+    public TimeSpan ExecutionTime {
+      get { return executionTime; }
+      protected set {
+        executionTime = value;
+        OnExecutionTimeChanged();
+      }
+    }
+
+    [StorableConstructor]
+    protected Executable(bool deserializing) : base(deserializing) { }
+    protected Executable(Executable original, Cloner cloner)
+      : base(original, cloner) {
+      executionState = original.executionState;
+      executionTime = original.executionTime;
+    }
+    protected Executable() {
+      executionState = ExecutionState.Stopped;
+      executionTime = TimeSpan.Zero;
+    }
+
+    public virtual void Prepare() {
+      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused) && (ExecutionState != ExecutionState.Stopped))
+        throw new InvalidOperationException(string.Format("Prepare not allowed in execution state \"{0}\".", ExecutionState));
+      ExecutionTime = TimeSpan.Zero;
+    }
+    public virtual void Start() {
+      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
+        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
+    }
+    public virtual void Pause() {
+      if (ExecutionState != ExecutionState.Started)
+        throw new InvalidOperationException(string.Format("Pause not allowed in execution state \"{0}\".", ExecutionState));
+    }
+    public virtual void Stop() {
+      if ((ExecutionState != ExecutionState.Started) && (ExecutionState != ExecutionState.Paused))
+        throw new InvalidOperationException(string.Format("Stop not allowed in execution state \"{0}\".", ExecutionState));
+    }
+
+    public event EventHandler ExecutionStateChanged;
+    protected virtual void OnExecutionStateChanged() {
+      EventHandler handler = ExecutionStateChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ExecutionTimeChanged;
+    protected virtual void OnExecutionTimeChanged() {
+      EventHandler handler = ExecutionTimeChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Prepared;
+    protected virtual void OnPrepared() {
+      ExecutionState = ExecutionState.Prepared;
+      EventHandler handler = Prepared;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Started;
+    protected virtual void OnStarted() {
+      ExecutionState = ExecutionState.Started;
+      EventHandler handler = Started;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Paused;
+    protected virtual void OnPaused() {
+      ExecutionState = ExecutionState.Paused;
+      EventHandler handler = Paused;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Stopped;
+    protected virtual void OnStopped() {
+      ExecutionState = ExecutionState.Stopped;
+      EventHandler handler = Stopped;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler<EventArgs<Exception>> ExceptionOccurred;
+    protected virtual void OnExceptionOccurred(Exception exception) {
+      EventHandler<EventArgs<Exception>> handler = ExceptionOccurred;
+      if (handler != null) handler(this, new EventArgs<Exception>(exception));
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ExecutionContext.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ExecutionContext.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ExecutionContext.cs	(revision 9191)
@@ -0,0 +1,89 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  public sealed class ExecutionContext : DeepCloneable, IExecutionContext, IAtomicOperation {
+    [Storable]
+    private IParameterizedItem parameterizedItem;
+
+    [Storable]
+    private IExecutionContext parent;
+    public IExecutionContext Parent {
+      get { return parent; }
+    }
+
+    public IKeyedItemCollection<string, IParameter> Parameters {
+      get { return parameterizedItem.Parameters; }
+    }
+
+    public IOperator Operator {
+      get { return parameterizedItem as IOperator; }
+    }
+
+    [Storable]
+    private IScope scope;
+    public IScope Scope {
+      get { return scope; }
+    }
+
+    [StorableConstructor]
+    private ExecutionContext(bool deserializing) { }
+    private ExecutionContext(ExecutionContext original, Cloner cloner)
+      : base(original, cloner) {
+      parent = cloner.Clone(original.parent);
+      parameterizedItem = cloner.Clone(original.parameterizedItem);
+      scope = cloner.Clone(original.scope);
+    }
+    private ExecutionContext() {
+      parent = null;
+      parameterizedItem = null;
+      scope = null;
+    }
+    public ExecutionContext(IExecutionContext parent, IParameterizedItem parameterizedItem, IScope scope) {
+      if ((parameterizedItem == null) || (scope == null)) throw new ArgumentNullException();
+      this.parent = parent;
+      this.parameterizedItem = parameterizedItem;
+      this.scope = scope;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExecutionContext(this, cloner);
+    }
+
+    public IAtomicOperation CreateOperation(IOperator op) {
+      return new ExecutionContext(parent, op, scope);
+    }
+    public IAtomicOperation CreateOperation(IOperator op, IScope scope) {
+      return new ExecutionContext(parent, op, scope);
+    }
+    public IAtomicOperation CreateChildOperation(IOperator op) {
+      return new ExecutionContext(this, op, scope);
+    }
+    public IAtomicOperation CreateChildOperation(IOperator op, IScope scope) {
+      return new ExecutionContext(this, op, scope);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ExecutionState.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ExecutionState.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ExecutionState.cs	(revision 9191)
@@ -0,0 +1,29 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  public enum ExecutionState {
+    Prepared,
+    Started,
+    Paused,
+    Stopped
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 9191)
@@ -0,0 +1,283 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{C36BD924-A541-4A00-AFA8-41701378DDC5}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Core</RootNamespace>
+    <AssemblyName>HeuristicLab.Core-3.3</AssemblyName>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <IsWebBootstrapper>true</IsWebBootstrapper>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <PublishUrl>http://localhost/HeuristicLab.Core/</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Web</InstallFrom>
+    <UpdateEnabled>true</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>
+    </DocumentationFile>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>
+    </DocumentationFile>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Attributes\ItemAttribute.cs" />
+    <Compile Include="Attributes\CreatableAttribute.cs" />
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="Collections\CheckedItemCollection.cs" />
+    <Compile Include="Collections\CheckedItemList.cs" />
+    <Compile Include="Collections\ReadOnlyCheckedItemCollection.cs" />
+    <Compile Include="Collections\ReadOnlyCheckedItemList.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Collections\ReadOnlyItemDictionary.cs" />
+    <Compile Include="Collections\ItemDictionary.cs" />
+    <Compile Include="Collections\ReadOnlyKeyedItemCollection.cs" />
+    <Compile Include="Collections\KeyedItemCollection.cs" />
+    <Compile Include="Collections\ReadOnlyItemSet.cs" />
+    <Compile Include="Collections\ReadOnlyItemList.cs" />
+    <Compile Include="Collections\ReadOnlyItemArray.cs" />
+    <Compile Include="Collections\ReadOnlyItemCollection.cs" />
+    <Compile Include="Collections\ItemArray.cs" />
+    <Compile Include="Collections\ItemCollection.cs" />
+    <Compile Include="Collections\ItemList.cs" />
+    <Compile Include="Collections\ItemSet.cs" />
+    <Compile Include="Collections\NamedItemCollection.cs" />
+    <Compile Include="Collections\OperationCollection.cs" />
+    <Compile Include="Collections\OperatorCollection.cs" />
+    <Compile Include="Collections\OperatorList.cs" />
+    <Compile Include="Collections\OperatorSet.cs" />
+    <Compile Include="Collections\ParameterCollection.cs" />
+    <Compile Include="Collections\ScopeList.cs" />
+    <Compile Include="Collections\ValueParameterCollection.cs" />
+    <Compile Include="Collections\VariableCollection.cs" />
+    <Compile Include="Constraints\ComparisonConstraint.cs" />
+    <Compile Include="Constraints\Constraint.cs" />
+    <Compile Include="Collections\ConstraintCollection.cs" />
+    <Compile Include="Constraints\ConstraintOperation.cs" />
+    <Compile Include="Constraints\EqualityConstraint.cs" />
+    <Compile Include="Constraints\IConstraint.cs" />
+    <Compile Include="Constraints\TypeCompatibilityConstraint.cs" />
+    <Compile Include="Interfaces\ICheckedMultiOperator.cs" />
+    <Compile Include="Interfaces\IConstrainedValueParameter.cs" />
+    <Compile Include="Interfaces\IMultiOperator.cs" />
+    <Compile Include="Interfaces\IFixedValueParameter.cs" />
+    <Compile Include="Interfaces\IOperatorGraphOperator.cs" />
+    <Compile Include="Interfaces\IStatefulItem.cs" />
+    <Compile Include="OperatorExecutionException.cs" />
+    <Compile Include="Interfaces\IScopeTreeLookupParameter.cs" />
+    <Compile Include="Interfaces\ICheckedItemList.cs" />
+    <Compile Include="Interfaces\ICheckedItemCollection.cs" />
+    <Compile Include="PersistenceContentManager.cs" />
+    <Compile Include="Interfaces\IKeyedItemCollection.cs" />
+    <Compile Include="Interfaces\IItemList.cs" />
+    <Compile Include="Interfaces\IItemSet.cs" />
+    <Compile Include="Interfaces\IItemDictionary.cs" />
+    <Compile Include="Interfaces\IItemArray.cs" />
+    <Compile Include="Interfaces\IItemCollection.cs" />
+    <Compile Include="Log.cs" />
+    <Compile Include="Executable.cs" />
+    <Compile Include="ExecutionState.cs" />
+    <Compile Include="Interfaces\ILog.cs" />
+    <Compile Include="Interfaces\IExecutable.cs" />
+    <Compile Include="Interfaces\IParameterizedNamedItem.cs" />
+    <Compile Include="Interfaces\IParameterizedItem.cs" />
+    <Compile Include="Interfaces\IAtomicOperation.cs" />
+    <Compile Include="Interfaces\IExecutionContext.cs" />
+    <Compile Include="Interfaces\IOperation.cs" />
+    <Compile Include="ParameterizedNamedItem.cs" />
+    <Compile Include="Interfaces\IValueLookupParameter.cs" />
+    <Compile Include="Interfaces\IValueParameter.cs" />
+    <Compile Include="Interfaces\ILookupParameter.cs" />
+    <Compile Include="Engine.cs" />
+    <Compile Include="Interfaces\IScope.cs" />
+    <Compile Include="Interfaces\IVariable.cs" />
+    <Compile Include="Item.cs" />
+    <Compile Include="NamedItem.cs" />
+    <Compile Include="OperatorGraph.cs" />
+    <Compile Include="Interfaces\IParameter.cs" />
+    <Compile Include="Interfaces\IEngine.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="ExecutionContext.cs" />
+    <Compile Include="Interfaces\INamedItem.cs" />
+    <Compile Include="Interfaces\IItem.cs" />
+    <Compile Include="Interfaces\IRandom.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Scope.cs" />
+    <Compile Include="Interfaces\IOperator.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ThreadSafeLog.cs" />
+    <Compile Include="Variable.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </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>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
+      <Project>{0E27A536-1C4A-4624-A65E-DC4F4F23E3E1}</Project>
+      <Name>HeuristicLab.Common.Resources-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
+      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
+      <Name>HeuristicLab.Common-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.2.0">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 2.0 %28x86%29</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.0">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.0 %28x86%29</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+</PreBuildEvent>
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+export ProjectDir=$(ProjectDir)
+export SolutionDir=$(SolutionDir)
+
+$SolutionDir/PreBuildEvent.sh
+</PreBuildEvent>
+  </PropertyGroup>
+</Project>
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IAtomicOperation.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IAtomicOperation.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IAtomicOperation.cs	(revision 9191)
@@ -0,0 +1,30 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  /// <summary>
+  /// Interface which represents an atomic operation.
+  /// </summary>
+  public interface IAtomicOperation : IOperation {
+    IOperator Operator { get; }
+    IScope Scope { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ICheckedItemCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ICheckedItemCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ICheckedItemCollection.cs	(revision 9191)
@@ -0,0 +1,33 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Core {
+  public interface ICheckedItemCollection<T> : IItemCollection<T> where T : class, IItem {
+    event CollectionItemsChangedEventHandler<T> CheckedItemsChanged;
+    IEnumerable<T> CheckedItems { get; }
+    bool ItemChecked(T item);
+    void SetItemCheckedState(T item, bool checkedState);
+    void Add(T item, bool checkedState);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ICheckedItemList.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ICheckedItemList.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ICheckedItemList.cs	(revision 9191)
@@ -0,0 +1,34 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Core {
+  public interface ICheckedItemList<T> : IItemList<T> where T : class, IItem {
+    event CollectionItemsChangedEventHandler<IndexedItem<T>> CheckedItemsChanged;
+    IEnumerable<IndexedItem<T>> CheckedItems { get; }
+    bool ItemChecked(T item);
+    void SetItemCheckedState(T item, bool checkedState);
+    void Add(T item, bool checkedState);
+    void Insert(int index, T item, bool checkedState);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ICheckedMultiOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ICheckedMultiOperator.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ICheckedMultiOperator.cs	(revision 9191)
@@ -0,0 +1,27 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  public interface ICheckedMultiOperator<T> : IMultiOperator<T> where T : class,IOperator {
+    new ICheckedItemList<T> Operators { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IConstrainedValueParameter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IConstrainedValueParameter.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IConstrainedValueParameter.cs	(revision 9191)
@@ -0,0 +1,28 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+
+namespace HeuristicLab.Core {
+  public interface IConstrainedValueParameter<T> : IValueParameter<T> where T : class, IItem {
+    IItemSet<T> ValidValues { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IEngine.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IEngine.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IEngine.cs	(revision 9191)
@@ -0,0 +1,28 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  public interface IEngine : IExecutable {
+    ILog Log { get; }
+
+    void Prepare(IOperation initialOperation);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IExecutable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IExecutable.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IExecutable.cs	(revision 9191)
@@ -0,0 +1,43 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+
+namespace HeuristicLab.Core {
+  public interface IExecutable : IItem {
+    ExecutionState ExecutionState { get; }
+    TimeSpan ExecutionTime { get; }
+
+    void Prepare();
+    void Start();
+    void Pause();
+    void Stop();
+
+    event EventHandler ExecutionStateChanged;
+    event EventHandler ExecutionTimeChanged;
+    event EventHandler Prepared;
+    event EventHandler Started;
+    event EventHandler Paused;
+    event EventHandler Stopped;
+    event EventHandler<EventArgs<Exception>> ExceptionOccurred;
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IExecutionContext.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IExecutionContext.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IExecutionContext.cs	(revision 9191)
@@ -0,0 +1,38 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface which represents an execution context.
+  /// </summary>
+  public interface IExecutionContext : IDeepCloneable {
+    IExecutionContext Parent { get; }
+    IKeyedItemCollection<string, IParameter> Parameters { get; }
+    IScope Scope { get; }
+
+    IAtomicOperation CreateOperation(IOperator op);
+    IAtomicOperation CreateOperation(IOperator op, IScope scope);
+    IAtomicOperation CreateChildOperation(IOperator op);
+    IAtomicOperation CreateChildOperation(IOperator op, IScope scope);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IFixedValueParameter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IFixedValueParameter.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IFixedValueParameter.cs	(revision 9191)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  public interface IFixedValueParameter : IValueParameter {
+    new IItem Value { get; }
+    new IItem ActualValue { get; }
+  }
+
+  public interface IFixedValueParameter<T> : IFixedValueParameter, IValueParameter<T> where T : class, IItem {
+    new T Value { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItem.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItem.cs	(revision 9191)
@@ -0,0 +1,39 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent (almost) every HeuristicLab object (an object, an operator,...).
+  /// </summary>
+  public interface IItem : IContent, IDeepCloneable {
+    string ItemName { get; }
+    string ItemDescription { get; }
+    Version ItemVersion { get; }
+    Image ItemImage { get; }
+
+    event EventHandler ItemImageChanged;
+    event EventHandler ToStringChanged;
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemArray.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemArray.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemArray.cs	(revision 9191)
@@ -0,0 +1,26 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Core {
+  public interface IItemArray<T> : IObservableArray<T>, IItem where T : class, IItem { }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemCollection.cs	(revision 9191)
@@ -0,0 +1,26 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Core {
+  public interface IItemCollection<T> : IObservableCollection<T>, IItem where T : class, IItem { }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemDictionary.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemDictionary.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemDictionary.cs	(revision 9191)
@@ -0,0 +1,28 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Core {
+  public interface IItemDictionary<TKey, TValue> : IObservableDictionary<TKey, TValue>, IItem
+    where TKey : class, IItem
+    where TValue : class, IItem { }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemList.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemList.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemList.cs	(revision 9191)
@@ -0,0 +1,26 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Core {
+  public interface IItemList<T> : IObservableList<T>, IItemCollection<T>, IItem where T : class, IItem { }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemSet.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemSet.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IItemSet.cs	(revision 9191)
@@ -0,0 +1,26 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Core {
+  public interface IItemSet<T> : IObservableSet<T>, IItemCollection<T>, IItem where T : class, IItem { }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IKeyedItemCollection.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IKeyedItemCollection.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IKeyedItemCollection.cs	(revision 9191)
@@ -0,0 +1,26 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Core {
+  public interface IKeyedItemCollection<TKey, TItem> : IObservableKeyedCollection<TKey, TItem>, IItemCollection<TItem>, IItem where TItem : class, IItem { }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ILog.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ILog.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ILog.cs	(revision 9191)
@@ -0,0 +1,37 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+
+namespace HeuristicLab.Core {
+  public interface ILog : IItem {
+    IEnumerable<string> Messages { get; }
+
+    void Clear();
+    void LogMessage(string message);
+    void LogException(Exception ex);
+
+    event EventHandler<EventArgs<string>> MessageAdded;
+    event EventHandler Cleared;
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ILookupParameter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ILookupParameter.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ILookupParameter.cs	(revision 9191)
@@ -0,0 +1,34 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+
+namespace HeuristicLab.Core {
+  public interface ILookupParameter : IParameter {
+    string ActualName { get; set; }
+    string TranslatedName { get; }
+    event EventHandler ActualNameChanged;
+  }
+
+  public interface ILookupParameter<T> : ILookupParameter where T : class, IItem {
+    new T ActualValue { get; set; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IMultiOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IMultiOperator.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IMultiOperator.cs	(revision 9191)
@@ -0,0 +1,27 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  public interface IMultiOperator<T> : IOperator where T : class,IOperator {
+    IItemList<T> Operators { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/INamedItem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/INamedItem.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/INamedItem.cs	(revision 9191)
@@ -0,0 +1,36 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+
+namespace HeuristicLab.Core {
+  public interface INamedItem : IItem {
+    string Name { get; set; }
+    bool CanChangeName { get; }
+    string Description { get; set; }
+    bool CanChangeDescription { get; }
+
+    event EventHandler<CancelEventArgs<string>> NameChanging;
+    event EventHandler NameChanged;
+    event EventHandler DescriptionChanged;
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IOperation.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IOperation.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IOperation.cs	(revision 9191)
@@ -0,0 +1,29 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface which represents an operation.
+  /// </summary>
+  public interface IOperation : IDeepCloneable { }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IOperator.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IOperator.cs	(revision 9191)
@@ -0,0 +1,37 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Threading;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent an operator.
+  /// </summary>
+  public interface IOperator : IParameterizedNamedItem {
+    bool Breakpoint { get; set; }
+
+    IOperation Execute(IExecutionContext context, CancellationToken cancellationToken);
+
+    event EventHandler BreakpointChanged;
+    event EventHandler Executed;
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IOperatorGraphOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IOperatorGraphOperator.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IOperatorGraphOperator.cs	(revision 9191)
@@ -0,0 +1,28 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#endregion
+
+namespace HeuristicLab.Core {
+  public interface IOperatorGraphOperator : IOperator {
+    OperatorGraph OperatorGraph { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameter.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameter.cs	(revision 9191)
@@ -0,0 +1,33 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+
+namespace HeuristicLab.Core {
+  public interface IParameter : INamedItem {
+    Type DataType { get; }
+    bool Hidden { get; set; }
+    IItem ActualValue { get; set; }
+    IExecutionContext ExecutionContext { get; set; }
+
+    event EventHandler HiddenChanged;
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameterizedItem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameterizedItem.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameterizedItem.cs	(revision 9191)
@@ -0,0 +1,33 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// An interface which represents an item which contains parameters.
+  /// </summary>
+  public interface IParameterizedItem : IItem {
+    IKeyedItemCollection<string, IParameter> Parameters { get; }
+
+    void CollectParameterValues(IDictionary<string, IItem> values);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameterizedNamedItem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameterizedNamedItem.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameterizedNamedItem.cs	(revision 9191)
@@ -0,0 +1,27 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  /// <summary>
+  /// An interface which represents an item which has a name and contains parameters.
+  /// </summary>
+  public interface IParameterizedNamedItem : INamedItem, IParameterizedItem { }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IRandom.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IRandom.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IRandom.cs	(revision 9191)
@@ -0,0 +1,61 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  /// <summary>
+  /// Represents an interface for random number generators.
+  /// </summary>
+  public interface IRandom : IItem {
+    /// <summary>
+    /// Resets the random number generator.
+    /// </summary>
+    void Reset();
+    /// <summary>
+    /// Resets the random number generator with the given <paramref name="seed"/>.
+    /// </summary>
+    /// <param name="seed">The new seed.</param>
+    void Reset(int seed);
+
+    /// <summary>
+    /// Gets a new random number.
+    /// </summary>
+    /// <returns>A random integer number.</returns>
+    int Next();
+    /// <summary>
+    /// Gets a new random number between 0 and <paramref name="maxVal"/>.
+    /// </summary>
+    /// <param name="maxVal">The maximal value of the random number (exclusive).</param>
+    /// <returns>A random integer number smaller than <paramref name="maxVal"/>.</returns>
+    int Next(int maxVal);
+    /// <summary>
+    /// Gets a new random number between <paramref name="minVal"/> and <paramref name="maxVal"/>.
+    /// </summary>
+    /// <param name="maxVal">The maximal value of the random number (exclusive).</param>
+    /// <param name="minVal">The minimal value of the random number (inclusive).</param>
+    /// <returns>A random integer number. (<paramref name="minVal"/> &lt;= x &lt; <paramref name="maxVal"/>).</returns>
+    int Next(int minVal, int maxVal);
+    /// <summary>
+    /// Gets a new double random number.
+    /// </summary>
+    /// <returns>A random double number.</returns>
+    double NextDouble();
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IScope.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IScope.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IScope.cs	(revision 9191)
@@ -0,0 +1,33 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  /// <summary>
+  /// Hierarchical container of variables (and of subscopes).
+  /// </summary>
+  public interface IScope : INamedItem {
+    IScope Parent { get; set; }
+    VariableCollection Variables { get; }
+    ScopeList SubScopes { get; }
+
+    void Clear();
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IScopeTreeLookupParameter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IScopeTreeLookupParameter.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IScopeTreeLookupParameter.cs	(revision 9191)
@@ -0,0 +1,31 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+
+namespace HeuristicLab.Core {
+  public interface IScopeTreeLookupParameter : ILookupParameter {
+    int Depth { get; set; }
+    event EventHandler DepthChanged;
+  }
+
+  public interface IScopeTreeLookupParameter<T> : IScopeTreeLookupParameter, ILookupParameter<ItemArray<T>> where T : class, IItem { }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IStatefulItem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IStatefulItem.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IStatefulItem.cs	(revision 9191)
@@ -0,0 +1,27 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  public interface IStatefulItem : IItem {
+    void InitializeState();
+    void ClearState();
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IValueLookupParameter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IValueLookupParameter.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IValueLookupParameter.cs	(revision 9191)
@@ -0,0 +1,26 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  public interface IValueLookupParameter : IValueParameter, ILookupParameter { }
+
+  public interface IValueLookupParameter<T> : IValueLookupParameter, IValueParameter<T>, ILookupParameter<T> where T : class, IItem { }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IValueParameter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IValueParameter.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IValueParameter.cs	(revision 9191)
@@ -0,0 +1,35 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+
+namespace HeuristicLab.Core {
+  public interface IValueParameter : IParameter {
+    IItem Value { get; set; }
+    bool GetsCollected { get; set; }
+    event EventHandler ValueChanged;
+    event EventHandler GetsCollectedChanged;
+  }
+
+  public interface IValueParameter<T> : IValueParameter where T : class, IItem {
+    new T Value { get; set; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IVariable.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IVariable.cs	(revision 9191)
@@ -0,0 +1,34 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents a variable which has a name and holds an IItem.
+  /// </summary>
+  public interface IVariable : INamedItem {
+    IItem Value { get; set; }
+
+    /// <inheritdoc/>
+    event EventHandler ValueChanged;
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Item.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Item.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Item.cs	(revision 9191)
@@ -0,0 +1,81 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents the base class for all basic item types.
+  /// </summary>
+  [StorableClass]
+  [Item("Item", "Base class for all HeuristicLab items.")]
+  public abstract class Item : IItem {
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    [StorableConstructor]
+    protected Item(bool deserializing) { }
+    protected Item(Item original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+    }
+    protected Item() { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public abstract IDeepCloneable Clone(Cloner cloner);
+
+    /// <summary>
+    /// Gets the string representation of the current instance.
+    /// </summary>
+    /// <returns>The type name of the current instance.</returns>
+    public override string ToString() {
+      return ItemName;
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Log.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Log.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Log.cs	(revision 9191)
@@ -0,0 +1,107 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Core {
+  [Item("Log", "A log for logging string messages.")]
+  [StorableClass]
+  public class Log : Item, ILog, IStorableContent {
+    public string Filename { get; set; }
+
+    public static new Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.File; }
+    }
+
+    [Storable]
+    protected IList<string> messages;
+    public virtual IEnumerable<string> Messages {
+      get { return messages; }
+    }
+
+    [Storable]
+    protected long maxMessageCount;
+    public virtual long MaxMessageCount {
+      get { return maxMessageCount; }
+    }
+
+    [StorableConstructor]
+    protected Log(bool deserializing) : base(deserializing) { }
+    protected Log(Log original, Cloner cloner)
+      : base(original, cloner) {
+      this.messages = new List<string>(original.messages);
+      this.maxMessageCount = original.maxMessageCount;
+    }
+    public Log(long maxMessageCount = -1)
+      : base() {
+      this.messages = new List<string>();
+      this.maxMessageCount = maxMessageCount;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Log(this, cloner);
+    }
+
+    public virtual void Clear() {
+      messages.Clear();
+      OnCleared();
+    }
+    public virtual void LogMessage(string message) {
+      string s = FormatLogMessage(message);
+      messages.Add(s);
+      CapMessages();
+      OnMessageAdded(s);
+    }
+    public virtual void LogException(Exception ex) {
+      string s = FormatException(ex);
+      messages.Add(s);
+      CapMessages();
+      OnMessageAdded(s);
+    }
+    protected virtual void CapMessages() {
+      while (maxMessageCount >= 0 && messages.Count > maxMessageCount) {
+        messages.RemoveAt(0);
+      }
+    }
+    protected virtual string FormatLogMessage(string message) {
+      return DateTime.Now.ToString() + "\t" + message;
+    }
+    protected virtual string FormatException(Exception ex) {
+      return DateTime.Now.ToString() + "\t" + "Exception occurred:" + Environment.NewLine + ErrorHandling.BuildErrorMessage(ex);
+    }
+
+    public event EventHandler<EventArgs<string>> MessageAdded;
+    protected virtual void OnMessageAdded(string message) {
+      EventHandler<EventArgs<string>> handler = MessageAdded;
+      if (handler != null) handler(this, new EventArgs<string>(message));
+    }
+    public event EventHandler Cleared;
+    protected virtual void OnCleared() {
+      EventHandler handler = Cleared;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/NamedItem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/NamedItem.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/NamedItem.cs	(revision 9191)
@@ -0,0 +1,141 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [Item("NamedItem", "Base class for items which have a name and an optional description.")]
+  [StorableClass]
+  public abstract class NamedItem : Item, INamedItem {
+    [Storable]
+    protected string name;
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnNameChanging"/> and also <see cref="OnNameChanged"/> 
+    /// eventually in the setter.</remarks>
+    public string Name {
+      get { return name; }
+      set {
+        if (!CanChangeName) throw new NotSupportedException("Name cannot be changed.");
+        if (!(name.Equals(value) || (value == null) && (name == string.Empty))) {
+          CancelEventArgs<string> e = value == null ? new CancelEventArgs<string>(string.Empty) : new CancelEventArgs<string>(value);
+          OnNameChanging(e);
+          if (!e.Cancel) {
+            name = value == null ? string.Empty : value;
+            OnNameChanged();
+          }
+        }
+      }
+    }
+    public virtual bool CanChangeName {
+      get { return true; }
+    }
+    [Storable]
+    protected string description;
+    public string Description {
+      get { return description; }
+      set {
+        if (!CanChangeDescription) throw new NotSupportedException("Description cannot be changed.");
+        if (!(description.Equals(value) || (value == null) && (description == string.Empty))) {
+          description = value == null ? string.Empty : value;
+          OnDescriptionChanged();
+        }
+      }
+    }
+    public virtual bool CanChangeDescription {
+      get { return true; }
+    }
+
+    [StorableConstructor]
+    protected NamedItem(bool deserializing) : base(deserializing) { }
+    protected NamedItem(NamedItem original, Cloner cloner)
+      : base(original, cloner) {
+      name = original.name;
+      description = original.description;
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Variable"/> with name <c>Anonymous</c> 
+    /// and value <c>null</c>.
+    /// </summary>
+    protected NamedItem() {
+      name = string.Empty;
+      description = string.Empty;
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Variable"/> with the specified <paramref name="name"/>
+    /// and the specified <paramref name="value"/>.
+    /// </summary>
+    /// <param name="name">The name of the current instance.</param>
+    /// <param name="value">The value of the current instance.</param>
+    protected NamedItem(string name) {
+      if (name == null) this.name = string.Empty;
+      else this.name = name;
+      description = string.Empty;
+    }
+    protected NamedItem(string name, string description) {
+      if (name == null) this.name = string.Empty;
+      else this.name = name;
+      if (description == null) this.description = string.Empty;
+      else this.description = description;
+    }
+
+    /// <summary>
+    /// Gets the string representation of the current instance in the format: <c>Name: [null|Value]</c>.
+    /// </summary>
+    /// <returns>The current instance as a string.</returns>
+    public override string ToString() {
+      return Name;
+    }
+
+    /// <inheritdoc/>
+    public event EventHandler<CancelEventArgs<string>> NameChanging;
+    /// <summary>
+    /// Fires a new <c>NameChanging</c> event.
+    /// </summary>
+    /// <param name="e">The event arguments of the changing.</param>
+    protected virtual void OnNameChanging(CancelEventArgs<string> e) {
+      var handler = NameChanging;
+      if (handler != null) handler(this, e);
+    }
+    /// <inheritdoc/>
+    public event EventHandler NameChanged;
+    /// <summary>
+    /// Fires a new <c>NameChanged</c> event.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/>.</remarks>
+    protected virtual void OnNameChanged() {
+      var handler = NameChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+      OnToStringChanged();
+    }
+    /// <inheritdoc/>
+    public event EventHandler DescriptionChanged;
+    /// <summary>
+    /// Fires a new <c>DescriptionChanged</c> event.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/>.</remarks>
+    protected virtual void OnDescriptionChanged() {
+      var handler = DescriptionChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/OperatorExecutionException.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/OperatorExecutionException.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/OperatorExecutionException.cs	(revision 9191)
@@ -0,0 +1,53 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+
+namespace HeuristicLab.Core {
+  public class OperatorExecutionException : Exception {
+    private IOperator op;
+    public IOperator Operator {
+      get { return op; }
+    }
+    public override string Message {
+      get {
+        string name = "\"" + op.Name + "\"";
+        if (!op.Name.Equals(op.ItemName)) name += " (" + op.ItemName + ")";
+
+        if (InnerException == null)
+          return base.Message + name + ".";
+        else
+          return base.Message + name + ": " + InnerException.Message;
+      }
+    }
+
+    public OperatorExecutionException(IOperator op)
+      : base("An exception was thrown by the operator ") {
+      if (op == null) throw new ArgumentNullException();
+      this.op = op;
+    }
+    public OperatorExecutionException(IOperator op, Exception innerException)
+      : base("An exception was thrown by the operator ", innerException) {
+      if (op == null) throw new ArgumentNullException();
+      this.op = op;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/OperatorGraph.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/OperatorGraph.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/OperatorGraph.cs	(revision 9191)
@@ -0,0 +1,279 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents a graph of operators.
+  /// </summary>
+  [Item("Operator Graph", "Represents a graph of operators.")]
+  [StorableClass]
+  public class OperatorGraph : Item, IStorableContent {
+    public string Filename { get; set; }
+
+    [Storable]
+    private OperatorSet operators;
+    /// <summary>
+    /// Gets all operators of the current instance.
+    /// </summary>
+    public OperatorSet Operators {
+      get { return operators; }
+    }
+
+    [Storable]
+    private IOperator initialOperator;
+    /// <summary>
+    /// Gets or sets the initial operator (the starting one).
+    /// </summary>
+    /// <remarks>Calls <see cref="OnInitialOperatorChanged"/> in the setter.</remarks>
+    public IOperator InitialOperator {
+      get { return initialOperator; }
+      set {
+        if (initialOperator != value) {
+          if (value != null) Operators.Add(value);
+          initialOperator = value;
+          OnInitialOperatorChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private IDeepCloneable visualizationInfo;
+    /// <summary>
+    /// Gets or sets the visualizationInfo.
+    /// </summary>
+    /// /// <remarks>The VisualizationInfo can only be set once and fires afterwards and InvalidOperationException</remarks>
+    public IDeepCloneable VisualizationInfo {
+      get { return visualizationInfo; }
+      set {
+        if (visualizationInfo != null)
+          throw new InvalidOperationException("The value of the property VisualizationInfo is already set and cannot be set again.");
+        visualizationInfo = value;
+      }
+    }
+
+    [StorableConstructor]
+    protected OperatorGraph(bool deserializing) : base(deserializing) { }
+    protected OperatorGraph(OperatorGraph original, Cloner cloner)
+      : base(original, cloner) {
+      operators = cloner.Clone(original.operators);
+      initialOperator = cloner.Clone(original.initialOperator);
+      visualizationInfo = cloner.Clone(original.visualizationInfo);
+      Initialize();
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorGraph"/>.
+    /// </summary>
+    public OperatorGraph() {
+      operators = new OperatorSet();
+      initialOperator = null;
+      visualizationInfo = null;
+      Initialize();
+    }
+
+    //mkommend: IMPORTANT DO NOT REMOVE THIS EVENT
+    //needed to register OperatorGraph events in GraphVisualizationInfo
+    public event EventHandler DeserializationFinished;
+    private void OnOperatorGraphDeserializationFinished() {
+      EventHandler handler = DeserializationFinished;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+      OnOperatorGraphDeserializationFinished();
+    }
+    private void Initialize() {
+      RegisterOperatorsEvents();
+    }
+
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <remarks>Deep clone through <see cref="cloner.Clone"/> method of helper class 
+    /// <see cref="Auxiliary"/>.</remarks>
+    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="OperatorGraph"/>.</returns>
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new OperatorGraph(this, cloner);
+    }
+
+    /// <inheritdoc/>
+    public event EventHandler InitialOperatorChanged;
+    /// <summary>
+    /// Fires a new <c>InitialOperatorChanged</c> event.
+    /// </summary>
+    protected virtual void OnInitialOperatorChanged() {
+      var handler = InitialOperatorChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    #region Operators Events
+    private void AddOperator(IOperator op) {
+      RegisterOperatorEvents(op);
+      foreach (IParameter param in op.Parameters)
+        AddParameter(param);
+    }
+    private void RemoveOperator(IOperator op) {
+      foreach (IParameter param in op.Parameters)
+        RemoveParameter(param);
+      DeregisterOperatorEvents(op);
+
+      // remove edges to removed operator
+      IValueParameter[] opParams = (from o in Operators
+                                    from p in o.Parameters
+                                    where p is IValueParameter
+                                    where typeof(IOperator).IsAssignableFrom(((IValueParameter)p).DataType)
+                                    where (((IValueParameter)p).Value != null) && (((IValueParameter)p).Value == op)
+                                    select (IValueParameter)p).ToArray();
+      foreach (IValueParameter opParam in opParams)
+        opParam.Value = null;
+    }
+    private void AddParameter(IParameter param) {
+      IValueParameter valueParam = param as IValueParameter;
+      if ((valueParam != null) && (typeof(IOperator).IsAssignableFrom(valueParam.DataType))) {
+        RegisterOperatorParameterEvents(valueParam);
+        if (valueParam.Value != null) Operators.Add((IOperator)valueParam.Value);
+      }
+    }
+    private void RemoveParameter(IParameter param) {
+      IValueParameter valueParam = param as IValueParameter;
+      if ((valueParam != null) && (typeof(IOperator).IsAssignableFrom(valueParam.DataType))) {
+        DeregisterOperatorParameterEvents(valueParam);
+      }
+    }
+
+    private void RegisterOperatorsEvents() {
+      if (operators != null) {
+        operators.ItemsAdded += new CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsAdded);
+        operators.ItemsRemoved += new CollectionItemsChangedEventHandler<IOperator>(Operators_ItemsRemoved);
+        operators.CollectionReset += new CollectionItemsChangedEventHandler<IOperator>(Operators_CollectionReset);
+        foreach (IOperator op in operators) {
+          RegisterOperatorEvents(op);
+          var opParams = from p in op.Parameters
+                         where p is IValueParameter
+                         where typeof(IOperator).IsAssignableFrom(((IValueParameter)p).DataType)
+                         select (IValueParameter)p;
+          foreach (IValueParameter opParam in opParams)
+            RegisterOperatorParameterEvents(opParam);
+        }
+      }
+    }
+    private void RegisterOperatorEvents(IOperator op) {
+      op.Parameters.ItemsAdded += new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsAdded);
+      op.Parameters.ItemsRemoved += new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsRemoved);
+      op.Parameters.ItemsReplaced += new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsReplaced);
+      op.Parameters.CollectionReset += new CollectionItemsChangedEventHandler<IParameter>(Parameters_CollectionReset);
+    }
+    private void DeregisterOperatorEvents(IOperator op) {
+      op.Parameters.ItemsAdded -= new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsAdded);
+      op.Parameters.ItemsRemoved -= new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsRemoved);
+      op.Parameters.ItemsReplaced -= new CollectionItemsChangedEventHandler<IParameter>(Parameters_ItemsReplaced);
+      op.Parameters.CollectionReset -= new CollectionItemsChangedEventHandler<IParameter>(Parameters_CollectionReset);
+    }
+    private void RegisterOperatorParameterEvents(IValueParameter opParam) {
+      opParam.ValueChanged += new EventHandler(opParam_ValueChanged);
+    }
+    private void DeregisterOperatorParameterEvents(IValueParameter opParam) {
+      opParam.ValueChanged -= new EventHandler(opParam_ValueChanged);
+    }
+
+    private void Operators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IOperator> e) {
+      foreach (IOperator op in e.Items)
+        AddOperator(op);
+    }
+    private void Operators_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IOperator> e) {
+      foreach (IOperator op in e.Items)
+        RemoveOperator(op);
+      if (!Operators.Contains(InitialOperator)) InitialOperator = null;
+    }
+    private void Operators_CollectionReset(object sender, CollectionItemsChangedEventArgs<IOperator> e) {
+      foreach (IOperator op in e.OldItems)
+        RemoveOperator(op);
+      foreach (IOperator op in e.Items)
+        AddOperator(op);
+      if (!Operators.Contains(InitialOperator)) InitialOperator = null;
+    }
+    private void Parameters_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
+      foreach (IParameter param in e.Items)
+        AddParameter(param);
+    }
+    private void Parameters_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
+      foreach (IParameter param in e.Items)
+        RemoveParameter(param);
+    }
+    private void Parameters_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
+      foreach (IParameter param in e.OldItems)
+        RemoveParameter(param);
+      foreach (IParameter param in e.Items)
+        AddParameter(param);
+    }
+    private void Parameters_CollectionReset(object sender, CollectionItemsChangedEventArgs<IParameter> e) {
+      foreach (IParameter param in e.OldItems)
+        RemoveParameter(param);
+      foreach (IParameter param in e.Items)
+        AddParameter(param);
+    }
+    private void opParam_ValueChanged(object sender, EventArgs e) {
+      IValueParameter opParam = (IValueParameter)sender;
+      if (opParam.Value != null) Operators.Add((IOperator)opParam.Value);
+    }
+    #endregion
+
+    // <summary>
+    /// Iterates an operator graph so that it jumps from the intial operator to all other operators and yields each operator it touches.
+    /// Cycles are detected and not iterated twice.
+    /// </summary>
+    /// <returns>An enumeration of all the operators that could be found.</returns>
+    public virtual IEnumerable<IOperator> Iterate() {
+      if (InitialOperator == null) yield break;
+
+      var open = new Stack<IOperator>();
+      var visited = new HashSet<IOperator>();
+      open.Push(InitialOperator);
+
+      while (open.Any()) {
+        IOperator current = open.Pop();
+        if (visited.Contains(current)) continue;
+        visited.Add(current);
+
+        IOperatorGraphOperator operatorGraphOperator = current as IOperatorGraphOperator;
+        if (operatorGraphOperator != null) open.Push(operatorGraphOperator.OperatorGraph.InitialOperator);
+
+        foreach (var parameter in current.Parameters.OfType<IValueParameter>()) {
+          if (!typeof(IOperator).IsAssignableFrom(parameter.DataType)) continue;
+          if (parameter.Value == null) continue;
+
+          open.Push((IOperator)parameter.Value);
+        }
+
+        yield return current;
+      }
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ParameterizedNamedItem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ParameterizedNamedItem.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ParameterizedNamedItem.cs	(revision 9191)
@@ -0,0 +1,107 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// A base class for items which have a name and contain parameters.
+  /// </summary>
+  [Item("ParameterizedNamedItem", "A base class for items which have a name and contain parameters.")]
+  [StorableClass]
+  public abstract class ParameterizedNamedItem : NamedItem, IParameterizedNamedItem {
+    [Storable]
+    private ParameterCollection parameters;
+    protected ParameterCollection Parameters {
+      get { return parameters; }
+    }
+    private ReadOnlyKeyedItemCollection<string, IParameter> readOnlyParameters;
+    IKeyedItemCollection<string, IParameter> IParameterizedItem.Parameters {
+      get {
+        if (readOnlyParameters == null) readOnlyParameters = parameters.AsReadOnly();
+        return readOnlyParameters;
+      }
+    }
+
+    [StorableConstructor]
+    protected ParameterizedNamedItem(bool deserializing) : base(deserializing) { }
+    protected ParameterizedNamedItem(ParameterizedNamedItem original, Cloner cloner)
+      : base(original, cloner) {
+      parameters = cloner.Clone(original.parameters);
+      readOnlyParameters = null;
+    }
+    protected ParameterizedNamedItem()
+      : base() {
+      name = ItemName;
+      description = ItemDescription;
+      parameters = new ParameterCollection();
+      readOnlyParameters = null;
+    }
+    protected ParameterizedNamedItem(string name)
+      : base(name) {
+      description = ItemDescription;
+      parameters = new ParameterCollection();
+      readOnlyParameters = null;
+    }
+    protected ParameterizedNamedItem(string name, ParameterCollection parameters)
+      : base(name) {
+      description = ItemDescription;
+      this.parameters = parameters;
+      readOnlyParameters = null;
+    }
+    protected ParameterizedNamedItem(string name, string description)
+      : base(name, description) {
+      parameters = new ParameterCollection();
+      readOnlyParameters = null;
+    }
+    protected ParameterizedNamedItem(string name, string description, ParameterCollection parameters)
+      : base(name, description) {
+      this.parameters = parameters;
+      readOnlyParameters = null;
+    }
+
+    public virtual void CollectParameterValues(IDictionary<string, IItem> values) {
+      foreach (IValueParameter param in parameters.OfType<IValueParameter>()) {
+        var children = GetCollectedValues(param);
+        foreach (var c in children) {
+          if (String.IsNullOrEmpty(c.Key))
+            values.Add(param.Name, c.Value);
+          else values.Add(param.Name + "." + c.Key, c.Value);
+        }
+      }
+    }
+
+    protected virtual IEnumerable<KeyValuePair<string, IItem>> GetCollectedValues(IValueParameter param) {
+      if (param.Value == null) yield break;
+      if (param.GetsCollected) yield return new KeyValuePair<string, IItem>(String.Empty, param.Value);
+      var parameterizedItem = param.Value as IParameterizedItem;
+      if (parameterizedItem != null) {
+        var children = new Dictionary<string, IItem>();
+        parameterizedItem.CollectParameterValues(children);
+        foreach (var child in children) yield return child;
+      }
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/PersistenceContentManager.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/PersistenceContentManager.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/PersistenceContentManager.cs	(revision 9191)
@@ -0,0 +1,37 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.Xml;
+
+namespace HeuristicLab.Core {
+  public class PersistenceContentManager : ContentManager {
+    public PersistenceContentManager() : base() { }
+
+    protected override IStorableContent LoadContent(string filename) {
+      return XmlParser.Deserialize<IStorableContent>(filename);
+    }
+
+    protected override void SaveContent(IStorableContent content, string filename, bool compressed) {
+      XmlGenerator.Serialize(content, filename, compressed ? 9 : 0);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Plugin.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Plugin.cs.frame	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Plugin.cs.frame	(revision 9191)
@@ -0,0 +1,39 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Core {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Core plugin.
+  /// </summary>
+  [Plugin("HeuristicLab.Core", "3.3.7.$WCREV$")]
+  [PluginFile("HeuristicLab.Core-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  public class HeuristicLabCorePlugin : PluginBase {
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Properties/AssemblyInfo.cs.frame	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Properties/AssemblyInfo.cs.frame	(revision 9191)
@@ -0,0 +1,56 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Core")]
+[assembly: AssemblyDescription("HeuristicLab core classes")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2012 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("7d0840b8-3382-4b99-ab4e-5d1eb91fbec1")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// 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.0")]
+[assembly: AssemblyFileVersion("3.3.7.$WCREV$")]
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Scope.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Scope.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Scope.cs	(revision 9191)
@@ -0,0 +1,150 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Hierarchical container of variables (and of subscopes).
+  /// </summary>
+  [Item("Scope", "A scope which contains variables and sub-scopes.")]
+  [StorableClass]
+  public sealed class Scope : NamedItem, IScope {
+    public static new Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.OrgChart; }
+    }
+
+    [Storable]
+    private IScope parent;
+    public IScope Parent {
+      get { return parent; }
+      set {
+        if (parent != value) {
+          parent = value;
+        }
+      }
+    }
+
+    [Storable]
+    private VariableCollection variables;
+    public VariableCollection Variables {
+      get { return variables; }
+    }
+
+    [Storable]
+    private ScopeList subScopes;
+    public ScopeList SubScopes {
+      get { return subScopes; }
+    }
+
+    [StorableConstructor]
+    private Scope(bool deserializing) : base(deserializing) { }
+    private Scope(Scope original, Cloner cloner)
+      : base(original, cloner) {
+      if (original.variables.Count > 0) variables = cloner.Clone(original.variables);
+      else variables = new VariableCollection();
+      if (original.subScopes.Count > 0) {
+        subScopes = cloner.Clone(original.subScopes);
+        foreach (IScope child in SubScopes)
+          child.Parent = this;
+      } else subScopes = new ScopeList();
+      RegisterSubScopesEvents();
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Scope"/> having "Anonymous" as default name.
+    /// </summary>
+    public Scope()
+      : base("Anonymous") {
+      parent = null;
+      variables = new VariableCollection();
+      subScopes = new ScopeList();
+      RegisterSubScopesEvents();
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Scope"/> with the given <paramref name="name"/>.
+    /// </summary>
+    /// <param name="name">The name of the scope.</param>
+    public Scope(string name)
+      : base(name) {
+      parent = null;
+      variables = new VariableCollection();
+      subScopes = new ScopeList();
+      RegisterSubScopesEvents();
+    }
+    public Scope(string name, string description)
+      : base(name, description) {
+      parent = null;
+      variables = new VariableCollection();
+      subScopes = new ScopeList();
+      RegisterSubScopesEvents();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterSubScopesEvents();
+    }
+
+    /// <inheritdoc/>
+    public void Clear() {
+      variables.Clear();
+      subScopes.Clear();
+    }
+
+    /// <inheritdoc/>
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Scope(this, cloner);
+    }
+
+    #region SubScopes Events
+    private void RegisterSubScopesEvents() {
+      if (subScopes != null) {
+        subScopes.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsAdded);
+        subScopes.ItemsRemoved += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsRemoved);
+        subScopes.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_ItemsReplaced);
+        subScopes.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<IScope>>(SubScopes_CollectionReset);
+      }
+    }
+    private void SubScopes_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
+      foreach (IndexedItem<IScope> item in e.Items)
+        item.Value.Parent = this;
+    }
+    private void SubScopes_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
+      foreach (IndexedItem<IScope> item in e.Items)
+        item.Value.Parent = null;
+    }
+    private void SubScopes_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
+      foreach (IndexedItem<IScope> oldItem in e.OldItems)
+        oldItem.Value.Parent = null;
+      foreach (IndexedItem<IScope> item in e.Items)
+        item.Value.Parent = this;
+    }
+    private void SubScopes_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<IScope>> e) {
+      foreach (IndexedItem<IScope> oldItem in e.OldItems)
+        oldItem.Value.Parent = null;
+      foreach (IndexedItem<IScope> item in e.Items)
+        item.Value.Parent = this;
+    }
+    #endregion
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ThreadSafeLog.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ThreadSafeLog.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/ThreadSafeLog.cs	(revision 9191)
@@ -0,0 +1,88 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [Item("ThreadSafeLog", "A thread-safe log for logging string messages.")]
+  [StorableClass]
+  public sealed class ThreadSafeLog : Log {
+    private ReaderWriterLockSlim locker = new ReaderWriterLockSlim();
+
+    public override IEnumerable<string> Messages {
+      get {
+        locker.EnterReadLock();
+        try {
+          return messages.ToArray(); // return copy of messages
+        } finally { locker.ExitReadLock(); }
+      }
+    }
+
+    [StorableConstructor]
+    private ThreadSafeLog(bool deserializing) : base(deserializing) { }
+    public ThreadSafeLog(long maxMessageCount = -1)
+      : base(maxMessageCount) {
+    }
+
+    private ThreadSafeLog(ThreadSafeLog original, Cloner cloner)
+      : base(original, cloner) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      locker.EnterReadLock();
+      try {
+        return new ThreadSafeLog(this, cloner);
+      } finally { locker.ExitReadLock(); }
+    }
+
+    public override void Clear() {
+      locker.EnterWriteLock();
+      try {
+        messages.Clear();
+      } finally { locker.ExitWriteLock(); }
+      OnCleared();
+    }
+
+    public override void LogMessage(string message) {
+      string s = FormatLogMessage(message);
+      locker.EnterWriteLock();
+      try {
+        messages.Add(s);
+        CapMessages();
+      } finally { locker.ExitWriteLock(); }
+      OnMessageAdded(s);
+    }
+
+    public override void LogException(Exception ex) {
+      string s = FormatException(ex);
+      locker.EnterWriteLock();
+      try {
+        messages.Add(s);
+        CapMessages();
+      } finally { locker.ExitWriteLock(); }
+      OnMessageAdded(s);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Variable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Variable.cs	(revision 9191)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Variable.cs	(revision 9191)
@@ -0,0 +1,153 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Drawing;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents a variable which has a name and holds an IItem.
+  /// </summary>
+  [Item("Variable", "A variable which has a name and holds an IItem.")]
+  [StorableClass]
+  public sealed class Variable : NamedItem, IVariable {
+    public override Image ItemImage {
+      get {
+        if (value != null) return value.ItemImage;
+        else return base.ItemImage;
+      }
+    }
+
+    [Storable]
+    private IItem value;
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnValueChanged"/> in the setter.</remarks>
+    public IItem Value {
+      get { return value; }
+      set {
+        if (this.value != value) {
+          DeregisterValueEvents();
+          this.value = value;
+          RegisterValueEvents();
+          OnValueChanged();
+        }
+      }
+    }
+
+    [StorableConstructor]
+    private Variable(bool deserializing) : base(deserializing) { }
+    private Variable(Variable original, Cloner cloner)
+      : base(original, cloner) {
+      value = cloner.Clone(original.value);
+      RegisterValueEvents();
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Variable"/> with name <c>Anonymous</c> 
+    /// and value <c>null</c>.
+    /// </summary>
+    public Variable()
+      : base("Anonymous") {
+      this.value = null;
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Variable"/> with the specified <paramref name="name"/>
+    /// and the specified <paramref name="value"/>.
+    /// </summary>
+    /// <param name="name">The name of the current instance.</param>
+    /// <param name="value">The value of the current instance.</param>
+    public Variable(string name)
+      : base(name) {
+      this.value = null;
+    }
+    public Variable(string name, string description)
+      : base(name, description) {
+      this.value = null;
+    }
+    public Variable(string name, IItem value)
+      : base(name) {
+      this.value = value;
+      RegisterValueEvents();
+    }
+    public Variable(string name, string description, IItem value)
+      : base(name, description) {
+      this.value = value;
+      RegisterValueEvents();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterValueEvents();
+    }
+
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="Variable"/>.</returns>
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Variable(this, cloner);
+    }
+
+    /// <summary>
+    /// Gets the string representation of the current instance in the format: <c>Name: [null|Value]</c>.
+    /// </summary>
+    /// <returns>The current instance as a string.</returns>
+    public override string ToString() {
+      if (Value == null)
+        return string.Format("{0}: null", Name);
+      else
+        return string.Format("{0}: {1}", Name, Value.ToString());
+    }
+
+    /// <inheritdoc/>
+    public event EventHandler ValueChanged;
+    /// <summary>
+    /// Fires a new <c>ValueChanged</c> even.
+    /// </summary>
+    private void OnValueChanged() {
+      var handler = ValueChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+      OnItemImageChanged();
+      OnToStringChanged();
+    }
+
+    private void RegisterValueEvents() {
+      if (value != null) {
+        value.ItemImageChanged += new EventHandler(Value_ItemImageChanged);
+        value.ToStringChanged += new EventHandler(Value_ToStringChanged);
+      }
+    }
+    private void DeregisterValueEvents() {
+      if (value != null) {
+        value.ItemImageChanged -= new EventHandler(Value_ItemImageChanged);
+        value.ToStringChanged -= new EventHandler(Value_ToStringChanged);
+      }
+    }
+    private void Value_ItemImageChanged(object sender, EventArgs e) {
+      OnItemImageChanged();
+    }
+    private void Value_ToStringChanged(object sender, EventArgs e) {
+      OnToStringChanged();
+    }
+  }
+}
