refactoring of expression api to make multiply arity support

Author: raydac

jcp-tests/jcp-test-maven-action/jcp-test-maven-action-action/src/main/java/com/igormaznitsa/jcp/it/CustomPreprocessorExtension.java

@@ -4,9 +4,13 @@
 import com.igormaznitsa.jcp.expression.Value;
 import com.igormaznitsa.jcp.extension.PreprocessorExtension;
 import java.util.Arrays;
+import java.util.Set;
+import java.util.List;
 
 public class CustomPreprocessorExtension implements PreprocessorExtension {
 
+  private static final Set<Integer> ARITY = Set.of(1);
+
   @Override
   public boolean hasAction(int arity) {
     return true;
@@ -27,9 +31,9 @@ public boolean processAction(PreprocessorContext context, Value[] parameters) {
   }
 
   @Override
-  public int getUserFunctionArity(String functionName) {
+  public Set<Integer> getUserFunctionArity(String functionName) {
     if (functionName.equals("hellofunc")) {
-      return 1;
+      return ARITY;
     } else {
       throw new IllegalArgumentException("Unexpected user function: " + functionName);
     }
@@ -39,9 +43,9 @@ public int getUserFunctionArity(String functionName) {
   public Value processUserFunction(
       PreprocessorContext context,
       String functionName,
-      Value[] arguments) {
+      List<Value> arguments) {
     if (functionName.equals("hellofunc")) {
-      return Value.valueOf("Hello " + arguments[0].toString() + "!");
+      return Value.valueOf("Hello " + arguments.get(0).toString() + "!");
     } else {
       throw new IllegalArgumentException("Unexpected user function call: " + functionName);
     }

jcp/src/main/java/com/igormaznitsa/jcp/InfoHelper.java

@@ -192,16 +192,16 @@ private static String makeFunctionReference(final AbstractFunction func) {
     final String result = func.getResultType().getSignature().toUpperCase(Locale.ROOT);
 
     int variantIndex = 0;
-    for (ValueType[] signature : func.getAllowedArgumentTypes()) {
+    for (final List<ValueType> signature : func.getAllowedArgumentTypes()) {
       if (variantIndex > 0) {
         variants.append(" | ");
       }
       variants.append(result).append(' ').append(funcName).append(" (");
-      for (int i = 0; i < signature.length; i++) {
+      for (int i = 0; i < signature.size(); i++) {
         if (i > 0) {
           variants.append(',');
         }
-        variants.append(signature[i].getSignature().toUpperCase(Locale.ROOT));
+        variants.append(signature.get(i).getSignature().toUpperCase(Locale.ROOT));
       }
       variants.append(')');
       variantIndex++;

jcp/src/main/java/com/igormaznitsa/jcp/expression/Expression.java

@@ -30,7 +30,9 @@
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Objects;
 
 /**
@@ -89,12 +91,21 @@ public static Value evalTree(final ExpressionTree tree, final PreprocessorContex
     return exp.eval(context);
   }
 
-  private ExpressionTreeElement evalFunction(final ExpressionTreeElement functionElement,
-                                             final PreprocessorContext context) {
-    final AbstractFunction function = (AbstractFunction) functionElement.getItem();
+  private ExpressionTreeElement evalFunction(
+      final ExpressionTreeElement treeElement,
+      final PreprocessorContext context) {
 
-    final int arity = function.getArity();
-    final Value[] arguments = new Value[arity];
+    final AbstractFunction functionElement = (AbstractFunction) treeElement.getItem();
+    final List<ExpressionTreeElement> children = treeElement.extractEffectiveChildren();
+
+    if (!functionElement.getArity().contains(children.size())) {
+      throw context
+          .makeException(
+              "Can't find '" + functionElement.getName() + "' for arity " + children.size(), null);
+    }
+
+    final int arity = children.size();
+    final List<Value> arguments = new ArrayList<>();
     final Class<?>[] methodArguments = new Class<?>[arity + 1];
     methodArguments[0] = PreprocessorContext.class;
 
@@ -112,27 +123,27 @@ private ExpressionTreeElement evalFunction(final ExpressionTreeElement functionE
 
     for (int i = 0; i < arity; i++) {
       final ExpressionTreeElement item =
-          this.calculateTreeElement(functionElement.getChildForIndex(i), context);
+          this.calculateTreeElement(children.get(i), context);
 
       final ExpressionItem itemValue = item.getItem();
 
       if (itemValue instanceof Value) {
-        arguments[i] = (Value) itemValue;
+        arguments.add((Value) itemValue);
       } else {
         throw context.makeException(
-            "[Expression]Wrong argument type detected for the '" + function.getName() +
+            "[Expression]Wrong argument type detected for the '" + functionElement.getName() +
                 "' function", null);
       }
     }
 
-    final ValueType[][] allowedSignatures = function.getAllowedArgumentTypes();
-    ValueType[] allowed = null;
-    for (final ValueType[] current : allowedSignatures) {
+    final List<List<ValueType>> allowedSignatures = functionElement.getAllowedArgumentTypes();
+    List<ValueType> allowed = null;
+    for (final List<ValueType> current : allowedSignatures) {
       boolean allCompatible = true;
 
       int thatIndex = 0;
       for (final ValueType type : current) {
-        if (!type.isCompatible(arguments[thatIndex].getType())) {
+        if (!type.isCompatible(arguments.get(thatIndex).getType())) {
           allCompatible = false;
           break;
         }
@@ -150,11 +161,12 @@ private ExpressionTreeElement evalFunction(final ExpressionTreeElement functionE
 
     if (allowed == null) {
       throw context.makeException(
-          "[Expression]Unsupported argument detected for '" + function.getName() + '\'', null);
+          "[Expression]Unsupported argument detected for '" + functionElement.getName() + '\'',
+          null);
     }
 
-    if (function instanceof FunctionDefinedByUser) {
-      final FunctionDefinedByUser userFunction = (FunctionDefinedByUser) function;
+    if (functionElement instanceof FunctionDefinedByUser) {
+      final FunctionDefinedByUser userFunction = (FunctionDefinedByUser) functionElement;
       try {
         return new ExpressionTreeElement(userFunction.execute(context, arguments), stack, sources);
       } catch (Exception unexpected) {
@@ -164,15 +176,16 @@ private ExpressionTreeElement evalFunction(final ExpressionTreeElement functionE
       }
     } else {
       try {
-        final Method method = function.getClass().getMethod(signature.toString(), methodArguments);
+        final Method method =
+            functionElement.getClass().getMethod(signature.toString(), methodArguments);
 
         final Object[] callArgs = new Object[arity + 1];
         callArgs[0] = context;
-        System.arraycopy(arguments, 0, callArgs, 1, arity);
+        System.arraycopy(arguments.toArray(), 0, callArgs, 1, arity);
 
-        final Value result = (Value) method.invoke(function, callArgs);
+        final Value result = (Value) method.invoke(functionElement, callArgs);
 
-        if (!result.getType().isCompatible(function.getResultType())) {
+        if (!result.getType().isCompatible(functionElement.getResultType())) {
           throw context.makeException("[Expression]Unsupported function result detected [" +
               result.getType().getSignature() + ']', null);
         }
@@ -189,7 +202,7 @@ private ExpressionTreeElement evalFunction(final ExpressionTreeElement functionE
         }
         throw context.makeException(
             "[Expression]Can't execute a function method to process data [" +
-                function.getClass().getName() + '.' + signature + ']', unexpected);
+                functionElement.getClass().getName() + '.' + signature + ']', unexpected);
       }
     }
   }
@@ -323,7 +336,7 @@ private ExpressionTreeElement calculateTreeElement(final ExpressionTreeElement e
       }
       break;
       case FUNCTION: {
-        treeElement = evalFunction(element, context);
+        treeElement = this.evalFunction(element, context);
       }
       break;
     }

jcp/src/main/java/com/igormaznitsa/jcp/expression/ExpressionParser.java

@@ -38,6 +38,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
+import java.util.stream.Collectors;
 
 /**
  * This class is a parser allows to parse an expression and make a tree as the output
@@ -205,21 +206,23 @@ public ExpressionItem readExpression(
    * @return an expression tree containing parsed function arguments
    * @throws IOException it will be thrown if there is any problem to read chars
    */
-  private ExpressionTree readFunction(final AbstractFunction function, final PushbackReader reader,
-                                      final PreprocessorContext context,
-                                      final FilePositionInfo[] includeStack, final String sources)
+  private ExpressionTree readFunction(
+      final AbstractFunction function,
+      final PushbackReader reader,
+      final PreprocessorContext context,
+      final FilePositionInfo[] includeStack,
+      final String sources)
       throws IOException {
     final ExpressionItem expectedBracket = nextItem(reader, context);
     if (expectedBracket == null) {
       throw context
           .makeException("Detected function without params [" + function.getName() + ']', null);
     }
 
-    final int arity = function.getArity();
+    final int maxArity = function.getArity().stream().mapToInt(x -> x).max().orElse(0);
 
     ExpressionTree functionTree;
-
-    if (arity == 0) {
+    if (maxArity == 0) {
       final ExpressionTree subExpression = new ExpressionTree(includeStack, sources);
       final ExpressionItem lastItem =
           readFunctionArgument(reader, subExpression, context, includeStack, sources);
@@ -236,9 +239,8 @@ private ExpressionTree readFunction(final AbstractFunction function, final Pushb
         functionTree.addItem(function);
       }
     } else {
-
-      final List<ExpressionTree> arguments = new ArrayList<>(arity);
-      for (int i = 0; i < function.getArity(); i++) {
+      final List<ExpressionTree> arguments = new ArrayList<>();
+      for (int i = 0; i < maxArity; i++) {
         final ExpressionTree subExpression = new ExpressionTree(includeStack, sources);
         final ExpressionItem lastItem =
             readFunctionArgument(reader, subExpression, context, includeStack, sources);
@@ -250,18 +252,19 @@ private ExpressionTree readFunction(final AbstractFunction function, final Pushb
           arguments.add(subExpression);
         } else {
           throw context
-              .makeException("Wrong argument for function [" + function.getName() + ']', null);
+              .makeException("Error argument for function '" + function.getName() + '\'', null);
         }
       }
 
       functionTree = new ExpressionTree(includeStack, sources);
       functionTree.addItem(function);
       ExpressionTreeElement functionTreeElement = functionTree.getRoot();
 
-      if (arguments.size() != functionTreeElement.getArity()) {
+      if (!functionTreeElement.getAllowedArities().contains(arguments.size())) {
         throw context.makeException(
-            "Wrong argument number detected '" + function.getName() + "', must be " +
-                function.getArity() + " argument(s)", null);
+            "Wrong argument number detected for '" + function.getName() + "', expected " +
+                function.getArity().stream().map(Object::toString)
+                    .collect(Collectors.joining(";")) + " argument(s)", null);
       }
 
       functionTreeElement.fillArguments(arguments);

jcp/src/main/java/com/igormaznitsa/jcp/expression/ExpressionTreeElement.java

@@ -29,6 +29,8 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 /**
  * The class describes a wrapper around an expression item to be saved into an expression tree
@@ -75,10 +77,18 @@ public class ExpressionTreeElement {
    */
   private int nextChildSlot = 0;
 
+  private static final Set<Integer> ZERO_ARITY = Set.of(0);
+
   private ExpressionTreeElement() {
     this.sourceString = "";
     this.includeStack = new FilePositionInfo[0];
   }
+  /**
+   * Set of allowed arities.
+   *
+   * @since 7.3.0
+   */
+  private Set<Integer> allowedArities = Set.of();
 
   /**
    * The constructor
@@ -97,18 +107,45 @@ private ExpressionTreeElement() {
           this.includeStack, null);
     }
 
-    int arity = 0;
+    final int arity;
     if (item.getExpressionItemType() == ExpressionItemType.OPERATOR) {
       arity = ((AbstractOperator) item).getArity();
+      this.allowedArities = Set.of(arity);
     } else if (item.getExpressionItemType() == ExpressionItemType.FUNCTION) {
-      arity = ((AbstractFunction) item).getArity();
+      final AbstractFunction functionItem = (AbstractFunction) item;
+      this.allowedArities = functionItem.getArity();
+      arity = this.allowedArities.stream().mapToInt(x -> x).max().orElse(0);
+    } else {
+      arity = 0;
+      this.allowedArities = ZERO_ARITY;
     }
     priority = item.getExpressionItemPriority().getPriority();
     this.savedItem = item;
     childElements = arity == 0 ? EMPTY : new ExpressionTreeElement[arity];
     Arrays.fill(this.childElements, EMPTY_SLOT);
   }
 
+  /**
+   * Get effective child slots.
+   *
+   * @return list of non-empty child slots.
+   * @since 7.3.0
+   */
+  public List<ExpressionTreeElement> extractEffectiveChildren() {
+    return Arrays.stream(this.childElements).takeWhile(x -> x != EMPTY_SLOT)
+        .collect(Collectors.toUnmodifiableList());
+  }
+
+  /**
+   * Variants of allowed arities by the expression tree element
+   *
+   * @return allowed artiy numbers as set
+   * @since 7.3.0
+   */
+  public Set<Integer> getAllowedArities() {
+    return this.allowedArities;
+  }
+
   /**
    * Allows to check that the element is EMPTY_SLOT
    *
@@ -166,7 +203,7 @@ public ExpressionTreeElement getParent() {
    * @return the priority
    */
   public int getPriority() {
-    return priority;
+    return this.priority;
   }
 
   /**

jcp/src/main/java/com/igormaznitsa/jcp/expression/functions/AbstractFunction.java

@@ -38,6 +38,7 @@
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
@@ -49,6 +50,12 @@
  */
 public abstract class AbstractFunction implements ExpressionItem {
 
+  public static final Set<Integer> ARITY_0 = Set.of(0);
+  public static final Set<Integer> ARITY_1 = Set.of(1);
+  public static final Set<Integer> ARITY_1_2 = Set.of(1, 2);
+  public static final Set<Integer> ARITY_2 = Set.of(2);
+  public static final Set<Integer> ARITY_3 = Set.of(3);
+
   /**
    * The string contains the prefix for all executing methods of functions
    */
@@ -164,19 +171,20 @@ public static AbstractFunction findForName(final String functionName) {
   public abstract String getReference();
 
   /**
-   * Get the function arity
+   * Get the function arities
    *
-   * @return the function arity (zero or greater)
+   * @return all allowed arities for the function
+   * @since 7.3.0
    */
-  public abstract int getArity();
+  public abstract Set<Integer> getArity();
 
   /**
    * Get arrays of supported argument types
    *
-   * @return the array of argument type combinations allowed by the function
+   * @return list of argument type combinations allowed by the function
    * handler, must not be null
    */
-  public abstract ValueType[][] getAllowedArgumentTypes();
+  public abstract List<List<ValueType>> getAllowedArgumentTypes();
 
   /**
    * Get the result type