Changeset 17322 for branches/3026_IntegrationIntoSymSpace

Timestamp:

10/08/19 14:13:42 (5 years ago)

Author:

dpiringe

Message:

#3026

• changed project type from console to library
• activated signing
• lots of refactors in JCInstantiator and JsonItem

Location:

branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface

Files:

• App.config (deleted)
• Converters/MultiCheckedOperatorConverter.cs (modified) (1 diff)
• HeuristicLab.JsonInterface.csproj (modified) (5 diffs)
• HeuristicLab.snk (copied) (copied from branches/3026_IntegrationIntoSymSpace/HeuristicLab.Operators/3.3/HeuristicLab.snk)
• JCGenerator.cs (modified) (1 diff)
• JCInstantiator.cs (modified) (4 diffs)
• JsonItem.cs (modified) (6 diffs)
• Program.cs (deleted)

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

@@ -29 +29 @@
 
       dynamic val = item.Cast<dynamic>();
-      foreach (var op in val.Operators) {
+      foreach (var op in val.Operators)
         val.Operators.SetItemCheckedState(op, GetOperatorState(op.Name, data));
-      }
     }
 

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

@@ -6 +6 @@
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
     <ProjectGuid>{0E3AAB5E-F152-44E0-A054-4D9A83ECEE08}</ProjectGuid>
-    <OutputType>Exe</OutputType>
+    <OutputType>Library</OutputType>
     <RootNamespace>HeuristicLab.JsonInterface</RootNamespace>
     <AssemblyName>HeuristicLab.JsonInterface</AssemblyName>
-    <TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
     <Deterministic>true</Deterministic>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
@@ -19 +20 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
+    <OutputPath>..\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -32 +33 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject />
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
   <ItemGroup>
@@ -71 +81 @@
     <Compile Include="Converters\ValueTypeMatrixConverter.cs" />
     <Compile Include="Converters\ValueTypeValueConverter.cs" />
-    <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="JsonItem.cs" />
@@ -78 +87 @@
   </ItemGroup>
   <ItemGroup>
-    <None Include="App.config" />
+    <None Include="HeuristicLab.snk" />
     <None Include="packages.config" />
   </ItemGroup>

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

@@ -77 +77 @@
           objToRemove.Add(x);
         } else {
-          x.Property(nameof(JsonItem.Path))?.Remove();
+          //x.Property(nameof(JsonItem.Path))?.Remove();
           x.Property(nameof(JsonItem.Type))?.Remove();
           x.Property(nameof(JsonItem.Parameters))?.Remove();

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

@@ -15 +15 @@
   public class JCInstantiator {
 
-    private JToken Config { get; set; }
+    private JToken Template { get; set; }
+    private JArray Config { get; set; }
+
     private Dictionary<string, string> TypeList = new Dictionary<string, string>();
+    private IDictionary<string, JsonItem> ParameterizedItems { get; set; } = new Dictionary<string, JsonItem>();
+    private IDictionary<string, JsonItem> ConfigurableItems { get; set; } = new Dictionary<string, JsonItem>();
+    
+    public IAlgorithm Instantiate(string templateFile, string configFile) {
 
-    public IAlgorithm Instantiate(string configFile) {
-      Config = JToken.Parse(File.ReadAllText(configFile));
-      TypeList = Config[Constants.Types].ToObject<Dictionary<string, string>>();
+      //1. Parse Template and Config files
+      Template = JToken.Parse(File.ReadAllText(templateFile));
+      Config = JArray.Parse(File.ReadAllText(configFile));
+      TypeList = Template[Constants.Types].ToObject<Dictionary<string, string>>();
+      string algorithmName = Template[Constants.Metadata][Constants.Algorithm].ToString();
+      string problemName = Template[Constants.Metadata][Constants.Problem].ToString();
 
-      JsonItem algorithmData = GetData(Config[Constants.Metadata][Constants.Algorithm].ToString());
-      ResolveReferences(algorithmData);
+      //2. Collect all parameterizedItems from template
+      CollectParameterizedItems();
+
+      //3. select all ConfigurableItems
+      SelectConfigurableItems();
+
+      //4. Merge Template and Config
+      MergeTemplateWithConfig();
+
+      //5. resolve the references between parameterizedItems
+      ResolveReferences();
+
+      //6. get algorthm data and object
+      JsonItem algorithmData = GetData(algorithmName);
       IAlgorithm algorithm = CreateObject<IAlgorithm>(algorithmData);
-     
-      JsonItem problemData = GetData(Config[Constants.Metadata][Constants.Problem].ToString());
-      ResolveReferences(problemData);
+
+      //7. get problem data and object
+      JsonItem problemData = GetData(problemName);
       IProblem problem = CreateObject<IProblem>(problemData);
       algorithm.Problem = problem;
 
+      //8. inject configuration
       JsonItemConverter.Inject(algorithm, algorithmData);
-      JsonItemConverter.Inject(algorithm, problemData);
+      JsonItemConverter.Inject(problem, problemData);
 
       return algorithm;
     }
 
-    private void ResolveReferences(JsonItem data) {
-      foreach (var p in data.Parameters)
-        if (p.Default is string && p.Reference == null)
-          p.Reference = GetData(p.Default.Cast<string>());
+    private void CollectParameterizedItems() {
+      foreach (JObject item in Template[Constants.Objects]) {
+        JsonItem data = BuildJsonItem(item);
+        ParameterizedItems.Add(data.Path, data);
+      }
+    }
+
+    private void SelectConfigurableItems() {
+      foreach (var item in ParameterizedItems.Values) {
+        if (item.Parameters != null)
+          AddConfigurableItems(item.Parameters);
+
+        if (item.Operators != null)
+          AddConfigurableItems(item.Operators);
+      }
+    }
+
+    private void AddConfigurableItems(IEnumerable<JsonItem> items) {
+      foreach (var item in items)
+        if (item.IsConfigurable)
+          ConfigurableItems.Add(item.Path, item);
+    }
+
+    private void ResolveReferences() {
+      foreach(var x in ParameterizedItems.Values)
+        foreach (var p in x.Parameters)
+          if (p.Default is string) {
+            string key = $"{p.Path}.{p.Default.Cast<string>()}";
+            if (ParameterizedItems.TryGetValue(key, out JsonItem value))
+              p.Reference = value;
+          }
+    }
+
+    private void MergeTemplateWithConfig() {
+      foreach (JObject obj in Config) {
+        // build item from config object
+        JsonItem item = BuildJsonItem(obj);
+        // override default value
+        if (ConfigurableItems.TryGetValue(item.Path, out JsonItem param)) {
+          param.Default = item.Default;
+          // override default value of reference (for ValueLookupParameters)
+          if (param.Reference != null)
+            param.Reference.Default = item.Reference?.Default;
+        } else throw new InvalidDataException($"No {Constants.FreeParameters.Trim('s')} with path='{item.Path}' defined!");
+      }
     }
 
     private JsonItem GetData(string key)
     {
-      foreach(JObject item in Config[Constants.Objects])
-      {
-        JsonItem data = BuildJsonItem(item);
-        if (data.Name == key) return data;
-      }
-      return null;
+      if (ParameterizedItems.TryGetValue(key, out JsonItem value))
+        return value;
+      else
+        throw new InvalidDataException($"Type of item '{key}' is not defined!");
     }
 
@@ -60 +121 @@
     }
 
+    #region BuildJsonItemMethods
     private JsonItem BuildJsonItem(JObject obj) =>
       new JsonItem() {
         Name = obj[nameof(JsonItem.Name)]?.ToString(),
+        Path = obj[nameof(JsonItem.Path)]?.ToString(),
         Default = obj[nameof(JsonItem.Default)]?.ToObject<object>(),
         Range = obj[nameof(JsonItem.Range)]?.ToObject<object[]>(),
-        Type = obj[nameof(JsonItem.Type)]?.ToObject<string>(),
+        Type = GetType(obj[nameof(JsonItem.Path)]?.ToObject<string>()),
         Reference = obj[nameof(JsonItem.Type)] == null ? 
                     null : 
@@ -73 +136 @@
       };
 
+    private string GetType(string path) {
+      if(!string.IsNullOrEmpty(path))
+        if (TypeList.TryGetValue(path, out string value))
+          return value;
+      return null;
+    }
+
     private IList<JsonItem> PopulateParameters(JObject obj) {
       IList<JsonItem> list = new List<JsonItem>();
+
+      // add staticParameters
       if (obj[Constants.StaticParameters] != null)
         foreach (JObject param in obj[Constants.StaticParameters])
           list.Add(BuildJsonItem(param));
 
+      // merge staticParameter with freeParameter
       if (obj[Constants.FreeParameters] != null) {
         foreach (JObject param in obj[Constants.FreeParameters]) {
           JsonItem tmp = BuildJsonItem(param);
+          
+          // search staticParameter from list
           JsonItem comp = null;
-          foreach (var p in list) // TODO: nicht notwendig, da immer alle params im static block sind
+          foreach (var p in list)
             if (p.Name == tmp.Name) comp = p;
-          if (comp != null) 
-            JsonItem.Merge(comp, tmp);
-          else list.Add(tmp);
+          if (comp == null)
+            throw new InvalidDataException($"Invalid {Constants.FreeParameters.Trim('s')}: '{tmp.Name}'!");
+
+          JsonItem.Merge(comp, tmp);
         }
       }
@@ -95 +171 @@
     private IList<JsonItem> PopulateOperators(JObject obj) {
       IList<JsonItem> list = new List<JsonItem>();
-      if (obj[nameof(Operators)] != null)
-        foreach (JObject sp in obj[nameof(Operators)]) {
-          JsonItem tmp = BuildJsonItem(sp);
-          list.Add(tmp);
-        }
+      JToken operators = obj[nameof(Operators)];
+      if (operators != null)
+        foreach (JObject sp in operators)
+          list.Add(BuildJsonItem(sp));
       return list;
     }
+    #endregion
   }
 }

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

@@ -15 +15 @@
     public string Name { get; set; }
     public string Type { get; set; }
+    public string Path { get; set; } = "";
+    public IList<JsonItem> Parameters { get; set; }
+    public IList<JsonItem> Operators { get; set; }
+
     public object Default {
       get => defaultValue; 
@@ -23 +27 @@
       } 
     }
-    public string Path { get; set; } = "";
 
     public IList<object> Range { 
@@ -33 +36 @@
       } 
     }
+        
+    public JsonItem Reference { get; set; }
 
-    public IList<JsonItem> Parameters { get; set; }
-    public IList<JsonItem> Operators { get; set; }
-    
-    public override bool Equals(object obj) => 
-      (obj is JsonItem ? (obj.Cast<JsonItem>().Name == this.Name) : false);
-      
-    public override int GetHashCode() => Name.GetHashCode();
+    [JsonIgnore]
+    public bool IsConfigurable => (Default != null && Range != null);
 
-    public JsonItem Reference { get; set; }
-    
     public static void Merge(JsonItem target, JsonItem from) {
       target.Name = from.Name ?? target.Name;
@@ -70 +68 @@
       if (Parameters != null)
         foreach (var p in Parameters)
-          p.Path = Path + "." + p.Name;
+          p.Path = $"{Path}.{p.Name}";
 
       if (Operators != null) 
         foreach (var p in Operators)
-          p.Path = Path + "." + p.Name;
+          p.Path = $"{Path}.{p.Name}";
     }
 
@@ -81 +79 @@
       PrependPathHelper(Parameters, str);
       PrependPathHelper(Operators, str);
-    }
-
-    private void PrependPathHelper(IEnumerable<JsonItem> items, string str) {
-      if (items != null)
-        foreach (var p in items)
-          p.PrependPath(str);
     }
 
@@ -100 +92 @@
         (((T)min).CompareTo(value) == -1 || ((T)min).CompareTo(value) == 0) &&
         (((T)max).CompareTo(value) == 1 || ((T)max).CompareTo(value) == 0));
+
+    private void PrependPathHelper(IEnumerable<JsonItem> items, string str) {
+      if (items != null)
+        foreach (var p in items)
+          p.PrependPath(str);
+    }
     #endregion
   }