/** * Visits the expression tree. * * @param visitor The visitor to use. */ public void visit(Visitor visitor) { expression.accept(visitor); } }
public Object evaluate(Context context) { return node.evaluate(context); }
public BucketSet getBucketSet(BucketIdFactory factory) { return node.getBucketSet(factory); }
/** * Returns the ordering specification, if any, implied by this document * selection expression. * * @param order The order of the */ public OrderingSpecification getOrdering(int order) { return expression.getOrdering(order); }
public OrderingSpecification getOrdering(int order) { Stack<OrderingItem> buf = new Stack<>(); for (NodeItem item : items) { if (!buf.isEmpty()) { while (buf.peek().operator > item.operator) { pickOrdering(buf); } } buf.push(new OrderingItem(item.operator, item.node.getOrdering(order))); } while (buf.size() > 1) { pickOrdering(buf); } return buf.pop().ordering; }
@Override public void visit(AttributeNode attributeNode) { attributeNode.getValue().accept(this); }
/** * Returns the list of different variables resulting in a true state for this * expression. * * @param context The context to match in. * @return True if the document is accepted. * @throws RuntimeException if the evaluation enters an illegal state */ public ResultList getMatchingResultList(Context context) { return ResultList.toResultList(expression.evaluate(context)); }
public BucketSet getBucketSet(BucketIdFactory factory) { Stack<BucketItem> buf = new Stack<>(); for (NodeItem item : items) { if (!buf.isEmpty()) { while (buf.peek().operator > item.operator) { combineBuckets(buf); } } buf.push(new BucketItem(item.operator, item.node.getBucketSet(factory))); } while (buf.size() > 1) { combineBuckets(buf); } return buf.pop().buckets; }
/** * Returns true if the document referenced by this context is accepted by this selector * * @param context The context to match in. * @return True if the document is accepted. * @throws RuntimeException if the evaluation enters an illegal state */ public Result accepts(Context context) { return Result.toResult(expression.evaluate(context)); }
SelectionParser simple = new SelectionParser(); if (simple.parse(selector) && (simple.getRemaining().length() == 0)) { return simple.getNode().getBucketSet(factory); } else { SelectParser parser = new SelectParser(new SelectInput(selector)); return parser.expression().getBucketSet(factory);
@Override public Object evaluate(Context context) { Stack<ValueItem> buf = new Stack<>(); for (NodeItem item : items) { if ( ! buf.isEmpty()) { while (buf.peek().operator > item.operator) { combineValues(buf); } } buf.push(new ValueItem(item.operator, ResultList.toResultList(item.node.evaluate(context)))); } while (buf.size() > 1) { combineValues(buf); } return buf.pop().value; }
@Override public void visit(NegationNode negationNode) { negationNode.getNode().accept(this); }
public Object evaluate(Context context) { return Result.invert(Result.toResult(node.evaluate(context))); }
public void visit(EmbracedNode node) { node.getNode().accept(this); }
public Number evaluate(Document doc, Map<String, Object> variables) { Context context = new Context(new DocumentPut(doc)); context.setVariables(variables); try { Object o = comparison.getLHS().evaluate(context); if (Double.isInfinite(((Number)o).doubleValue())) { throw new IllegalArgumentException("Expression evaluated to an infinite number"); } return ((Number)o).doubleValue(); } catch (ArithmeticException e) { throw new IllegalArgumentException("Arithmetic exception " + e.getMessage(), e); } } }
public void visit(AttributeNode node) { node.getValue().accept(this); }
public Object evaluate(Context context) { String pos = value.toString(); Object obj = value.evaluate(context); StringBuilder builder = new StringBuilder(); for (Item item : items) { if (obj == null) { throw new IllegalStateException("Can not invoke '" + item + "' on '" + pos + "' because that term " + "evaluated to null."); } if (item.getType() != Item.FUNCTION) { if (builder.length() > 0) { builder.append("."); } builder.append(item.getName()); } else { if (builder.length() > 0) { obj = evaluateFieldPath(builder.toString(), obj); builder = new StringBuilder(); } obj = evaluateFunction(item.getName(), obj); } pos = pos + "." + item; } if (builder.length() > 0) { obj = evaluateFieldPath(builder.toString(), obj); } return obj; }
@Override public void visit(EmbracedNode embracedNode) { embracedNode.getNode().accept(this); }