private static Predicate createScanPredicate(final PathToken target, final EvaluationContextImpl ctx) { if (target instanceof PropertyPathToken) { return new PropertyPathTokenPredicate(target, ctx); } else if (target instanceof ArrayPathToken) { return new ArrayPathTokenPredicate(ctx); } else if (target instanceof WildcardPathToken) { return new WildcardPathTokenPredicate(); } else if (target instanceof PredicatePathToken) { return new FilterPathTokenPredicate(target, ctx); } else { return FALSE_PREDICATE; } }
@Override public boolean matches(Object model) { return predicatePathToken.accept(model, ctx.rootDocument(), ctx.configuration(), ctx); } }
@Override public void evaluate(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) { PathFunction pathFunction = PathFunctionFactory.newFunction(functionName); evaluateParameters(currentPath, parent, model, ctx); Object result = pathFunction.invoke(currentPath, parent, model, ctx, functionParams); ctx.addResult(currentPath + "." + functionName, parent, result); if (!isLeaf()) { next().evaluate(currentPath, parent, result, ctx); } }
@Override public String toString() { if (isLeaf()) { return getPathFragment(); } else { return getPathFragment() + next().toString(); } }
@Override public EvaluationContext evaluate(Object document, Object rootDocument, Configuration configuration, boolean forUpdate) { if (logger.isDebugEnabled()) { logger.debug("Evaluating path: {}", toString()); } EvaluationContextImpl ctx = new EvaluationContextImpl(this, rootDocument, configuration, forUpdate); try { PathRef op = ctx.forUpdate() ? PathRef.createRoot(rootDocument) : PathRef.NO_OP; root.evaluate("", op, document, ctx); } catch (EvaluationAbortException abort) {} return ctx; }
boolean isUpstreamDefinite() { if (upstreamDefinite == null) { upstreamDefinite = isRoot() || prev.isTokenDefinite() && prev.isUpstreamDefinite(); } return upstreamDefinite; }
private Path compile() { RootPathToken root = readContextToken(); return new CompiledPath(root, root.getPathFragment().equals("$")); }
@Override public void evaluate(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) { PathToken pt = next(); walk(pt, currentPath, parent, model, ctx, createScanPredicate(pt, ctx)); }
public static void walk(PathToken pt, String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx, Predicate predicate) { if (ctx.jsonProvider().isMap(model)) { walkObject(pt, currentPath, parent, model, ctx, predicate); } else if (ctx.jsonProvider().isArray(model)) { walkArray(pt, currentPath, parent, model, ctx, predicate); } }
@Override public void evaluate(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) { if (!checkArrayModel(currentPath, model, ctx)) return; if (arrayIndexOperation.isSingleIndexOperation()) { handleArrayIndex(arrayIndexOperation.indexes().get(0), currentPath, model, ctx); } else { for (Integer index : arrayIndexOperation.indexes()) { handleArrayIndex(index, currentPath, model, ctx); } } }
private static Path path() { return new CompiledPath(PathTokenFactory.createRootPathToken('$'), true); }
@Override public void evaluate(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) { if (!checkArrayModel(currentPath, model, ctx)) return; switch (operation.operation()) { case SLICE_FROM: sliceFrom(currentPath, parent, model, ctx); break; case SLICE_BETWEEN: sliceBetween(currentPath, parent, model, ctx); break; case SLICE_TO: sliceTo(currentPath, parent, model, ctx); break; } }
@Override public boolean isTokenDefinite() { // in case of leaf multiprops will be merged, so it's kinda definite return singlePropertyCase() || multiPropertyMergeCase(); }
public RootPathToken append(PathToken next) { this.tail = tail.appendTailToken(next); this.tokenCount++; return this; }
@Override public String toString() { return root.toString(); } }
@SuppressWarnings("unchecked") @Override public <T> T getValue() { return getValue(true); }
@Override public PathTokenAppender appendPathToken(PathToken next) { append(next); return this; } };
private PathToken makePathReturningTail(final PathToken ... tokens) { PathToken last = null; for (final PathToken token : tokens) { if (last != null) { last.appendTailToken(token); } last = token; } return last; } }