operations on interface backed objects should also work now

Author: Kajetan Fuchsberger

src/java/org/tensorics/core/tensor/lang/OngoingTensorManipulation.java

@@ -29,6 +29,7 @@
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import org.tensorics.core.tensor.Coordinates;
@@ -38,8 +39,10 @@
 import org.tensorics.core.tensor.Positions;
 import org.tensorics.core.tensor.Tensor;
 import org.tensorics.core.tensor.operations.TensorInternals;
+import org.tensorics.core.tensor.stream.TensorStreams;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 
 /**
  * Part of the tensoric fluent API which provides methods to describe misc manipulations on a given tensor.
@@ -96,17 +99,27 @@ public V get(Object... coordinates) {
         return tensor.get(coordinates);
     }
 
-    public <C> List<V> list(List<C> listCoordinateValues, Position remainingCoordinates) {
+    public <C> List<V> list(List<C> listCoordinateValues, Position otherCoordinates) {
         return listCoordinateValues.stream().map(Position::of)//
-                .map(p -> Positions.union(remainingCoordinates, p)) //
+                .map(p -> Positions.union(otherCoordinates, p)) //
                 .map(p -> get(p))//
                 .collect(toImmutableList());
     }
 
-    public <C> List<V> list(List<C> listCoordinateValues, Object ...otherCoordinates) {
+    public <C> List<V> list(List<C> listCoordinateValues, Object... otherCoordinates) {
         return list(listCoordinateValues, Position.of(otherCoordinates));
     }
 
+    public <C> Map<C, V> map(Class<C> mapKeyType, Position otherCoordinates) {
+        Tensor<V> remaining = extract(otherCoordinates);
+        return TensorStreams.tensorEntryStream(remaining)
+                .collect(ImmutableMap.toImmutableMap(e -> e.getKey().coordinateFor(mapKeyType), e-> e.getValue())); //
+    }
+
+    public <C> Map<C, V> map(Class<C> mapKeyType, Object... otherCoordinates) {
+        return map(mapKeyType, Position.of(otherCoordinates));
+    }
+
     public Tensor<V> extract(Position position) {
         return extractTensor(position.coordinates());
     }

src/java/org/tensorics/core/tensorbacked/ProxiedInterfaceTensorbackeds.java

@@ -11,6 +11,7 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.Objects;
+import java.util.Optional;
 
 import org.tensorics.core.tensor.Tensor;
 import org.tensorics.core.util.JavaVersions;
@@ -30,6 +31,19 @@ public static <V, T extends Tensorbacked<V>> T create(Class<T> tensorbackedType,
                 new DelegatingInvocationHandler<>(tensor, tensorbackedType));
     }
 
+    public static < T extends Tensorbacked<?>> Optional<Class<T>> tensorbackedInterfaceFrom(T object) {
+        if (!(object instanceof Proxy)) {
+            return Optional.empty();
+        }
+
+        InvocationHandler handler = Proxy.getInvocationHandler(object);
+        if (!(handler instanceof DelegatingInvocationHandler)) {
+            return Optional.empty();
+        }
+
+        return Optional.of((DelegatingInvocationHandler<?, T>) handler).map(h -> h.intfc);
+    }
+    
     private final static class DelegatingInvocationHandler<V, T extends Tensorbacked<V>> implements InvocationHandler {
         private final Tensor<V> delegate;
         private final Class<T> intfc;

src/java/org/tensorics/core/tensorbacked/TensorbackedInternals.java

@@ -28,6 +28,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 
 import org.tensorics.core.lang.Tensorics;
@@ -58,7 +59,7 @@ private TensorbackedInternals() {
      * {@link Dimensions} annotation.
      *
      * @param tensorBackedClass the class for which to determine the dimensions
-     * @return the set of dimentions (classses of coordinates) which are required to create an instance of the given
+     * @return the set of dimensions (classses of coordinates) which are required to create an instance of the given
      * class.
      */
     public static <T extends Tensorbacked<?>> Set<Class<?>> dimensionsOf(Class<T> tensorBackedClass) {
@@ -123,6 +124,10 @@ public static final <TB extends Tensorbacked<?>> Iterable<Shape> shapesOf(Iterab
 
     @SuppressWarnings("unchecked")
     public static final <TB extends Tensorbacked<?>> Class<TB> classOf(TB tensorBacked) {
+        Optional<Class<TB>> proxiedInterface = ProxiedInterfaceTensorbackeds.tensorbackedInterfaceFrom(tensorBacked);
+        if (proxiedInterface.isPresent()) {
+            return proxiedInterface.get();
+        }
         return (Class<TB>) tensorBacked.getClass();
     }
 

src/java/org/tensorics/core/tensorbacked/dimtyped/Tensorbacked1d.java

@@ -5,5 +5,9 @@ public interface Tensorbacked1d<C1, V> extends DimtypedTensorbacked<V> {
     default V get(C1 c1) {
         return tensor().get(c1);
     }
+    
+    default boolean contains(C1 c1) {
+        return tensor().contains(c1);
+    }
 
 }

src/java/org/tensorics/core/tensorbacked/dimtyped/Tensorbacked2d.java

@@ -6,4 +6,8 @@ default V get(C1 c1, C2 c2) {
         return tensor().get(c1, c2);
     }
 
+    
+    default boolean contains(C1 c1, C2 c2) {
+        return tensor().contains(c1, c2);
+    }
 }

src/java/org/tensorics/core/tensorbacked/dimtyped/Tensorbacked3d.java

@@ -6,4 +6,8 @@ default V get(C1 c1, C2 c2, C3 c3) {
         return tensor().get(c1, c2, c3);
     }
 
+    default boolean contains(C1 c1, C2 c2, C3 c3) {
+        return tensor().contains(c1, c2, c3);
+    }
+    
 }

src/java/org/tensorics/core/tensorbacked/dimtyped/Tensorbacked4d.java

@@ -6,4 +6,8 @@ default V get(C1 c1, C2 c2, C3 c3, C4 c4) {
         return tensor().get(c1, c2, c3, c4);
     }
 
+    default boolean contains(C1 c1, C2 c2, C3 c3, C4 c4) {
+        return tensor().contains(c1, c2, c3, c4);
+    }
+
 }

src/java/org/tensorics/core/tensorbacked/dimtyped/Tensorbacked5d.java

@@ -5,5 +5,10 @@ public interface Tensorbacked5d<C1, C2, C3, C4, C5, V> extends DimtypedTensorbac
     default V get(C1 c1, C2 c2, C3 c3, C4 c4, C5 c5) {
         return tensor().get(c1, c2, c3, c4, c5);
     }
+    
+    default boolean contains(C1 c1, C2 c2, C3 c3, C4 c4, C5 c5) {
+        return tensor().contains(c1, c2, c3, c4, c5);
+    }
+    
 
 }

src/test/org/tensorics/core/tensorbacked/dimtyped/DimtypedOperationsTest.java

@@ -0,0 +1,34 @@
+package org.tensorics.core.tensorbacked.dimtyped;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.tensorics.core.lang.TensoricDoubles;
+import org.tensorics.core.lang.Tensorics;
+
+import java.util.NoSuchElementException;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DimtypedOperationsTest {
+
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+
+    @Test
+    public void tensorbacked1dElementMultiplication() {
+        ADoubleBackedVector vector = Tensorics.builderFor1D(ADoubleBackedVector.class).put("a", 1.2).build();
+        
+        ADoubleBackedVector newVector = TensoricDoubles.calculate(vector).elementTimesV(2.0);
+        Assertions.assertThat(newVector.get("a")).isEqualTo(2.4);
+    }
+
+
+    public interface ADoubleBackedVector extends Tensorbacked1d<String, Double> {
+
+    }
+
+}