Merge pull request #45 from LIonWeb-org/issue42

Implementing lower level unserialization

Author: ftomassetti

core/build.gradle

@@ -62,6 +62,7 @@ publishing {
     }
 }
 
-tasks.withType(JavaCompile) {
-    options.release = 8
+compileJava {
+    sourceCompatibility = '1.8'
+    targetCompatibility = '1.8'
 }

core/src/main/java/org/lionweb/lioncore/java/serialization/JsonSerialization.java

@@ -11,6 +11,7 @@
 import org.lionweb.lioncore.java.model.impl.M3Node;
 import org.lionweb.lioncore.java.self.LionCore;
 
+import javax.annotation.Nullable;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -58,6 +59,7 @@ public static JsonSerialization getBasicSerialization() {
 
     private Map<String, JsonObject> nodeIdToData = new HashMap<>();
     private Map<String, Node> nodeIdToNode = new HashMap<>();
+    private Map<String, NodeData> nodeIdToNodeData = new HashMap<>();
 
     private JsonSerialization() {
         // prevent public access
@@ -194,6 +196,19 @@ private <T extends Node> T populateProperties(T instance, JsonObject jsonObject)
         return instance;
     }
 
+    private NodeData populateProperties(NodeData instance, JsonObject jsonObject) {
+        if (!jsonObject.has("properties") && jsonObject.get("properties").isJsonObject()) {
+            return instance;
+        }
+        JsonObject properties = jsonObject.getAsJsonObject("properties");
+        for (String propertyId : properties.keySet()) {
+            String serializedValue = properties.get(propertyId).getAsString();
+            instance.setPropertyValue(propertyId, serializedValue);
+        }
+
+        return instance;
+    }
+
     private void populateLinks(Node node, JsonObject data) {
         if (data.has("children")) {
             JsonObject children = data.get("children").getAsJsonObject();
@@ -248,6 +263,40 @@ private void populateLinks(Node node, JsonObject data) {
         }
     }
 
+    private void populateLinks(NodeData node, JsonObject data) {
+        if (data.has("children")) {
+            JsonObject children = data.get("children").getAsJsonObject();
+            for (String containmentID : children.keySet()) {
+                JsonArray value = children.get(containmentID).getAsJsonArray();
+                for (JsonElement childEl : value.asList()) {
+                    String childId = childEl.getAsString();
+                    node.addChild(containmentID, childId);
+                }
+            }
+        }
+        if (data.has("references")) {
+            JsonObject references = data.get("references").getAsJsonObject();
+            for (String referenceID : references.keySet()) {
+                JsonArray value = references.get(referenceID).getAsJsonArray();
+                for (JsonElement referredEl : value.asList()) {
+                    try {
+                        JsonObject referenceObj = referredEl.getAsJsonObject();
+                        String referredId = getAsStringOrNull(referenceObj.get("reference"));
+                        String resolveInfo = getAsStringOrNull(referenceObj.get("resolveInfo"));
+                        node.addReferenceValue(referenceID, new NodeData.RawReferenceValue(referredId, resolveInfo));
+                    } catch (Exception e) {
+                        throw new RuntimeException("Issue deserializing reference " + referenceID, e);
+                    }
+                }
+            }
+        }
+        if (data.has("parent")) {
+            JsonElement parentValue = data.get("parent");
+            String parentNodeID = parentValue instanceof JsonNull ? null : parentValue.getAsString();
+            node.setParentNodeID(parentNodeID);
+        }
+    }
+
     private String getAsStringOrNull(JsonElement element) {
         if (element == null || element.isJsonNull()) {
             return null;
@@ -256,7 +305,53 @@ private String getAsStringOrNull(JsonElement element) {
         }
     }
 
-    public List<Node> unserialize(JsonElement jsonElement) {
+    /**
+     * This will return a lower-level representation of the information stored in JSON.
+     * It is intended to load broken models.
+     *
+     * Possible usages: repair a broken model, extract a metamodel from the model (“model archeology”), etc.
+     *
+     * This method follows a "best-effort" approach, try to limit exception thrown and return data whenever is possible,
+     * in the measure that it is possible.
+     */
+    public List<NodeData> rawUnserialization(JsonElement jsonElement) {
+        if (jsonElement.isJsonObject()) {
+            JsonObject topLevel = jsonElement.getAsJsonObject();
+            if (!topLevel.has("nodes")) {
+                return Collections.emptyList();
+            }
+            if (topLevel.get("nodes").isJsonArray()) {
+                List<NodeData> nodes = topLevel.get("nodes").getAsJsonArray().asList().stream().map(element -> {
+                    try {
+                        NodeData nodeData = unserializeNodeData(element);
+                        if (nodeData != null && nodeData.getID() != null) {
+                            this.nodeIdToData.put(nodeData.getID(), element.getAsJsonObject());
+                            this.nodeIdToNodeData.put(nodeData.getID(), nodeData);
+                        }
+                        return nodeData;
+                    } catch (Exception e) {
+                        throw new RuntimeException("Issue while unserializing " + element, e);
+                    }
+                }).filter(e -> e != null).collect(Collectors.toList());
+                for (Map.Entry<String, JsonObject> entry : nodeIdToData.entrySet()) {
+                    try {
+                        populateLinks(nodeIdToNodeData.get(entry.getKey()), entry.getValue());
+                    } catch (Exception e) {
+                        throw new RuntimeException("Issue while unserializing " + entry, e);
+                    }
+                }
+                nodeIdToData.clear();
+                nodeIdToNodeData.clear();
+                return nodes;
+            } else {
+                return Collections.emptyList();
+            }
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+    public List<Node> unserializeToNode(JsonElement jsonElement) {
         if (jsonElement.isJsonObject()) {
             JsonObject topLevel = jsonElement.getAsJsonObject();
             if (!topLevel.has("serializationFormatVersion")) {
@@ -315,6 +410,20 @@ private Node unserializeNode(JsonElement jsonElement) {
         }
     }
 
+    @Nullable
+    private NodeData unserializeNodeData(JsonElement jsonElement) {
+        if (jsonElement.isJsonObject()) {
+            JsonObject jsonObject = jsonElement.getAsJsonObject();
+            String conceptID = tryToGetStringProperty(jsonObject, CONCEPT_LABEL);
+            String nodeID = tryToGetStringProperty(jsonObject, ID_LABEL);
+            NodeData nodeData = new NodeData(nodeID, conceptID);
+            populateProperties(nodeData, jsonObject);
+            return nodeData;
+        } else {
+            return null;
+        }
+    }
+
     private String getStringProperty(JsonObject jsonObject, String propertyName) {
         if (!jsonObject.has(propertyName)) {
             throw new IllegalArgumentException(propertyName + " property not found in " + jsonObject);
@@ -327,4 +436,17 @@ private String getStringProperty(JsonObject jsonObject, String propertyName) {
         }
     }
 
+    @Nullable
+    private String tryToGetStringProperty(JsonObject jsonObject, String propertyName) {
+        if (!jsonObject.has(propertyName)) {
+            return null;
+        }
+        JsonElement value = jsonObject.get(propertyName);
+        if (value.isJsonPrimitive() && value.getAsJsonPrimitive().isString()) {
+            return value.getAsJsonPrimitive().getAsString();
+        } else {
+            return null;
+        }
+    }
+
 }

core/src/main/java/org/lionweb/lioncore/java/serialization/NodeData.java

@@ -0,0 +1,121 @@
+package org.lionweb.lioncore.java.serialization;
+
+import javax.annotation.Nullable;
+import java.util.*;
+import java.util.function.Function;
+
+/**
+ * Lower level representation of Node which is used to load broken nodes during serialization.
+ */
+public class NodeData {
+    private String id;
+    private String conceptId;
+    private String parentNodeID;
+    private Map<String, String> propertyValues = new HashMap<>();
+    private Map<String, List<String>> containmentsValues = new HashMap<>();
+    private Map<String, List<RawReferenceValue>> referencesValues = new HashMap<>();
+
+    public String getParentNodeID() {
+        return parentNodeID;
+    }
+
+    public void setParentNodeID(String parentNodeID) {
+        this.parentNodeID = parentNodeID;
+    }
+
+    public List<String> getChildren() {
+        List<String> children = new ArrayList<>();
+        for (List<String> ch : containmentsValues.values()) {
+            children.addAll(ch);
+        }
+        return children;
+    }
+
+    public static class RawReferenceValue {
+        public String referredId;
+        public String resolveInfo;
+
+        public String getReferredId() {
+            return referredId;
+        }
+
+        public void setReferredId(String referredId) {
+            this.referredId = referredId;
+        }
+
+        public String getResolveInfo() {
+            return resolveInfo;
+        }
+
+        public void setResolveInfo(String resolveInfo) {
+            this.resolveInfo = resolveInfo;
+        }
+
+        public RawReferenceValue(String referredId, String resolveInfo) {
+            this.referredId = referredId;
+            this.resolveInfo = resolveInfo;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (!(o instanceof RawReferenceValue)) return false;
+            RawReferenceValue that = (RawReferenceValue) o;
+            return Objects.equals(referredId, that.referredId) && Objects.equals(resolveInfo, that.resolveInfo);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(referredId, resolveInfo);
+        }
+    }
+
+    public NodeData() {
+
+    }
+
+    public NodeData(String id, String conceptId) {
+        setID(id);
+        setConceptID(conceptId);
+    }
+
+    public String getConceptID() {
+        return conceptId;
+    }
+
+    public void setConceptID(String conceptId) {
+        this.conceptId = conceptId;
+    }
+
+    @Nullable
+    public String getID() {
+        return id;
+    }
+
+
+    public void setID(String id) {
+        this.id = id;
+    }
+
+    public void setPropertyValue(String propertyId, String serializedValue) {
+        this.propertyValues.put(propertyId, serializedValue);
+    }
+
+    public void addChild(String containmentID, String childId) {
+        this.containmentsValues.computeIfAbsent(containmentID, s -> new ArrayList<>()).add(childId);
+    }
+
+    public void addReferenceValue(String referenceID, RawReferenceValue referenceValue) {
+        this.referencesValues.computeIfAbsent(referenceID, s -> new ArrayList<>()).add(referenceValue);
+    }
+
+    @Nullable
+    public String getPropertyValue(String propertyId) {
+        return this.propertyValues.get(propertyId);
+    }
+
+    @Nullable
+    public List<RawReferenceValue> getReferenceValues(String referenceID) {
+        return this.referencesValues.getOrDefault(referenceID, new ArrayList<>());
+    }
+}