Changeset 17287 for branches/3026_IntegrationIntoSymSpace

Timestamp:

10/02/19 12:44:44 (5 years ago)

Author:

dpiringe

Message:

#3026

• added class for constants -> Constants
• added new converter -> ValueLookupParameterConverter
• fixed a bug with type extension IsEqualTo
• fixed converter priorities

Location:

branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface

Files:

• Constants.cs (added)
• Converters/LookupParameterConverter.cs (modified) (1 diff)
• Converters/ValueLookupParameterConverter.cs (added)
• Extensions/TypeExtensions.cs (modified) (1 diff)
• HeuristicLab.JsonInterface.csproj (modified) (1 diff)
• JCGenerator.cs (modified) (5 diffs)
• JCInstantiator.cs (modified) (4 diffs)
• JsonItem.cs (modified) (3 diffs)
• JsonItemConverter.cs (modified) (2 diffs)

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

@@ -8 +8 @@
 namespace HeuristicLab.JsonInterface {
   public class LookupParameterConverter : ParameterBaseConverter {
-    public override JsonItem ExtractData(IParameter value) {
-      return new JsonItem() { Name = value.Name };
-    }
+    public override JsonItem ExtractData(IParameter value) => 
+      new JsonItem() { 
+        Name = value.Name,
+        Default = value.Cast<ILookupParameter>().ActualName
+      };
 
-    public override void InjectData(IParameter parameter, JsonItem data) {
-      
-    }
+    public override void InjectData(IParameter parameter, JsonItem data) =>
+      parameter.Cast<ILookupParameter>().ActualName = data.Default.Cast<string>();
+    
   }
 }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Extensions/TypeExtensions.cs

@@ -30 +30 @@
         }
       }
-      return type.IsAssignableFrom(other);
+      return false;//type.IsAssignableFrom(other);
     }
   }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/HeuristicLab.JsonInterface.csproj

@@ -51 +51 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Constants.cs" />
+    <Compile Include="Converters\ValueLookupParameterConverter.cs" />
     <Compile Include="CustomJsonWriter.cs" />
     <Compile Include="Extensions\ObjectExtensions.cs" />

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

@@ -15 +15 @@
   public class JCGenerator {
 
-    private JObject template = JObject.Parse(@"{
-      'Metadata': {
-        'Algorithm':'',
-        'Problem':''
-      },
-      'Objects': [],
-      'Types': {}
-    }");
+    private JObject template = JObject.Parse(Constants.Template);
 
     private Dictionary<string, string> TypeList = new Dictionary<string, string>();
@@ -39 +32 @@
     private JObject Serialize(JsonItem item) {
       JObject obj = JObject.FromObject(item, Settings());
-      obj["StaticParameters"] = obj["Parameters"];
-      obj["FreeParameters"] = obj["Parameters"];
+      obj[Constants.StaticParameters] = obj[nameof(JsonItem.Parameters)];
+      obj[Constants.FreeParameters] = obj[nameof(JsonItem.Parameters)];
 
-      obj.Property("Parameters")?.Remove();
+      obj.Property(nameof(JsonItem.Parameters))?.Remove();
       RefactorFreeParameters(obj, null);
       RefactorStaticParameters(obj);
 
-      obj.Property("Default")?.Remove();
-      obj.Property("Type")?.Remove();
+      obj.Property(nameof(JsonItem.Default))?.Remove();
+      obj.Property(nameof(JsonItem.Type))?.Remove();
 
       TypeList.Add(item.Path, item.Type);
@@ -60 +53 @@
       PopulateJsonItems(problemData);
 
-      template["Metadata"]["Algorithm"] = algorithm.Name;
-      template["Metadata"]["Problem"] = problem.Name;
-      template["Objects"] = jsonItems;
-      template["Types"] = JObject.FromObject(TypeList);
+      template[Constants.Metadata][Constants.Algorithm] = algorithm.Name;
+      template[Constants.Metadata][Constants.Problem] = problem.Name;
+      template[Constants.Objects] = jsonItems;
+      template[Constants.Types] = JObject.FromObject(TypeList);
 
       return CustomJsonWriter.Serialize(template);
@@ -84 +77 @@
           objToRemove.Add(x);
         } else {
-          x.Property("Path")?.Remove();
-          x.Property("Type")?.Remove();
-          x.Property("Parameters")?.Remove();
+          x.Property(nameof(JsonItem.Path))?.Remove();
+          x.Property(nameof(JsonItem.Type))?.Remove();
+          x.Property(nameof(JsonItem.Parameters))?.Remove();
         }
-      }, token["FreeParameters"]);
+      }, token[Constants.FreeParameters]);
       foreach (var x in objToRemove) x.Remove();
-
     }
 
@@ -97 +89 @@
       TransformNodes(x => {
         var p = x.ToObject<JsonItem>();
-        x.Property("Range")?.Remove();
-        x.Property("Operators")?.Remove();
-        x.Property("Parameters")?.Remove();
-        x.Property("Type")?.Remove();
+        x.Property(nameof(JsonItem.Range))?.Remove();
+        x.Property(nameof(JsonItem.Operators))?.Remove();
+        x.Property(nameof(JsonItem.Parameters))?.Remove();
+        x.Property(nameof(JsonItem.Type))?.Remove();
         if (p.Default == null) objToRemove.Add(x);
-      }, token["StaticParameters"]);
+      }, token[Constants.StaticParameters]);
       foreach (var x in objToRemove) x.Remove();
     }

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

@@ -20 +20 @@
     public IAlgorithm Instantiate(string configFile) {
       Config = JToken.Parse(File.ReadAllText(configFile));
-      TypeList = Config["Types"].ToObject<Dictionary<string, string>>();
+      TypeList = Config[Constants.Types].ToObject<Dictionary<string, string>>();
 
-      JsonItem algorithmData = GetData(Config["Metadata"]["Algorithm"].ToString());
+      JsonItem algorithmData = GetData(Config[Constants.Metadata][Constants.Algorithm].ToString());
       ResolveReferences(algorithmData);
       IAlgorithm algorithm = CreateObject<IAlgorithm>(algorithmData);
      
-      JsonItem problemData = GetData(Config["Metadata"]["Problem"].ToString());
+      JsonItem problemData = GetData(Config[Constants.Metadata][Constants.Problem].ToString());
       ResolveReferences(problemData);
       IProblem problem = CreateObject<IProblem>(problemData);
@@ -45 +45 @@
     private JsonItem GetData(string key)
     {
-      foreach(JObject item in Config["Objects"])
+      foreach(JObject item in Config[Constants.Objects])
       {
         JsonItem data = BuildJsonItem(item);
@@ -66 +66 @@
         Range = obj[nameof(JsonItem.Range)]?.ToObject<object[]>(),
         Type = obj[nameof(JsonItem.Type)]?.ToObject<string>(),
+        Reference = obj[nameof(JsonItem.Type)] == null ? 
+                    null : 
+                    BuildJsonItem(obj[nameof(JsonItem.Type)].ToObject<JObject>()),
         Parameters = PopulateParameters(obj),
         Operators = PopulateOperators(obj)
@@ -72 +75 @@
     private IList<JsonItem> PopulateParameters(JObject obj) {
       IList<JsonItem> list = new List<JsonItem>();
-      if (obj["StaticParameters"] != null)
-        foreach (JObject param in obj["StaticParameters"])
+      if (obj[Constants.StaticParameters] != null)
+        foreach (JObject param in obj[Constants.StaticParameters])
           list.Add(BuildJsonItem(param));
 
-      if (obj["FreeParameters"] != null) {
-        foreach (JObject param in obj["FreeParameters"]) {
+      if (obj[Constants.FreeParameters] != null) {
+        foreach (JObject param in obj[Constants.FreeParameters]) {
           JsonItem tmp = BuildJsonItem(param);
           JsonItem comp = null;

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

@@ -42 +42 @@
     public override int GetHashCode() => Name.GetHashCode();
 
-    [JsonIgnore]
     public JsonItem Reference { get; set; }
     
@@ -68 +67 @@
       IsInNumericRange<double>(data.Default, data.Range[0], data.Range[1]));
 
+    public void UpdatePaths() {
+      if (Parameters != null)
+        foreach (var p in Parameters)
+          p.Path = Path + "." + p.Name;
 
-
-    public void UpdatePaths() {
-      if (Parameters != null) {
-        foreach (var p in Parameters) {
+      if (Operators != null) 
+        foreach (var p in Operators)
           p.Path = Path + "." + p.Name;
-        }
-      }
-
-      if (Operators != null) {
-        foreach (var p in Operators) {
-          p.Path = Path + "." + p.Name;
-        }
-      }
     }
 
@@ -91 +84 @@
 
     private void PrependPathHelper(IEnumerable<JsonItem> items, string str) {
-      if (items != null) {
+      if (items != null)
         foreach (var p in items)
           p.PrependPath(str);
-      }
     }
 

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

@@ -52 +52 @@
       Register<IntValue>(new ValueTypeValueConverter<IntValue, int>(), 1);
       Register<DoubleValue>(new ValueTypeValueConverter<DoubleValue, double>(), 1);
-      Register<PercentValue>(new ValueTypeValueConverter<PercentValue, double>(), 1);
+      Register<PercentValue>(new ValueTypeValueConverter<PercentValue, double>(), 2);
       Register<BoolValue>(new ValueTypeValueConverter<BoolValue, bool>(), 1);
       Register<DateTimeValue>(new ValueTypeValueConverter<DateTimeValue, DateTime>(), 1);
@@ -59 +59 @@
       Register<IntArray>(new ValueTypeArrayConverter<IntArray, int>(), 1);
       Register<DoubleArray>(new ValueTypeArrayConverter<DoubleArray, double>(), 1);
-      Register<PercentArray>(new ValueTypeArrayConverter<PercentArray, double>(), 1);
+      Register<PercentArray>(new ValueTypeArrayConverter<PercentArray, double>(), 2);
       Register<BoolArray>(new ValueTypeArrayConverter<BoolArray, bool>(), 1);
 
       Register<IntMatrix>(new ValueTypeMatrixConverter<IntMatrix, int>(), 1);
       Register<DoubleMatrix>(new ValueTypeMatrixConverter<DoubleMatrix, double>(), 1);
-      Register<PercentMatrix>(new ValueTypeMatrixConverter<PercentMatrix, double>(), 1);
+      Register<PercentMatrix>(new ValueTypeMatrixConverter<PercentMatrix, double>(), 2);
       Register<BoolMatrix>(new ValueTypeMatrixConverter<BoolMatrix, bool>(), 1);
 
-      Register(typeof(IConstrainedValueParameter<>), new ConstrainedValueParameterConverter(), 1);
-      Register(typeof(ILookupParameter), new LookupParameterConverter(), 1);
-      Register(typeof(IValueParameter), new ValueParameterConverter(), 1);
-      Register(typeof(IParameterizedItem), new ParameterizedItemConverter(), 1);
+      Register(typeof(EnumValue<>), new EnumTypeConverter(), 1);
+
+      Register<IValueParameter>(new ValueParameterConverter(), 1);
+      Register<IParameterizedItem>(new ParameterizedItemConverter(), 1);
+      Register<ILookupParameter>(new LookupParameterConverter(), 2);
+      Register<IValueLookupParameter>(new ValueLookupParameterConverter(), 3);
+
+      Register(typeof(IConstrainedValueParameter<>), new ConstrainedValueParameterConverter(), 2);
       Register(typeof(ICheckedMultiOperator<>), new MultiCheckedOperatorConverter(), 2);
-      Register(typeof(EnumValue<>), new EnumTypeConverter(), 1);
     }
-
   }
 }