Merge pull request #46 from tensorics/gson-prep

kaifox · web-flow · commit bff97b72cea2 · 2022-11-21T22:54:48.000+01:00
preparation for gson adaptation
diff --git a/src/java/org/tensorics/core/lang/Tensorics.java b/src/java/org/tensorics/core/lang/Tensorics.java
@@ -124,6 +124,10 @@ public static <T> TensorBuilder<T> builder(Class<?>... dimensions) {
         return ImmutableTensor.builder(dimensions);
     }
 
+    public static <T> TensorbackedScalarBuilder<T, TensorbackedScalar<T>> builderBacked() {
+        return DimtypedTensorbackedBuilderImpl.from(ImmutableTensor.builder(), TensorbackedScalarBuilder.class, TensorbackedScalar.class);
+    }
+
     public static <C1, T> Tensorbacked1dBuilder<C1, T, Tensorbacked1d<C1, T>> builderBacked(Class<C1> dimension1) {
         return DimtypedTensorbackedBuilderImpl.from(ImmutableTensor.builder(dimension1), Tensorbacked1dBuilder.class, Tensorbacked1d.class);
     }
@@ -198,6 +202,13 @@ public static <V, TB extends Tensorbacked<V>> SimpleTensorbackedBuilder<V, TB> b
         return Tensorbackeds.builderFor(tensorbackedClass);
     }
 
+    /**
+     * @see Tensorbackeds#builderForScalar(Class) 
+     */
+    public static <V, TB extends TensorbackedScalar< V>> TensorbackedScalarBuilder<V, TB> builderForScalar(Class<TB> tensorbackedClass) {
+        return Tensorbackeds.builderForScalar(tensorbackedClass);
+    }
+
     /**
      * @see Tensorbackeds#builderFor1D(Class)
      */
@@ -450,7 +461,7 @@ public static <S> void forEach(Tensor<S> tensor, BiConsumer<Position, S> consume
     }
 
     public static Scalar<QuantifiedValue<Double>> zeroDimensionalOf(double value,
-                                                                          javax.measure.unit.Unit<?> unit) {
+                                                                    javax.measure.unit.Unit<?> unit) {
         QuantifiedValue<Double> quantity = quantityOf(value, unit);
         return scalarOf(quantity);
     }
diff --git a/src/java/org/tensorics/core/tensorbacked/TensorbackedInternals.java b/src/java/org/tensorics/core/tensorbacked/TensorbackedInternals.java
@@ -31,6 +31,8 @@
 import java.util.Optional;
 import java.util.Set;
 
+import com.google.common.collect.ImmutableList;
+import com.google.common.reflect.TypeToken;
 import org.tensorics.core.lang.Tensorics;
 import org.tensorics.core.tensor.Positions;
 import org.tensorics.core.tensor.Shape;
@@ -63,23 +65,28 @@ private TensorbackedInternals() {
      * class.
      */
     public static <T extends Tensorbacked<?>> Set<Class<?>> dimensionsOf(Class<T> tensorBackedClass) {
+        return ImmutableSet.copyOf(dimensionListFrom(tensorBackedClass));
+    }
+
+    public static <T extends Tensorbacked<?>> List<Class<?>> dimensionListFrom(Class<T> tensorBackedClass) {
         if (DimtypedTensorbacked.class.isAssignableFrom(tensorBackedClass)) {
             if (tensorBackedClass.isAnnotationPresent(Dimensions.class)) {
                 throw new IllegalArgumentException("No annotation of type '" + Dimensions.class + "' must be present in case " +
                         DimtypedTensorbacked.class + " is implemented. This rule is violated for class " + tensorBackedClass + ".");
             }
-            return DimtypedTypes.dimensionsFrom((Class<? extends DimtypedTensorbacked>) tensorBackedClass);
+            return DimtypedTypes.dimensionListFrom((Class<? extends DimtypedTensorbacked>) tensorBackedClass);
         } else {
             Dimensions dimensionAnnotation = tensorBackedClass.getAnnotation(Dimensions.class);
             if (dimensionAnnotation == null) {
                 throw new IllegalArgumentException(
                         "Neither an annotation of type '" + Dimensions.class + "' is present on the class '" + tensorBackedClass
                                 + "', nor does it inherit from " + DimtypedTensorbacked.class + ". Therefore, the dimensions of this tensorbacked type cannot be determined.");
             }
-            return ImmutableSet.copyOf(dimensionAnnotation.value());
+            return ImmutableList.copyOf(dimensionAnnotation.value());
         }
     }
 
+
     /**
      * Creates an instance of a class backed by a tensor.
      *
@@ -154,4 +161,17 @@ private static <E> Tensor<E> copyWithDimensions(Tensor<E> tensor, Set<Class<?>>
         builder.context(tensor.context());
         return builder.build();
     }
+
+    /**
+     * Determines the type of the value of the given tensorbacked class.
+     *
+     * @param tensorBackedClass the class from which to determine the value type
+     * @param <T>               the type of the tensorbacked
+     * @return the type of the value
+     */
+    public static <V, T extends Tensorbacked<V>> Class<V> valueTypeFrom(Class<T> tensorBackedClass) {
+        TypeToken<T> tbToken = TypeToken.of(tensorBackedClass);
+        TypeToken<?> valueToken = tbToken.resolveType(Tensorbacked.class.getTypeParameters()[0]);
+        return (Class<V>) valueToken.getRawType();
+    }
 }
diff --git a/src/java/org/tensorics/core/tensorbacked/Tensorbackeds.java b/src/java/org/tensorics/core/tensorbacked/Tensorbackeds.java
@@ -32,17 +32,7 @@
 import org.tensorics.core.tensor.lang.QuantityTensors;
 import org.tensorics.core.tensor.lang.TensorStructurals;
 import org.tensorics.core.tensorbacked.annotation.Dimensions;
-import org.tensorics.core.tensorbacked.dimtyped.DimtypedTensorbackedBuilderImpl;
-import org.tensorics.core.tensorbacked.dimtyped.Tensorbacked1d;
-import org.tensorics.core.tensorbacked.dimtyped.Tensorbacked1dBuilder;
-import org.tensorics.core.tensorbacked.dimtyped.Tensorbacked2d;
-import org.tensorics.core.tensorbacked.dimtyped.Tensorbacked2dBuilder;
-import org.tensorics.core.tensorbacked.dimtyped.Tensorbacked3d;
-import org.tensorics.core.tensorbacked.dimtyped.Tensorbacked3dBuilder;
-import org.tensorics.core.tensorbacked.dimtyped.Tensorbacked4d;
-import org.tensorics.core.tensorbacked.dimtyped.Tensorbacked4dBuilder;
-import org.tensorics.core.tensorbacked.dimtyped.Tensorbacked5d;
-import org.tensorics.core.tensorbacked.dimtyped.Tensorbacked5dBuilder;
+import org.tensorics.core.tensorbacked.dimtyped.*;
 import org.tensorics.core.tensorbacked.lang.OngoingTensorbackedConstruction;
 import org.tensorics.core.tensorbacked.lang.OngoingTensorbackedFiltering;
 import org.tensorics.core.units.Unit;
@@ -75,6 +65,10 @@ public static <V, TB extends Tensorbacked<V>> SimpleTensorbackedBuilder<V, TB> b
         return new SimpleTensorbackedBuilder<>(tensorbackedClass);
     }
 
+    public static <V, TB extends TensorbackedScalar< V>> TensorbackedScalarBuilder<V, TB> builderForScalar(Class<TB> tensorbackedClass) {
+        return DimtypedTensorbackedBuilderImpl.immutableBuilderFrom(tensorbackedClass, TensorbackedScalarBuilder.class);
+    }
+
     public static <C1, V, TB extends Tensorbacked1d<C1, V>> Tensorbacked1dBuilder<C1, V, TB> builderFor1D(Class<TB> tensorbackedClass) {
         return DimtypedTensorbackedBuilderImpl.immutableBuilderFrom(tensorbackedClass, Tensorbacked1dBuilder.class);
     }
diff --git a/src/java/org/tensorics/core/tensorbacked/dimtyped/DimtypedTypes.java b/src/java/org/tensorics/core/tensorbacked/dimtyped/DimtypedTypes.java
@@ -1,15 +1,19 @@
 package org.tensorics.core.tensorbacked.dimtyped;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.reflect.TypeToken;
 
+import java.util.Collection;
+import java.util.List;
 import java.util.NoSuchElementException;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
+import static com.google.common.collect.ImmutableList.toImmutableList;
 import static java.util.stream.Collectors.toSet;
 
 public final class DimtypedTypes {
@@ -63,29 +67,42 @@ public static Class<? extends DimtypedTensorbacked> coordinateParametrizedSubtyp
         return Iterables.getOnlyElement(found);
     }
 
-    public static Set<Class<?>> dimensionsFrom(Class<? extends DimtypedTensorbacked> tensorbackedClass) {
+    public static List<Class<?>> dimensionListFrom(Class<? extends DimtypedTensorbacked> tensorbackedClass) {
         Class<? extends DimtypedTensorbacked> coordinateParametrized = coordinateParametrizedSubtypeOf(tensorbackedClass);
         int dimensionality = DIMENSION_PARAMETRIZED_TYPES.get(coordinateParametrized);
 
         TypeToken<?> tt = TypeToken.of(tensorbackedClass);
-        Set<Class<?>> dimensions = IntStream.range(0, dimensionality)
+        List<Class<?>> dimensions = IntStream.range(0, dimensionality)
                 .mapToObj(i -> tt.resolveType(coordinateParametrized.getTypeParameters()[i]))
                 .map(typeToken -> typeToken.getRawType())
-                .collect(toSet());
+                .collect(toImmutableList());
+
+        assertNoObjectDimension(tensorbackedClass, dimensions);
+        assertDistinctDimensionality(coordinateParametrized, dimensions);
+        return dimensions;
+    }
 
+    private static void assertNoObjectDimension(Class<? extends DimtypedTensorbacked> tensorbackedClass, Collection<Class<?>> dimensions) {
         if (dimensions.contains(Object.class)) {
             /* If type parameters are not explicitely defined in a subtype, then they seem to be resolved to Object.class.
                However, this is not what we want for dimensions...            */
             throw new IllegalArgumentException("At least one of the extracted dimensions is '" + Object.class + "'. This is most probably a conceptual error.\n" +
                     "Most probably, the passed in class (" + tensorbackedClass + ") is not a valid subtype with resolvable type parameters.");
         }
-        if (dimensions.size() != dimensionality) {
-            throw new IllegalArgumentException("The size of the set of the retrieved dimensions (size=" + dimensions.size() + ", dimensions=" + dimensions + "), " +
+    }
+
+    private static void assertDistinctDimensionality(Class<? extends DimtypedTensorbacked> coordinateParametrized, Collection<Class<?>> dimensions) {
+        int dimensionality = DIMENSION_PARAMETRIZED_TYPES.get(coordinateParametrized);
+        Collection<Class<?>> distinctDimensions = ImmutableSet.copyOf(dimensions);
+        if (distinctDimensions.size() != dimensionality) {
+            throw new IllegalArgumentException("The size of the set of the retrieved distinct dimensions (size=" + distinctDimensions.size() + ", dimensions=" + distinctDimensions + "), " +
                     "is not equal to the required number of dimensions (" + dimensionality + ") for the parametrized class " + coordinateParametrized + ".\n"
                     + "Probably two dimensions are of the same type?");
         }
-        return dimensions;
+    }
 
+    public static Set<Class<?>> dimensionsFrom(Class<? extends DimtypedTensorbacked> tensorbackedClass) {
+        return ImmutableSet.copyOf(dimensionListFrom(tensorbackedClass));
     }
 
     private static ImmutableSet<Class<? extends DimtypedTensorbacked>> allowedTypes() {
diff --git a/src/test/org/tensorics/core/tensorbacked/ValueTypeDeterminationTest.java b/src/test/org/tensorics/core/tensorbacked/ValueTypeDeterminationTest.java
@@ -0,0 +1,38 @@
+package org.tensorics.core.tensorbacked;
+
+import org.junit.Test;
+import org.tensorics.core.tensor.Tensor;
+import org.tensorics.core.tensorbacked.AbstractTensorbacked;
+import org.tensorics.core.tensorbacked.TensorbackedInternals;
+import org.tensorics.core.tensorbacked.annotation.Dimensions;
+import org.tensorics.core.tensorbacked.dimtyped.Tensorbacked1d;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ValueTypeDeterminationTest {
+
+    @Test
+    public void valueTypeWorksForInherited() {
+        Class<?> valueType = TensorbackedInternals.valueTypeFrom(AnInheritedTensorbacked.class);
+        assertThat(valueType).isEqualTo(Double.class);
+    }
+
+    @Test
+    public void valueTypeWorksForInterface() {
+        Class<?> valueType = TensorbackedInternals.valueTypeFrom(AnInterfaceDerivedTensorbacked.class);
+        assertThat(valueType).isEqualTo(Double.class);
+    }
+
+    @Dimensions({String.class, Integer.class})
+    public static class AnInheritedTensorbacked extends AbstractTensorbacked<Double> {
+
+        public AnInheritedTensorbacked(Tensor<Double> tensor) {
+            super(tensor);
+        }
+
+    }
+
+    public interface AnInterfaceDerivedTensorbacked extends Tensorbacked1d<String, Double> {
+
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -124,6 +124,10 @@ public static <T> TensorBuilder<T> builder(Class<?>... dimensions) {`
`124`	`124`	`return ImmutableTensor.builder(dimensions);`
`125`	`125`	`}`
`126`	`126`
	`127`	`+ public static <T> TensorbackedScalarBuilder<T, TensorbackedScalar<T>> builderBacked() {`
	`128`	`+ return DimtypedTensorbackedBuilderImpl.from(ImmutableTensor.builder(), TensorbackedScalarBuilder.class, TensorbackedScalar.class);`
	`129`	`+ }`
	`130`	`+`
`127`	`131`	`public static <C1, T> Tensorbacked1dBuilder<C1, T, Tensorbacked1d<C1, T>> builderBacked(Class<C1> dimension1) {`
`128`	`132`	`return DimtypedTensorbackedBuilderImpl.from(ImmutableTensor.builder(dimension1), Tensorbacked1dBuilder.class, Tensorbacked1d.class);`
`129`	`133`	`}`
`@@ -198,6 +202,13 @@ public static <V, TB extends Tensorbacked<V>> SimpleTensorbackedBuilder<V, TB> b`
`198`	`202`	`return Tensorbackeds.builderFor(tensorbackedClass);`
`199`	`203`	`}`
`200`	`204`
	`205`	`+ /**`
	`206`	`+ * @see Tensorbackeds#builderForScalar(Class)`
	`207`	`+ */`
	`208`	`+ public static <V, TB extends TensorbackedScalar< V>> TensorbackedScalarBuilder<V, TB> builderForScalar(Class<TB> tensorbackedClass) {`
	`209`	`+ return Tensorbackeds.builderForScalar(tensorbackedClass);`
	`210`	`+ }`
	`211`	`+`
`201`	`212`	`/**`
`202`	`213`	`* @see Tensorbackeds#builderFor1D(Class)`
`203`	`214`	`*/`
`@@ -450,7 +461,7 @@ public static <S> void forEach(Tensor<S> tensor, BiConsumer<Position, S> consume`
`450`	`461`	`}`
`451`	`462`
`452`	`463`	`public static Scalar<QuantifiedValue<Double>> zeroDimensionalOf(double value,`
`453`		`- javax.measure.unit.Unit<?> unit) {`
	`464`	`+ javax.measure.unit.Unit<?> unit) {`
`454`	`465`	`QuantifiedValue<Double> quantity = quantityOf(value, unit);`
`455`	`466`	`return scalarOf(quantity);`
`456`	`467`	`}`