Changeset 17283

Timestamp:

10/01/19 14:36:32 (5 years ago)

Author:

dpiringe

Message:

#3026: renamed Component to JsonItem

Location:

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture

Files:

• Converters/BaseConverter.cs (modified) (1 diff)
• Converters/ConstrainedValueParameterConverter.cs (modified) (3 diffs)
• Converters/DummyConverter.cs (modified) (1 diff)
• Converters/EnumTypeConverter.cs (modified) (1 diff)
• Converters/LookupParameterConverter.cs (modified) (1 diff)
• Converters/MultiCheckedOperatorConverter.cs (modified) (3 diffs)
• Converters/ParameterBaseConverter.cs (modified) (2 diffs)
• Converters/ParameterizedItemConverter.cs (modified) (3 diffs)
• Converters/StringValueConverter.cs (modified) (1 diff)
• Converters/ValueParameterConverter.cs (modified) (1 diff)
• Converters/ValueTypeArrayConverter.cs (modified) (1 diff)
• Converters/ValueTypeMatrixConverter.cs (modified) (1 diff)
• Converters/ValueTypeValueConverter.cs (modified) (1 diff)
• HeuristicLab.Manufacture.csproj (modified) (1 diff)
• Interfaces/IJsonItemConverter.cs (modified) (1 diff)
• JCGenerator.cs (modified) (7 diffs)
• JCInstantiator.cs (modified) (6 diffs)
• JsonItem.cs (moved) (moved from branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Component.cs) (4 diffs)
• JsonItemConverter.cs (modified) (2 diffs)

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/BaseConverter.cs

@@ -10 +10 @@
   public abstract class BaseConverter : IJsonItemConverter
   {
-    public Component Extract(IItem value) {
-      Component data = ExtractData(value);
+    public JsonItem Extract(IItem value) {
+      JsonItem data = ExtractData(value);
       data.Name = String.IsNullOrEmpty(data.Name) ? value.ItemName : data.Name;
       return data;
     }
 
-    public void Inject(IItem item, Component data) {
+    public void Inject(IItem item, JsonItem data) {
       if(data.Reference != null) {
-        Component.Merge(data, data.Reference);
+        JsonItem.Merge(data, data.Reference);
       }
       InjectData(item, data);
     }
 
-    public abstract void InjectData(IItem item, Component data);
-    public abstract Component ExtractData(IItem value);
+    public abstract void InjectData(IItem item, JsonItem data);
+    public abstract JsonItem ExtractData(IItem value);
 
     #region Helper

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ConstrainedValueParameterConverter.cs

@@ -8 +8 @@
 namespace HeuristicLab.Manufacture {
   public class ConstrainedValueParameterConverter : ParameterBaseConverter {
-    public override void InjectData(IParameter parameter, Component data) {
+    public override void InjectData(IParameter parameter, JsonItem data) {
       foreach (var x in parameter.Cast<dynamic>().ValidValues)
         if (x.GetType().Name == CastValue<string>(data.Default))
@@ -17 +17 @@
     }
 
-    public override Component ExtractData(IParameter value) =>
-      new Component() {
+    public override JsonItem ExtractData(IParameter value) =>
+      new JsonItem() {
         Name = value.Name,
         Default = value.ActualValue?.GetType().Name,
@@ -33 +33 @@
     }
     // id = kombi aus path + default 
-    private IList<Component> GetParameterizedChilds(IParameter value) {
-      List<Component> list = new List<Component>();
+    private IList<JsonItem> GetParameterizedChilds(IParameter value) {
+      List<JsonItem> list = new List<JsonItem>();
       var values = value.Cast<dynamic>().ValidValues;
       foreach(var x in values) {
         if (x is IParameterizedItem) {
-          Component tmp = JsonItemConverter.Extract(x);
+          JsonItem tmp = JsonItemConverter.Extract(x);
           tmp.PrependPath(value.Name);
           list.Add(tmp);

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/DummyConverter.cs

@@ -8 +8 @@
 namespace HeuristicLab.Manufacture {
   public class DummyConverter : BaseConverter {
-    public override void InjectData(IItem item, Component data) {
+    public override void InjectData(IItem item, JsonItem 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 };
+    public override JsonItem ExtractData(IItem value) => 
+      new JsonItem() { Default = value.GetType().Name };
   }
 }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/EnumTypeConverter.cs

@@ -9 +9 @@
 namespace HeuristicLab.Manufacture {
   public class EnumTypeConverter : BaseConverter {
-    public override void InjectData(IItem item, Component data) =>
+    public override void InjectData(IItem item, JsonItem 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();
+    public override JsonItem ExtractData(IItem value) {
+      JsonItem data = new JsonItem();
       object val = ((dynamic)value).Value;
       Type enumType = val.GetType();

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/LookupParameterConverter.cs

@@ -8 +8 @@
 namespace HeuristicLab.Manufacture {
   public class LookupParameterConverter : ParameterBaseConverter {
-    public override Component ExtractData(IParameter value) {
-      return new Component() { Name = value.Name };
+    public override JsonItem ExtractData(IParameter value) {
+      return new JsonItem() { Name = value.Name };
     }
 
-    public override void InjectData(IParameter parameter, Component data) {
+    public override void InjectData(IParameter parameter, JsonItem data) {
       
     }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/MultiCheckedOperatorConverter.cs

@@ -8 +8 @@
 namespace HeuristicLab.Manufacture {
   public class MultiCheckedOperatorConverter : ParameterizedItemConverter {
-    public override Component ExtractData(IItem value) {
-      Component data = base.ExtractData(value);
+    public override JsonItem ExtractData(IItem value) {
+      JsonItem 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);
-      */
+      data.Operators = new List<JsonItem>();
       dynamic val = value.Cast<dynamic>();
       foreach (var op in val.Operators) {
-        data.Operators.Add(new Component() {
+        data.Operators.Add(new JsonItem() {
           Name = op.Name,
           Default = val.Operators.ItemChecked(op),
@@ -30 +25 @@
     }
 
-    public override void InjectData(IItem item, Component data) {
+    public override void InjectData(IItem item, JsonItem data) {
       base.InjectData(item, data);
 
@@ -39 +34 @@
     }
 
-    private bool GetOperatorState(string name, Component data) {
+    private bool GetOperatorState(string name, JsonItem data) {
       foreach(var op in data.Operators) {
         if (op.Name == name) return op.Default.Cast<bool>();

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ParameterBaseConverter.cs

@@ -8 +8 @@
 namespace HeuristicLab.Manufacture {
   public abstract class ParameterBaseConverter : BaseConverter {
-    public override Component ExtractData(IItem value) {
+    public override JsonItem ExtractData(IItem value) {
       IParameter param = value.Cast<IParameter>();
-      Component comp = ExtractData(param);
+      JsonItem comp = ExtractData(param);
       //comp.Path = value.Cast<IParameter>().ActualValue?.ItemName;
       /*comp.Path = value.Cast<IParameter>().Name + "." + comp.Path;
@@ -20 +20 @@
       return comp;
     }
-    public abstract Component ExtractData(IParameter value);
+    public abstract JsonItem ExtractData(IParameter value);
 
-    public override void InjectData(IItem item, Component data) => InjectData(item.Cast<IParameter>(), data);
+    public override void InjectData(IItem item, JsonItem data) => InjectData(item.Cast<IParameter>(), data);
 
-    public abstract void InjectData(IParameter parameter, Component data);
+    public abstract void InjectData(IParameter parameter, JsonItem data);
   }
 }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ParameterizedItemConverter.cs

@@ -2 +2 @@
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
+using System.Text;JsonItem obj
 using System.Threading.Tasks;
 using HeuristicLab.Core;
@@ -9 +9 @@
 {
   public class ParameterizedItemConverter : BaseConverter {
-    public override void InjectData(IItem item, Component data) {
+    public override void InjectData(IItem item, JsonItem data) {
       IParameterizedItem pItem = item.Cast<IParameterizedItem>();
 
@@ -19 +19 @@
     }
 
-    public override Component ExtractData(IItem value) {
-      Component obj = new Component();
-      obj.Name = value.ItemName;
-      obj.Type = value.GetType().AssemblyQualifiedName;
-      obj.Path = value.ItemName;
+    public override JsonItem ExtractData(IItem value) {
+      JsonItem item = new JsonItem();
+      item.Name = value.ItemName;
+      item.Type = value.GetType().AssemblyQualifiedName;
+      item.Path = value.ItemName;
 
       foreach (var param in value.Cast<IParameterizedItem>().Parameters) {
-        Component data = JsonItemConverter.Extract(param);
+        JsonItem data = JsonItemConverter.Extract(param);
         data.Name = param.Name;
         data.Path = param.Name;
-        data.PrependPath(obj.Path);
+        data.PrependPath(item.Path);
         data.UpdatePaths();
         
-        if (obj.Parameters == null)
-          obj.Parameters = new List<Component>();
-        obj.Parameters.Add(data);
+        if (item.Parameters == null)
+          item.Parameters = new List<JsonItem>();
+        item.Parameters.Add(data);
       }
-      return obj;
+      return item;
     }
   }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/StringValueConverter.cs

@@ -9 +9 @@
 namespace HeuristicLab.Manufacture {
   public class StringValueConverter : BaseConverter {
-    public override void InjectData(IItem item, Component data) =>
+    public override void InjectData(IItem item, JsonItem data) =>
       item.Cast<StringValue>().Value = CastValue<string>(data.Default);
 
-    public override Component ExtractData(IItem value) => 
-      new Component() {
+    public override JsonItem ExtractData(IItem value) => 
+      new JsonItem() {
         Default = value.Cast<StringValue>().Value
       };

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueParameterConverter.cs

@@ -9 +9 @@
   public class ValueParameterConverter : ParameterBaseConverter {
 
-    public override void InjectData(IParameter parameter, Component data) => 
+    public override void InjectData(IParameter parameter, JsonItem data) => 
       JsonItemConverter.Inject(parameter.ActualValue, data);
 
-    public override Component ExtractData(IParameter value) {
-      Component data = null;
+    public override JsonItem ExtractData(IParameter value) {
+      JsonItem data = null;
       if (value.ActualValue == null)
-        data = new Component();
+        data = new JsonItem();
       else
         data = JsonItemConverter.Extract(value.ActualValue);

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeArrayConverter.cs

@@ -13 +13 @@
     where T : struct 
   {
-    public override void InjectData(IItem item, Component data) => 
+    public override void InjectData(IItem item, JsonItem data) => 
       CopyArrayData(item.Cast<ArrayType>(), CastValue<T[]>(data.Default));
 
-    public override Component ExtractData(IItem value) => 
-      new Component() {
+    public override JsonItem ExtractData(IItem value) => 
+      new JsonItem() {
         Default = value.Cast<ArrayType>().CloneAsArray()
       };

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeMatrixConverter.cs

@@ -13 +13 @@
     where T : struct 
   {
-    public override void InjectData(IItem item, Component data) => 
+    public override void InjectData(IItem item, JsonItem data) => 
       CopyMatrixData(item.Cast<MatrixType>(), CastValue<T[,]>(data.Default));
 
-    public override Component ExtractData(IItem value) =>
-      new Component() {
+    public override JsonItem ExtractData(IItem value) =>
+      new JsonItem() {
         Default = value.Cast<MatrixType>().CloneAsMatrix()
       };

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Converters/ValueTypeValueConverter.cs

@@ -12 +12 @@
     where T : struct {
 
-    public override void InjectData(IItem item, Component data) =>
+    public override void InjectData(IItem item, JsonItem data) =>
       item.Cast<ValueType>().Value = CastValue<T>(data.Default);
 
-    public override Component ExtractData(IItem value) => 
-      new Component() {
+    public override JsonItem ExtractData(IItem value) => 
+      new JsonItem() {
         Default = value.Cast<ValueType>().Value,
         Range = new object[] { GetMinValue(), GetMaxValue() }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/HeuristicLab.Manufacture.csproj

@@ -71 +71 @@
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Component.cs" />
+    <Compile Include="JsonItem.cs" />
     <Compile Include="Interfaces\IJsonItemConverter.cs" />
     <Compile Include="JsonItemConverter.cs" />

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/Interfaces/IJsonItemConverter.cs

@@ -10 +10 @@
   public interface IJsonItemConverter {
     /// <summary>
-    /// Extracts all infos out of an IItem to create a Component. 
+    /// Extracts all infos out of an IItem to create a JsonItem. 
     /// (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);
+    /// <returns>JsonItem with infos to reinitialise the IItem.</returns>
+    JsonItem Extract(IItem value);
 
     /// <summary>
-    /// Injects the saved infos from the Component into the IItem.
+    /// Injects the saved infos from the JsonItem 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);
+    /// <param name="data">The JsonItem with the saved values.</param>
+    void Inject(IItem item, JsonItem data);
   }
 }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JCGenerator.cs

@@ -27 +27 @@
 
     JArray jsonItems = new JArray();
-    private void PopulateJsonItems(Component component) {
-      if (component.Parameters != null) {
-        if(component.Range == null)
-          jsonItems.Add(Serialize(component));
-        foreach (var p in component.Parameters)
+    private void PopulateJsonItems(JsonItem item) {
+      if (item.Parameters != null) {
+        if(item.Range == null)
+          jsonItems.Add(Serialize(item));
+        foreach (var p in item.Parameters)
           if(p.Parameters != null)
             PopulateJsonItems(p);
@@ -37 +37 @@
     }
 
-    private JObject Serialize(Component component) {
-      JObject obj = JObject.FromObject(component, Settings());
+    private JObject Serialize(JsonItem item) {
+      JObject obj = JObject.FromObject(item, Settings());
       obj["StaticParameters"] = obj["Parameters"];
       obj["FreeParameters"] = obj["Parameters"];
@@ -49 +49 @@
       obj.Property("Type")?.Remove();
 
-      TypeList.Add(component.Path, component.Type);
+      TypeList.Add(item.Path, item.Type);
       return obj;
     }
@@ -55 +55 @@
     public string GenerateTemplate(IAlgorithm algorithm, IProblem problem, params string[] freeParameters) {
       algorithm.Problem = problem;
-      Component algorithmData = JsonItemConverter.Extract(algorithm);
-      Component problemData = JsonItemConverter.Extract(problem);
+      JsonItem algorithmData = JsonItemConverter.Extract(algorithm);
+      JsonItem problemData = JsonItemConverter.Extract(problem);
       PopulateJsonItems(algorithmData);
       PopulateJsonItems(problemData);
@@ -74 +74 @@
       IList<JObject> objToRemove = new List<JObject>();
       TransformNodes(x => {
-        var p = x.ToObject<Component>();
+        var p = x.ToObject<JsonItem>();
 
         /*bool isSelected = false;
@@ -96 +96 @@
       IList<JObject> objToRemove = new List<JObject>();
       TransformNodes(x => {
-        var p = x.ToObject<Component>();
+        var p = x.ToObject<JsonItem>();
         x.Property("Range")?.Remove();
         x.Property("Operators")?.Remove();
@@ -105 +105 @@
       foreach (var x in objToRemove) x.Remove();
     }
-
 
     private JsonSerializer Settings() => new JsonSerializer() {

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JCInstantiator.cs

@@ -22 +22 @@
       TypeList = Config["Types"].ToObject<Dictionary<string, string>>();
 
-      Component algorithmData = GetData(Config["Metadata"]["Algorithm"].ToString());
+      JsonItem algorithmData = GetData(Config["Metadata"]["Algorithm"].ToString());
       ResolveReferences(algorithmData);
       IAlgorithm algorithm = CreateObject<IAlgorithm>(algorithmData);
      
-      Component problemData = GetData(Config["Metadata"]["Problem"].ToString());
+      JsonItem problemData = GetData(Config["Metadata"]["Problem"].ToString());
       ResolveReferences(problemData);
       IProblem problem = CreateObject<IProblem>(problemData);
@@ -37 +37 @@
     }
 
-    private void ResolveReferences(Component data) {
+    private void ResolveReferences(JsonItem data) {
       foreach (var p in data.Parameters)
         if (p.Default is string && p.Reference == null)
@@ -43 +43 @@
     }
 
-    private Component GetData(string key)
+    private JsonItem GetData(string key)
     {
       foreach(JObject item in Config["Objects"])
       {
-        Component data = BuildComponent(item);
+        JsonItem data = BuildJsonItem(item);
         if (data.Name == key) return data;
       }
@@ -53 +53 @@
     }
 
-    private T CreateObject<T>(Component data) {
+    private T CreateObject<T>(JsonItem data) {
       if (TypeList.TryGetValue(data.Name, out string typeName)) {
         Type type = Type.GetType(typeName);
@@ -60 +60 @@
     }
 
-    private Component BuildComponent(JObject obj) =>
-      new Component() {
-        Name = obj[nameof(Component.Name)]?.ToString(),
-        Default = obj[nameof(Component.Default)]?.ToObject<object>(),
-        Range = obj[nameof(Component.Range)]?.ToObject<object[]>(),
-        Type = obj[nameof(Component.Type)]?.ToObject<string>(),
+    private JsonItem BuildJsonItem(JObject obj) =>
+      new JsonItem() {
+        Name = obj[nameof(JsonItem.Name)]?.ToString(),
+        Default = obj[nameof(JsonItem.Default)]?.ToObject<object>(),
+        Range = obj[nameof(JsonItem.Range)]?.ToObject<object[]>(),
+        Type = obj[nameof(JsonItem.Type)]?.ToObject<string>(),
         Parameters = PopulateParameters(obj),
         Operators = PopulateOperators(obj)
       };
 
-    private IList<Component> PopulateParameters(JObject obj) {
-      IList<Component> list = new List<Component>();
+    private IList<JsonItem> PopulateParameters(JObject obj) {
+      IList<JsonItem> list = new List<JsonItem>();
       if (obj["StaticParameters"] != null)
         foreach (JObject param in obj["StaticParameters"])
-          list.Add(BuildComponent(param));
+          list.Add(BuildJsonItem(param));
 
       if (obj["FreeParameters"] != null) {
         foreach (JObject param in obj["FreeParameters"]) {
-          Component tmp = BuildComponent(param);
-          Component comp = null;
+          JsonItem tmp = BuildJsonItem(param);
+          JsonItem comp = null;
           foreach (var p in list) // TODO: nicht notwendig, da immer alle params im static block sind
             if (p.Name == tmp.Name) comp = p;
           if (comp != null) 
-            Component.Merge(comp, tmp);
+            JsonItem.Merge(comp, tmp);
           else list.Add(tmp);
         }
@@ -90 +90 @@
     }
 
-    private IList<Component> PopulateOperators(JObject obj) {
-      IList<Component> list = new List<Component>();
+    private IList<JsonItem> PopulateOperators(JObject obj) {
+      IList<JsonItem> list = new List<JsonItem>();
       if (obj[nameof(Operators)] != null)
         foreach (JObject sp in obj[nameof(Operators)]) {
-          Component tmp = BuildComponent(sp);
+          JsonItem tmp = BuildJsonItem(sp);
           list.Add(tmp);
         }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JsonItem.cs

@@ -10 +10 @@
 namespace HeuristicLab.Manufacture {
   //JsonItem
-  public class Component {
+  public class JsonItem {
     private IList<object> range;
     private object defaultValue;
@@ -35 +35 @@
     }
 
-    public IList<Component> Parameters { get; set; }
-    public IList<Component> Operators { get; set; }
+    public IList<JsonItem> Parameters { get; set; }
+    public IList<JsonItem> Operators { get; set; }
     
     public override bool Equals(object obj) => 
-      (obj is Component ? (obj.Cast<Component>().Name == this.Name) : false);
+      (obj is JsonItem ? (obj.Cast<JsonItem>().Name == this.Name) : false);
       
     public override int GetHashCode() => Name.GetHashCode();
 
     [JsonIgnore]
-    public Component Reference { get; set; }
+    public JsonItem Reference { get; set; }
     
-    public static void Merge(Component target, Component from) {
+    public static void Merge(JsonItem target, JsonItem from) {
       target.Name = from.Name ?? target.Name;
       target.Type = from.Type ?? target.Type;
@@ -59 +59 @@
     public bool FulfillConstraints() => FulfillConstraints(this);
 
-    public static bool FulfillConstraints(Component data) =>
+    public static bool FulfillConstraints(JsonItem data) =>
       data.Range != null && data.Default != null && (
       IsInRangeList(data.Range, data.Default) ||
@@ -91 +91 @@
     }
 
-    private void PrependPathHelper(IEnumerable<Component> components, string str) {
-      if (components != null) {
-        foreach (var p in components)
+    private void PrependPathHelper(IEnumerable<JsonItem> items, string str) {
+      if (items != null) {
+        foreach (var p in items)
           p.PrependPath(str);
       }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Manufacture/JsonItemConverter.cs

@@ -22 +22 @@
     }
 
-
     public static void Register<T>(IJsonItemConverter converter, int priority) => Register(typeof(T), converter, priority);
 
@@ -43 +42 @@
     }
 
-    internal static void Inject(IItem item, Component data) =>
+    internal static void Inject(IItem item, JsonItem data) =>
       Get(item.GetType()).Inject(item, data);
 
-    internal static Component Extract(IItem item) => 
+    internal static JsonItem Extract(IItem item) => 
       Get(item.GetType()).Extract(item);