latestofexpression. Better error message when a node is not resolved. Placeholder of classes

Author: andreacalia

src/java/org/tensorics/core/expressions/LatestOfExpression.java

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2017 European Organisation for Nuclear Research (CERN), All Rights Reserved.
+ */
+
+package org.tensorics.core.expressions;
+
+import java.util.List;
+
+import org.tensorics.core.tree.domain.Expression;
+
+import com.google.common.collect.Iterables;
+
+/**
+ * Expression that given an {@link Expression} of {@link List} of T, it gets the latest. Especially usefull for buffers.
+ * 
+ * @param <T>
+ */
+public class LatestOfExpression<T> extends ConversionOperationExpression<Iterable<T>, T> {
+
+    private static final long serialVersionUID = 6562010523280754793L;
+
+    private final Expression<Iterable<T>> bufferExpression;
+
+    private LatestOfExpression(Expression<Iterable<T>> source) {
+        super(Iterables::getLast, source);
+        bufferExpression = source;
+    }
+
+    public static <T> LatestOfExpression<T> latestOf(Expression<Iterable<T>> source) {
+        return new LatestOfExpression<>(source);
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = super.hashCode();
+        result = prime * result + ((bufferExpression == null) ? 0 : bufferExpression.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (!super.equals(obj))
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        LatestOfExpression<?> other = (LatestOfExpression<?>) obj;
+        if (bufferExpression == null) {
+            if (other.bufferExpression != null)
+                return false;
+        } else if (!bufferExpression.equals(other.bufferExpression))
+            return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "LatestOfExpression [bufferExpression=" + bufferExpression + "]";
+    }
+
+}

src/java/org/tensorics/core/expressions/Placeholder.java

@@ -22,6 +22,10 @@ public class Placeholder<R> extends AbstractDeferredExpression<R> {
     public static <R> Placeholder<R> ofName(String name) {
         return new Placeholder<>(name);
     }
+    
+    public static <R> Placeholder<R> ofClass(Class<R> clazz) {
+        return new Placeholder<>(clazz.getName());
+    }
 
     private Placeholder(String name) {
         this.name = requireNonNull(name, "name must not be null.");

src/java/org/tensorics/core/resolve/engine/BiggestSubTreeDispatcher.java

@@ -33,6 +33,7 @@
 import org.tensorics.core.resolve.options.ResolvingOption;
 import org.tensorics.core.resolve.resolvers.Resolver;
 import org.tensorics.core.resolve.resolvers.ResolverRepository;
+import org.tensorics.core.resolve.resolvers.Resolvers;
 import org.tensorics.core.tree.domain.Contexts;
 import org.tensorics.core.tree.domain.EditableResolvingContext;
 import org.tensorics.core.tree.domain.Expression;
@@ -84,7 +85,7 @@ public ResolvingContext processTree(Node rootNode, ResolvingContext oldContext,
      */
     private ResolverCandidateRepository findResolverCandidates(Node startingNode, final ResolvingContext oldContext) {
 
-        final ResolverCandidateRepository directlyExecutableNodes = new ResolverCandidateRepository(oldContext);
+        final ResolverCandidateRepository repository = new ResolverCandidateRepository(oldContext);
 
         Trees.walkParentAfterChildren(startingNode, new SkipNodeAndSubTreesCallback() {
 
@@ -105,15 +106,20 @@ private <R> boolean process(Expression<R> expression) {
 
                 for (Resolver<R, Expression<R>> resolver : resolvers) {
                     if (resolver.canResolve(expression, oldContext)) {
-                        directlyExecutableNodes.put(expression, resolver);
+                        repository.put(expression, resolver);
                     }
                 }
 
-                return directlyExecutableNodes.containsKey(expression);
+                if (repository.resolversFor(expression).isEmpty() && Resolvers.contextResolvesAllNodes(expression.getChildren(), oldContext)) {
+                    throw new IllegalStateException("No resolvers could be found for node " + expression
+                            + ", while all children are already resolved.");
+                }
+                
+                return repository.containsKey(expression);
             }
 
         });
-        return directlyExecutableNodes;
+        return repository;
     }
 
     static class ResolverCandidateRepository {
@@ -152,7 +158,8 @@ private boolean containsKey(Expression<?> expression) {
 
         private <R, E extends Expression<R>> void resolveNode(E expression, EditableResolvingContext context,
                 ResolverSelectionStrategy resolverSelection) {
-            Resolver<R, E> resolver = resolverSelection.selectResolver(resolversFor(expression));
+            List<Resolver<R, E>> resolverCandidates = resolversFor(expression);
+            Resolver<R, E> resolver = resolverSelection.selectResolver(resolverCandidates);
             context.put(expression, resolver.resolve(expression, oldContext));
         }
 

src/java/org/tensorics/core/resolve/resolvers/Resolvers.java

@@ -27,6 +27,7 @@
 import java.util.List;
 
 import org.tensorics.core.tree.domain.Expression;
+import org.tensorics.core.tree.domain.Node;
 import org.tensorics.core.tree.domain.ResolvingContext;
 
 /**
@@ -76,4 +77,10 @@ public static final boolean contextResolvesAll(List<? extends Expression<?>> exp
             ResolvingContext context) {
         return expressions.stream().allMatch(context::resolves);
     }
+    
+    public static final boolean contextResolvesAllNodes(List<? extends Node> expressions,
+            ResolvingContext context) {
+        /*XXX ugly cast */
+        return expressions.stream().map(n -> (Expression<?>) n).allMatch(context::resolves);
+    }
 }

src/test/org/tensorics/core/expressions/LatestOfExpressionTest.java

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2017 European Organisation for Nuclear Research (CERN), All Rights Reserved.
+ */
+
+package org.tensorics.core.expressions;
+
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.tensorics.core.expressions.LatestOfExpression.latestOf;
+import static org.tensorics.core.tree.domain.ResolvedExpression.of;
+
+import java.util.Arrays;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.tensorics.core.resolve.engine.ResolvingEngine;
+import org.tensorics.core.resolve.engine.ResolvingEngines;
+import org.tensorics.core.tree.domain.Expression;
+import org.tensorics.core.tree.domain.ResolvedExpression;
+
+public class LatestOfExpressionTest {
+
+    private ResolvingEngine engine;
+
+    @Before
+    public void setUp() {
+        engine = ResolvingEngines.defaultEngine();
+    }
+
+    @Test
+    public void testLatestValue() {
+        Expression<Iterable<Integer>> buffer = ResolvedExpression.of(Arrays.asList(1, 2, 3, 4));
+        Expression<Integer> latestFromBuffer = latestOf(buffer);
+
+        assertThat(engine.resolve(latestFromBuffer)).isEqualTo(4);
+    }
+
+    @Test
+    public void equality() {
+        assertThat(latestOf(of(asList(new Integer(300))))).isEqualTo(latestOf(of(asList(300))));
+    }
+
+}