Changeset 17349 for branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/JCGenerator.cs

Timestamp:

11/08/19 11:36:09 (5 years ago)

Author:

dpiringe

Message:

#3026

• added ConvertableAttribute, a new attribute for classes/structs (usage: convertable with JsonInterface)
• changed JCGenerator -> is now a static class with one public static method Instantiate
• changed JCInstantiator -> is now a static class with one public static method GenerateTemplate
• refactored JsonItem

File:

• branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/JCGenerator.cs (modified) (5 diffs)

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

@@ -9 +9 @@
 
 namespace HeuristicLab.JsonInterface {
-  public class JCGenerator {
-    private JObject template = JObject.Parse(Constants.Template);
-    private Dictionary<string, string> TypeList = new Dictionary<string, string>();
-    private JArray JsonItems { get; set; } = new JArray();
+  public static class JCGenerator {
 
-    public string GenerateTemplate(IAlgorithm algorithm) {
-      JsonItems.Clear();
-      TypeList.Clear();
+    private struct GenData {
+      public JObject Template { get; set; }
+      public IDictionary<string, string> TypeList { get; set; }
+      public JArray JsonItems { get; set; }
+    }
+
+
+    public static string GenerateTemplate(IAlgorithm algorithm) {
+      // data container
+      GenData genData = new GenData() {
+        Template = JObject.Parse(Constants.Template),
+        TypeList = new Dictionary<string, string>(),
+        JsonItems = new JArray()
+      };
 
       // 1.1. extract JsonItem, save the name in the metadata section of the 
       // template and save it an JArray incl. all parameters of the JsonItem, 
       // which have parameters aswell
-      AddInstantiableIItem(Constants.Algorithm, algorithm);
-      if (algorithm.Problem != null) // 1.2. only when an problem exists
-        AddInstantiableIItem(Constants.Problem, algorithm.Problem);
+      AddInstantiableIItem(Constants.Algorithm, algorithm, genData);
+      IsConvertable(algorithm, true);
+      if (algorithm.Problem != null && IsConvertable(algorithm.Problem, true)) // 1.2. only when an problem exists
+        AddInstantiableIItem(Constants.Problem, algorithm.Problem, genData);
 
       // 2. save the JArray with JsonItems (= IParameterizedItems)
-      template[Constants.Objects] = JsonItems;
+      genData.Template[Constants.Objects] = genData.JsonItems;
       // 3. save the types of the JsonItems (for instatiation)
-      template[Constants.Types] = JObject.FromObject(TypeList);
+      genData.Template[Constants.Types] = JObject.FromObject(genData.TypeList);
       // 4. serialize template and return string
-      return CustomJsonWriter.Serialize(template);
+      return CustomJsonWriter.Serialize(genData.Template);
+    }
+    
+    #region Helper
+    private static bool IsConvertable(object obj, bool throwException) {
+      bool tmp = ConvertableAttribute.IsConvertable(obj);
+      if (throwException && tmp)
+        throw new NotSupportedException($"Type {obj.GetType().Name} is not convertable!");
+      return tmp;
+    }
+    private static void AddInstantiableIItem(string metaDataTagName, IItem item, GenData genData) {
+      JsonItem jsonItem = JsonItemConverter.Extract(item);
+      genData.Template[Constants.Metadata][metaDataTagName] = item.ItemName;
+      PopulateJsonItems(jsonItem, genData);
     }
 
-    #region Helper
-    private void AddInstantiableIItem(string metaDataTagName, IItem item) {
-      JsonItem jsonItem = JsonItemConverter.Extract(item);
-      template[Constants.Metadata][metaDataTagName] = item.ItemName;
-      PopulateJsonItems(jsonItem);
-    }
-
-    private void PopulateJsonItems(JsonItem item) {
+    // serializes ParameterizedItems and saves them in list "JsonItems".
+    private static void PopulateJsonItems(JsonItem item, GenData genData) {
       if (item.Parameters != null) {
         if (item.Range == null)
-          JsonItems.Add(Serialize(item));
+          genData.JsonItems.Add(Serialize(item, genData));
         foreach (var p in item.Parameters)
-          if (p.Parameters != null)
-            PopulateJsonItems(p);
+          if (p.IsParameterizedItem)
+            PopulateJsonItems(p, genData);
       }
     }
 
-    private JObject Serialize(JsonItem item) {
+    private static JObject Serialize(JsonItem item, GenData genData) {
       JObject obj = JObject.FromObject(item, Settings());
       obj[Constants.StaticParameters] = obj[nameof(JsonItem.Parameters)];
@@ -62 +78 @@
       obj.Property(nameof(JsonItem.Type))?.Remove();
 
-      TypeList.Add(item.Path, item.Type);
+      genData.TypeList.Add(item.Path, item.Type);
       return obj;
     }
 
-    private void RefactorFreeParameters(JToken token) {
+    // deletes unnecessary properties for free parameters.
+    private static void RefactorFreeParameters(JToken token) {
       IList<JObject> objToRemove = new List<JObject>();
       TransformNodes(x => {
@@ -80 +97 @@
     }
 
-    private void RefactorStaticParameters(JToken token) {
+    // deletes unnecessary properties for static parameters.
+    private static void RefactorStaticParameters(JToken token) {
       IList<JObject> objToRemove = new List<JObject>();
       TransformNodes(x => {
@@ -88 +106 @@
         x.Property(nameof(JsonItem.Parameters))?.Remove();
         x.Property(nameof(JsonItem.Type))?.Remove();
-        if (p.Value == null) objToRemove.Add(x);
+        //TODO: maybe allow JsonItems with Value==null in static parameters too?
+        if (p.Value == null) objToRemove.Add(x); 
       }, token[Constants.StaticParameters]);
       foreach (var x in objToRemove) x.Remove();
     }
 
-    private JsonSerializer Settings() => new JsonSerializer() {
+    /// <summary>
+    /// Settings for the json serialization.
+    /// </summary>
+    /// <returns>A configured JsonSerializer.</returns>
+    private static JsonSerializer Settings() => new JsonSerializer() {
       TypeNameHandling = TypeNameHandling.None,
       NullValueHandling = NullValueHandling.Ignore,
@@ -99 +122 @@
     };
 
-    private void TransformNodes(Action<JObject> action, params JToken[] tokens) {
+    private static void TransformNodes(Action<JObject> action, params JToken[] tokens) {
       foreach(JObject obj in tokens.SelectMany(x => x.Children<JObject>()))
         action(obj);