Some work towards supporting array lookup. Still working on postfix and unary lookups.

Author: david-waltermire

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/antlr/AbstractAstVisitor.java

@@ -52,6 +52,7 @@
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.IntersectexceptexprContext;
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.LetexprContext;
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.LiteralContext;
+import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.LookupContext;
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.MetapathContext;
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.MultiplicativeexprContext;
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.NametestContext;
@@ -358,10 +359,34 @@ public R visitPostfixexpr(PostfixexprContext ctx) {
     return handle(ctx, (context) -> handlePostfixexpr(ctx));
   }
 
+  /**
+   * Handle the provided expression.
+   *
+   * @param ctx
+   *          the provided expression context
+   * @return the result
+   */
+  protected abstract R handlePredicate(@NonNull PredicateContext ctx);
+
   @Override
   public R visitPredicate(PredicateContext ctx) {
-    // should never be called, since this is handled by the parent expression
-    throw new IllegalStateException();
+    assert ctx != null;
+    return handlePredicate(ctx);
+  }
+
+  /**
+   * Handle the provided expression.
+   *
+   * @param ctx
+   *          the provided expression context
+   * @return the result
+   */
+  protected abstract R handleLookup(@NonNull LookupContext ctx);
+
+  @Override
+  public R visitLookup(LookupContext ctx) {
+    assert ctx != null;
+    return handleLookup(ctx);
   }
 
   /*

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/cst/AbstractCSTVisitorBase.java

@@ -295,12 +295,11 @@ protected <CONTEXT extends ParserRuleContext> IExpression handleGroupedNAiry(
     IExpression retval = null;
     if (numChildren > 0) {
       ParseTree leftTree = context.getChild(startingIndex);
-      IExpression result = ObjectUtils.notNull(leftTree.accept(this));
+      retval = ObjectUtils.notNull(leftTree.accept(this));
 
       for (int i = startingIndex + 1; i < numChildren; i = i + step) {
-        result = parser.apply(context, i, result);
+        retval = parser.apply(context, i, retval);
       }
-      retval = result;
     }
     return retval;
   }

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/cst/AbstractExpressionVisitor.java

@@ -362,4 +362,14 @@ public RESULT visitArray(ArraySequence expr, CONTEXT context) {
   public RESULT visitArray(ArraySquare expr, CONTEXT context) {
     return visitChildren(expr, context);
   }
+
+  @Override
+  public RESULT visitPostfixLookup(PostfixLookup expr, CONTEXT context) {
+    return visitChildren(expr, context);
+  }
+
+  @Override
+  public RESULT visitFunctionCallAccessor(FunctionCallAccessor expr, CONTEXT context) {
+    return visitChildren(expr, context);
+  }
 }

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/cst/AbstractLookup.java

@@ -0,0 +1,103 @@
+/*
+ * Portions of this software was developed by employees of the National Institute
+ * of Standards and Technology (NIST), an agency of the Federal Government and is
+ * being made available as a public service. Pursuant to title 17 United States
+ * Code Section 105, works of NIST employees are not subject to copyright
+ * protection in the United States. This software may be subject to foreign
+ * copyright. Permission in the United States and in foreign countries, to the
+ * extent that NIST may hold copyright, to use, copy, modify, create derivative
+ * works, and distribute this software and its documentation without fee is hereby
+ * granted on a non-exclusive basis, provided that this notice and disclaimer
+ * of warranty appears in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS' WITHOUT ANY WARRANTY OF ANY KIND, EITHER
+ * EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY
+ * THAT THE SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND FREEDOM FROM
+ * INFRINGEMENT, AND ANY WARRANTY THAT THE DOCUMENTATION WILL CONFORM TO THE
+ * SOFTWARE, OR ANY WARRANTY THAT THE SOFTWARE WILL BE ERROR FREE.  IN NO EVENT
+ * SHALL NIST BE LIABLE FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT,
+ * INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF, RESULTING FROM,
+ * OR IN ANY WAY CONNECTED WITH THIS SOFTWARE, WHETHER OR NOT BASED UPON WARRANTY,
+ * CONTRACT, TORT, OR OTHERWISE, WHETHER OR NOT INJURY WAS SUSTAINED BY PERSONS OR
+ * PROPERTY OR OTHERWISE, AND WHETHER OR NOT LOSS WAS SUSTAINED FROM, OR AROSE OUT
+ * OF THE RESULTS OF, OR USE OF, THE SOFTWARE OR SERVICES PROVIDED HEREUNDER.
+ */
+
+package gov.nist.secauto.metaschema.core.metapath.cst;
+
+import gov.nist.secauto.metaschema.core.metapath.DynamicContext;
+import gov.nist.secauto.metaschema.core.metapath.ISequence;
+import gov.nist.secauto.metaschema.core.metapath.item.IItem;
+import gov.nist.secauto.metaschema.core.metapath.item.atomic.IIntegerItem;
+
+import java.util.List;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+public abstract class AbstractLookup implements IExpression {
+
+  @NonNull
+  private final IExpression base;
+  @NonNull
+  private final IKeySpecifier keySpecifier;
+
+  protected AbstractLookup(@NonNull IExpression base, @NonNull IKeySpecifier keySpecifier) {
+    this.base = base;
+    this.keySpecifier = keySpecifier;
+  }
+
+  /**
+   * Get the base sub-expression.
+   *
+   * @return the sub-expression
+   */
+  @NonNull
+  public IExpression getBase() {
+    return base;
+  }
+
+  @NonNull
+  public IKeySpecifier getKeySpecifier() {
+    return keySpecifier;
+  }
+
+  @SuppressWarnings("null")
+  @Override
+  public List<? extends IExpression> getChildren() {
+    return List.of(getBase());
+  }
+
+  @Override
+  public ISequence<? extends IItem> accept(DynamicContext dynamicContext, ISequence<?> focus) {
+    ISequence<?> retval = getBase().accept(dynamicContext, focus);
+
+    // getKeySpecifier().accept(dynamicContext, retval);
+
+    return retval;
+  }
+
+  protected interface IKeySpecifier {
+
+  }
+
+  protected static class NCNameKeySpecifier implements IKeySpecifier {
+
+    public NCNameKeySpecifier(String ncname) {
+      // TODO Auto-generated constructor stub
+    }
+
+  }
+
+  protected static class IntegerLiteralKeySpecifier implements IKeySpecifier {
+
+    public IntegerLiteralKeySpecifier(IIntegerItem literal) {
+      // TODO Auto-generated constructor stub
+    }
+
+  }
+
+  protected static class WildcardKeySpecifier implements IKeySpecifier {
+
+  }
+}

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/cst/BuildCSTVisitor.java

@@ -50,6 +50,7 @@
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.IntersectexceptexprContext;
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.LetexprContext;
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.LiteralContext;
+import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.LookupContext;
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.MultiplicativeexprContext;
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.NametestContext;
 import gov.nist.secauto.metaschema.core.metapath.antlr.Metapath10.NodetestContext;
@@ -472,22 +473,48 @@ protected List<IExpression> parsePredicates(@NonNull ParseTree context, int star
   }
 
   @Override
-  protected IExpression handlePostfixexpr(PostfixexprContext ctx) {
-    int numChildren = ctx.getChildCount();
-    ParseTree primaryTree = ctx.getChild(0);
-    IExpression retval = ObjectUtils.notNull(primaryTree.accept(this));
-
-    List<IExpression> predicates = numChildren > 1 ? parsePredicates(ctx, 1) : CollectionUtil.emptyList();
-
-    if (!predicates.isEmpty()) {
-      retval = new PredicateExpression(retval, predicates);
-    }
-    return retval;
+  protected IExpression handlePostfixexpr(PostfixexprContext context) {
+    return handleGroupedNAiry(
+        context,
+        0,
+        1,
+        (ctx, idx, left) -> {
+          ParseTree tree = ctx.getChild(idx);
+          IExpression result;
+          if (tree instanceof ArgumentlistContext) {
+            // map or array access using function call syntax
+            result = new FunctionCallAccessor(
+                left,
+                parseArgumentList((ArgumentlistContext) tree).findFirst().get());
+          } else if (tree instanceof PredicateContext) {
+            result = new PredicateExpression(
+                left,
+                CollectionUtil.singletonList(parsePredicate((PredicateContext) tree)));
+          } else if (tree instanceof LookupContext) {
+            result = new PostfixLookup(left, (LookupContext) tree);
+          } else {
+            result = visit(tree);
+          }
+          return result;
+        });
   }
+
   // ======================================================================
   // Path Expressions - https://www.w3.org/TR/xpath-31/#id-path-expressions
   // ======================================================================
 
+  @Override
+  protected IExpression handlePredicate(PredicateContext ctx) {
+    parsePredicate(ctx);
+    return null;
+  }
+
+  @Override
+  protected IExpression handleLookup(LookupContext ctx) {
+    // TODO Auto-generated method stub
+    return null;
+  }
+
   @Override
   protected IExpression handlePathexpr(PathexprContext ctx) {
     int numChildren = ctx.getChildCount();

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/cst/CSTPrinter.java

@@ -345,6 +345,17 @@ public String visitArray(ArraySequence expr, State context) {
     public String visitArray(ArraySquare expr, State context) {
       return appendNode(expr, super.visitArray(expr, context), context);
     }
+
+    @Override
+    public String visitPostfixLookup(PostfixLookup expr, State context) {
+      return appendNode(expr, super.visitPostfixLookup(expr, context), context);
+    }
+
+    @Override
+    public String visitFunctionCallAccessor(FunctionCallAccessor expr, State context) {
+      return appendNode(expr, super.visitFunctionCallAccessor(expr, context), context);
+    }
+
   }
 
   static class State {

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/cst/FunctionCallAccessor.java

@@ -0,0 +1,88 @@
+/*
+ * Portions of this software was developed by employees of the National Institute
+ * of Standards and Technology (NIST), an agency of the Federal Government and is
+ * being made available as a public service. Pursuant to title 17 United States
+ * Code Section 105, works of NIST employees are not subject to copyright
+ * protection in the United States. This software may be subject to foreign
+ * copyright. Permission in the United States and in foreign countries, to the
+ * extent that NIST may hold copyright, to use, copy, modify, create derivative
+ * works, and distribute this software and its documentation without fee is hereby
+ * granted on a non-exclusive basis, provided that this notice and disclaimer
+ * of warranty appears in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS' WITHOUT ANY WARRANTY OF ANY KIND, EITHER
+ * EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY
+ * THAT THE SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND FREEDOM FROM
+ * INFRINGEMENT, AND ANY WARRANTY THAT THE DOCUMENTATION WILL CONFORM TO THE
+ * SOFTWARE, OR ANY WARRANTY THAT THE SOFTWARE WILL BE ERROR FREE.  IN NO EVENT
+ * SHALL NIST BE LIABLE FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT,
+ * INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF, RESULTING FROM,
+ * OR IN ANY WAY CONNECTED WITH THIS SOFTWARE, WHETHER OR NOT BASED UPON WARRANTY,
+ * CONTRACT, TORT, OR OTHERWISE, WHETHER OR NOT INJURY WAS SUSTAINED BY PERSONS OR
+ * PROPERTY OR OTHERWISE, AND WHETHER OR NOT LOSS WAS SUSTAINED FROM, OR AROSE OUT
+ * OF THE RESULTS OF, OR USE OF, THE SOFTWARE OR SERVICES PROVIDED HEREUNDER.
+ */
+
+package gov.nist.secauto.metaschema.core.metapath.cst;
+
+import gov.nist.secauto.metaschema.core.metapath.DynamicContext;
+import gov.nist.secauto.metaschema.core.metapath.ISequence;
+import gov.nist.secauto.metaschema.core.metapath.function.library.ArrayGet;
+import gov.nist.secauto.metaschema.core.metapath.item.IItem;
+import gov.nist.secauto.metaschema.core.util.ObjectUtils;
+
+import java.util.List;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+public class FunctionCallAccessor implements IExpression {
+  @NonNull
+  private final IExpression base;
+  @NonNull
+  private final IExpression argument;
+
+  public FunctionCallAccessor(@NonNull IExpression base, @NonNull IExpression argument) {
+    this.base = base;
+    this.argument = argument;
+  }
+
+  /**
+   * Get the base sub-expression.
+   *
+   * @return the sub-expression
+   */
+  @NonNull
+  public IExpression getBase() {
+    return base;
+  }
+
+  /**
+   * Retrieve the argument to use for the lookup.
+   *
+   * @return the argument
+   */
+  @NonNull
+  public IExpression getArgument() {
+    return argument;
+  }
+
+  @SuppressWarnings("null")
+  @Override
+  public List<? extends IExpression> getChildren() {
+    return List.of(getBase(), getArgument());
+  }
+
+  @Override
+  public ISequence<? extends IItem> accept(DynamicContext dynamicContext, ISequence<?> focus) {
+    ISequence<?> collection = getBase().accept(dynamicContext, focus);
+    ISequence<?> key = getArgument().accept(dynamicContext, focus);
+
+    return ArrayGet.SIGNATURE.execute(ObjectUtils.notNull(List.of(collection, key)), dynamicContext, focus);
+  }
+
+  @Override
+  public <RESULT, CONTEXT> RESULT accept(@NonNull IExpressionVisitor<RESULT, CONTEXT> visitor, CONTEXT context) {
+    return visitor.visitFunctionCallAccessor(this, context);
+  }
+}

core/src/main/java/gov/nist/secauto/metaschema/core/metapath/cst/IExpressionVisitor.java

@@ -532,4 +532,26 @@ public interface IExpressionVisitor<RESULT, CONTEXT> {
    * @return the visitation result or {@code null} if no result was produced
    */
   RESULT visitArray(@NonNull ArraySquare expr, @NonNull CONTEXT context);
+
+  /**
+   * Visit the CST node.
+   *
+   * @param expr
+   *          the CST node to visit
+   * @param context
+   *          the processing context
+   * @return the visitation result or {@code null} if no result was produced
+   */
+  RESULT visitPostfixLookup(@NonNull PostfixLookup expr, @NonNull CONTEXT context);
+
+  /**
+   * Visit the CST node.
+   *
+   * @param expr
+   *          the CST node to visit
+   * @param context
+   *          the processing context
+   * @return the visitation result or {@code null} if no result was produced
+   */
+  RESULT visitFunctionCallAccessor(@NonNull FunctionCallAccessor expr, @NonNull CONTEXT context);
 }