Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs	(revision 9226)
@@ -29,5 +29,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.VariableVector.Covering {
+namespace HeuristicLab.Encodings.VariableVector {
   [Item("VariableVectorCoveringCreator", "Description missing")]
   [StorableClass]
@@ -63,10 +63,10 @@
     private IEnumerable<IVariable> CoverInput(VariableVectorInput input, VariableVectorCondition sample, IRandom random, double changeSymbolProbability) {
       var conditionVariables = new List<IVariable>();
-      if (!input.Order.SequenceEqual(sample.Order)) {
-        throw new ArgumentException("Sample and input do not contain the same variable names");
+      if (!sample.Keys.All(x => input.ContainsKey(x))) {
+        throw new ArgumentException("Input does not contain all variable names from sample");
       }
       foreach (var keyValuePair in sample) {
         IVariable variable = keyValuePair.Value.GetEmptyCopy();
-        variable.Cover(random, input[keyValuePair.Key].Value, changeSymbolProbability);
+        variable.Cover(random, input[keyValuePair.Key], changeSymbolProbability);
         conditionVariables.Add(variable);
       }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Creators/UniformRandomVariableVectorCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Creators/UniformRandomVariableVectorCreator.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Creators/UniformRandomVariableVectorCreator.cs	(revision 9226)
@@ -20,10 +20,9 @@
 #endregion
 
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.VariableVector.Creators {
+namespace HeuristicLab.Encodings.VariableVector {
   [Item("UniformRandomVariableVectorCreator", "Description missing")]
   [StorableClass]
@@ -46,5 +45,5 @@
 
     protected override VariableVector Create(IRandom random, VariableVector sampleVariableVector, double spreadPercentage) {
-      var result = new VariableVector(sampleVariableVector.Condition.Values.Select(x => x.GetEmptyCopy()), sampleVariableVector.Action.Values.Select(x => x.GetEmptyCopy()));
+      var result = sampleVariableVector.GetEmptyCopy();
       result.Randomize(random, spreadPercentage);
       return result;
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs	(revision 9226)
@@ -27,5 +27,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.VariableVector.Crossover {
+namespace HeuristicLab.Encodings.VariableVector {
   [Item("SinglePointCrossover", "Description missing")]
   [StorableClass]
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj	(revision 9226)
@@ -44,4 +44,5 @@
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
     </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.Data-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
@@ -64,4 +65,5 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
@@ -79,4 +81,5 @@
     <Compile Include="Manipulator\UniformOnePositionInConditionManipulator.cs" />
     <Compile Include="Manipulator\UniformSomePositionManipulator.cs" />
+    <Compile Include="VariableVectorActionComparer.cs" />
     <Compile Include="VariableVectorCrossover.cs" />
     <Compile Include="VariableVectorManipulator.cs" />
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9226)
@@ -56,9 +56,10 @@
       var keyEnumerator = condition.Order.GetEnumerator();
       int count = 0;
-      while (keyEnumerator.MoveNext() && count < condition.VirtualLength
-        && count < index && count + condition[keyEnumerator.Current].VirtualLength < index) {
+      keyEnumerator.MoveNext();
+      while (count < condition.VirtualLength && count < index && count + condition[keyEnumerator.Current].VirtualLength <= index) {
         count += condition[keyEnumerator.Current].VirtualLength;
+        keyEnumerator.MoveNext();
       }
-      condition[keyEnumerator.Current].Manipulate(random, input[keyEnumerator.Current].Value, index - count - 1);
+      condition[keyEnumerator.Current].Manipulate(random, input[keyEnumerator.Current], index - count);
       return child;
     }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Plugin.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Plugin.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Plugin.cs	(revision 9226)
@@ -23,5 +23,5 @@
 
 namespace HeuristicLab.Encodings.VariableVector {
-  [Plugin("HeuristicLab.Encodings.VariableVector", "3.3.7.9194")]
+  [Plugin("HeuristicLab.Encodings.VariableVector", "3.3.7.9204")]
   [PluginFile("HeuristicLab.Encodings.VariableVector-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Properties/AssemblyInfo.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Properties/AssemblyInfo.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Properties/AssemblyInfo.cs	(revision 9226)
@@ -55,3 +55,3 @@
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.7.9194")]
+[assembly: AssemblyFileVersion("3.3.7.9204")]
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs	(revision 9226)
@@ -100,9 +100,9 @@
     }
 
-    public new DoubleVariable GetEmptyCopy() {
+    public override IVariable GetEmptyCopy() {
       return new DoubleVariable(variableName, min, max);
     }
-    public new DoubleVariable GetSetCopy() {
-      DoubleVariable copy = GetEmptyCopy();
+    public override IVariable GetSetCopy() {
+      DoubleVariable copy = (DoubleVariable)GetEmptyCopy();
       copy.CurrentCenter = this.CurrentCenter;
       copy.CurrentSpread = this.CurrentSpread;
@@ -153,5 +153,5 @@
       if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
       if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
-      DoubleVariable crossed = this.GetSetCopy();
+      DoubleVariable crossed = (DoubleVariable)this.GetSetCopy();
       if (pos == 0) {
         crossed.CurrentSpread = parent2Cast.CurrentSpread;
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IActionVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IActionVariable.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IActionVariable.cs	(revision 9226)
@@ -20,8 +20,14 @@
 #endregion
 
+using System.Collections.Generic;
 
 namespace HeuristicLab.Encodings.VariableVector {
   // variables which can be used in the action
   public interface IActionVariable : IVariable {
+    new IActionVariable GetEmptyCopy();
+    new IActionVariable GetSetCopy();
+
+    void SetTo(string value);
+    IEnumerable<string> GetAllPossibleActions();
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs	(revision 9226)
@@ -31,4 +31,5 @@
     IVariable GetEmptyCopy();
     IVariable GetSetCopy();
+
     void Randomize(IRandom random);
     bool MatchInput(string target);
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs	(revision 9226)
@@ -63,4 +63,5 @@
       this.possibleFeatures = new List<int>(original.possibleFeatures);
       this.Wildcard = original.Wildcard;
+      this.currentValue = original.currentValue;
     }
     public IntVariable()
@@ -70,9 +71,10 @@
     public IntVariable(string variableName, IEnumerable<int> variableValues)
       : base(variableName) {
-      if (variableValues.Count() != variableValues.Distinct().Count()) {
-        throw new ArgumentException("variableValues have to be distinct.");
+      if (variableValues.Count() > 0 && variableValues.Count() != variableValues.Distinct().Count()) {
+        throw new ArgumentException("variableValues have to be distinct and there has to be at least one value.");
       }
       possibleFeatures = variableValues;
       Wildcard = false;
+      currentValue = possibleFeatures.First();
     }
     public IntVariable(string variableName, IEnumerable<int> variableValues, int currentValue)
@@ -102,12 +104,20 @@
     }
 
-    public new IntVariable GetEmptyCopy() {
+    public override IVariable GetEmptyCopy() {
       return new IntVariable(variableName, possibleFeatures);
     }
-    public new IntVariable GetSetCopy() {
-      IntVariable copy = GetEmptyCopy();
+
+    public override IVariable GetSetCopy() {
+      IntVariable copy = (IntVariable)GetEmptyCopy();
       copy.Wildcard = this.Wildcard;
       copy.CurrentValue = this.CurrentValue;
       return copy;
+    }
+
+    IActionVariable IActionVariable.GetEmptyCopy() {
+      return (IntVariable)GetEmptyCopy();
+    }
+    IActionVariable IActionVariable.GetSetCopy() {
+      return (IntVariable)GetSetCopy();
     }
 
@@ -143,5 +153,5 @@
       if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
       if (pos != 0) { throw new ArgumentOutOfRangeException(); }
-      return this.GetSetCopy();
+      return (IntVariable)this.GetSetCopy();
     }
 
@@ -160,4 +170,25 @@
       }
     }
+
+    public override int GetHashCode() {
+      int result = 1;
+      int wildcardInt = Wildcard ? 1 : 0;
+      result = 37 * result + wildcardInt;
+      result = 37 * result + currentValue;
+      foreach (var feature in possibleFeatures) {
+        result = 37 * result + feature;
+      }
+      return result;
+    }
+
+    #region IActionVariable Members
+    public void SetTo(string value) {
+      currentValue = int.Parse(value);
+    }
+
+    public IEnumerable<string> GetAllPossibleActions() {
+      return possibleFeatures.Select(x => x.ToString());
+    }
+    #endregion
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs	(revision 9226)
@@ -74,4 +74,5 @@
       this.featureMapping = new Dictionary<int, string>(original.featureMapping);
       this.Wildcard = original.Wildcard;
+      this.currentValue = original.currentValue;
     }
     public StringVariable()
@@ -150,12 +151,18 @@
     }
 
-    public new StringVariable GetEmptyCopy() {
+    public override IVariable GetEmptyCopy() {
       return new StringVariable(variableName, featureMapping);
     }
-    public new StringVariable GetSetCopy() {
-      StringVariable copy = GetEmptyCopy();
+    public override IVariable GetSetCopy() {
+      StringVariable copy = (StringVariable)GetEmptyCopy();
       copy.Wildcard = this.Wildcard;
       copy.CurrentValue = this.CurrentValue;
       return copy;
+    }
+    IActionVariable IActionVariable.GetEmptyCopy() {
+      return (StringVariable)GetEmptyCopy();
+    }
+    IActionVariable IActionVariable.GetSetCopy() {
+      return (StringVariable)GetSetCopy();
     }
 
@@ -195,5 +202,5 @@
       if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
       if (pos != 0) { throw new ArgumentOutOfRangeException(); }
-      return this.GetSetCopy();
+      return (StringVariable)this.GetSetCopy();
     }
 
@@ -202,6 +209,5 @@
       Wildcard = !Wildcard;
       if (!Wildcard) {
-        int newValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
-        currentValue = newValue;
+        currentValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
       }
     }
@@ -210,8 +216,29 @@
       Wildcard = random.NextDouble() < changeSymbolProbability;
       if (!Wildcard) {
-        int newValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
-        currentValue = newValue;
-      }
-    }
+        currentValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
+      }
+    }
+
+    public override int GetHashCode() {
+      int result = 1;
+      int wildcardInt = Wildcard ? 1 : 0;
+      result = 37 * result + wildcardInt;
+      result = 37 * result + currentValue;
+      foreach (var feature in featureMapping) {
+        result = 37 * result + feature.Key;
+        result = 37 * result + feature.Value.GetHashCode();
+      }
+      return result;
+    }
+
+    #region IActionVariable Members
+    public void SetTo(string value) {
+      currentValue = featureMapping.First(x => x.Value.Equals(value)).Key;
+    }
+
+    public IEnumerable<string> GetAllPossibleActions() {
+      return featureMapping.Values;
+    }
+    #endregion
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs	(revision 9226)
@@ -52,6 +52,6 @@
     }
 
-    public virtual IVariable GetEmptyCopy() { throw new NotSupportedException("This method is not supported. It should be implemented by every non abstract class."); }
-    public virtual IVariable GetSetCopy() { throw new NotSupportedException("This method is not supported. It should be implemented by every non abstract class."); }
+    public abstract IVariable GetEmptyCopy();
+    public abstract IVariable GetSetCopy();
 
     public abstract void Randomize(IRandom random);
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs	(revision 9226)
@@ -54,6 +54,6 @@
     protected VariableVector(VariableVector original, Cloner cloner)
       : base(original, cloner) {
-      condition = new VariableVectorCondition(original.condition);
-      action = new VariableVectorAction(original.action);
+      condition = (VariableVectorCondition)original.condition.Clone();
+      action = (VariableVectorAction)original.action;
     }
     public VariableVector() {
@@ -64,5 +64,5 @@
       : this() {
       if (condition == null || action == null) { throw new ArgumentNullException(); }
-      if (action.All(x => x is IActionVariable)) { throw new ArgumentException("Action can only use IActionVariable"); }
+      if (!action.All(x => x is IActionVariable)) { throw new ArgumentException("Action can only use IActionVariable"); }
       this.Condition.Add(condition);
       this.Action.Add(action.Cast<IActionVariable>());
@@ -70,4 +70,8 @@
     public override IDeepCloneable Clone(Cloner cloner) {
       return new VariableVector(this, cloner);
+    }
+
+    public VariableVector GetEmptyCopy() {
+      return new VariableVector(Condition.Values.Select(x => x.GetEmptyCopy()), Action.Values.Select(x => x.GetEmptyCopy()));
     }
 
@@ -128,41 +132,7 @@
       var targetCast = target as VariableVector;
       if (targetCast == null) { return false; }
-      if (!condition.Identical(targetCast.condition)) { return false; }
-      if (!action.Identical(targetCast.condition)) { return false; }
+      if (!condition.Identical(targetCast.Condition)) { return false; }
+      if (!action.Identical(targetCast.Action)) { return false; }
       return true;
-    }
-
-    [StorableClass]
-    [Item("VariableVectorActionComparer", "")]
-    public class VariableVectorActionComparer : Item, IEqualityComparer<VariableVectorAction>, IClassifierComparer {
-
-      [StorableConstructor]
-      protected VariableVectorActionComparer(bool deserializing) : base(deserializing) { }
-      protected VariableVectorActionComparer(VariableVectorActionComparer original, Cloner cloner)
-        : base(original, cloner) {
-      }
-      public override IDeepCloneable Clone(Cloner cloner) {
-        return new VariableVectorActionComparer(this, cloner);
-      }
-      public VariableVectorActionComparer() : base() { }
-
-      public bool Equals(VariableVectorAction x, VariableVectorAction y) {
-        throw new NotImplementedException();
-      }
-
-      public int GetHashCode(VariableVectorAction obj) {
-        throw new NotImplementedException();
-      }
-
-      public bool Equals(IAction x, IAction y) {
-        var xCast = x as VariableVectorAction;
-        var yCast = y as VariableVectorAction;
-        return x != null && y != null && Equals(xCast, yCast);
-      }
-
-      public int GetHashCode(IAction obj) {
-        var objCast = obj as VariableVectorAction;
-        return objCast != null ? GetHashCode(objCast) : obj.GetHashCode();
-      }
     }
   }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs	(revision 9226)
@@ -22,9 +22,9 @@
 using System;
 using System.Collections.Generic;
+using System.Drawing;
 using System.Linq;
 using System.Text;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -33,29 +33,43 @@
   [StorableClass]
   [Item("VariableVectorAction", "")]
-  public class VariableVectorAction : ItemDictionary<StringValue, IActionVariable>, IAction {
+  public class VariableVectorAction : Dictionary<string, IActionVariable>, IAction {
 
-    public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
+    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
 
     public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
 
     [StorableConstructor]
-    protected VariableVectorAction(bool deserializing) : base(deserializing) { }
-    protected VariableVectorAction(VariableVectorAction original, Cloner cloner)
-      : base(original, cloner) {
+    protected VariableVectorAction(bool deserializing) { }
+    protected VariableVectorAction(VariableVectorAction original, Cloner cloner) {
+      foreach (var item in original) {
+        Add((string)item.Key.Clone(), (IActionVariable)item.Value.Clone());
+      }
     }
     public VariableVectorAction() : base() { }
     public VariableVectorAction(int capacity) : base(capacity) { }
-    public VariableVectorAction(IDictionary<StringValue, IActionVariable> dictionary) : base(dictionary) { }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new VariableVectorAction(this, cloner);
+    public VariableVectorAction(IDictionary<string, IActionVariable> dictionary) : base(dictionary) { }
+
+    //protected override void OnItemsAdded(IEnumerable<KeyValuePair<string, IActionVariable>> items) {
+    //  foreach (var item in items) {
+    //    if (!(item.Value is StringVariable || item.Value is IntVariable)) {
+    //      throw new ArgumentException("Value has to be of type 'StringVariable' or 'IntVariable'");
+    //    }
+    //  }
+    //}
+
+    public VariableVectorAction GetEmptyCopy() {
+      VariableVectorAction emptyCopy = new VariableVectorAction(this.Count);
+      foreach (var keyValuePair in this) {
+        emptyCopy.Add(keyValuePair.Key, keyValuePair.Value.GetEmptyCopy());
+      }
+      return emptyCopy;
     }
 
-    protected override void OnItemsAdded(IEnumerable<KeyValuePair<StringValue, IActionVariable>> items) {
-      foreach (var item in items) {
-        if (!(item.Value is StringVariable || item.Value is IntVariable)) {
-          throw new ArgumentException("Value has to be of type 'StringVariable' or 'IntVariable'");
-        }
+    public VariableVectorAction GetSetCopy() {
+      VariableVectorAction setCopy = new VariableVectorAction(this.Count);
+      foreach (var keyValuePair in this) {
+        setCopy.Add(keyValuePair.Key, keyValuePair.Value.GetSetCopy());
       }
-      base.OnItemsAdded(items);
+      return setCopy;
     }
 
@@ -63,5 +77,5 @@
       var targetCast = target as VariableVectorAction;
       if (targetCast == null) { return false; }
-      if (this.Order.SequenceEqual(targetCast.Order)) { return false; }
+      if (!this.Order.SequenceEqual(targetCast.Order)) { return false; }
       foreach (var keyValuePair in targetCast) {
         if (!this[keyValuePair.Key].MatchVariable(keyValuePair.Value)) {
@@ -74,5 +88,5 @@
     public void Add(IEnumerable<IActionVariable> action) {
       foreach (var variable in action) {
-        this.Add(new StringValue(variable.VariableName), variable);
+        this.Add(variable.VariableName, variable);
       }
     }
@@ -82,5 +96,5 @@
       bool first = true;
       foreach (var variable in this.Values) {
-        if (!first) {
+        if (first) {
           first = false;
         } else {
@@ -98,5 +112,5 @@
     }
 
-    public bool Identical(VariableVectorCondition target) {
+    public bool Identical(VariableVectorAction target) {
       if (this.Order.SequenceEqual(target.Order)) { return false; }
       foreach (var keyValuePair in target) {
@@ -107,4 +121,39 @@
       return true;
     }
+
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorAction(this, cloner);
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorActionComparer.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorActionComparer.cs	(revision 9226)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorActionComparer.cs	(revision 9226)
@@ -0,0 +1,77 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [StorableClass]
+  [Item("VariableVectorActionComparer", "")]
+  public class VariableVectorActionComparer : Item, IEqualityComparer<VariableVectorAction>, IClassifierComparer {
+
+    [StorableConstructor]
+    protected VariableVectorActionComparer(bool deserializing) : base(deserializing) { }
+    protected VariableVectorActionComparer(VariableVectorActionComparer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorActionComparer(this, cloner);
+    }
+    public VariableVectorActionComparer() : base() { }
+
+    public bool Equals(VariableVectorAction x, VariableVectorAction y) {
+      if (!x.Order.SequenceEqual(y.Order)) return false;
+      foreach (var key in x.Keys) {
+        if (!x[key].Identical(y[key])) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    public int GetHashCode(VariableVectorAction obj) {
+      int result = 1;
+      foreach (var key in obj.Keys) {
+        result = 37 * result + key.GetHashCode();
+      }
+
+      foreach (var val in obj.Values) {
+        result = 37 * result + val.GetHashCode();
+      }
+      return result;
+    }
+
+    public bool Equals(IAction x, IAction y) {
+      var xCast = x as VariableVectorAction;
+      var yCast = y as VariableVectorAction;
+      return x != null && y != null && Equals(xCast, yCast);
+    }
+
+    public int GetHashCode(IAction obj) {
+      var objCast = obj as VariableVectorAction;
+      return objCast != null ? GetHashCode(objCast) : obj.GetHashCode();
+    }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs	(revision 9226)
@@ -20,10 +20,11 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
+using System.Drawing;
 using System.Linq;
 using System.Text;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -32,28 +33,27 @@
   [StorableClass]
   [Item("VariableVectorCondition", "")]
-  public class VariableVectorCondition : ItemDictionary<StringValue, IVariable>, ICondition {
+  public class VariableVectorCondition : Dictionary<string, IVariable>, ICondition {
 
-    public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
+    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
 
     public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
 
     [StorableConstructor]
-    protected VariableVectorCondition(bool deserializing) : base(deserializing) { }
-    protected VariableVectorCondition(VariableVectorCondition original, Cloner cloner)
-      : base(original, cloner) {
+    protected VariableVectorCondition(bool deserializing) { }
+    protected VariableVectorCondition(VariableVectorCondition original, Cloner cloner) {
+      foreach (var item in original) {
+        Add((string)item.Key.Clone(), (IVariable)item.Value.Clone());
+      }
     }
     public VariableVectorCondition() : base() { }
     public VariableVectorCondition(int capacity) : base(capacity) { }
-    public VariableVectorCondition(IDictionary<StringValue, IVariable> dictionary) : base(dictionary) { }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new VariableVectorCondition(this, cloner);
-    }
+    public VariableVectorCondition(IDictionary<string, IVariable> dictionary) : base(dictionary) { }
 
     public bool Match(IInput target) {
       var targetCast = target as VariableVectorInput;
       if (targetCast == null) { return false; }
-      if (this.Order.SequenceEqual(targetCast.Order)) { return false; }
-      foreach (var keyValuePair in targetCast) {
-        if (!this[keyValuePair.Key].MatchInput(keyValuePair.Value.Value)) {
+      if (!this.Keys.All(x => targetCast.Keys.Contains(x))) { return false; }
+      foreach (var key in this.Keys) {
+        if (!this[key].MatchInput(targetCast[key])) {
           return false;
         }
@@ -64,5 +64,5 @@
     public void Add(IEnumerable<IVariable> condition) {
       foreach (var variable in condition) {
-        this.Add(new StringValue(variable.VariableName), variable);
+        this.Add(variable.VariableName, variable);
       }
     }
@@ -72,5 +72,5 @@
       bool first = true;
       foreach (var variable in this.Values) {
-        if (!first) {
+        if (first) {
           first = false;
         } else {
@@ -93,5 +93,5 @@
 
     public bool Identical(VariableVectorCondition target) {
-      if (this.Order.SequenceEqual(target.Order)) { return false; }
+      if (!this.Order.SequenceEqual(target.Order)) { return false; }
       foreach (var keyValuePair in target) {
         if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {
@@ -101,4 +101,39 @@
       return true;
     }
+
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    public virtual IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorCondition(this, cloner);
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs	(revision 9204)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs	(revision 9226)
@@ -20,9 +20,11 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
+using System.Drawing;
 using System.Linq;
+using System.Text;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -31,18 +33,66 @@
   [StorableClass]
   [Item("VariableVectorInput", "")]
-  public class VariableVectorInput : ItemDictionary<StringValue, StringValue>, IInput {
+  public class VariableVectorInput : Dictionary<string, string>, IInput {
 
-    public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
+    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
 
     [StorableConstructor]
-    protected VariableVectorInput(bool deserializing) : base(deserializing) { }
-    protected VariableVectorInput(VariableVectorInput original, Cloner cloner)
-      : base(original, cloner) {
+    protected VariableVectorInput(bool deserializing) { }
+    protected VariableVectorInput(VariableVectorInput original, Cloner cloner) {
+      foreach (var item in original) {
+        Add((string)item.Key.Clone(), (string)item.Value.Clone());
+      }
     }
     public VariableVectorInput() : base() { }
     public VariableVectorInput(int capacity) : base(capacity) { }
-    public VariableVectorInput(IDictionary<StringValue, StringValue> dictionary) : base(dictionary) { }
-    public override IDeepCloneable Clone(Cloner cloner) {
+    public VariableVectorInput(IDictionary<string, string> dictionary) : base(dictionary) { }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      bool first = true;
+      foreach (var item in this) {
+        if (first) {
+          first = false;
+        } else {
+          sb.Append("; ");
+        }
+        sb.Append(String.Format("{0}: {1}", item.Key, item.Value));
+      }
+      return sb.ToString();
+    }
+
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+
+    public virtual IDeepCloneable Clone(Cloner cloner) {
       return new VariableVectorInput(this, cloner);
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    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);
     }
   }
