DerivationNode JSON Serialization Using Gson

Author: rcosta358

liquidjava-verifier/pom.xml

@@ -188,6 +188,11 @@
 			<artifactId>antlr4-runtime</artifactId>
 			<version>4.7.1</version>
 		</dependency>
+		<dependency>
+			<groupId>com.google.code.gson</groupId>
+			<artifactId>gson</artifactId>
+			<version>2.10.1</version>
+		</dependency>
 
 	</dependencies>
 	<dependencyManagement>

liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/BinaryDerivationNode.java

@@ -1,12 +1,10 @@
 package liquidjava.rj_language.opt.derivation_node;
 
-import java.util.Map;
-
 public class BinaryDerivationNode extends DerivationNode {
 
+    private final String op;
     private final ValDerivationNode left;
     private final ValDerivationNode right;
-    private final String op;
 
     public BinaryDerivationNode(ValDerivationNode left, ValDerivationNode right, String op) {
         this.left = left;
@@ -25,15 +23,4 @@ public ValDerivationNode getRight() {
     public String getOp() {
         return op;
     }
-
-    @Override
-    public Map<String, Object> toJson() {
-        Map<String, Object> json = baseJson();
-        json.put("op", op);
-        if (left != null)
-            json.put("left", left.toJson());
-        if (right != null)
-            json.put("right", right.toJson());
-        return json;
-    }
 }

liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/DerivationNode.java

@@ -1,42 +1,17 @@
 package liquidjava.rj_language.opt.derivation_node;
 
-import java.util.LinkedHashMap;
-import java.util.Map;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
 
 public abstract class DerivationNode {
 
+    private static final Gson gson = new GsonBuilder()
+        .setPrettyPrinting() // remove later
+        .disableHtmlEscaping() // to not escape characters like &, >, <, =, etc.
+        .create();
+
     @Override
     public String toString() {
-        return prettyPrint(toJson(), "");
-    }
-
-    private String prettyPrint(Map<String, Object> json, String indent) {
-        StringBuilder sb = new StringBuilder();
-        String nextIndent = indent + "  ";
-        sb.append("{\n");
-        for (String key : json.keySet()) {
-            sb.append(nextIndent + "\"" + key + "\": ");
-            Object value = json.get(key);
-            if (value instanceof Map) {
-                sb.append(prettyPrint((Map<String, Object>) value, nextIndent));
-            } else if (value instanceof String) {
-                sb.append("\"" + value + "\"");
-            } else {
-                sb.append(value);
-            }
-            sb.append(",\n");
-        }
-        if (json.size() > 0) {
-            sb.setLength(sb.length() - 2); // remove last comma
-            sb.append("\n");
-        }
-        sb.append(indent + "}");
-        return sb.toString();
-    }
-
-    public abstract Map<String, Object> toJson();
-
-    protected Map<String, Object> baseJson() {
-        return new LinkedHashMap<>();
+        return gson.toJson(this);
     }
 }

liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/UnaryDerivationNode.java

@@ -1,31 +1,20 @@
 package liquidjava.rj_language.opt.derivation_node;
 
-import java.util.Map;
-
 public class UnaryDerivationNode extends DerivationNode {
 
+    private final String op;
     private final ValDerivationNode operand;
-    private final String operator;
 
-    public UnaryDerivationNode(ValDerivationNode operand, String operator) {
+    public UnaryDerivationNode(ValDerivationNode operand, String op) {
         this.operand = operand;
-        this.operator = operator;
+        this.op = op;
     }
 
     public ValDerivationNode getOperand() {
         return operand;
     }
 
-    public String getOperator() {
-        return operator;
-    }
-
-    @Override
-    public Map<String, Object> toJson() {
-        Map<String, Object> json = baseJson();
-        json.put("op", operator);
-        if (operand != null)
-            json.put("operand", operand.toJson());
-        return json;
+    public String getOp() {
+        return op;
     }
 }

liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/ValDerivationNode.java

@@ -1,6 +1,13 @@
 package liquidjava.rj_language.opt.derivation_node;
 
-import java.util.Map;
+import java.lang.reflect.Type;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonNull;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+import com.google.gson.annotations.JsonAdapter;
 
 import liquidjava.rj_language.ast.Expression;
 import liquidjava.rj_language.ast.LiteralBoolean;
@@ -10,6 +17,7 @@
 
 public class ValDerivationNode extends DerivationNode {
 
+    @JsonAdapter(ExpressionSerializer.class)
     private final Expression value;
     private final DerivationNode origin;
 
@@ -26,26 +34,20 @@ public DerivationNode getOrigin() {
         return origin;
     }
 
-    @Override
-    public Map<String, Object> toJson() {
-        Map<String, Object> json = baseJson();
-        json.put("value", expToValue(value));
-        if (origin != null)
-            json.put("origin", origin.toJson());
-        return json;
-    }
-
-    private Object expToValue(Expression exp) {
-        if (exp == null)
-            return null;
-        if (exp instanceof LiteralInt)
-            return ((LiteralInt) exp).getValue();
-        if (exp instanceof LiteralReal)
-            return ((LiteralReal) exp).getValue();
-        if (exp instanceof LiteralBoolean)
-            return ((LiteralBoolean) exp).isBooleanTrue();
-        if (exp instanceof Var)
-            return ((Var) exp).getName();
-        return exp.toString();
+    private static class ExpressionSerializer implements JsonSerializer<Expression> {
+        @Override
+        public JsonElement serialize(Expression exp, Type typeOfSrc, JsonSerializationContext context) {
+            if (exp == null)
+                return JsonNull.INSTANCE;
+            if (exp instanceof LiteralInt)
+                return new JsonPrimitive(((LiteralInt) exp).getValue());
+            if (exp instanceof LiteralReal)
+                return new JsonPrimitive(((LiteralReal) exp).getValue());
+            if (exp instanceof LiteralBoolean)
+                return new JsonPrimitive(((LiteralBoolean) exp).isBooleanTrue());
+            if (exp instanceof Var)
+                return new JsonPrimitive(((Var) exp).getName());
+            return new JsonPrimitive(exp.toString());
+        }
     }
 }

liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/VarDerivationNode.java

@@ -1,7 +1,5 @@
 package liquidjava.rj_language.opt.derivation_node;
 
-import java.util.Map;
-
 public class VarDerivationNode extends DerivationNode {
 
     private final String var;
@@ -13,12 +11,4 @@ public VarDerivationNode(String var) {
     public String getVar() {
         return var;
     }
-
-    @Override
-    public Map<String, Object> toJson() {
-        Map<String, Object> json = baseJson();
-        if (var != null)
-            json.put("var", var);
-        return json;
-    }
 }

liquidjava-verifier/src/test/java/liquidjava/rj_language/opt/ExpressionSimplifierTest.java

@@ -331,7 +331,7 @@ private void assertDerivationEquals(DerivationNode expected, DerivationNode actu
         } else if (expected instanceof UnaryDerivationNode) {
             UnaryDerivationNode expectedUnary = (UnaryDerivationNode) expected;
             UnaryDerivationNode actualUnary = (UnaryDerivationNode) actual;
-            assertEquals(expectedUnary.getOperator(), actualUnary.getOperator(), message + ": operators should match");
+            assertEquals(expectedUnary.getOp(), actualUnary.getOp(), message + ": operators should match");
             assertDerivationEquals(expectedUnary.getOperand(), actualUnary.getOperand(), message + " > operand");
         }
     }