Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/BaseConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/BaseConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/BaseConverter.cs	(revision 17281)
@@ -0,0 +1,43 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+using Newtonsoft.Json.Linq;
+
+namespace HeuristicLab.Manufacture {
+  public abstract class BaseConverter : IJsonItemConverter
+  {
+    public Component Extract(IItem value) {
+      Component data = ExtractData(value);
+      data.Name = String.IsNullOrEmpty(data.Name) ? value.ItemName : data.Name;
+      return data;
+    }
+
+    public void Inject(IItem item, Component data) {
+      if(data.Reference != null) {
+        Component.Merge(data, data.Reference);
+      }
+      InjectData(item, data);
+    }
+
+    public abstract void InjectData(IItem item, Component data);
+    public abstract Component ExtractData(IItem value);
+
+    #region Helper
+    protected ValueType CastValue<ValueType>(object obj) {
+      if (obj is JToken)
+        return (obj.Cast<JToken>()).ToObject<ValueType>();
+      else if (obj is IConvertible)
+        return Convert.ChangeType(obj, typeof(ValueType)).Cast<ValueType>();
+      else return (ValueType)obj;
+    }
+
+    protected IItem Instantiate(Type type, params object[] args) =>
+      (IItem)Activator.CreateInstance(type,args);
+
+    protected IItem Instantiate<T>(params object[] args) => Instantiate(typeof(T), args);
+    #endregion
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ConstrainedValueParameterConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ConstrainedValueParameterConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ConstrainedValueParameterConverter.cs	(revision 17281)
@@ -0,0 +1,49 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Manufacture {
+  public class ConstrainedValueParameterConverter : ParameterBaseConverter {
+    public override void InjectData(IParameter parameter, Component data) {
+      foreach (var x in parameter.Cast<dynamic>().ValidValues)
+        if (x.GetType().Name == CastValue<string>(data.Default))
+          parameter.ActualValue = x;
+
+      if (parameter.ActualValue is IParameterizedItem && data.Reference != null)
+        JsonItemConverter.Inject(parameter.ActualValue, data.Reference);
+    }
+
+    public override Component ExtractData(IParameter value) =>
+      new Component() {
+        Name = value.Name,
+        Default = value.ActualValue?.GetType().Name,
+        Range = GetValidValues(value),
+        Parameters = GetParameterizedChilds(value)
+      };
+
+    #region Helper
+    private object[] GetValidValues(IParameter value) {
+      List<object> list = new List<object>();
+      var values = value.Cast<dynamic>().ValidValues;
+      foreach (var x in values) list.Add(x.GetType().Name);
+      return list.ToArray();
+    }
+    // id = kombi aus path + default 
+    private IList<Component> GetParameterizedChilds(IParameter value) {
+      List<Component> list = new List<Component>();
+      var values = value.Cast<dynamic>().ValidValues;
+      foreach(var x in values) {
+        if (x is IParameterizedItem) {
+          Component tmp = JsonItemConverter.Extract(x);
+          tmp.PrependPath(value.Name);
+          list.Add(tmp);
+        }
+      }
+      return list.Count == 0 ? null : list;
+    }
+    #endregion
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/DummyConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/DummyConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/DummyConverter.cs	(revision 17281)
@@ -0,0 +1,18 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Manufacture {
+  public class DummyConverter : BaseConverter {
+    public override void InjectData(IItem item, Component data) {
+      // do nothing because the instance already exists and 
+      // there are no values to inject
+    }
+
+    public override Component ExtractData(IItem value) => 
+      new Component() { Default = value.GetType().Name };
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/EnumTypeConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/EnumTypeConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/EnumTypeConverter.cs	(revision 17281)
@@ -0,0 +1,25 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Manufacture {
+  public class EnumTypeConverter : BaseConverter {
+    public override void InjectData(IItem item, Component data) =>
+      item.Cast<dynamic>().Value = Enum.Parse(
+        item.GetType().GenericTypeArguments.First(), 
+        CastValue<string>(data.Default));
+
+    public override Component ExtractData(IItem value) {
+      Component data = new Component();
+      object val = ((dynamic)value).Value;
+      Type enumType = val.GetType();
+      data.Default = Enum.GetName(enumType, val);
+      data.Range = Enum.GetNames(enumType);
+      return data;
+    }
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/LookupParameterConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/LookupParameterConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/LookupParameterConverter.cs	(revision 17281)
@@ -0,0 +1,18 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Manufacture {
+  public class LookupParameterConverter : ParameterBaseConverter {
+    public override Component ExtractData(IParameter value) {
+      return new Component() { Name = value.Name };
+    }
+
+    public override void InjectData(IParameter parameter, Component data) {
+      
+    }
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/MultiCheckedOperatorConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/MultiCheckedOperatorConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/MultiCheckedOperatorConverter.cs	(revision 17281)
@@ -0,0 +1,48 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Manufacture {
+  public class MultiCheckedOperatorConverter : ParameterizedItemConverter {
+    public override Component ExtractData(IItem value) {
+      Component data = base.ExtractData(value);
+
+      data.Default = value.GetType().Name;
+      data.Operators = new List<Component>();
+      /*
+      if (data.ParameterizedItems == null)
+        data.ParameterizedItems = new List<Component>();
+      data.ParameterizedItems.Add(data);
+      */
+      dynamic val = value.Cast<dynamic>();
+      foreach (var op in val.Operators) {
+        data.Operators.Add(new Component() {
+          Name = op.Name,
+          Default = val.Operators.ItemChecked(op),
+          Range = new object[] { false, true },
+          Path = data.Path + "." + op.Name
+        });
+      }
+      return data;
+    }
+
+    public override void InjectData(IItem item, Component data) {
+      base.InjectData(item, data);
+
+      dynamic val = item.Cast<dynamic>();
+      foreach (var op in val.Operators) {
+        val.Operators.SetItemCheckedState(op, GetOperatorState(op.Name, data));
+      }
+    }
+
+    private bool GetOperatorState(string name, Component data) {
+      foreach(var op in data.Operators) {
+        if (op.Name == name) return op.Default.Cast<bool>();
+      }
+      return false;
+    }
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ParameterBaseConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ParameterBaseConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ParameterBaseConverter.cs	(revision 17281)
@@ -0,0 +1,28 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Manufacture {
+  public abstract class ParameterBaseConverter : BaseConverter {
+    public override Component ExtractData(IItem value) {
+      IParameter param = value.Cast<IParameter>();
+      Component comp = ExtractData(param);
+      //comp.Path = value.Cast<IParameter>().ActualValue?.ItemName;
+      /*comp.Path = value.Cast<IParameter>().Name + "." + comp.Path;
+      if(comp.ParameterizedItems != null) {
+        foreach (var item in comp.ParameterizedItems) {
+          item.Path = value.Cast<IParameter>().Name + "." + item.Path;
+        }
+      }*/
+      return comp;
+    }
+    public abstract Component ExtractData(IParameter value);
+
+    public override void InjectData(IItem item, Component data) => InjectData(item.Cast<IParameter>(), data);
+
+    public abstract void InjectData(IParameter parameter, Component data);
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ParameterizedItemConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ParameterizedItemConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ParameterizedItemConverter.cs	(revision 17281)
@@ -0,0 +1,41 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Manufacture
+{
+  public class ParameterizedItemConverter : BaseConverter {
+    public override void InjectData(IItem item, Component data) {
+      IParameterizedItem pItem = item.Cast<IParameterizedItem>();
+
+      if(data.Parameters != null) {
+        foreach (var sp in data.Parameters)
+          if (pItem.Parameters.TryGetValue(sp.Name, out IParameter param))
+            JsonItemConverter.Inject(param, sp);
+      }
+    }
+
+    public override Component ExtractData(IItem value) {
+      Component obj = new Component();
+      obj.Name = value.ItemName;
+      obj.Type = value.GetType().AssemblyQualifiedName;
+      obj.Path = value.ItemName;
+
+      foreach (var param in value.Cast<IParameterizedItem>().Parameters) {
+        Component data = JsonItemConverter.Extract(param);
+        data.Name = param.Name;
+        data.Path = param.Name;
+        data.PrependPath(obj.Path);
+        data.UpdatePaths();
+        
+        if (obj.Parameters == null)
+          obj.Parameters = new List<Component>();
+        obj.Parameters.Add(data);
+      }
+      return obj;
+    }
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/StringValueConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/StringValueConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/StringValueConverter.cs	(revision 17281)
@@ -0,0 +1,19 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Manufacture {
+  public class StringValueConverter : BaseConverter {
+    public override void InjectData(IItem item, Component data) =>
+      item.Cast<StringValue>().Value = CastValue<string>(data.Default);
+
+    public override Component ExtractData(IItem value) => 
+      new Component() {
+        Default = value.Cast<StringValue>().Value
+      };
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueParameterConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueParameterConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueParameterConverter.cs	(revision 17281)
@@ -0,0 +1,24 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Manufacture {
+  public class ValueParameterConverter : ParameterBaseConverter {
+
+    public override void InjectData(IParameter parameter, Component data) => 
+      JsonItemConverter.Inject(parameter.ActualValue, data);
+
+    public override Component ExtractData(IParameter value) {
+      Component data = null;
+      if (value.ActualValue == null)
+        data = new Component();
+      else
+        data = JsonItemConverter.Extract(value.ActualValue);
+      data.Name = value.Name;
+      return data;
+    }
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeArrayConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeArrayConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeArrayConverter.cs	(revision 17281)
@@ -0,0 +1,31 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using Newtonsoft.Json.Linq;
+
+namespace HeuristicLab.Manufacture {
+  public class ValueTypeArrayConverter<ArrayType, T> : BaseConverter
+    where ArrayType : ValueTypeArray<T>
+    where T : struct 
+  {
+    public override void InjectData(IItem item, Component data) => 
+      CopyArrayData(item.Cast<ArrayType>(), CastValue<T[]>(data.Default));
+
+    public override Component ExtractData(IItem value) => 
+      new Component() {
+        Default = value.Cast<ArrayType>().CloneAsArray()
+      };
+
+    #region Helper
+    private void CopyArrayData(ArrayType array, T[] data) {
+      for (int i = 0; i < data.Length; ++i) {
+        array[i] = data[i];
+      }
+    }
+    #endregion
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeMatrixConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeMatrixConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeMatrixConverter.cs	(revision 17281)
@@ -0,0 +1,33 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Manufacture {
+  public class ValueTypeMatrixConverter<MatrixType, T> : BaseConverter
+    where MatrixType : ValueTypeMatrix<T> 
+    where T : struct 
+  {
+    public override void InjectData(IItem item, Component data) => 
+      CopyMatrixData(item.Cast<MatrixType>(), CastValue<T[,]>(data.Default));
+
+    public override Component ExtractData(IItem value) =>
+      new Component() {
+        Default = value.Cast<MatrixType>().CloneAsMatrix()
+      };
+
+    #region Helper
+    private void CopyMatrixData(MatrixType matrix, T[,] data) {
+      for (int x = 0; x < data.GetLength(0); ++x) {
+        for (int y = 0; y < data.GetLength(1); ++y) {
+          matrix[x, y] = data[x, y];
+        }
+      }
+    }
+    #endregion
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeValueConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeValueConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeValueConverter.cs	(revision 17281)
@@ -0,0 +1,69 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Manufacture {
+  public class ValueTypeValueConverter<ValueType, T> : BaseConverter
+    where ValueType : ValueTypeValue<T>
+    where T : struct {
+
+    public override void InjectData(IItem item, Component data) =>
+      item.Cast<ValueType>().Value = CastValue<T>(data.Default);
+
+    public override Component ExtractData(IItem value) => 
+      new Component() {
+        Default = value.Cast<ValueType>().Value,
+        Range = new object[] { GetMinValue(), GetMaxValue() }
+      };
+
+    #region Helper
+    private object GetMaxValue() {
+      TypeCode typeCode = Type.GetTypeCode(typeof(T));
+
+      if (typeof(ValueType).IsEqualTo(typeof(PercentValue)))
+        return 1.0d;
+
+      switch (typeCode) {
+        case TypeCode.Int16: return Int16.MaxValue;
+        case TypeCode.Int32: return Int32.MaxValue;
+        case TypeCode.Int64: return Int64.MaxValue;
+        case TypeCode.UInt16: return UInt16.MaxValue;
+        case TypeCode.UInt32: return UInt32.MaxValue;
+        case TypeCode.UInt64: return UInt64.MaxValue;
+        case TypeCode.Single: return Single.MaxValue;
+        case TypeCode.Double: return Double.MaxValue;
+        case TypeCode.Decimal: return Decimal.MaxValue;
+        case TypeCode.Byte: return Byte.MaxValue;
+        case TypeCode.Boolean: return true;
+        default: return default(T);
+      }
+    }
+
+    private object GetMinValue() {
+      TypeCode typeCode = Type.GetTypeCode(typeof(T));
+
+      if (typeof(ValueType).IsEqualTo(typeof(PercentValue)))
+        return 0.0d;
+
+      switch (typeCode) {
+        case TypeCode.Int16: return Int16.MinValue;
+        case TypeCode.Int32: return Int32.MinValue;
+        case TypeCode.Int64: return Int64.MinValue;
+        case TypeCode.UInt16: return UInt16.MinValue;
+        case TypeCode.UInt32: return UInt32.MinValue;
+        case TypeCode.UInt64: return UInt64.MinValue;
+        case TypeCode.Single: return Single.MinValue;
+        case TypeCode.Double: return Double.MinValue;
+        case TypeCode.Decimal: return Decimal.MinValue;
+        case TypeCode.Byte: return Byte.MinValue;
+        case TypeCode.Boolean: return false;
+        default: return default(T);
+      }
+    }
+    #endregion
+  }
+}
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Interfaces/IJsonItemConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Interfaces/IJsonItemConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Interfaces/IJsonItemConverter.cs	(revision 17281)
@@ -0,0 +1,28 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+using Newtonsoft.Json.Linq;
+
+namespace HeuristicLab.Manufacture {
+  public interface IJsonItemConverter {
+    /// <summary>
+    /// Extracts all infos out of an IItem to create a Component. 
+    /// (For template generation.)
+    /// </summary>
+    /// <param name="value">The IItem to extract infos.</param>
+    /// <returns>Component with infos to reinitialise the IItem.</returns>
+    Component Extract(IItem value);
+
+    /// <summary>
+    /// Injects the saved infos from the Component into the IItem.
+    /// (Sets the necessary values.)
+    /// </summary>
+    /// <param name="item">The IItem which get the data injected.</param>
+    /// <param name="data">The Component with the saved values.</param>
+    void Inject(IItem item, Component data);
+  }
+}
+
Index: anches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Interfaces/ITypeTransformer.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Interfaces/ITypeTransformer.cs	(revision 17280)
+++ 	(revision )
@@ -1,28 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using HeuristicLab.Core;
-using Newtonsoft.Json.Linq;
-
-namespace HeuristicLab.Manufacture {
-  public interface ITypeTransformer {
-    /// <summary>
-    /// Extracts all infos out of an IItem to create a Component. 
-    /// (For template generation.)
-    /// </summary>
-    /// <param name="value">The IItem to extract infos.</param>
-    /// <returns>Component with infos to reinitialise the IItem.</returns>
-    Component Extract(IItem value);
-
-    /// <summary>
-    /// Injects the saved infos from the Component into the IItem.
-    /// (Sets the necessary values.)
-    /// </summary>
-    /// <param name="item">The IItem which get the data injected.</param>
-    /// <param name="data">The Component with the saved values.</param>
-    void Inject(IItem item, Component data);
-  }
-}
-
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JCGenerator.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JCGenerator.cs	(revision 17280)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JCGenerator.cs	(revision 17281)
@@ -55,6 +55,6 @@
     public string GenerateTemplate(IAlgorithm algorithm, IProblem problem, params string[] freeParameters) {
       algorithm.Problem = problem;
-      Component algorithmData = Transformer.Extract(algorithm);
-      Component problemData = Transformer.Extract(problem);
+      Component algorithmData = JsonItemConverter.Extract(algorithm);
+      Component problemData = JsonItemConverter.Extract(problem);
       PopulateJsonItems(algorithmData);
       PopulateJsonItems(problemData);
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JCInstantiator.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JCInstantiator.cs	(revision 17280)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JCInstantiator.cs	(revision 17281)
@@ -31,6 +31,6 @@
       algorithm.Problem = problem;
 
-      Transformer.Inject(algorithm, algorithmData);
-      Transformer.Inject(algorithm, problemData);
+      JsonItemConverter.Inject(algorithm, algorithmData);
+      JsonItemConverter.Inject(algorithm, problemData);
 
       return algorithm;
Index: /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JsonItemConverter.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JsonItemConverter.cs	(revision 17281)
+++ /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JsonItemConverter.cs	(revision 17281)
@@ -0,0 +1,93 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Manufacture {
+  public static class JsonItemConverter {
+    private static IDictionary<Type, IJsonItemConverter> transformers = new Dictionary<Type, IJsonItemConverter>();
+    
+    public static void Register(Type type, IJsonItemConverter transformer) { // TODO: explizit
+      if (!transformers.ContainsKey(type))
+        transformers.Add(type, transformer);
+    }
+
+
+    public static void Register<T>(IJsonItemConverter transformer) => Register(typeof(T), transformer);
+
+    public static IEnumerable<IJsonItemConverter> Get(Type type) { 
+      IList<KeyValuePair<Type, IJsonItemConverter>> possibleTransformers = new List<KeyValuePair<Type, IJsonItemConverter>>();
+
+
+      foreach (var x in transformers) {
+        if (type.IsEqualTo(x.Key))
+          possibleTransformers.Add(x);
+      }
+
+
+      if(possibleTransformers.Count > 0) {
+        IJsonItemConverter nearest = possibleTransformers.First().Value;
+        int nearestDistance = -1;
+        foreach (var x in possibleTransformers) {
+          int d = type.GetInterfaceDistance(x.Key);
+          if (d != -1 && (nearestDistance == -1 || d < nearestDistance)) {
+            nearestDistance = d;
+            nearest = x.Value;
+          }
+        }
+        return new IJsonItemConverter[] { nearest };
+        /*
+        return possibleTransformers.OrderBy(x => {
+          return type.GetInterfaceDistance(x.Key);
+        }).Select(x => x.Value);
+        */
+      }
+      return new IJsonItemConverter[] { new DummyConverter() };
+    }
+
+    internal static void Inject(IItem item, Component data) {
+      IEnumerable<IJsonItemConverter> arr = Get(item.GetType());
+      foreach (var transformer in arr)
+        transformer.Inject(item, data);
+    }
+
+    internal static Component Extract(IItem item) {
+      IEnumerable<IJsonItemConverter> arr = Get(item.GetType());
+      Component data = new Component();
+      foreach (var transformer in arr)
+        Component.Merge(data, transformer.Extract(item));
+      return data;
+    }
+
+
+    static JsonItemConverter() {
+      Register<IntValue>(new ValueTypeValueConverter<IntValue, int>());
+      Register<DoubleValue>(new ValueTypeValueConverter<DoubleValue, double>());
+      Register<PercentValue>(new ValueTypeValueConverter<PercentValue, double>());
+      Register<BoolValue>(new ValueTypeValueConverter<BoolValue, bool>());
+      Register<DateTimeValue>(new ValueTypeValueConverter<DateTimeValue, DateTime>());
+      Register<StringValue>(new StringValueConverter());
+
+      Register<IntArray>(new ValueTypeArrayConverter<IntArray, int>());
+      Register<DoubleArray>(new ValueTypeArrayConverter<DoubleArray, double>());
+      Register<PercentArray>(new ValueTypeArrayConverter<PercentArray, double>());
+      Register<BoolArray>(new ValueTypeArrayConverter<BoolArray, bool>());
+
+      Register<IntMatrix>(new ValueTypeMatrixConverter<IntMatrix, int>());
+      Register<DoubleMatrix>(new ValueTypeMatrixConverter<DoubleMatrix, double>());
+      Register<PercentMatrix>(new ValueTypeMatrixConverter<PercentMatrix, double>());
+      Register<BoolMatrix>(new ValueTypeMatrixConverter<BoolMatrix, bool>());
+
+      Register(typeof(IConstrainedValueParameter<>), new ConstrainedValueParameterConverter());
+      Register(typeof(ILookupParameter), new LookupParameterConverter());
+      Register(typeof(IValueParameter), new ValueParameterConverter());
+      Register(typeof(IParameterizedItem), new ParameterizedItemConverter());
+      Register(typeof(ICheckedMultiOperator<>), new MultiCheckedOperatorConverter());
+      Register(typeof(EnumValue<>), new EnumTypeConverter())
+    }
+
+  }
+}
Index: anches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Transformer.cs
===================================================================
--- /branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Transformer.cs	(revision 17280)
+++ 	(revision )
@@ -1,92 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Manufacture {
-  public static class Transformer {
-    private static IDictionary<Type, ITypeTransformer> transformers = new Dictionary<Type, ITypeTransformer>();
-    
-    public static void Register(Type type, ITypeTransformer transformer) { // TODO: explizit
-      if (!transformers.ContainsKey(type))
-        transformers.Add(type, transformer);
-    }
-
-
-    public static void Register<T>(ITypeTransformer transformer) => Register(typeof(T), transformer);
-
-    public static IEnumerable<ITypeTransformer> Get(Type type) { 
-      IList<KeyValuePair<Type, ITypeTransformer>> possibleTransformers = new List<KeyValuePair<Type, ITypeTransformer>>();
-
-
-      foreach (var x in transformers) {
-        if (type.IsEqualTo(x.Key))
-          possibleTransformers.Add(x);
-      }
-
-
-      if(possibleTransformers.Count > 0) {
-        ITypeTransformer nearest = possibleTransformers.First().Value;
-        int nearestDistance = -1;
-        foreach (var x in possibleTransformers) {
-          int d = type.GetInterfaceDistance(x.Key);
-          if (d != -1 && (nearestDistance == -1 || d < nearestDistance)) {
-            nearestDistance = d;
-            nearest = x.Value;
-          }
-        }
-        return new ITypeTransformer[] { nearest };
-        /*
-        return possibleTransformers.OrderBy(x => {
-          return type.GetInterfaceDistance(x.Key);
-        }).Select(x => x.Value);
-        */
-      }
-      return new ITypeTransformer[] { new DummyTransformer() };
-    }
-
-    internal static void Inject(IItem item, Component data) {
-      IEnumerable<ITypeTransformer> arr = Get(item.GetType());
-      foreach (var transformer in arr)
-        transformer.Inject(item, data);
-    }
-
-    internal static Component Extract(IItem item) {
-      IEnumerable<ITypeTransformer> arr = Get(item.GetType());
-      Component data = new Component();
-      foreach (var transformer in arr)
-        Component.Merge(data, transformer.Extract(item));
-      return data;
-    }
-
-
-    static Transformer() {
-      Register<IntValue>(new ValueTypeValueTransformer<IntValue, int>());
-      Register<DoubleValue>(new ValueTypeValueTransformer<DoubleValue, double>());
-      Register<PercentValue>(new ValueTypeValueTransformer<PercentValue, double>());
-      Register<BoolValue>(new ValueTypeValueTransformer<BoolValue, bool>());
-      Register<DateTimeValue>(new ValueTypeValueTransformer<DateTimeValue, DateTime>());
-      Register<StringValue>(new StringValueTransformer());
-
-      Register<IntArray>(new ValueTypeArrayTransformer<IntArray, int>());
-      Register<DoubleArray>(new ValueTypeArrayTransformer<DoubleArray, double>());
-      Register<PercentArray>(new ValueTypeArrayTransformer<PercentArray, double>());
-      Register<BoolArray>(new ValueTypeArrayTransformer<BoolArray, bool>());
-
-      Register<IntMatrix>(new ValueTypeMatrixTransformer<IntMatrix, int>());
-      Register<DoubleMatrix>(new ValueTypeMatrixTransformer<DoubleMatrix, double>());
-      Register<PercentMatrix>(new ValueTypeMatrixTransformer<PercentMatrix, double>());
-      Register<BoolMatrix>(new ValueTypeMatrixTransformer<BoolMatrix, bool>());
-
-      Register(typeof(IConstrainedValueParameter<>), new ConstrainedValueParameterTransformer());
-      Register(typeof(ILookupParameter), new LookupParameterTransformer());
-      Register(typeof(IValueParameter), new ValueParameterTransformer());
-      Register(typeof(IParameterizedItem), new ParameterizedItemTransformer());
-      Register(typeof(ICheckedMultiOperator<>), new MultiCheckedOperatorTransformer());
-    }
-
-  }
-}
