Index: /trunk/sources/HeuristicLab.Collections/3.3/HeuristicLab.Collections-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/HeuristicLab.Collections-3.3.csproj	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/HeuristicLab.Collections-3.3.csproj	(revision 3390)
@@ -122,12 +122,4 @@
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
-      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
-      <Name>HeuristicLab.Common-3.3</Name>
-    </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>
-    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\HeuristicLab.PluginInfrastructure.csproj">
       <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
Index: /trunk/sources/HeuristicLab.Collections/3.3/IObservableArray.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/IObservableArray.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/IObservableArray.cs	(revision 3390)
@@ -23,8 +23,7 @@
 using System.Collections.Generic;
 using System.ComponentModel;
-using HeuristicLab.Common;
 
 namespace HeuristicLab.Collections {
-  public interface IObservableArray<T> : IList<T>, INotifyObservableArrayItemsChanged<T>, INotifyPropertyChanged, IContent {
+  public interface IObservableArray<T> : IList<T>, INotifyObservableArrayItemsChanged<T>, INotifyPropertyChanged {
     int Length { get; }
   }
Index: /trunk/sources/HeuristicLab.Collections/3.3/IObservableCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/IObservableCollection.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/IObservableCollection.cs	(revision 3390)
@@ -23,7 +23,6 @@
 using System.Collections.Generic;
 using System.ComponentModel;
-using HeuristicLab.Common;
 
 namespace HeuristicLab.Collections {
-  public interface IObservableCollection<T> : ICollection<T>, INotifyObservableCollectionItemsChanged<T>, INotifyPropertyChanged, IContent { }
+  public interface IObservableCollection<T> : ICollection<T>, INotifyObservableCollectionItemsChanged<T>, INotifyPropertyChanged { }
 }
Index: /trunk/sources/HeuristicLab.Collections/3.3/ObservableArray.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ObservableArray.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ObservableArray.cs	(revision 3390)
@@ -25,27 +25,11 @@
 using System.ComponentModel;
 using System.Linq;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public class ObservableArray<T> : IObservableArray<T> {
-    [Storable]
     protected T[] array;
 
     #region Properties
-    [Storable]
-    private bool readOnlyView;
-    public virtual bool ReadOnlyView {
-      get { return readOnlyView; }
-      set {
-        if ((readOnlyView != value) && !array.IsReadOnly) {
-          readOnlyView = value;
-          OnReadOnlyViewChanged();
-          OnPropertyChanged("ReadOnlyView");
-        }
-      }
-    }
-
     public int Length {
       get { return array.Length; }
@@ -76,17 +60,13 @@
     public ObservableArray() {
       array = new T[0];
-      readOnlyView = array.IsReadOnly;
     }
     public ObservableArray(int length) {
       array = new T[length];
-      readOnlyView = array.IsReadOnly;
     }
     public ObservableArray(T[] array) {
       this.array = (T[])array.Clone();
-      readOnlyView = array.IsReadOnly;
     }
     public ObservableArray(IEnumerable<T> collection) {
       array = collection.ToArray();
-      readOnlyView = array.IsReadOnly;
     }
     #endregion
@@ -297,11 +277,4 @@
 
     #region Events
-    [field: NonSerialized]
-    public event EventHandler ReadOnlyViewChanged;
-    protected virtual void OnReadOnlyViewChanged() {
-      EventHandler handler = ReadOnlyViewChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
     [field: NonSerialized]
     public event CollectionItemsChangedEventHandler<IndexedItem<T>> ItemsReplaced;
Index: /trunk/sources/HeuristicLab.Collections/3.3/ObservableCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ObservableCollection.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ObservableCollection.cs	(revision 3390)
@@ -24,27 +24,11 @@
 using System.Collections.Generic;
 using System.ComponentModel;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public class ObservableCollection<T> : IObservableCollection<T> {
-    [Storable]
     protected List<T> list;
 
     #region Properties
-    [Storable]
-    private bool readOnlyView;
-    public virtual bool ReadOnlyView {
-      get { return readOnlyView; }
-      set {
-        if ((readOnlyView != value) && !((ICollection<T>)list).IsReadOnly) {
-          readOnlyView = value;
-          OnReadOnlyViewChanged();
-          OnPropertyChanged("ReadOnlyView");
-        }
-      }
-    }
-
     public int Capacity {
       get { return list.Capacity; }
@@ -67,13 +51,10 @@
     public ObservableCollection() {
       list = new List<T>();
-      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     }
     public ObservableCollection(int capacity) {
       list = new List<T>(capacity);
-      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     }
     public ObservableCollection(IEnumerable<T> collection) {
       list = new List<T>(collection);
-      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     }
     #endregion
@@ -205,11 +186,4 @@
     #region Events
     [field: NonSerialized]
-    public event EventHandler ReadOnlyViewChanged;
-    protected virtual void OnReadOnlyViewChanged() {
-      EventHandler handler = ReadOnlyViewChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    [field: NonSerialized]
     public event CollectionItemsChangedEventHandler<T> ItemsAdded;
     protected virtual void OnItemsAdded(IEnumerable<T> items) {
Index: /trunk/sources/HeuristicLab.Collections/3.3/ObservableDictionary.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ObservableDictionary.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ObservableDictionary.cs	(revision 3390)
@@ -25,27 +25,11 @@
 using System.ComponentModel;
 using System.Linq;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public class ObservableDictionary<TKey, TValue> : IObservableDictionary<TKey, TValue> {
-    [Storable]
-    private Dictionary<TKey, TValue> dict;
+    protected Dictionary<TKey, TValue> dict;
 
     #region Properties
-    [Storable]
-    private bool readOnlyView;
-    public virtual bool ReadOnlyView {
-      get { return readOnlyView; }
-      set {
-        if ((readOnlyView != value) && !((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly) {
-          readOnlyView = value;
-          OnReadOnlyViewChanged();
-          OnPropertyChanged("ReadOnlyView");
-        }
-      }
-    }
-
     public ICollection<TKey> Keys {
       get { return dict.Keys; }
@@ -84,25 +68,19 @@
     public ObservableDictionary() {
       dict = new Dictionary<TKey, TValue>();
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly;
     }
     public ObservableDictionary(int capacity) {
       dict = new Dictionary<TKey, TValue>(capacity);
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly;
     }
     public ObservableDictionary(IEqualityComparer<TKey> comparer) {
       dict = new Dictionary<TKey, TValue>(comparer);
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly;
     }
     public ObservableDictionary(IDictionary<TKey, TValue> dictionary) {
       dict = new Dictionary<TKey, TValue>(dictionary);
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly;
     }
     public ObservableDictionary(int capacity, IEqualityComparer<TKey> comparer) {
       dict = new Dictionary<TKey, TValue>(capacity, comparer);
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly;
     }
     public ObservableDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer) {
       dict = new Dictionary<TKey, TValue>(dictionary, comparer);
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly;
     }
     #endregion
@@ -200,11 +178,4 @@
     #region Events
     [field: NonSerialized]
-    public event EventHandler ReadOnlyViewChanged;
-    protected virtual void OnReadOnlyViewChanged() {
-      EventHandler handler = ReadOnlyViewChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    [field: NonSerialized]
     public event CollectionItemsChangedEventHandler<KeyValuePair<TKey, TValue>> ItemsAdded;
     protected virtual void OnItemsAdded(IEnumerable<KeyValuePair<TKey, TValue>> items) {
Index: /trunk/sources/HeuristicLab.Collections/3.3/ObservableKeyedCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ObservableKeyedCollection.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ObservableKeyedCollection.cs	(revision 3390)
@@ -25,27 +25,11 @@
 using System.ComponentModel;
 using System.Linq;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public abstract class ObservableKeyedCollection<TKey, TItem> : IObservableKeyedCollection<TKey, TItem> {
-    [Storable]
     protected Dictionary<TKey, TItem> dict;
 
     #region Properties
-    [Storable]
-    private bool readOnlyView;
-    public virtual bool ReadOnlyView {
-      get { return readOnlyView; }
-      set {
-        if ((readOnlyView != value) && !((ICollection<KeyValuePair<TKey, TItem>>)dict).IsReadOnly) {
-          readOnlyView = value;
-          OnReadOnlyViewChanged();
-          OnPropertyChanged("ReadOnlyView");
-        }
-      }
-    }
-
     public int Count {
       get { return dict.Count; }
@@ -68,13 +52,10 @@
     protected ObservableKeyedCollection() {
       dict = new Dictionary<TKey, TItem>();
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TItem>>)dict).IsReadOnly;
     }
     protected ObservableKeyedCollection(int capacity) {
       dict = new Dictionary<TKey, TItem>(capacity);
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TItem>>)dict).IsReadOnly;
     }
     protected ObservableKeyedCollection(IEqualityComparer<TKey> comparer) {
       dict = new Dictionary<TKey, TItem>(comparer);
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TItem>>)dict).IsReadOnly;
     }
     protected ObservableKeyedCollection(IEnumerable<TItem> collection) {
@@ -83,9 +64,7 @@
       foreach (TItem item in collection)
         dict.Add(GetKeyForItem(item), item);
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TItem>>)dict).IsReadOnly;
     }
     protected ObservableKeyedCollection(int capacity, IEqualityComparer<TKey> comparer) {
       dict = new Dictionary<TKey, TItem>(capacity, comparer);
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TItem>>)dict).IsReadOnly;
     }
     protected ObservableKeyedCollection(IEnumerable<TItem> collection, IEqualityComparer<TKey> comparer) {
@@ -94,5 +73,4 @@
       foreach (TItem item in collection)
         dict.Add(GetKeyForItem(item), item);
-      readOnlyView = ((ICollection<KeyValuePair<TKey, TItem>>)dict).IsReadOnly;
     }
     #endregion
@@ -269,11 +247,4 @@
     #region Events
     [field: NonSerialized]
-    public event EventHandler ReadOnlyViewChanged;
-    protected virtual void OnReadOnlyViewChanged() {
-      EventHandler handler = ReadOnlyViewChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    [field: NonSerialized]
     public event CollectionItemsChangedEventHandler<TItem> ItemsAdded;
     protected virtual void OnItemsAdded(IEnumerable<TItem> items) {
Index: /trunk/sources/HeuristicLab.Collections/3.3/ObservableList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ObservableList.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ObservableList.cs	(revision 3390)
@@ -24,27 +24,11 @@
 using System.Collections.Generic;
 using System.ComponentModel;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public class ObservableList<T> : IObservableList<T> {
-    [Storable]
     protected List<T> list;
 
     #region Properties
-    [Storable]
-    private bool readOnlyView;
-    public virtual bool ReadOnlyView {
-      get { return readOnlyView; }
-      set {
-        if ((readOnlyView != value) && !((ICollection<T>)list).IsReadOnly) {
-          readOnlyView = value;
-          OnReadOnlyViewChanged();
-          OnPropertyChanged("ReadOnlyView");
-        }
-      }
-    }
-
     public int Capacity {
       get { return list.Capacity; }
@@ -81,13 +65,10 @@
     public ObservableList() {
       list = new List<T>();
-      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     }
     public ObservableList(int capacity) {
       list = new List<T>(capacity);
-      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     }
     public ObservableList(IEnumerable<T> collection) {
       list = new List<T>(collection);
-      readOnlyView = ((ICollection<T>)list).IsReadOnly;
     }
     #endregion
@@ -391,11 +372,4 @@
     #region Events
     [field: NonSerialized]
-    public event EventHandler ReadOnlyViewChanged;
-    protected virtual void OnReadOnlyViewChanged() {
-      EventHandler handler = ReadOnlyViewChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    [field: NonSerialized]
     public event CollectionItemsChangedEventHandler<IndexedItem<T>> ItemsAdded;
     protected virtual void OnItemsAdded(IEnumerable<IndexedItem<T>> items) {
Index: /trunk/sources/HeuristicLab.Collections/3.3/ObservableSet.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ObservableSet.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ObservableSet.cs	(revision 3390)
@@ -25,27 +25,11 @@
 using System.ComponentModel;
 using System.Linq;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public class ObservableSet<T> : IObservableSet<T> {
-    [Storable]
     protected HashSet<T> set;
 
     #region Properties
-    [Storable]
-    private bool readOnlyView;
-    public virtual bool ReadOnlyView {
-      get { return readOnlyView; }
-      set {
-        if ((readOnlyView != value) && !((ICollection<T>)set).IsReadOnly) {
-          readOnlyView = value;
-          OnReadOnlyViewChanged();
-          OnPropertyChanged("ReadOnlyView");
-        }
-      }
-    }
-
     public IEqualityComparer<T> Comparer {
       get { return set.Comparer; }
@@ -62,17 +46,13 @@
     public ObservableSet() {
       set = new HashSet<T>();
-      readOnlyView = ((ICollection<T>)set).IsReadOnly;
     }
     public ObservableSet(IEnumerable<T> collection) {
       set = new HashSet<T>(collection);
-      readOnlyView = ((ICollection<T>)set).IsReadOnly;
     }
     public ObservableSet(IEqualityComparer<T> comparer) {
       set = new HashSet<T>(comparer);
-      readOnlyView = ((ICollection<T>)set).IsReadOnly;
     }
     public ObservableSet(IEnumerable<T> collection, IEqualityComparer<T> comparer) {
       set = new HashSet<T>(collection, comparer);
-      readOnlyView = ((ICollection<T>)set).IsReadOnly;
     }
     #endregion
@@ -244,11 +224,4 @@
     #region Events
     [field: NonSerialized]
-    public event EventHandler ReadOnlyViewChanged;
-    protected virtual void OnReadOnlyViewChanged() {
-      EventHandler handler = ReadOnlyViewChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    [field: NonSerialized]
     public event CollectionItemsChangedEventHandler<T> ItemsAdded;
     protected virtual void OnItemsAdded(IEnumerable<T> items) {
Index: /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableArray.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableArray.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableArray.cs	(revision 3390)
@@ -24,20 +24,11 @@
 using System.Collections.Generic;
 using System.ComponentModel;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public class ReadOnlyObservableArray<T> : IObservableArray<T> {
-    [Storable]
-    private IObservableArray<T> array;
+    protected IObservableArray<T> array;
 
     #region Properties
-    public bool ReadOnlyView {
-      get { return true; }
-      set { }
-    }
-
     public int Length {
       get { return array.Length; }
@@ -115,5 +106,4 @@
 
     #region Events
-    [StorableHook(HookType.AfterDeserialization)]
     protected void RegisterEvents() {
       array.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<T>>(array_ItemsReplaced);
@@ -121,9 +111,4 @@
       array.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<T>>(array_CollectionReset);
       array.PropertyChanged += new PropertyChangedEventHandler(array_PropertyChanged);
-    }
-
-    event EventHandler IContent.ReadOnlyViewChanged {
-      add { }
-      remove { }
     }
 
Index: /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableCollection.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableCollection.cs	(revision 3390)
@@ -24,20 +24,11 @@
 using System.Collections.Generic;
 using System.ComponentModel;
-using HeuristicLab.Common;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public class ReadOnlyObservableCollection<T> : IObservableCollection<T> {
-    [Storable]
-    private IObservableCollection<T> collection;
+    protected IObservableCollection<T> collection;
 
     #region Properties
-    public bool ReadOnlyView {
-      get { return true; }
-      set { }
-    }
-
     public int Count {
       get { return collection.Count; }
@@ -93,5 +84,4 @@
 
     #region Events
-    [StorableHook(HookType.AfterDeserialization)]
     protected void RegisterEvents() {
       collection.ItemsAdded += new CollectionItemsChangedEventHandler<T>(collection_ItemsAdded);
@@ -101,8 +91,4 @@
     }
 
-    event EventHandler IContent.ReadOnlyViewChanged {
-      add { }
-      remove { }
-    }
 
     [field: NonSerialized]
Index: /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableDictionary.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableDictionary.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableDictionary.cs	(revision 3390)
@@ -24,20 +24,11 @@
 using System.Collections.Generic;
 using System.ComponentModel;
-using HeuristicLab.Common;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public class ReadOnlyObservableDictionary<TKey, TValue> : IObservableDictionary<TKey, TValue> {
-    [Storable]
-    private IObservableDictionary<TKey, TValue> dict;
+    protected IObservableDictionary<TKey, TValue> dict;
 
     #region Properties
-    public bool ReadOnlyView {
-      get { return true; }
-      set { }
-    }
-
     public ICollection<TKey> Keys {
       get { return dict.Keys; }
@@ -120,5 +111,4 @@
 
     #region Events
-    [StorableHook(HookType.AfterDeserialization)]
     protected void RegisterEvents() {
       dict.ItemsAdded += new CollectionItemsChangedEventHandler<KeyValuePair<TKey, TValue>>(dict_ItemsAdded);
@@ -127,9 +117,4 @@
       dict.CollectionReset += new CollectionItemsChangedEventHandler<KeyValuePair<TKey, TValue>>(dict_CollectionReset);
       dict.PropertyChanged += new PropertyChangedEventHandler(dict_PropertyChanged);
-    }
-
-    event EventHandler IContent.ReadOnlyViewChanged {
-      add { }
-      remove { }
     }
 
Index: /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableKeyedCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableKeyedCollection.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableKeyedCollection.cs	(revision 3390)
@@ -24,20 +24,11 @@
 using System.Collections.Generic;
 using System.ComponentModel;
-using HeuristicLab.Common;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public class ReadOnlyObservableKeyedCollection<TKey, TItem> : IObservableKeyedCollection<TKey, TItem> {
-    [Storable]
-    private IObservableKeyedCollection<TKey, TItem> collection;
+    protected IObservableKeyedCollection<TKey, TItem> collection;
 
     #region Properties
-    public virtual bool ReadOnlyView {
-      get { return true; }
-      set { throw new NotSupportedException(); }
-    }
-
     public int Count {
       get { return collection.Count; }
@@ -109,5 +100,4 @@
 
     #region Events
-    [StorableHook(HookType.AfterDeserialization)]
     protected void RegisterEvents() {
       collection.ItemsAdded += new CollectionItemsChangedEventHandler<TItem>(collection_ItemsAdded);
@@ -116,9 +106,4 @@
       collection.CollectionReset += new CollectionItemsChangedEventHandler<TItem>(collection_CollectionReset);
       collection.PropertyChanged += new PropertyChangedEventHandler(collection_PropertyChanged);
-    }
-
-    event EventHandler IContent.ReadOnlyViewChanged {
-      add { }
-      remove { }
     }
 
Index: /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableList.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableList.cs	(revision 3390)
@@ -24,20 +24,11 @@
 using System.Collections.Generic;
 using System.ComponentModel;
-using HeuristicLab.Common;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public class ReadOnlyObservableList<T> : IObservableList<T> {
-    [Storable]
-    private IObservableList<T> list;
+    protected IObservableList<T> list;
 
     #region Properties
-    public bool ReadOnlyView {
-      get { return true; }
-      set { }
-    }
-
     public int Count {
       get { return ((ICollection<T>)list).Count; }
@@ -112,5 +103,4 @@
 
     #region Events
-    [StorableHook(HookType.AfterDeserialization)]
     protected void RegisterEvents() {
       list.ItemsAdded += new CollectionItemsChangedEventHandler<IndexedItem<T>>(list_ItemsAdded);
@@ -125,9 +115,4 @@
     }
 
-    event EventHandler IContent.ReadOnlyViewChanged {
-      add { }
-      remove { }
-    }
-
     [field: NonSerialized]
     public event CollectionItemsChangedEventHandler<IndexedItem<T>> ItemsAdded;
Index: /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableSet.cs
===================================================================
--- /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableSet.cs	(revision 3389)
+++ /trunk/sources/HeuristicLab.Collections/3.3/ReadOnlyObservableSet.cs	(revision 3390)
@@ -24,20 +24,11 @@
 using System.Collections.Generic;
 using System.ComponentModel;
-using HeuristicLab.Common;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Collections {
   [Serializable]
-  [StorableClass]
   public class ReadOnlyObservableSet<T> : IObservableSet<T> {
-    [Storable]
-    private IObservableSet<T> set;
+    protected IObservableSet<T> set;
 
     #region Properties
-    public bool ReadOnlyView {
-      get { return true; }
-      set { }
-    }
-
     public int Count {
       get { return set.Count; }
@@ -134,5 +125,4 @@
 
     #region Events
-    [StorableHook(HookType.AfterDeserialization)]
     protected void RegisterEvents() {
       set.ItemsAdded += new CollectionItemsChangedEventHandler<T>(set_ItemsAdded);
@@ -140,9 +130,4 @@
       set.CollectionReset += new CollectionItemsChangedEventHandler<T>(set_CollectionReset);
       set.PropertyChanged += new PropertyChangedEventHandler(set_PropertyChanged);
-    }
-
-    event EventHandler IContent.ReadOnlyViewChanged {
-      add { }
-      remove { }
     }
 
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemArray.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemArray.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemArray.cs	(revision 3390)
@@ -0,0 +1,121 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text;
+using System.Drawing;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Common.Resources;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ItemArray<T>", "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 virtual Image ItemImage {
+      get { return VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private T[] Items {
+      get { return array; }
+      set { array = value; }
+    }
+
+    [Storable]
+    private bool readOnlyView;
+    public virtual bool ReadOnlyView {
+      get { return readOnlyView; }
+      set {
+        if ((readOnlyView != value) && !(array.IsReadOnly)) {
+          readOnlyView = value;
+          OnReadOnlyViewChanged();
+          OnPropertyChanged("ReadOnlyView");
+        }
+      }
+    }
+
+    public ItemArray()
+      : base() {
+      readOnlyView = array.IsReadOnly;
+    }
+    public ItemArray(int length)
+      : base(length) {
+      readOnlyView = array.IsReadOnly;
+    }
+    public ItemArray(T[] array)
+      : base(array) {
+      readOnlyView = array.IsReadOnly;
+    }
+    public ItemArray(IEnumerable<T> collection)
+      : base(collection) {
+      readOnlyView = array.IsReadOnly;
+    }
+    [StorableConstructor]
+    protected ItemArray(bool deserializing) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      ItemArray<T> clone = (ItemArray<T>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.readOnlyView = readOnlyView;
+      clone.array = this.Select(x => (T)cloner.Clone(x)).ToArray();
+      return clone;
+    }
+
+    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);
+    }
+    public event EventHandler ReadOnlyViewChanged;
+    protected virtual void OnReadOnlyViewChanged() {
+      EventHandler handler = ReadOnlyViewChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemCollection.cs	(revision 3390)
@@ -0,0 +1,114 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Common.Resources;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ItemCollection<T>", "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 virtual Image ItemImage {
+      get { return VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private List<T> Items {
+      get { return list; }
+      set { list = value; }
+    }
+
+    [Storable]
+    private bool readOnlyView;
+    public virtual bool ReadOnlyView {
+      get { return readOnlyView; }
+      set {
+        if ((readOnlyView != value) && !((ICollection<T>)list).IsReadOnly) {
+          readOnlyView = value;
+          OnReadOnlyViewChanged();
+          OnPropertyChanged("ReadOnlyView");
+        }
+      }
+    }
+
+    public ItemCollection()
+      : base() {
+      readOnlyView = ((ICollection<T>)list).IsReadOnly;
+    }
+    public ItemCollection(int capacity)
+      : base(capacity) {
+      readOnlyView = ((ICollection<T>)list).IsReadOnly;
+    }
+    public ItemCollection(IEnumerable<T> collection)
+      : base(collection) {
+      readOnlyView = ((ICollection<T>)list).IsReadOnly;
+    }
+    [StorableConstructor]
+    protected ItemCollection(bool deserializing) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      ItemCollection<T> clone = (ItemCollection<T>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.readOnlyView = readOnlyView;
+      clone.list = new List<T>(this.Select(x => (T)cloner.Clone(x)));
+      return clone;
+    }
+
+    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);
+    }
+    public event EventHandler ReadOnlyViewChanged;
+    protected virtual void OnReadOnlyViewChanged() {
+      EventHandler handler = ReadOnlyViewChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemDictionary.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemDictionary.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemDictionary.cs	(revision 3390)
@@ -0,0 +1,115 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Common.Resources;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ItemDictionary<TKey, TValue>", "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 virtual Image ItemImage {
+      get { return VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private Dictionary<TKey, TValue> Items {
+      get { return dict; }
+      set { dict = value; }
+    }
+
+    [Storable]
+    private bool readOnlyView;
+    public virtual bool ReadOnlyView {
+      get { return readOnlyView; }
+      set {
+        if ((readOnlyView != value) && !((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly) {
+          readOnlyView = value;
+          OnReadOnlyViewChanged();
+          OnPropertyChanged("ReadOnlyView");
+        }
+      }
+    }
+
+    public ItemDictionary()
+      : base() {
+      readOnlyView = ((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly;
+    }
+    public ItemDictionary(int capacity)
+      : base(capacity) {
+      readOnlyView = ((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly;
+    }
+    public ItemDictionary(IDictionary<TKey, TValue> dictionary)
+      : base(dictionary) {
+      readOnlyView = ((ICollection<KeyValuePair<TKey, TValue>>)dict).IsReadOnly;
+    }
+    [StorableConstructor]
+    protected ItemDictionary(bool deserializing) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      ItemDictionary<TKey, TValue> clone = (ItemDictionary<TKey, TValue>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.readOnlyView = readOnlyView;
+      foreach (TKey key in dict.Keys)
+        clone.dict.Add((TKey)cloner.Clone(key), (TValue)cloner.Clone(dict[key]));
+      return clone;
+    }
+
+    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);
+    }
+    public event EventHandler ReadOnlyViewChanged;
+    protected virtual void OnReadOnlyViewChanged() {
+      EventHandler handler = ReadOnlyViewChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemList.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemList.cs	(revision 3390)
@@ -0,0 +1,117 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text;
+using System.Drawing;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Common.Resources;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ItemList<T>", "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 virtual Image ItemImage {
+      get { return VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private List<T> Items {
+      get { return list; }
+      set { list = value; }
+    }
+
+    [Storable]
+    private bool readOnlyView;
+    public virtual bool ReadOnlyView {
+      get { return readOnlyView; }
+      set {
+        if ((readOnlyView != value) && !((ICollection<T>)list).IsReadOnly) {
+          readOnlyView = value;
+          OnReadOnlyViewChanged();
+          OnPropertyChanged("ReadOnlyView");
+        }
+      }
+    }
+
+    public ItemList()
+      : base() {
+      readOnlyView = ((ICollection<T>)list).IsReadOnly;
+    }
+    public ItemList(int capacity)
+      : base(capacity) {
+      readOnlyView = ((ICollection<T>)list).IsReadOnly;
+    }
+    public ItemList(IEnumerable<T> collection)
+      : base(collection) {
+      readOnlyView = ((ICollection<T>)list).IsReadOnly;
+    }
+    [StorableConstructor]
+    protected ItemList(bool deserializing) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      ItemList<T> clone = (ItemList<T>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.readOnlyView = readOnlyView;
+      clone.list = new List<T>(this.Select(x => (T)cloner.Clone(x)));
+      return clone;
+    }
+
+    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);
+    }
+    public event EventHandler ReadOnlyViewChanged;
+    protected virtual void OnReadOnlyViewChanged() {
+      EventHandler handler = ReadOnlyViewChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemSet.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemSet.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ItemSet.cs	(revision 3390)
@@ -0,0 +1,113 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text;
+using System.Drawing;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Common.Resources;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ItemSet<T>", "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 virtual Image ItemImage {
+      get { return VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private HashSet<T> Items {
+      get { return set; }
+      set { set = value; }
+    }
+
+    [Storable]
+    private bool readOnlyView;
+    public virtual bool ReadOnlyView {
+      get { return readOnlyView; }
+      set {
+        if ((readOnlyView != value) && !((ICollection<T>)set).IsReadOnly) {
+          readOnlyView = value;
+          OnReadOnlyViewChanged();
+          OnPropertyChanged("ReadOnlyView");
+        }
+      }
+    }
+
+    public ItemSet()
+      : base() {
+      readOnlyView = ((ICollection<T>)set).IsReadOnly;
+    }
+    public ItemSet(IEnumerable<T> collection)
+      : base(collection) {
+      readOnlyView = ((ICollection<T>)set).IsReadOnly;
+    }
+    [StorableConstructor]
+    protected ItemSet(bool deserializing) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      ItemSet<T> clone = (ItemSet<T>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.readOnlyView = readOnlyView;
+      clone.set = new HashSet<T>(this.Select(x => (T)cloner.Clone(x)));
+      return clone;
+    }
+
+    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);
+    }
+    public event EventHandler ReadOnlyViewChanged;
+    protected virtual void OnReadOnlyViewChanged() {
+      EventHandler handler = ReadOnlyViewChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/KeyedItemCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/KeyedItemCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/KeyedItemCollection.cs	(revision 3390)
@@ -0,0 +1,113 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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 {
+  [Item("KeyedItemCollection<TKey, TItem>", "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 virtual Image ItemImage {
+      get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private Dictionary<TKey, TItem> Items {
+      get { return dict; }
+      set { dict = value; }
+    }
+
+    [Storable]
+    private bool readOnlyView;
+    public virtual bool ReadOnlyView {
+      get { return readOnlyView; }
+      set {
+        if ((readOnlyView != value) && !((ICollection<KeyValuePair<TKey, TItem>>)dict).IsReadOnly) {
+          readOnlyView = value;
+          OnReadOnlyViewChanged();
+          OnPropertyChanged("ReadOnlyView");
+        }
+      }
+    }
+
+    protected KeyedItemCollection() : base() {
+      readOnlyView = ((ICollection<KeyValuePair<TKey, TItem>>)dict).IsReadOnly;
+    }
+    protected KeyedItemCollection(int capacity) : base(capacity) {
+      readOnlyView = ((ICollection<KeyValuePair<TKey, TItem>>)dict).IsReadOnly;
+    }
+    protected KeyedItemCollection(IEnumerable<TItem> collection) : base(collection) {
+      readOnlyView = ((ICollection<KeyValuePair<TKey, TItem>>)dict).IsReadOnly;
+    }
+    [StorableConstructor]
+    protected KeyedItemCollection(bool deserializing) { }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      KeyedItemCollection<TKey, TItem> clone = (KeyedItemCollection<TKey, TItem>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.readOnlyView = readOnlyView;
+      foreach (TItem item in dict.Values) {
+        TItem clonedItem = (TItem)cloner.Clone(item);
+        clone.dict.Add(GetKeyForItem(clonedItem), clonedItem);
+      }
+      return clone;
+    }
+
+    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);
+    }
+    public event EventHandler ReadOnlyViewChanged;
+    protected virtual void OnReadOnlyViewChanged() {
+      EventHandler handler = ReadOnlyViewChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/NamedItemCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/NamedItemCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/NamedItemCollection.cs	(revision 3390)
@@ -0,0 +1,102 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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 {
+  [Item("NamedItemCollection<T>", "Represents a collection of named items.")]
+  [StorableClass]
+  public class NamedItemCollection<T> : KeyedItemCollection<string, T> where T : class, INamedItem {
+    public NamedItemCollection() : base() { }
+    public NamedItemCollection(int capacity) : base(capacity) { }
+    public NamedItemCollection(IEnumerable<T> collection) : base(collection) {
+      Initialize();
+    }
+    [StorableConstructor]
+    protected NamedItemCollection(bool deserializing) { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    protected void Initialize() {
+      RegisterItemEvents(this);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      NamedItemCollection<T> clone = (NamedItemCollection<T>)base.Clone(cloner);
+      clone.Initialize();
+      return clone;
+    }
+
+    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);
+    }
+
+    private 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: /trunk/sources/HeuristicLab.Core/3.3/Collections/OperationCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/OperationCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/OperationCollection.cs	(revision 3390)
@@ -0,0 +1,116 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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 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; }
+    }
+
+    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;
+    }
+    [StorableConstructor]
+    private OperationCollection(bool deserializing) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      OperationCollection clone = (OperationCollection)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.operations = new List<IOperation>(this.Select(x => (IOperation)cloner.Clone(x)));
+      clone.parallel = parallel;
+      return clone;
+    }
+
+    #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: /trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorCollection.cs	(revision 3390)
@@ -0,0 +1,40 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text;
+using System.Drawing;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Creatable("Algorithm Design")]
+  [Item("Operator Collection", "Represents a collection of operators.")]
+  public class OperatorCollection : ItemCollection<IOperator> {
+    public OperatorCollection() : base() { }
+    public OperatorCollection(IEnumerable<IOperator> collection) : base(collection) { }
+    [StorableConstructor]
+    protected OperatorCollection(bool deserializing) : base(deserializing) { }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorList.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorList.cs	(revision 3390)
@@ -0,0 +1,40 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text;
+using System.Drawing;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("OperatorList", "Represents a list of operators.")]
+  public class OperatorList : ItemList<IOperator> {
+    public OperatorList() : base() { }
+    public OperatorList(int capacity) : base(capacity) { }
+    public OperatorList(IEnumerable<IOperator> collection) : base(collection) { }
+    [StorableConstructor]
+    protected OperatorList(bool deserializing) : base(deserializing) { }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorSet.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorSet.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/OperatorSet.cs	(revision 3390)
@@ -0,0 +1,39 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text;
+using System.Drawing;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("OperatorSet", "Represents a set of operators.")]
+  public class OperatorSet : ItemSet<IOperator> {
+    public OperatorSet() : base() { }
+    public OperatorSet(IEnumerable<IOperator> collection) : base(collection) { }
+    [StorableConstructor]
+    protected OperatorSet(bool deserializing) : base(deserializing) { }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ParameterCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ParameterCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ParameterCollection.cs	(revision 3390)
@@ -0,0 +1,35 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ParameterCollection", "Represents a collection of parameters.")]
+  public class ParameterCollection : NamedItemCollection<IParameter> {
+    public ParameterCollection() : base() { }
+    public ParameterCollection(int capacity) : base(capacity) { }
+    public ParameterCollection(IEnumerable<IParameter> collection) : base(collection) { }
+    [StorableConstructor]
+    protected ParameterCollection(bool deserializing) : base(deserializing) { }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemArray.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemArray.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemArray.cs	(revision 3390)
@@ -0,0 +1,96 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Common.Resources;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyItemArray<T>", "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 virtual Image ItemImage {
+      get { return VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private IObservableArray<T> Items {
+      get { return array; }
+      set { array = value; }
+    }
+
+    public bool ReadOnlyView {
+      get { return true; }
+      set { }
+    }
+
+    public ReadOnlyItemArray() : base(new ItemArray<T>()) { }
+    public ReadOnlyItemArray(IItemArray<T> array) : base(array) { }
+    [StorableConstructor]
+    protected ReadOnlyItemArray(bool deserializing) { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      RegisterEvents();
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      ReadOnlyItemArray<T> clone = (ReadOnlyItemArray<T>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.array = (IItemArray<T>)((IItemArray<T>)array).Clone(cloner);
+      clone.Initialize();
+      return clone;
+    }
+
+    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);
+    }
+    event EventHandler IContent.ReadOnlyViewChanged {
+      add { }
+      remove { }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemCollection.cs	(revision 3390)
@@ -0,0 +1,96 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Common.Resources;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyItemCollection<T>", "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 virtual Image ItemImage {
+      get { return VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private IObservableCollection<T> Items {
+      get { return collection; }
+      set { collection = value; }
+    }
+
+    public bool ReadOnlyView {
+      get { return true; }
+      set { }
+    }
+
+    public ReadOnlyItemCollection() : base(new ItemCollection<T>()) { }
+    public ReadOnlyItemCollection(IItemCollection<T> collection) : base(collection) { }
+    [StorableConstructor]
+    protected ReadOnlyItemCollection(bool deserializing) { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      RegisterEvents();
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      ReadOnlyItemCollection<T> clone = (ReadOnlyItemCollection<T>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.collection = (IItemCollection<T>)((IItemCollection<T>)collection).Clone(cloner);
+      clone.Initialize();
+      return clone;
+    }
+
+    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);
+    }
+    event EventHandler IContent.ReadOnlyViewChanged {
+      add { }
+      remove { }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemDictionary.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemDictionary.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemDictionary.cs	(revision 3390)
@@ -0,0 +1,96 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Common.Resources;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyItemDictionary<TKey, TValue>", "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 virtual Image ItemImage {
+      get { return VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private IObservableDictionary<TKey, TValue> Items {
+      get { return dict; }
+      set { dict = value; }
+    }
+
+    public bool ReadOnlyView {
+      get { return true; }
+      set { }
+    }
+
+    public ReadOnlyItemDictionary() : base(new ItemDictionary<TKey, TValue>()) { }
+    public ReadOnlyItemDictionary(IItemDictionary<TKey, TValue> dictionary) : base(dictionary) { }
+    [StorableConstructor]
+    protected ReadOnlyItemDictionary(bool deserializing) { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      RegisterEvents();
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      ReadOnlyItemDictionary<TKey, TValue> clone = (ReadOnlyItemDictionary<TKey, TValue>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.dict = (IItemDictionary<TKey, TValue>)((IItemDictionary<TKey, TValue>)dict).Clone(cloner);
+      clone.Initialize();
+      return clone;
+    }
+
+    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);
+    }
+    event EventHandler IContent.ReadOnlyViewChanged {
+      add { }
+      remove { }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemList.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemList.cs	(revision 3390)
@@ -0,0 +1,96 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Common.Resources;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyItemList<T>", "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 virtual Image ItemImage {
+      get { return VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private IObservableList<T> Items {
+      get { return list; }
+      set { list = value; }
+    }
+
+    public bool ReadOnlyView {
+      get { return true; }
+      set { }
+    }
+
+    public ReadOnlyItemList() : base(new ItemList<T>()) { }
+    public ReadOnlyItemList(IItemList<T> list) : base(list) { }
+    [StorableConstructor]
+    protected ReadOnlyItemList(bool deserializing) { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      RegisterEvents();
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      ReadOnlyItemList<T> clone = (ReadOnlyItemList<T>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.list = (IItemList<T>)((IItemList<T>)list).Clone(cloner);
+      clone.Initialize();
+      return clone;
+    }
+
+    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);
+    }
+    event EventHandler IContent.ReadOnlyViewChanged {
+      add { }
+      remove { }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemSet.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemSet.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyItemSet.cs	(revision 3390)
@@ -0,0 +1,96 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Common.Resources;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyItemSet<T>", "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 virtual Image ItemImage {
+      get { return VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private IObservableSet<T> Items {
+      get { return set; }
+      set { set = value; }
+    }
+
+    public bool ReadOnlyView {
+      get { return true; }
+      set { }
+    }
+
+    public ReadOnlyItemSet() : base(new ItemSet<T>()) { }
+    public ReadOnlyItemSet(IItemSet<T> set) : base(set) { }
+    [StorableConstructor]
+    protected ReadOnlyItemSet(bool deserializing) { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      RegisterEvents();
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      ReadOnlyItemSet<T> clone = (ReadOnlyItemSet<T>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.set = (IItemSet<T>)((IItemSet<T>)set).Clone(cloner);
+      clone.Initialize();
+      return clone;
+    }
+
+    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);
+    }
+    event EventHandler IContent.ReadOnlyViewChanged {
+      add { }
+      remove { }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyKeyedItemCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyKeyedItemCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ReadOnlyKeyedItemCollection.cs	(revision 3390)
@@ -0,0 +1,96 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Common.Resources;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ReadOnlyKeyedItemCollection<TKey, TItem>", "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 virtual Image ItemImage {
+      get { return VS2008ImageLibrary.Class; }
+    }
+
+    [Storable]
+    private IObservableKeyedCollection<TKey, TItem> Items {
+      get { return collection; }
+      set { collection = value; }
+    }
+
+    public bool ReadOnlyView {
+      get { return true; }
+      set { }
+    }
+
+    protected ReadOnlyKeyedItemCollection() : base() { }
+    public ReadOnlyKeyedItemCollection(IKeyedItemCollection<TKey, TItem> collection) : base(collection) { }
+    [StorableConstructor]
+    protected ReadOnlyKeyedItemCollection(bool deserializing) { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      RegisterEvents();
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      ReadOnlyKeyedItemCollection<TKey, TItem> clone = (ReadOnlyKeyedItemCollection<TKey, TItem>)Activator.CreateInstance(this.GetType());
+      cloner.RegisterClonedObject(this, clone);
+      clone.collection = (IKeyedItemCollection<TKey, TItem>)((IKeyedItemCollection<TKey, TItem>)collection).Clone(cloner);
+      clone.Initialize();
+      return clone;
+    }
+
+    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);
+    }
+    event EventHandler IContent.ReadOnlyViewChanged {
+      add { }
+      remove { }
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ScopeList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ScopeList.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ScopeList.cs	(revision 3390)
@@ -0,0 +1,45 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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> {
+    public ScopeList() : base() { }
+    public ScopeList(int capacity) : base(capacity) { }
+    public ScopeList(IEnumerable<IScope> collection) : base(collection) { }
+    [StorableConstructor]
+    private ScopeList(bool deserializing) : base(deserializing) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      ScopeList clone = new ScopeList();
+      cloner.RegisterClonedObject(this, clone);
+      clone.ReadOnlyView = ReadOnlyView;
+      clone.list = new List<IScope>(this.Select(x => (IScope)cloner.Clone(x)));
+      return clone;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/ValueParameterCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/ValueParameterCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/ValueParameterCollection.cs	(revision 3390)
@@ -0,0 +1,35 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Core {
+  [StorableClass]
+  [Item("ValueParameterCollection", "Represents a collection of value parameters.")]
+  public class ValueParameterCollection : NamedItemCollection<IValueParameter> {
+    public ValueParameterCollection() : base() { }
+    public ValueParameterCollection(int capacity) : base(capacity) { }
+    public ValueParameterCollection(IEnumerable<IValueParameter> collection) : base(collection) { }
+    [StorableConstructor]
+    protected ValueParameterCollection(bool deserializing) : base(deserializing) { }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Collections/VariableCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Collections/VariableCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Collections/VariableCollection.cs	(revision 3390)
@@ -0,0 +1,47 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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("VariableCollection", "Represents a collection of variables.")]
+  public sealed class VariableCollection : NamedItemCollection<IVariable> {
+    public VariableCollection() : base() { }
+    public VariableCollection(int capacity) : base(capacity) { }
+    public VariableCollection(IEnumerable<IVariable> collection) : base(collection) { }
+    [StorableConstructor]
+    private VariableCollection(bool deserializing) : base(deserializing) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      VariableCollection clone = new VariableCollection();
+      cloner.RegisterClonedObject(this, clone);
+      clone.ReadOnlyView = ReadOnlyView;
+      foreach (string key in dict.Keys)
+        clone.dict.Add(key, (IVariable)cloner.Clone(dict[key]));
+      clone.Initialize();
+      return clone;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 3389)
+++ /trunk/sources/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 3390)
@@ -102,4 +102,31 @@
     <Compile Include="Attributes\CreatableAttribute.cs" />
     <None Include="HeuristicLabCorePlugin.cs.frame" />
+    <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="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" />
@@ -112,11 +139,8 @@
     <Compile Include="Interfaces\IExecutionContext.cs" />
     <Compile Include="Interfaces\IOperation.cs" />
-    <Compile Include="OperationCollection.cs" />
     <Compile Include="ParameterizedNamedItem.cs" />
-    <Compile Include="ValueParameterCollection.cs" />
     <Compile Include="Interfaces\IValueLookupParameter.cs" />
     <Compile Include="Interfaces\IValueParameter.cs" />
     <Compile Include="Interfaces\ILookupParameter.cs" />
-    <Compile Include="ItemArray.cs" />
     <Compile Include="Engine.cs" />
     <Compile Include="Interfaces\IScope.cs" />
@@ -126,18 +150,8 @@
     <Compile Include="OperatorGraph.cs" />
     <Compile Include="Interfaces\IParameter.cs" />
-    <Compile Include="OperatorCollection.cs" />
-    <Compile Include="ItemCollection.cs" />
-    <Compile Include="OperatorSet.cs" />
-    <Compile Include="ItemSet.cs" />
-    <Compile Include="ItemList.cs" />
     <Compile Include="Interfaces\IEngine.cs">
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="ExecutionContext.cs" />
-    <Compile Include="OperatorList.cs" />
-    <Compile Include="ParameterCollection.cs" />
-    <Compile Include="VariableCollection.cs" />
-    <Compile Include="ScopeList.cs" />
-    <Compile Include="NamedItemCollection.cs" />
     <Compile Include="Interfaces\INamedItem.cs" />
     <Compile Include="Interfaces\IItem.cs" />
Index: /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemArray.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemArray.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemArray.cs	(revision 3390)
@@ -0,0 +1,26 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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: /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemCollection.cs	(revision 3390)
@@ -0,0 +1,26 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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: /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemDictionary.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemDictionary.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemDictionary.cs	(revision 3390)
@@ -0,0 +1,27 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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 IItemDictionary<TKey, TValue> : IObservableDictionary<TKey, TValue>, IItem where TKey : class, IItem where TValue : class, IItem { }
+}
Index: /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemList.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemList.cs	(revision 3390)
@@ -0,0 +1,26 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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: /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemSet.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemSet.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IItemSet.cs	(revision 3390)
@@ -0,0 +1,26 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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: /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IKeyedItemCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IKeyedItemCollection.cs	(revision 3390)
+++ /trunk/sources/HeuristicLab.Core/3.3/Interfaces/IKeyedItemCollection.cs	(revision 3390)
@@ -0,0 +1,26 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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: unk/sources/HeuristicLab.Core/3.3/ItemArray.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/ItemArray.cs	(revision 3389)
+++ 	(revision )
@@ -1,80 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Linq;
-using System.Collections;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Text;
-using System.Drawing;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Common.Resources;
-using HeuristicLab.Collections;
-
-namespace HeuristicLab.Core {
-  [StorableClass]
-  [Item("ItemArray<T>", "Represents an array of items.")]
-  public class ItemArray<T> : ObservableArray<T>, IItem 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 virtual Image ItemImage {
-      get { return VS2008ImageLibrary.Class; }
-    }
-
-    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) {
-      ItemArray<T> clone = (ItemArray<T>)Activator.CreateInstance(this.GetType());
-      cloner.RegisterClonedObject(this, clone);
-      clone.ReadOnlyView = ReadOnlyView;
-      clone.array = this.Select(x => (T)cloner.Clone(x)).ToArray();
-      return clone;
-    }
-
-    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: unk/sources/HeuristicLab.Core/3.3/ItemCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/ItemCollection.cs	(revision 3389)
+++ 	(revision )
@@ -1,76 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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.Common.Resources;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Core {
-  [StorableClass]
-  [Item("ItemCollection<T>", "Represents a collection of items.")]
-  public class ItemCollection<T> : ObservableCollection<T>, IItem 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 virtual Image ItemImage {
-      get { return VS2008ImageLibrary.Class; }
-    }
-
-    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) {
-      ItemCollection<T> clone = (ItemCollection<T>)Activator.CreateInstance(this.GetType());
-      cloner.RegisterClonedObject(this, clone);
-      clone.ReadOnlyView = ReadOnlyView;
-      clone.list = new List<T>(this.Select(x => (T)cloner.Clone(x)));
-      return clone;
-    }
-
-    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: unk/sources/HeuristicLab.Core/3.3/ItemList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/ItemList.cs	(revision 3389)
+++ 	(revision )
@@ -1,79 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Linq;
-using System.Collections;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Text;
-using System.Drawing;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Common.Resources;
-using HeuristicLab.Collections;
-
-namespace HeuristicLab.Core {
-  [StorableClass]
-  [Item("ItemList<T>", "Represents a list of items.")]
-  public class ItemList<T> : ObservableList<T>, IItem 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 virtual Image ItemImage {
-      get { return VS2008ImageLibrary.Class; }
-    }
-
-    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) {
-      ItemList<T> clone = (ItemList<T>)Activator.CreateInstance(this.GetType());
-      cloner.RegisterClonedObject(this, clone);
-      clone.ReadOnlyView = ReadOnlyView;
-      clone.list = new List<T>(this.Select(x => (T)cloner.Clone(x)));
-      return clone;
-    }
-
-    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: unk/sources/HeuristicLab.Core/3.3/ItemSet.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/ItemSet.cs	(revision 3389)
+++ 	(revision )
@@ -1,78 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Linq;
-using System.Collections;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Text;
-using System.Drawing;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Common.Resources;
-using HeuristicLab.Collections;
-
-namespace HeuristicLab.Core {
-  [StorableClass]
-  [Item("ItemSet<T>", "Represents a set of items.")]
-  public class ItemSet<T> : ObservableSet<T>, IItem 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 virtual Image ItemImage {
-      get { return VS2008ImageLibrary.Class; }
-    }
-
-    public ItemSet() : base() { }
-    public ItemSet(IEnumerable<T> collection) : base(collection) { }
-
-    public object Clone() {
-      return Clone(new Cloner());
-    }
-
-    public virtual IDeepCloneable Clone(Cloner cloner) {
-      ItemSet<T> clone = (ItemSet<T>)Activator.CreateInstance(this.GetType());
-      cloner.RegisterClonedObject(this, clone);
-      clone.ReadOnlyView = ReadOnlyView;
-      clone.set = new HashSet<T>(this.Select(x => (T)cloner.Clone(x)));
-      return clone;
-    }
-
-    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: unk/sources/HeuristicLab.Core/3.3/NamedItemCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/NamedItemCollection.cs	(revision 3389)
+++ 	(revision )
@@ -1,132 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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 {
-  [Item("NamedItemCollection<T>", "Represents a collection of named items.")]
-  [StorableClass]
-  public class NamedItemCollection<T> : ObservableKeyedCollection<string, T>, IItem where T : class, INamedItem {
-    public virtual string ItemName {
-      get { return ItemAttribute.GetName(this.GetType()); }
-    }
-    public virtual string ItemDescription {
-      get { return ItemAttribute.GetDescription(this.GetType()); }
-    }
-    public virtual Image ItemImage {
-      get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Class; }
-    }
-
-    public NamedItemCollection() : base() { }
-    public NamedItemCollection(int capacity) : base(capacity) { }
-    public NamedItemCollection(IEnumerable<T> collection) : base(collection) {
-      Initialize();
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    protected void Initialize() {
-      RegisterItemEvents(this);
-    }
-
-    public object Clone() {
-      return Clone(new Cloner());
-    }
-    public virtual IDeepCloneable Clone(Cloner cloner) {
-      NamedItemCollection<T> clone = (NamedItemCollection<T>)Activator.CreateInstance(this.GetType());
-      cloner.RegisterClonedObject(this, clone);
-      clone.ReadOnlyView = ReadOnlyView;
-      foreach (string key in dict.Keys)
-        clone.dict.Add(key, (T)cloner.Clone(dict[key]));
-      clone.Initialize();
-      return clone;
-    }
-
-    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);
-    }
-
-    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);
-    }
-
-    private 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: unk/sources/HeuristicLab.Core/3.3/OperationCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/OperationCollection.cs	(revision 3389)
+++ 	(revision )
@@ -1,114 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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 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; }
-    }
-
-    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) {
-      OperationCollection clone = (OperationCollection)Activator.CreateInstance(this.GetType());
-      cloner.RegisterClonedObject(this, clone);
-      clone.operations = new List<IOperation>(this.Select(x => (IOperation)cloner.Clone(x)));
-      clone.parallel = parallel;
-      return clone;
-    }
-
-    #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: unk/sources/HeuristicLab.Core/3.3/OperatorCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/OperatorCollection.cs	(revision 3389)
+++ 	(revision )
@@ -1,38 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Text;
-using System.Drawing;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Core {
-  [StorableClass]
-  [Creatable("Algorithm Design")]
-  [Item("Operator Collection", "Represents a collection of operators.")]
-  public class OperatorCollection : ItemCollection<IOperator> {
-    public OperatorCollection() : base() { }
-    public OperatorCollection(IEnumerable<IOperator> collection) : base(collection) { }
-  }
-}
Index: unk/sources/HeuristicLab.Core/3.3/OperatorList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/OperatorList.cs	(revision 3389)
+++ 	(revision )
@@ -1,38 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Text;
-using System.Drawing;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Core {
-  [StorableClass]
-  [Item("OperatorList", "Represents a list of operators.")]
-  public class OperatorList : ItemList<IOperator> {
-    public OperatorList() : base() { }
-    public OperatorList(int capacity) : base(capacity) { }
-    public OperatorList(IEnumerable<IOperator> collection) : base(collection) { }
-  }
-}
Index: unk/sources/HeuristicLab.Core/3.3/OperatorSet.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/OperatorSet.cs	(revision 3389)
+++ 	(revision )
@@ -1,37 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Text;
-using System.Drawing;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Core {
-  [StorableClass]
-  [Item("OperatorSet", "Represents a set of operators.")]
-  public class OperatorSet : ItemSet<IOperator> {
-    public OperatorSet() : base() { }
-    public OperatorSet(IEnumerable<IOperator> collection) : base(collection) { }
-  }
-}
Index: unk/sources/HeuristicLab.Core/3.3/ParameterCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/ParameterCollection.cs	(revision 3389)
+++ 	(revision )
@@ -1,33 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Core {
-  [StorableClass]
-  [Item("ParameterCollection", "Represents a collection of parameters.")]
-  public class ParameterCollection : NamedItemCollection<IParameter> {
-    public ParameterCollection() : base() { }
-    public ParameterCollection(int capacity) : base(capacity) { }
-    public ParameterCollection(IEnumerable<IParameter> collection) : base(collection) { }
-  }
-}
Index: unk/sources/HeuristicLab.Core/3.3/ScopeList.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/ScopeList.cs	(revision 3389)
+++ 	(revision )
@@ -1,43 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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> {
-    public ScopeList() : base() { }
-    public ScopeList(int capacity) : base(capacity) { }
-    public ScopeList(IEnumerable<IScope> collection) : base(collection) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      ScopeList clone = new ScopeList();
-      cloner.RegisterClonedObject(this, clone);
-      clone.ReadOnlyView = ReadOnlyView;
-      clone.list = new List<IScope>(this.Select(x => (IScope)cloner.Clone(x)));
-      return clone;
-    }
-  }
-}
Index: unk/sources/HeuristicLab.Core/3.3/ValueParameterCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/ValueParameterCollection.cs	(revision 3389)
+++ 	(revision )
@@ -1,33 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Core {
-  [StorableClass]
-  [Item("ValueParameterCollection", "Represents a collection of value parameters.")]
-  public class ValueParameterCollection : NamedItemCollection<IValueParameter> {
-    public ValueParameterCollection() : base() { }
-    public ValueParameterCollection(int capacity) : base(capacity) { }
-    public ValueParameterCollection(IEnumerable<IValueParameter> collection) : base(collection) { }
-  }
-}
Index: unk/sources/HeuristicLab.Core/3.3/VariableCollection.cs
===================================================================
--- /trunk/sources/HeuristicLab.Core/3.3/VariableCollection.cs	(revision 3389)
+++ 	(revision )
@@ -1,45 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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("VariableCollection", "Represents a collection of variables.")]
-  public sealed class VariableCollection : NamedItemCollection<IVariable> {
-    public VariableCollection() : base() { }
-    public VariableCollection(int capacity) : base(capacity) { }
-    public VariableCollection(IEnumerable<IVariable> collection) : base(collection) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      VariableCollection clone = new VariableCollection();
-      cloner.RegisterClonedObject(this, clone);
-      clone.ReadOnlyView = ReadOnlyView;
-      foreach (string key in dict.Keys)
-        clone.dict.Add(key, (IVariable)cloner.Clone(dict[key]));
-      clone.Initialize();
-      return clone;
-    }
-  }
-}
