deserialization now also works

Author: kaifox

src/main/java/org/tensorics/gson/adapters/TensorbackedGsonAdapter.java

@@ -1,73 +1,120 @@
 package org.tensorics.gson.adapters;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.Iterables;
 import com.google.gson.Gson;
 import com.google.gson.TypeAdapter;
+import com.google.gson.internal.JsonReaderInternalAccess;
 import com.google.gson.reflect.TypeToken;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
 import org.tensorics.core.lang.Tensorics;
+import org.tensorics.core.tensor.Position;
 import org.tensorics.core.tensor.Tensor;
-import org.tensorics.core.tensor.operations.TensorInternals;
 import org.tensorics.core.tensorbacked.Tensorbacked;
 import org.tensorics.core.tensorbacked.TensorbackedInternals;
+import org.tensorics.gson.util.Nestmaps;
 
 import java.io.IOException;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import static java.util.Objects.requireNonNull;
+import static org.tensorics.core.tensorbacked.TensorbackedInternals.valueTypeFrom;
 
 public class TensorbackedGsonAdapter<V, TB extends Tensorbacked<V>> extends TypeAdapter<TB> {
 
     private final Gson context;
     private final Class<TB> tensorbackedClass;
 
+    private final TypeAdapter<V> valueAdapter;
+
     public TensorbackedGsonAdapter(Gson context, Class<TB> tensorbackedClass) {
         this.context = context;
         this.tensorbackedClass = requireNonNull(tensorbackedClass, "tensorbackedClass must not be null.");
+
+        this.valueAdapter = adapterFor(valueTypeFrom(tensorbackedClass));
     }
 
     @Override
     public void write(JsonWriter out, TB value) throws IOException {
         /*XXX: The context of the tensor will currently NOT be serialized! */
 
         List<Class<?>> dimensions = TensorbackedInternals.dimensionListFrom(tensorbackedClass);
-        Object nested = nestmap(value.tensor(), dimensions);
+        Object nested = Nestmaps.nestmap(value.tensor(), dimensions);
         if (nested instanceof Map) {
             TypeAdapter<Map<?, ?>> adapter = context.getAdapter(new TypeToken<Map<?, ?>>() {
             });
             adapter.write(out, (Map<?, ?>) nested);
         } else { /* This is the special case of a scalar */
-            Class<V> valueType = TensorbackedInternals.valueTypeFrom(tensorbackedClass);
-            TypeAdapter<V> adapter = context.getAdapter(TypeToken.get(valueType));
-            adapter.write(out, (V) nested);
+            valueAdapter.write(out, (V) nested);
         }
     }
 
+    @Override
+    public TB read(JsonReader in) throws IOException {
+        List<Class<?>> dimensions = TensorbackedInternals.dimensionListFrom(tensorbackedClass);
+        Object object = recursiveRead(in, dimensions);
+        Tensor<V> unnested = Nestmaps.unnestmap(object, dimensions);
+        return TensorbackedInternals.createBackedByTensor(tensorbackedClass, unnested);
+    }
+
     @VisibleForTesting
-    static Object nestmap(Tensor<?> tensor, List<Class<?>> dimensions) {
-        int tensorDimensionality = Tensorics.dimensionsOf(tensor).size();
-        if (tensorDimensionality != dimensions.size()) {
-            throw new IllegalArgumentException("Tensor dimensionality (" + tensorDimensionality +
-                    ") and number of provided dimensions (" + dimensions.size() + ": " + dimensions +
-                    ") do not match!");
+    Object recursiveRead(JsonReader in, List<Class<?>> dimensions) throws IOException {
+        if (dimensions.isEmpty()) {
+            /* This is the special case of a scalar and the final value */
+            return valueAdapter.read(in);
+        } else {
+            Class<?> thisDim = dimensions.get(0);
+            List<Class<?>> remainingDims = dimensions.subList(1, dimensions.size());
+            return readMap(in, thisDim, remainingDims);
         }
+    }
 
-        if (dimensions.isEmpty()) {
-            return Tensorics.from(tensor).optional().orElse(null);
+    private <T> Map<T, Object> readMap(JsonReader in, Class<T> keyDim, List<Class<?>> remainingDimensions) throws IOException {
+        TypeAdapter<T> dimAdapter = adapterFor(keyDim);
+        Map<T, Object> map = new HashMap<>();
+
+        in.beginObject();
+        while (in.hasNext()) {
+            JsonReaderInternalAccess.INSTANCE.promoteNameToValue(in);
+            T key = dimAdapter.read(in);
+            Object value = recursiveRead(in, remainingDimensions);
+            map.put(key, value);
         }
+        in.endObject();
+
+        return map;
+    }
 
-        Class<?> dimension = Iterables.getLast(dimensions);
-        Tensor<? extends Map<?, ?>> mappedOut = TensorInternals.mapOut(tensor).inDirectionOf(dimension);
 
-        List<Class<?>> remainingDimensions = dimensions.subList(0, dimensions.size() - 1);
-        return nestmap(mappedOut, remainingDimensions);
+    private <T> TypeAdapter<T> adapterFor(Class<T> valueType) {
+        return context.getAdapter(TypeToken.get(valueType));
     }
 
-    @Override
-    public TB read(JsonReader in) throws IOException {
+
+    /*
+     JsonToken peek = in.peek();
+      if (peek == JsonToken.NULL) {
+        in.nextNull();
         return null;
-    }
+      }
+
+      Map<K, V> map = constructor.construct();
+
+      if (peek == JsonToken.BEGIN_ARRAY) {
+        in.beginArray();
+        while (in.hasNext()) {
+          in.beginArray(); // entry array
+          K key = keyTypeAdapter.read(in);
+          V value = valueTypeAdapter.read(in);
+          V replaced = map.put(key, value);
+          if (replaced != null) {
+            throw new JsonSyntaxException("duplicate key: " + key);
+          }
+          in.endArray();
+        }
+        in.endArray();
+      }
+     */
 }

src/main/java/org/tensorics/gson/util/Nestmaps.java

@@ -0,0 +1,69 @@
+package org.tensorics.gson.util;
+
+import com.google.common.collect.Iterables;
+import org.tensorics.core.lang.Tensorics;
+import org.tensorics.core.tensor.Position;
+import org.tensorics.core.tensor.Positions;
+import org.tensorics.core.tensor.Tensor;
+import org.tensorics.core.tensor.TensorBuilder;
+import org.tensorics.core.tensor.operations.TensorInternals;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Contains utility methods to convert tensors into nested maps and vice versa.
+ */
+public class Nestmaps {
+
+    private Nestmaps() {
+        throw new UnsupportedOperationException("Only static methods");
+    }
+
+    /**
+     * Creates a map of map of ... from the given tensor. If the passed in tensor is a scalar (tensor with dimension 0),
+     * then a simple value is returned. If the tensor is empty, then null is returned.
+     *
+     * @param tensor     the tensor to convert into a nested map
+     * @param dimensions the dimensions of the tensor. The first value in there will be the top level key type,
+     *                   the second the next level, etc.
+     * @return a nested map, or a value if the passed in value is a scalar.
+     */
+    public static Object nestmap(Tensor<?> tensor, List<Class<?>> dimensions) {
+        int tensorDimensionality = Tensorics.dimensionsOf(tensor).size();
+        if (tensorDimensionality != dimensions.size()) {
+            throw new IllegalArgumentException("Tensor dimensionality (" + tensorDimensionality +
+                    ") and number of provided dimensions (" + dimensions.size() + ": " + dimensions +
+                    ") do not match!");
+        }
+
+        if (dimensions.isEmpty()) {
+            return Tensorics.from(tensor).optional().orElse(null);
+        }
+
+        Class<?> dimension = Iterables.getLast(dimensions);
+        Tensor<? extends Map<?, ?>> mappedOut = TensorInternals.mapOut(tensor).inDirectionOf(dimension);
+
+        List<Class<?>> remainingDimensions = dimensions.subList(0, dimensions.size() - 1);
+        return nestmap(mappedOut, remainingDimensions);
+    }
+
+    public static <T> Tensor<T> unnestmap(Object in, List<Class<?>> dimensions) {
+        TensorBuilder<T> builder = Tensorics.builder(dimensions);
+        unnestmap(in, Position.of(), builder);
+        return builder.build();
+    }
+
+    public static <T> void unnestmap(Object remainingIn, Position pos, TensorBuilder<T> builder) {
+        if (remainingIn instanceof Map) {
+            Map<?, ?> map = (Map<?, ?>) remainingIn;
+            for (Map.Entry<?, ?> entry : map.entrySet()) {
+                Position newPos = Positions.union(pos, Position.of(entry.getKey()));
+                unnestmap(entry.getValue(), newPos, builder);
+            }
+        } else {
+            builder.put(pos, (T) remainingIn);
+        }
+    }
+
+}