incorporated files from tensorics-expressions project. Solved warnings

Author: andreacalia

src/java/org/tensorics/core/commons/options/Environment.java

@@ -25,7 +25,7 @@
 import org.tensorics.core.math.ExtendedField;
 
 /**
- * Encapsulates a field (on which alll calculations are based) and a set of options, since the two are very commonly
+ * Encapsulates a field (on which all calculations are based) and a set of options, since the two are very commonly
  * used together and have to be passed on on many occasions.
  * 
  * @author kfuchsbe

src/java/org/tensorics/core/commons/options/ImmutableOptionRegistry.java

@@ -50,7 +50,6 @@ public final class ImmutableOptionRegistry<T extends Option<T>> implements Optio
      * @param processingOptions the options that will be contained in the registry
      * @return a new instance of a registry, containing the options
      */
-    @SuppressWarnings("PMD.ShortMethodName")
     public static <T extends Option<T>> ImmutableOptionRegistry<T> of(Collection<T> processingOptions) {
         return new ImmutableOptionRegistry<T>(processingOptions);
     }

src/java/org/tensorics/core/commons/util/AbstractPair.java

@@ -35,7 +35,6 @@
  * @param <T> the type of the elements of the pair
  * @author kfuchsbe
  */
-@SuppressWarnings("PMD.CyclomaticComplexity")
 public class AbstractPair<T> {
 
     private final T leftElement;
@@ -68,7 +67,6 @@ public final int hashCode() {
     }
 
     @Override
-    @SuppressWarnings("PMD.CyclomaticComplexity")
     public final boolean equals(Object obj) {
         if (this == obj) {
             return true;

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

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2016 European Organisation for Nuclear Research (CERN), All Rights Reserved.
+ */
+
+package org.tensorics.core.expressions;
+
+import org.tensorics.core.commons.operations.Conversion;
+import org.tensorics.core.tree.domain.Expression;
+
+/**
+ * This expression reduces an {@link Expression} of {@link Iterable} of boolean to an {@link Expression} of a
+ * {@link Boolean}. The conversion represents the reduction strategy that will be applied on the iterable.
+ * 
+ * @author acalia, caguiler, kfuchsberger
+ */
+public class CombinedBooleanExpression extends ConversionOperationExpression<Iterable<Boolean>, Boolean> {
+
+    public CombinedBooleanExpression(Conversion<Iterable<Boolean>, Boolean> operation,
+            Expression<Iterable<Boolean>> source) {
+        super(operation, source);
+    }
+
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2016 European Organisation for Nuclear Research (CERN), All Rights Reserved.
+ */
+
+package org.tensorics.core.expressions;
+
+public enum EvaluationStatus {
+    EVALUATED,
+    NOT_EVALUATED;
+
+    public static EvaluationStatus fromBoolean(boolean isExecuted) {
+        return isExecuted ? EVALUATED : NOT_EVALUATED;
+    }
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2016 European Organisation for Nuclear Research (CERN), All Rights Reserved.
+ */
+
+package org.tensorics.core.expressions;
+
+import static java.lang.String.format;
+
+import org.tensorics.core.math.predicates.IsEqualTo;
+import org.tensorics.core.tree.domain.Expression;
+
+public class IsEqualToExpression<T> extends BinaryPredicateExpression<T> {
+
+    public IsEqualToExpression(Expression<T> left, Expression<T> right) {
+        super(new IsEqualTo<T>(), left, right);
+    }
+
+    @Override
+    public String toString() {
+        return format("%s is equal to %s", getLeft(), getRight());
+    }
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2016 European Organisation for Nuclear Research (CERN), All Rights Reserved.
+ */
+
+package org.tensorics.core.expressions;
+
+import static java.lang.String.format;
+
+import org.tensorics.core.math.predicates.IsNotEqualTo;
+import org.tensorics.core.tree.domain.Expression;
+
+public class IsNotEqualExpression<T> extends BinaryPredicateExpression<T> {
+
+    public IsNotEqualExpression(Expression<T> left, Expression<T> right) {
+        super(new IsNotEqualTo<>(), left, right);
+    }
+
+    @Override
+    public String toString() {
+        return format("%s is not equal to %s", getLeft(), getRight());
+    }
+}

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

@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2016 European Organisation for Nuclear Research (CERN), All Rights Reserved.
+ */
+
+package org.tensorics.core.expressions;
+
+import java.util.List;
+
+import org.tensorics.core.resolve.resolvers.IterableResolvingExpressionResolver;
+import org.tensorics.core.tree.domain.AbstractDeferredExpression;
+import org.tensorics.core.tree.domain.Expression;
+import org.tensorics.core.tree.domain.Node;
+
+import com.google.common.collect.ImmutableList;
+
+/**
+ * Expression that given an {@link Iterable} of {@link Expression} of T, resolves to an {@link Iterable} of T. In other
+ * words, it resolves the inner {@link Expression} of the {@link Iterable}.
+ * 
+ * @see IterableResolvingExpressionResolver
+ * @author acalia, caguiler, kfuchsberger
+ * @param <T> type of the elements of the iterable
+ */
+public class IterableResolvingExpression<T> extends AbstractDeferredExpression<Iterable<T>> {
+
+    private final List<Expression<T>> expressions;
+
+    public IterableResolvingExpression(Iterable<Expression<T>> iterable) {
+        this.expressions = ImmutableList.copyOf(iterable);
+    }
+
+    @Override
+    public List<? extends Node> getChildren() {
+        return expressions;
+    }
+
+    public List<? extends Expression<T>> expressions() {
+        return expressions;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((expressions == null) ? 0 : expressions.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        IterableResolvingExpression<?> other = (IterableResolvingExpression<?>) obj;
+        if (expressions == null) {
+            if (other.expressions != null) {
+                return false;
+            }
+        } else if (!expressions.equals(other.expressions)) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "IterableResolvingExpression [expressions=" + expressions + "]";
+    }
+
+}

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

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2016 European Organisation for Nuclear Research (CERN), All Rights Reserved.
+ */
+
+package org.tensorics.core.expressions;
+
+import java.util.List;
+import java.util.function.Predicate;
+
+import org.tensorics.core.tree.domain.AbstractDeferredExpression;
+import org.tensorics.core.tree.domain.Expression;
+
+import com.google.common.collect.ImmutableList;
+
+public class PredicateExpression<T> extends AbstractDeferredExpression<Boolean> {
+
+    private final Expression<T> source;
+    private final Expression<Predicate<T>> predicate;
+
+    private PredicateExpression(Expression<T> source, Expression<Predicate<T>> predicate) {
+        super();
+        this.source = source;
+        this.predicate = predicate;
+    }
+
+    public static <T> PredicateExpression<T> ofSourceAndPredicate(Expression<T> source,
+            Expression<Predicate<T>> predicate) {
+        return new PredicateExpression<>(source, predicate);
+    }
+
+    @Override
+    public List<Expression<?>> getChildren() {
+        return ImmutableList.of(source, predicate);
+    }
+
+    public Expression<T> source() {
+        return source;
+    }
+
+    public Expression<Predicate<T>> predicate() {
+        return predicate;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((predicate == null) ? 0 : predicate.hashCode());
+        result = prime * result + ((source == null) ? 0 : source.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        PredicateExpression<?> other = (PredicateExpression<?>) obj;
+        if (predicate == null) {
+            if (other.predicate != null) {
+                return false;
+            }
+        } else if (!predicate.equals(other.predicate)) {
+            return false;
+        }
+        if (source == null) {
+            if (other.source != null) {
+                return false;
+            }
+        } else if (!source.equals(other.source)) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "PredicateCondition [source=" + source + ", predicate=" + predicate + "]";
+    }
+
+}

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

@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2016 European Organisation for Nuclear Research (CERN), All Rights Reserved.
+ */
+
+package org.tensorics.core.expressions;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.tensorics.core.resolve.resolvers.WindowedExpressionResolver;
+import org.tensorics.core.tree.domain.AbstractDeferredExpression;
+import org.tensorics.core.tree.domain.Expression;
+
+/**
+ * Expression that evaluates the targetExpression given the result of the enabling expression. The enabling
+ * expression is an {@link Expression} of {@link Boolean} that decides if the targetExpression is
+ * resolved or not. This expression resolves into an {@link EvaluationStatus}.
+ * 
+ * @see WindowedExpressionResolver
+ * @param T the type of the target expression
+ * @author acalia, caguiler
+ */
+public class WindowedExpression<T extends Expression<?>> extends AbstractDeferredExpression<EvaluationStatus> {
+
+    private final T targetExpression;
+    private final Expression<Boolean> enablingExpression;
+
+    public WindowedExpression(T targetExpression, Expression<Boolean> enablingExpression) {
+        this.targetExpression = targetExpression;
+        this.enablingExpression = enablingExpression;
+    }
+
+    @Override
+    public List<Expression<?>> getChildren() {
+        return Arrays.asList(targetExpression, enablingExpression);
+    }
+
+    public T targetExpression() {
+        return targetExpression;
+    }
+
+    public Expression<Boolean> enablingExpression() {
+        return enablingExpression;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((enablingExpression == null) ? 0 : enablingExpression.hashCode());
+        result = prime * result + ((targetExpression == null) ? 0 : targetExpression.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        WindowedExpression<?> other = (WindowedExpression<?>) obj;
+        if (enablingExpression == null) {
+            if (other.enablingExpression != null) {
+                return false;
+            }
+        } else if (!enablingExpression.equals(other.enablingExpression)) {
+            return false;
+        }
+        if (targetExpression == null) {
+            if (other.targetExpression != null) {
+                return false;
+            }
+        } else if (!targetExpression.equals(other.targetExpression)) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return this.getClass().getSimpleName() + " [targetExpression=" + targetExpression + ", enablingExpression="
+                + enablingExpression + "]";
+    }
+}