T notNull(T object, String message, Object... values) {\n if (object == null) {\n throw new IllegalArgumentException(String.format(message, values));\n }\n return object;\n }\n\n /**\n * Validate that the argument condition is {@code true}; otherwise\n * throwing an exception with the specified message. This method is useful when\n * validating according to an arbitrary boolean expression, such as validating a\n * primitive number or using your own custom validation expression.
\n *
\n * Validate.isTrue(i > 0.0, \"The value must be greater than zero: %d\", i); \n *
\n * For performance reasons, the long value is passed as a separate parameter and\n * appended to the exception message only in the case of an error.
\n *\n * @param expression the boolean expression to check\n * @param message\n * @throws IllegalArgumentException if expression is {@code false}\n */\n public static void isTrue(boolean expression, String message) {\n if (expression == false) {\n throw new IllegalArgumentException(message);\n }\n }\n\n /**\n * Check if one and only one condition is true; otherwise\n * throw an exception with the specified message.\n *\n * @param message error describing message\n * @param expressions the boolean expressions to check\n * @throws IllegalArgumentException if zero or more than one expressions are true\n */\n public static void onlyOneIsTrue(final String message, final boolean... expressions) {\n if (!onlyOneIsTrueNonThrow(expressions)) {\n throw new IllegalArgumentException(message);\n }\n }\n\n public static boolean onlyOneIsTrueNonThrow(final boolean... expressions) {\n int count = 0;\n for (final boolean expression : expressions) {\n if (expression && ++count > 1) {\n return false;\n }\n }\n return 1 == count;\n }\n\n /**\n * Validate that the specified argument character sequence is\n * neither {@code null} nor a length of zero (no characters);\n * otherwise throwing an exception with the specified message.\n *
\n * Validate.notEmpty(myString, \"The string must not be empty\"); \n *\n * @param the character sequence type\n * @param chars the character sequence to check, validated not null by this method\n * @param message the {@link String#format(String, Object...)} exception message if invalid, not null\n * @return the validated character sequence (never {@code null} method for chaining)\n * @throws NullPointerException if the character sequence is {@code null}\n * @throws IllegalArgumentException if the character sequence is empty\n */\n public static T notEmpty(T chars, String message) {\n if (chars == null || chars.length() == 0) {\n throw new IllegalArgumentException(message);\n }\n return chars;\n }\n\n /**\n * Validate that the specified argument character sequence is\n * neither {@code null} nor a length of zero (no characters);\n * otherwise throwing an exception with the specified message.\n *
\n * Validate.notEmpty(myString, \"The string must not be empty\"); \n *\n * @param bytes the bytes to check, validated not null by this method\n * @param message the {@link String#format(String, Object...)} exception message if invalid, not null\n * @return the validated character sequence (never {@code null} method for chaining)\n * @throws NullPointerException if the character sequence is {@code null}\n * @throws IllegalArgumentException if the character sequence is empty\n */\n public static byte[] notEmpty(byte[] bytes, String message) {\n if (bytes == null || bytes.length == 0) {\n throw new IllegalArgumentException(message);\n }\n return bytes;\n }\n\n /**\n * Validate that the specified argument character sequence is\n * neither {@code null} nor a length of zero (no characters);\n * otherwise throwing an exception with the specified message.\n *
\n * Validate.notEmpty(myString, \"The string must not be empty\"); \n *\n * @param the character sequence type\n * @param chars the character sequence to check, validated not null by this method\n * @param message the {@link String#format(String, Object...)} exception message if invalid, not null\n * @param values the optional values for the formatted exception message, null array not recommended\n * @return the validated character sequence (never {@code null} method for chaining)\n * @throws NullPointerException if the character sequence is {@code null}\n * @throws IllegalArgumentException if the character sequence is empty\n */\n public static T notEmpty(T chars, String message, Object... values) {\n if (chars == null || chars.length() == 0) {\n throw new IllegalArgumentException(String.format(message, values));\n }\n return chars;\n }\n\n\n //---------------------------------------------------------\n //\n // Converters\n //\n //---------------------------------------------------------\n public static String toString(Object o) {\n if (null == o) {\n return null;\n }\n return o.toString();\n }\n\n private Utils() {\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/filter/Evaluator.java",
"content": "package com.jayway.jsonpath.internal.filter;\n\nimport com.jayway.jsonpath.Predicate;\n\npublic interface Evaluator {\n boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx);\n}"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/filter/EvaluatorFactory.java",
"content": "package com.jayway.jsonpath.internal.filter;\n\nimport com.jayway.jsonpath.JsonPathException;\nimport com.jayway.jsonpath.Predicate;\n\nimport java.util.HashMap;\nimport java.util.Iterator;\nimport java.util.Map;\nimport java.util.regex.Pattern;\n\nimport static com.jayway.jsonpath.internal.filter.ValueNodes.PatternNode;\nimport static com.jayway.jsonpath.internal.filter.ValueNodes.ValueListNode;\n\npublic class EvaluatorFactory {\n\n private static final Map evaluators = new HashMap();\n\n static {\n evaluators.put(RelationalOperator.EXISTS, new ExistsEvaluator());\n evaluators.put(RelationalOperator.NE, new NotEqualsEvaluator());\n evaluators.put(RelationalOperator.TSNE, new TypeSafeNotEqualsEvaluator());\n evaluators.put(RelationalOperator.EQ, new EqualsEvaluator());\n evaluators.put(RelationalOperator.TSEQ, new TypeSafeEqualsEvaluator());\n evaluators.put(RelationalOperator.LT, new LessThanEvaluator());\n evaluators.put(RelationalOperator.LTE, new LessThanEqualsEvaluator());\n evaluators.put(RelationalOperator.GT, new GreaterThanEvaluator());\n evaluators.put(RelationalOperator.GTE, new GreaterThanEqualsEvaluator());\n evaluators.put(RelationalOperator.REGEX, new RegexpEvaluator());\n evaluators.put(RelationalOperator.SIZE, new SizeEvaluator());\n evaluators.put(RelationalOperator.EMPTY, new EmptyEvaluator());\n evaluators.put(RelationalOperator.IN, new InEvaluator());\n evaluators.put(RelationalOperator.NIN, new NotInEvaluator());\n evaluators.put(RelationalOperator.ALL, new AllEvaluator());\n evaluators.put(RelationalOperator.CONTAINS, new ContainsEvaluator());\n evaluators.put(RelationalOperator.MATCHES, new PredicateMatchEvaluator());\n evaluators.put(RelationalOperator.TYPE, new TypeEvaluator());\n evaluators.put(RelationalOperator.SUBSETOF, new SubsetOfEvaluator());\n evaluators.put(RelationalOperator.ANYOF, new AnyOfEvaluator());\n evaluators.put(RelationalOperator.NONEOF, new NoneOfEvaluator());\n }\n\n public static Evaluator createEvaluator(RelationalOperator operator){\n return evaluators.get(operator);\n }\n\n private static class ExistsEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n if(!left.isBooleanNode() && !right.isBooleanNode()){\n throw new JsonPathException(\"Failed to evaluate exists expression\");\n }\n return left.asBooleanNode().getBoolean() == right.asBooleanNode().getBoolean();\n }\n }\n\n private static class NotEqualsEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n return !evaluators.get(RelationalOperator.EQ).evaluate(left, right, ctx);\n }\n }\n\n private static class TypeSafeNotEqualsEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n return !evaluators.get(RelationalOperator.TSEQ).evaluate(left, right, ctx);\n }\n }\n\n private static class EqualsEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n if(left.isJsonNode() && right.isJsonNode()){\n return left.asJsonNode().equals(right.asJsonNode(), ctx);\n } else {\n return left.equals(right);\n }\n }\n }\n\n private static class TypeSafeEqualsEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n if(!left.getClass().equals(right.getClass())){\n return false;\n }\n return evaluators.get(RelationalOperator.EQ).evaluate(left, right, ctx);\n }\n }\n\n private static class TypeEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n return right.asClassNode().getClazz() == left.type(ctx);\n }\n }\n\n private static class LessThanEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n if(left.isNumberNode() && right.isNumberNode()){\n return left.asNumberNode().getNumber().compareTo(right.asNumberNode().getNumber()) < 0;\n } if(left.isStringNode() && right.isStringNode()){\n return left.asStringNode().getString().compareTo(right.asStringNode().getString()) < 0;\n } if (left.isOffsetDateTimeNode() && right.isOffsetDateTimeNode()){ //workaround for issue: https://github.com/json-path/JsonPath/issues/613\n return left.asOffsetDateTimeNode().getDate().compareTo(right.asOffsetDateTimeNode().getDate()) < 0;\n }\n return false;\n }\n }\n\n private static class LessThanEqualsEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n if(left.isNumberNode() && right.isNumberNode()){\n return left.asNumberNode().getNumber().compareTo(right.asNumberNode().getNumber()) <= 0;\n } if(left.isStringNode() && right.isStringNode()){\n return left.asStringNode().getString().compareTo(right.asStringNode().getString()) <= 0;\n } if (left.isOffsetDateTimeNode() && right.isOffsetDateTimeNode()){ //workaround for issue: https://github.com/json-path/JsonPath/issues/613\n return left.asOffsetDateTimeNode().getDate().compareTo(right.asOffsetDateTimeNode().getDate()) <= 0;\n }\n return false;\n }\n }\n\n private static class GreaterThanEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n if(left.isNumberNode() && right.isNumberNode()){\n return left.asNumberNode().getNumber().compareTo(right.asNumberNode().getNumber()) > 0;\n } else if(left.isStringNode() && right.isStringNode()){\n return left.asStringNode().getString().compareTo(right.asStringNode().getString()) > 0;\n } else if (left.isOffsetDateTimeNode() && right.isOffsetDateTimeNode()){ //workaround for issue: https://github.com/json-path/JsonPath/issues/613\n return left.asOffsetDateTimeNode().getDate().compareTo(right.asOffsetDateTimeNode().getDate()) > 0;\n }\n return false;\n }\n }\n\n private static class GreaterThanEqualsEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n if(left.isNumberNode() && right.isNumberNode()){\n return left.asNumberNode().getNumber().compareTo(right.asNumberNode().getNumber()) >= 0;\n } else if(left.isStringNode() && right.isStringNode()){\n return left.asStringNode().getString().compareTo(right.asStringNode().getString()) >= 0;\n } else if (left.isOffsetDateTimeNode() && right.isOffsetDateTimeNode()){ //workaround for issue: https://github.com/json-path/JsonPath/issues/613\n return left.asOffsetDateTimeNode().getDate().compareTo(right.asOffsetDateTimeNode().getDate()) >= 0;\n }\n return false;\n }\n }\n\n private static class SizeEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n if (! right.isNumberNode()) {\n return false;\n }\n int expectedSize = right.asNumberNode().getNumber().intValue();\n\n if(left.isStringNode()){\n return left.asStringNode().length() == expectedSize;\n } else if(left.isJsonNode()){\n return left.asJsonNode().length(ctx) == expectedSize;\n }\n return false;\n }\n }\n\n private static class EmptyEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n if(left.isStringNode()){\n return left.asStringNode().isEmpty() == right.asBooleanNode().getBoolean();\n } else if(left.isJsonNode()){\n return left.asJsonNode().isEmpty(ctx) == right.asBooleanNode().getBoolean();\n }\n return false;\n }\n }\n\n private static class InEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n ValueListNode valueListNode;\n if(right.isJsonNode()){\n ValueNode vn = right.asJsonNode().asValueListNode(ctx);\n if(vn.isUndefinedNode()){\n return false;\n } else {\n valueListNode = vn.asValueListNode();\n }\n } else {\n valueListNode = right.asValueListNode();\n }\n return valueListNode.contains(left);\n }\n }\n\n private static class NotInEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n return !evaluators.get(RelationalOperator.IN).evaluate(left, right, ctx);\n }\n }\n\n private static class AllEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n ValueListNode requiredValues = right.asValueListNode();\n\n if(left.isJsonNode()){\n ValueNode valueNode = left.asJsonNode().asValueListNode(ctx); //returns UndefinedNode if conversion is not possible\n if(valueNode.isValueListNode()){\n ValueListNode shouldContainAll = valueNode.asValueListNode();\n for (ValueNode required : requiredValues) {\n if(!shouldContainAll.contains(required)){\n return false;\n }\n }\n }\n return true;\n }\n return false;\n }\n }\n\n private static class ContainsEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n if(left.isStringNode() && right.isStringNode()){\n return left.asStringNode().contains(right.asStringNode().getString());\n } else if(left.isJsonNode()){\n ValueNode valueNode = left.asJsonNode().asValueListNode(ctx);\n if(valueNode.isUndefinedNode()) return false;\n else {\n boolean res = valueNode.asValueListNode().contains(right);\n return res;\n }\n }\n return false;\n }\n }\n\n private static class PredicateMatchEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n return right.asPredicateNode().getPredicate().apply(ctx);\n }\n }\n\n private static class RegexpEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n if(!(left.isPatternNode() ^ right.isPatternNode())){\n return false;\n }\n\n if (left.isPatternNode()) {\n if (right.isValueListNode() || (right.isJsonNode() && right.asJsonNode().isArray(ctx))) {\n return matchesAny(left.asPatternNode(), right.asJsonNode().asValueListNode(ctx));\n } else {\n return matches(left.asPatternNode(), getInput(right));\n }\n } else {\n if (left.isValueListNode() || (left.isJsonNode() && left.asJsonNode().isArray(ctx))) {\n return matchesAny(right.asPatternNode(), left.asJsonNode().asValueListNode(ctx));\n } else {\n return matches(right.asPatternNode(), getInput(left));\n }\n }\n }\n\n private boolean matches(PatternNode patternNode, String inputToMatch) {\n return patternNode.getCompiledPattern().matcher(inputToMatch).matches();\n }\n\n private boolean matchesAny(PatternNode patternNode, ValueNode valueNode) {\n if (!valueNode.isValueListNode()) {\n return false;\n }\n\n ValueListNode listNode = valueNode.asValueListNode();\n Pattern pattern = patternNode.getCompiledPattern();\n\n for (Iterator it = listNode.iterator(); it.hasNext(); ) {\n String input = getInput(it.next());\n if (pattern.matcher(input).matches()) {\n return true;\n }\n }\n return false;\n }\n\n private String getInput(ValueNode valueNode) {\n String input = \"\";\n\n if (valueNode.isStringNode() || valueNode.isNumberNode()) {\n input = valueNode.asStringNode().getString();\n } else if (valueNode.isBooleanNode()) {\n input = valueNode.asBooleanNode().toString();\n }\n\n return input;\n }\n }\n\n private static class SubsetOfEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n ValueListNode rightValueListNode;\n if(right.isJsonNode()){\n ValueNode vn = right.asJsonNode().asValueListNode(ctx);\n if(vn.isUndefinedNode()){\n return false;\n } else {\n rightValueListNode = vn.asValueListNode();\n }\n } else {\n rightValueListNode = right.asValueListNode();\n }\n ValueListNode leftValueListNode;\n if(left.isJsonNode()){\n ValueNode vn = left.asJsonNode().asValueListNode(ctx);\n if(vn.isUndefinedNode()){\n return false;\n } else {\n leftValueListNode = vn.asValueListNode();\n }\n } else {\n leftValueListNode = left.asValueListNode();\n }\n return leftValueListNode.subsetof(rightValueListNode);\n }\n }\n\n private static class AnyOfEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n ValueListNode rightValueListNode;\n if (right.isJsonNode()) {\n ValueNode vn = right.asJsonNode().asValueListNode(ctx);\n if (vn.isUndefinedNode()) {\n return false;\n } else {\n rightValueListNode = vn.asValueListNode();\n }\n } else {\n rightValueListNode = right.asValueListNode();\n }\n ValueListNode leftValueListNode;\n if (left.isJsonNode()) {\n ValueNode vn = left.asJsonNode().asValueListNode(ctx);\n if (vn.isUndefinedNode()) {\n return false;\n } else {\n leftValueListNode = vn.asValueListNode();\n }\n } else {\n leftValueListNode = left.asValueListNode();\n }\n\n for (ValueNode leftValueNode : leftValueListNode) {\n for (ValueNode rightValueNode : rightValueListNode) {\n if (leftValueNode.equals(rightValueNode)) {\n return true;\n }\n }\n }\n return false;\n }\n }\n\n private static class NoneOfEvaluator implements Evaluator {\n @Override\n public boolean evaluate(ValueNode left, ValueNode right, Predicate.PredicateContext ctx) {\n ValueListNode rightValueListNode;\n if (right.isJsonNode()) {\n ValueNode vn = right.asJsonNode().asValueListNode(ctx);\n if (vn.isUndefinedNode()) {\n return false;\n } else {\n rightValueListNode = vn.asValueListNode();\n }\n } else {\n rightValueListNode = right.asValueListNode();\n }\n ValueListNode leftValueListNode;\n if (left.isJsonNode()) {\n ValueNode vn = left.asJsonNode().asValueListNode(ctx);\n if (vn.isUndefinedNode()) {\n return false;\n } else {\n leftValueListNode = vn.asValueListNode();\n }\n } else {\n leftValueListNode = left.asValueListNode();\n }\n\n for (ValueNode leftValueNode : leftValueListNode) {\n for (ValueNode rightValueNode : rightValueListNode) {\n if (leftValueNode.equals(rightValueNode)) {\n return false;\n }\n }\n }\n return true;\n }\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/filter/ExpressionNode.java",
"content": "package com.jayway.jsonpath.internal.filter;\n\nimport com.jayway.jsonpath.Predicate;\n\npublic abstract class ExpressionNode implements Predicate {\n\n public static ExpressionNode createExpressionNode(ExpressionNode right, LogicalOperator operator, ExpressionNode left){\n if(operator == LogicalOperator.AND){\n if((right instanceof LogicalExpressionNode) && ((LogicalExpressionNode)right).getOperator() == LogicalOperator.AND ){\n LogicalExpressionNode len = (LogicalExpressionNode) right;\n return len.append(left);\n } else {\n return LogicalExpressionNode.createLogicalAnd(left, right);\n }\n } else {\n if((right instanceof LogicalExpressionNode) && ((LogicalExpressionNode)right).getOperator() == LogicalOperator.OR ){\n LogicalExpressionNode len = (LogicalExpressionNode) right;\n return len.append(left);\n } else {\n return LogicalExpressionNode.createLogicalOr(left, right);\n }\n }\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/filter/FilterCompiler.java",
"content": "package com.jayway.jsonpath.internal.filter;\n\nimport com.jayway.jsonpath.Filter;\nimport com.jayway.jsonpath.InvalidPathException;\nimport com.jayway.jsonpath.Predicate;\nimport com.jayway.jsonpath.internal.CharacterIndex;\nimport static com.jayway.jsonpath.internal.filter.ValueNodes.*;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\npublic class FilterCompiler {\n private static final Logger logger = LoggerFactory.getLogger(FilterCompiler.class);\n\n private static final char DOC_CONTEXT = '$';\n private static final char EVAL_CONTEXT = '@';\n\n private static final char OPEN_SQUARE_BRACKET = '[';\n private static final char CLOSE_SQUARE_BRACKET = ']';\n private static final char OPEN_PARENTHESIS = '(';\n private static final char CLOSE_PARENTHESIS = ')';\n private static final char OPEN_OBJECT = '{';\n private static final char CLOSE_OBJECT = '}';\n private static final char OPEN_ARRAY = '[';\n private static final char CLOSE_ARRAY = ']';\n\n private static final char SINGLE_QUOTE = '\\'';\n private static final char DOUBLE_QUOTE = '\"';\n\n private static final char SPACE = ' ';\n private static final char PERIOD = '.';\n\n private static final char AND = '&';\n private static final char OR = '|';\n\n private static final char MINUS = '-';\n private static final char LT = '<';\n private static final char GT = '>';\n private static final char EQ = '=';\n private static final char TILDE = '~';\n private static final char TRUE = 't';\n private static final char FALSE = 'f';\n private static final char NULL = 'n';\n private static final char NOT = '!';\n private static final char PATTERN = '/';\n private static final char IGNORE_CASE = 'i';\n\n private CharacterIndex filter;\n\n public static Filter compile(String filterString) {\n FilterCompiler compiler = new FilterCompiler(filterString);\n return new CompiledFilter(compiler.compile());\n }\n\n private FilterCompiler(String filterString) {\n filter = new CharacterIndex(filterString);\n filter.trim();\n if (!filter.currentCharIs('[') || !filter.lastCharIs(']')) {\n throw new InvalidPathException(\"Filter must start with '[' and end with ']'. \" + filterString);\n }\n filter.incrementPosition(1);\n filter.decrementEndPosition(1);\n filter.trim();\n if (!filter.currentCharIs('?')) {\n throw new InvalidPathException(\"Filter must start with '[?' and end with ']'. \" + filterString);\n }\n filter.incrementPosition(1);\n filter.trim();\n if (!filter.currentCharIs('(') || !filter.lastCharIs(')')) {\n throw new InvalidPathException(\"Filter must start with '[?(' and end with ')]'. \" + filterString);\n }\n }\n\n public Predicate compile() {\n try {\n final ExpressionNode result = readLogicalOR();\n filter.skipBlanks();\n if (filter.inBounds()) {\n throw new InvalidPathException(String.format(\"Expected end of filter expression instead of: %s\",\n filter.subSequence(filter.position(), filter.length())));\n }\n\n return result;\n } catch (InvalidPathException e){\n throw e;\n } catch (Exception e) {\n throw new InvalidPathException(\"Failed to parse filter: \" + filter + \", error on position: \" + filter.position() + \", char: \" + filter.currentChar());\n }\n }\n\n private ValueNode readValueNode() {\n switch (filter.skipBlanks().currentChar()) {\n case DOC_CONTEXT : return readPath();\n case EVAL_CONTEXT : return readPath();\n case NOT:\n filter.incrementPosition(1);\n switch (filter.skipBlanks().currentChar()) {\n case DOC_CONTEXT : return readPath();\n case EVAL_CONTEXT : return readPath();\n default: throw new InvalidPathException(String.format(\"Unexpected character: %c\", NOT));\n }\n default : return readLiteral();\n }\n }\n\n private ValueNode readLiteral(){\n switch (filter.skipBlanks().currentChar()){\n case SINGLE_QUOTE: return readStringLiteral(SINGLE_QUOTE);\n case DOUBLE_QUOTE: return readStringLiteral(DOUBLE_QUOTE);\n case TRUE: return readBooleanLiteral();\n case FALSE: return readBooleanLiteral();\n case MINUS: return readNumberLiteral();\n case NULL: return readNullLiteral();\n case OPEN_OBJECT: return readJsonLiteral();\n case OPEN_ARRAY: return readJsonLiteral();\n case PATTERN: return readPattern();\n default: return readNumberLiteral();\n }\n }\n\n /*\n * LogicalOR = LogicalAND { '||' LogicalAND }\n * LogicalAND = LogicalANDOperand { '&&' LogicalANDOperand }\n * LogicalANDOperand = RelationalExpression | '(' LogicalOR ')' | '!' LogicalANDOperand\n * RelationalExpression = Value [ RelationalOperator Value ]\n */\n\n private ExpressionNode readLogicalOR() {\n final List ops = new ArrayList();\n ops.add(readLogicalAND());\n\n while (true) {\n int savepoint = filter.position();\n if (filter.hasSignificantSubSequence(LogicalOperator.OR.getOperatorString())) {\n ops.add(readLogicalAND());\n } else {\n filter.setPosition(savepoint);\n break;\n }\n }\n\n return 1 == ops.size() ? ops.get(0) : LogicalExpressionNode.createLogicalOr(ops);\n }\n\n private ExpressionNode readLogicalAND() {\n /// @fixme copy-pasted\n final List ops = new ArrayList();\n ops.add(readLogicalANDOperand());\n\n while (true) {\n int savepoint = filter.position();\n if (filter.hasSignificantSubSequence(LogicalOperator.AND.getOperatorString())) {\n ops.add(readLogicalANDOperand());\n } else {\n filter.setPosition(savepoint);\n break;\n }\n }\n\n return 1 == ops.size() ? ops.get(0) : LogicalExpressionNode.createLogicalAnd(ops);\n }\n\n private ExpressionNode readLogicalANDOperand() {\n int savepoint = filter.skipBlanks().position();\n if (filter.skipBlanks().currentCharIs(NOT)) {\n filter.readSignificantChar(NOT);\n switch (filter.skipBlanks().currentChar()) {\n case DOC_CONTEXT:\n case EVAL_CONTEXT:\n filter.setPosition(savepoint);\n break;\n default:\n final ExpressionNode op = readLogicalANDOperand();\n return LogicalExpressionNode.createLogicalNot(op);\n }\n }\n if (filter.skipBlanks().currentCharIs(OPEN_PARENTHESIS)) {\n filter.readSignificantChar(OPEN_PARENTHESIS);\n final ExpressionNode op = readLogicalOR();\n filter.readSignificantChar(CLOSE_PARENTHESIS);\n return op;\n }\n\n return readExpression();\n }\n\n private RelationalExpressionNode readExpression() {\n ValueNode left = readValueNode();\n int savepoint = filter.position();\n try {\n RelationalOperator operator = readRelationalOperator();\n ValueNode right = readValueNode();\n return new RelationalExpressionNode(left, operator, right);\n }\n catch (InvalidPathException exc) {\n filter.setPosition(savepoint);\n }\n\n PathNode pathNode = left.asPathNode();\n left = pathNode.asExistsCheck(pathNode.shouldExists());\n RelationalOperator operator = RelationalOperator.EXISTS;\n ValueNode right = left.asPathNode().shouldExists() ? ValueNodes.TRUE : ValueNodes.FALSE;\n return new RelationalExpressionNode(left, operator, right);\n }\n\n private LogicalOperator readLogicalOperator(){\n int begin = filter.skipBlanks().position();\n int end = begin+1;\n\n if(!filter.inBounds(end)){\n throw new InvalidPathException(\"Expected boolean literal\");\n }\n CharSequence logicalOperator = filter.subSequence(begin, end+1);\n if(!logicalOperator.equals(\"||\") && !logicalOperator.equals(\"&&\")){\n throw new InvalidPathException(\"Expected logical operator\");\n }\n filter.incrementPosition(logicalOperator.length());\n logger.trace(\"LogicalOperator from {} to {} -> [{}]\", begin, end, logicalOperator);\n\n return LogicalOperator.fromString(logicalOperator.toString());\n }\n\n private RelationalOperator readRelationalOperator() {\n int begin = filter.skipBlanks().position();\n\n if(isRelationalOperatorChar(filter.currentChar())){\n while (filter.inBounds() && isRelationalOperatorChar(filter.currentChar())) {\n filter.incrementPosition(1);\n }\n } else {\n while (filter.inBounds() && filter.currentChar() != SPACE) {\n filter.incrementPosition(1);\n }\n }\n\n CharSequence operator = filter.subSequence(begin, filter.position());\n logger.trace(\"Operator from {} to {} -> [{}]\", begin, filter.position()-1, operator);\n return RelationalOperator.fromString(operator.toString());\n }\n\n private NullNode readNullLiteral() {\n int begin = filter.position();\n if(filter.currentChar() == NULL && filter.inBounds(filter.position() + 3)){\n CharSequence nullValue = filter.subSequence(filter.position(), filter.position() + 4);\n if(\"null\".equals(nullValue.toString())){\n logger.trace(\"NullLiteral from {} to {} -> [{}]\", begin, filter.position()+3, nullValue);\n filter.incrementPosition(nullValue.length());\n return ValueNode.createNullNode();\n }\n }\n throw new InvalidPathException(\"Expected value\");\n }\n\n private JsonNode readJsonLiteral(){\n int begin = filter.position();\n\n char openChar = filter.currentChar();\n\n assert openChar == OPEN_ARRAY || openChar == OPEN_OBJECT;\n\n char closeChar = openChar == OPEN_ARRAY ? CLOSE_ARRAY : CLOSE_OBJECT;\n\n int closingIndex = filter.indexOfMatchingCloseChar(filter.position(), openChar, closeChar, true, false);\n if (closingIndex == -1) {\n throw new InvalidPathException(\"String not closed. Expected \" + SINGLE_QUOTE + \" in \" + filter);\n } else {\n filter.setPosition(closingIndex + 1);\n }\n CharSequence json = filter.subSequence(begin, filter.position());\n logger.trace(\"JsonLiteral from {} to {} -> [{}]\", begin, filter.position(), json);\n return ValueNode.createJsonNode(json);\n\n }\n\n private int endOfFlags(int position) {\n int endIndex = position;\n char[] currentChar = new char[1];\n while (filter.inBounds(endIndex)) {\n currentChar[0] = filter.charAt(endIndex);\n if (PatternFlag.parseFlags(currentChar) > 0) {\n endIndex++;\n continue;\n }\n break;\n }\n return endIndex;\n }\n\n private PatternNode readPattern() {\n int begin = filter.position();\n int closingIndex = filter.nextIndexOfUnescaped(PATTERN);\n if (closingIndex == -1) {\n throw new InvalidPathException(\"Pattern not closed. Expected \" + PATTERN + \" in \" + filter);\n } else {\n if (filter.inBounds(closingIndex+1)) {\n int endFlagsIndex = endOfFlags(closingIndex + 1);\n if (endFlagsIndex > closingIndex) {\n CharSequence flags = filter.subSequence(closingIndex + 1, endFlagsIndex);\n closingIndex += flags.length();\n }\n }\n filter.setPosition(closingIndex + 1);\n }\n CharSequence pattern = filter.subSequence(begin, filter.position());\n logger.trace(\"PatternNode from {} to {} -> [{}]\", begin, filter.position(), pattern);\n return ValueNode.createPatternNode(pattern);\n }\n\n private StringNode readStringLiteral(char endChar) {\n int begin = filter.position();\n\n int closingSingleQuoteIndex = filter.nextIndexOfUnescaped(endChar);\n if (closingSingleQuoteIndex == -1) {\n throw new InvalidPathException(\"String literal does not have matching quotes. Expected \" + endChar + \" in \" + filter);\n } else {\n filter.setPosition(closingSingleQuoteIndex + 1);\n }\n CharSequence stringLiteral = filter.subSequence(begin, filter.position());\n logger.trace(\"StringLiteral from {} to {} -> [{}]\", begin, filter.position(), stringLiteral);\n return ValueNode.createStringNode(stringLiteral, true);\n }\n\n private NumberNode readNumberLiteral() {\n int begin = filter.position();\n\n while (filter.inBounds() && filter.isNumberCharacter(filter.position())) {\n filter.incrementPosition(1);\n }\n CharSequence numberLiteral = filter.subSequence(begin, filter.position());\n logger.trace(\"NumberLiteral from {} to {} -> [{}]\", begin, filter.position(), numberLiteral);\n return ValueNode.createNumberNode(numberLiteral);\n }\n\n private BooleanNode readBooleanLiteral() {\n int begin = filter.position();\n int end = filter.currentChar() == TRUE ? filter.position() + 3 : filter.position() + 4;\n\n if(!filter.inBounds(end)){\n throw new InvalidPathException(\"Expected boolean literal\");\n }\n CharSequence boolValue = filter.subSequence(begin, end+1);\n if(!boolValue.equals(\"true\") && !boolValue.equals(\"false\")){\n throw new InvalidPathException(\"Expected boolean literal\");\n }\n filter.incrementPosition(boolValue.length());\n logger.trace(\"BooleanLiteral from {} to {} -> [{}]\", begin, end, boolValue);\n\n return ValueNode.createBooleanNode(boolValue);\n }\n\n private PathNode readPath() {\n char previousSignificantChar = filter.previousSignificantChar();\n int begin = filter.position();\n\n filter.incrementPosition(1); //skip $ and @\n while (filter.inBounds()) {\n if (filter.currentChar() == OPEN_SQUARE_BRACKET) {\n int closingSquareBracketIndex = filter.indexOfMatchingCloseChar(filter.position(), OPEN_SQUARE_BRACKET, CLOSE_SQUARE_BRACKET, true, false);\n if (closingSquareBracketIndex == -1) {\n throw new InvalidPathException(\"Square brackets does not match in filter \" + filter);\n } else {\n filter.setPosition(closingSquareBracketIndex + 1);\n }\n }\n boolean closingFunctionBracket = (filter.currentChar() == CLOSE_PARENTHESIS && currentCharIsClosingFunctionBracket(begin));\n boolean closingLogicalBracket = (filter.currentChar() == CLOSE_PARENTHESIS && !closingFunctionBracket);\n\n if (!filter.inBounds() || isRelationalOperatorChar(filter.currentChar()) || filter.currentChar() == SPACE || closingLogicalBracket) {\n break;\n } else {\n filter.incrementPosition(1);\n }\n }\n\n boolean shouldExists = !(previousSignificantChar == NOT);\n CharSequence path = filter.subSequence(begin, filter.position());\n return ValueNode.createPathNode(path, false, shouldExists);\n }\n\n private boolean expressionIsTerminated(){\n char c = filter.currentChar();\n if(c == CLOSE_PARENTHESIS || isLogicalOperatorChar(c)){\n return true;\n }\n c = filter.nextSignificantChar();\n if(c == CLOSE_PARENTHESIS || isLogicalOperatorChar(c)){\n return true;\n }\n return false;\n }\n\n private boolean currentCharIsClosingFunctionBracket(int lowerBound){\n if(filter.currentChar() != CLOSE_PARENTHESIS){\n return false;\n }\n int idx = filter.indexOfPreviousSignificantChar();\n if(idx == -1 || filter.charAt(idx) != OPEN_PARENTHESIS){\n return false;\n }\n idx--;\n while(filter.inBounds(idx) && idx > lowerBound){\n if(filter.charAt(idx) == PERIOD){\n return true;\n }\n idx--;\n }\n return false;\n }\n\n private boolean isLogicalOperatorChar(char c) {\n return c == AND || c == OR;\n }\n\n private boolean isRelationalOperatorChar(char c) {\n return c == LT || c == GT || c == EQ || c == TILDE || c == NOT;\n }\n\n private static final class CompiledFilter extends Filter {\n\n private final Predicate predicate;\n\n private CompiledFilter(Predicate predicate) {\n this.predicate = predicate;\n }\n\n @Override\n public boolean apply(Predicate.PredicateContext ctx) {\n return predicate.apply(ctx);\n }\n\n @Override\n public String toString() {\n String predicateString = predicate.toString();\n if(predicateString.startsWith(\"(\")){\n return \"[?\" + predicateString + \"]\";\n } else {\n return \"[?(\" + predicateString + \")]\";\n }\n }\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/filter/LogicalExpressionNode.java",
"content": "package com.jayway.jsonpath.internal.filter;\n\nimport com.jayway.jsonpath.internal.Utils;\n\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.List;\n\npublic class LogicalExpressionNode extends ExpressionNode {\n protected List chain = new ArrayList();\n private final LogicalOperator operator;\n\n public static ExpressionNode createLogicalNot(ExpressionNode op) {\n return new LogicalExpressionNode(op, LogicalOperator.NOT, null);\n }\n\n public static LogicalExpressionNode createLogicalOr(ExpressionNode left,ExpressionNode right){\n return new LogicalExpressionNode(left, LogicalOperator.OR, right);\n }\n\n public static LogicalExpressionNode createLogicalOr(Collection operands){\n return new LogicalExpressionNode(LogicalOperator.OR, operands);\n }\n\n public static LogicalExpressionNode createLogicalAnd(ExpressionNode left,ExpressionNode right){\n return new LogicalExpressionNode(left, LogicalOperator.AND, right);\n }\n\n public static LogicalExpressionNode createLogicalAnd(Collection operands){\n return new LogicalExpressionNode(LogicalOperator.AND, operands);\n }\n\n private LogicalExpressionNode(ExpressionNode left, LogicalOperator operator, ExpressionNode right) {\n chain.add(left);\n chain.add(right);\n this.operator = operator;\n }\n\n private LogicalExpressionNode(LogicalOperator operator, Collection operands) {\n chain.addAll(operands);\n this.operator = operator;\n }\n\n public LogicalExpressionNode and(LogicalExpressionNode other){\n return createLogicalAnd(this, other);\n }\n\n public LogicalExpressionNode or(LogicalExpressionNode other){\n return createLogicalOr(this, other);\n }\n\n public LogicalOperator getOperator() {\n return operator;\n }\n\n public LogicalExpressionNode append(ExpressionNode expressionNode) {\n chain.add(0, expressionNode);\n return this;\n }\n\n @Override\n public String toString() {\n return \"(\" + Utils.join(\" \" + operator.getOperatorString() + \" \", chain) + \")\";\n }\n\n @Override\n public boolean apply(PredicateContext ctx) {\n if(operator == LogicalOperator.OR){\n for (ExpressionNode expression : chain) {\n if(expression.apply(ctx)){\n return true;\n }\n }\n return false;\n } else if (operator == LogicalOperator.AND) {\n for (ExpressionNode expression : chain) {\n if(!expression.apply(ctx)){\n return false;\n }\n }\n return true;\n } else {\n ExpressionNode expression = chain.get(0);\n return !expression.apply(ctx);\n }\n }\n\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/filter/LogicalOperator.java",
"content": "package com.jayway.jsonpath.internal.filter;\n\nimport com.jayway.jsonpath.InvalidPathException;\n\npublic enum LogicalOperator {\n\n AND(\"&&\"),\n NOT(\"!\"),\n OR(\"||\");\n\n private final String operatorString;\n\n LogicalOperator(String operatorString) {\n this.operatorString = operatorString;\n }\n\n public String getOperatorString() {\n return operatorString;\n }\n\n @Override\n public String toString() {\n return operatorString;\n }\n\n public static LogicalOperator fromString(String operatorString){\n if(AND.operatorString.equals(operatorString)) return AND;\n else if(NOT.operatorString.equals(operatorString)) return NOT;\n else if(OR.operatorString.equals(operatorString)) return OR;\n else throw new InvalidPathException(\"Failed to parse operator \" + operatorString);\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/filter/PatternFlag.java",
"content": "package com.jayway.jsonpath.internal.filter;\n\nimport java.util.regex.Pattern;\n\npublic enum PatternFlag {\n UNIX_LINES(Pattern.UNIX_LINES, 'd'),\n CASE_INSENSITIVE(Pattern.CASE_INSENSITIVE, 'i'),\n COMMENTS(Pattern.COMMENTS, 'x'),\n MULTILINE(Pattern.MULTILINE, 'm'),\n DOTALL(Pattern.DOTALL, 's'),\n UNICODE_CASE(Pattern.UNICODE_CASE, 'u'),\n UNICODE_CHARACTER_CLASS(Pattern.UNICODE_CHARACTER_CLASS, 'U');\n\n private final int code;\n private final char flag;\n\n private PatternFlag(int code, char flag) {\n this.code = code;\n this.flag = flag;\n }\n\n public static int parseFlags(char[] flags) {\n int flagsValue = 0;\n for (char flag : flags) {\n flagsValue |= getCodeByFlag(flag);\n }\n return flagsValue;\n }\n\n public static String parseFlags(int flags) {\n StringBuilder builder = new StringBuilder();\n for (PatternFlag patternFlag : PatternFlag.values()) {\n if ((patternFlag.code & flags) == patternFlag.code) {\n builder.append(patternFlag.flag);\n }\n }\n return builder.toString();\n }\n\n private static int getCodeByFlag(char flag) {\n for (PatternFlag patternFlag : PatternFlag.values()) {\n if (patternFlag.flag == flag) {\n return patternFlag.code;\n }\n }\n return 0;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/filter/RelationalExpressionNode.java",
"content": "package com.jayway.jsonpath.internal.filter;\n\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\npublic class RelationalExpressionNode extends ExpressionNode {\n\n private static final Logger logger = LoggerFactory.getLogger(RelationalExpressionNode.class);\n\n private final ValueNode left;\n private final RelationalOperator relationalOperator;\n private final ValueNode right;\n\n public RelationalExpressionNode(ValueNode left, RelationalOperator relationalOperator, ValueNode right) {\n this.left = left;\n this.relationalOperator = relationalOperator;\n this.right = right;\n\n logger.trace(\"ExpressionNode {}\", toString());\n }\n\n @Override\n public String toString() {\n if(relationalOperator == RelationalOperator.EXISTS){\n return left.toString();\n } else {\n return left.toString() + \" \" + relationalOperator.toString() + \" \" + right.toString();\n }\n }\n\n @Override\n public boolean apply(PredicateContext ctx) {\n ValueNode l = left;\n ValueNode r = right;\n\n if(left.isPathNode()){\n l = left.asPathNode().evaluate(ctx);\n }\n if(right.isPathNode()){\n r = right.asPathNode().evaluate(ctx);\n }\n Evaluator evaluator = EvaluatorFactory.createEvaluator(relationalOperator);\n if(evaluator != null){\n return evaluator.evaluate(l, r, ctx);\n }\n return false;\n }\n}"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/filter/RelationalOperator.java",
"content": "package com.jayway.jsonpath.internal.filter;\n\nimport com.jayway.jsonpath.InvalidPathException;\n\nimport java.util.Locale;\n\npublic enum RelationalOperator {\n\n GTE(\">=\"),\n LTE(\"<=\"),\n EQ(\"==\"),\n\n /**\n * Type safe equals\n */\n TSEQ(\"===\"),\n NE(\"!=\"),\n\n /**\n * Type safe not equals\n */\n TSNE(\"!==\"),\n LT(\"<\"),\n GT(\">\"),\n REGEX(\"=~\"),\n NIN(\"NIN\"),\n IN(\"IN\"),\n CONTAINS(\"CONTAINS\"),\n ALL(\"ALL\"),\n SIZE(\"SIZE\"),\n EXISTS(\"EXISTS\"),\n TYPE(\"TYPE\"),\n MATCHES(\"MATCHES\"),\n EMPTY(\"EMPTY\"),\n SUBSETOF(\"SUBSETOF\"),\n ANYOF(\"ANYOF\"),\n NONEOF(\"NONEOF\");\n\n private final String operatorString;\n\n RelationalOperator(String operatorString) {\n this.operatorString = operatorString;\n }\n\n public static RelationalOperator fromString(String operatorString) {\n String upperCaseOperatorString = operatorString.toUpperCase(Locale.ROOT);\n for (RelationalOperator operator : RelationalOperator.values()) {\n if(operator.operatorString.equals(upperCaseOperatorString) ){\n return operator;\n }\n }\n throw new InvalidPathException(\"Filter operator \" + operatorString + \" is not supported!\");\n }\n\n @Override\n public String toString() {\n return operatorString;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/filter/ValueNode.java",
"content": "package com.jayway.jsonpath.internal.filter;\n\nimport com.jayway.jsonpath.InvalidPathException;\nimport com.jayway.jsonpath.JsonPathException;\nimport com.jayway.jsonpath.Predicate;\nimport com.jayway.jsonpath.internal.Path;\nimport com.jayway.jsonpath.internal.path.PathCompiler;\nimport net.minidev.json.parser.JSONParser;\n\nimport java.time.OffsetDateTime;\nimport java.util.regex.Pattern;\n\nimport static com.jayway.jsonpath.internal.filter.ValueNodes.*;\n\npublic abstract class ValueNode {\n\n public abstract Class type(Predicate.PredicateContext ctx);\n\n public boolean isPatternNode() {\n return false;\n }\n\n public PatternNode asPatternNode() {\n throw new InvalidPathException(\"Expected regexp node\");\n }\n\n public boolean isPathNode() {\n return false;\n }\n\n public PathNode asPathNode() {\n throw new InvalidPathException(\"Expected path node\");\n }\n\n public boolean isNumberNode() {\n return false;\n }\n\n public NumberNode asNumberNode() {\n throw new InvalidPathException(\"Expected number node\");\n }\n\n public boolean isStringNode() {\n return false;\n }\n\n public StringNode asStringNode() {\n throw new InvalidPathException(\"Expected string node\");\n }\n\n public boolean isBooleanNode() {\n return false;\n }\n\n public BooleanNode asBooleanNode() {\n throw new InvalidPathException(\"Expected boolean node\");\n }\n\n public boolean isJsonNode() {\n return false;\n }\n\n public JsonNode asJsonNode() {\n throw new InvalidPathException(\"Expected json node\");\n }\n\n public boolean isPredicateNode() {\n return false;\n }\n\n public PredicateNode asPredicateNode() {\n throw new InvalidPathException(\"Expected predicate node\");\n }\n\n public boolean isValueListNode() {\n return false;\n }\n\n public ValueListNode asValueListNode() {\n throw new InvalidPathException(\"Expected value list node\");\n }\n\n public boolean isNullNode() {\n return false;\n }\n\n public NullNode asNullNode() {\n throw new InvalidPathException(\"Expected null node\");\n }\n\n public UndefinedNode asUndefinedNode() {\n throw new InvalidPathException(\"Expected undefined node\");\n }\n\n public boolean isUndefinedNode() {\n return false;\n }\n\n public boolean isClassNode() {\n return false;\n }\n\n public ClassNode asClassNode() {\n throw new InvalidPathException(\"Expected class node\");\n }\n\n //workaround for issue: https://github.com/json-path/JsonPath/issues/613\n public boolean isOffsetDateTimeNode(){\n return false;\n }\n\n public OffsetDateTimeNode asOffsetDateTimeNode(){\n throw new InvalidPathException(\"Expected offsetDateTime node\");\n }\n\n\n private static boolean isPath(Object o) {\n if(o == null || !(o instanceof String)){\n return false;\n }\n String str = o.toString().trim();\n if (str.length() <= 0) {\n return false;\n }\n char c0 = str.charAt(0);\n if(c0 == '@' || c0 == '$'){\n try {\n PathCompiler.compile(str);\n return true;\n } catch(Exception e){\n return false;\n }\n }\n return false;\n }\n\n private static boolean isJson(Object o) {\n if(o == null || !(o instanceof String)){\n return false;\n }\n String str = o.toString().trim();\n if (str.length() <= 1) {\n return false;\n }\n char c0 = str.charAt(0);\n char c1 = str.charAt(str.length() - 1);\n if ((c0 == '[' && c1 == ']') || (c0 == '{' && c1 == '}')){\n try {\n new JSONParser(JSONParser.MODE_PERMISSIVE).parse(str);\n return true;\n } catch(Exception e){\n return false;\n }\n }\n return false;\n }\n\n\n\n //----------------------------------------------------\n //\n // Factory methods\n //\n //----------------------------------------------------\n public static ValueNode toValueNode(Object o){\n\n if(o == null) return NULL_NODE;\n if(o instanceof ValueNode) return (ValueNode)o;\n if(o instanceof Class) return createClassNode((Class)o);\n else if(isPath(o)) return new PathNode(o.toString(), false, false);\n else if(isJson(o)) return createJsonNode(o.toString());\n else if(o instanceof String) return createStringNode(o.toString(), true);\n else if(o instanceof Character) return createStringNode(o.toString(), false);\n else if(o instanceof Number) return createNumberNode(o.toString());\n else if(o instanceof Boolean) return createBooleanNode(o.toString());\n else if(o instanceof Pattern) return createPatternNode((Pattern)o);\n else if (o instanceof OffsetDateTime) return createOffsetDateTimeNode(o.toString()); //workaround for issue: https://github.com/json-path/JsonPath/issues/613\n else throw new JsonPathException(\"Could not determine value type\");\n\n }\n\n public static StringNode createStringNode(CharSequence charSequence, boolean escape){\n return new StringNode(charSequence, escape);\n }\n\n public static ClassNode createClassNode(Class clazz){\n return new ClassNode(clazz);\n }\n\n public static NumberNode createNumberNode(CharSequence charSequence){\n return new NumberNode(charSequence);\n }\n\n public static BooleanNode createBooleanNode(CharSequence charSequence){\n return Boolean.parseBoolean(charSequence.toString()) ? TRUE : FALSE;\n }\n\n public static NullNode createNullNode(){\n return NULL_NODE;\n }\n\n public static JsonNode createJsonNode(CharSequence json) {\n return new JsonNode(json);\n }\n\n public static JsonNode createJsonNode(Object parsedJson) {\n return new JsonNode(parsedJson);\n }\n\n public static PatternNode createPatternNode(CharSequence pattern) {\n return new PatternNode(pattern);\n }\n\n public static PatternNode createPatternNode(Pattern pattern) {\n return new PatternNode(pattern);\n }\n\n //workaround for issue: https://github.com/json-path/JsonPath/issues/613\n public static OffsetDateTimeNode createOffsetDateTimeNode(CharSequence charSequence){\n return new OffsetDateTimeNode(charSequence);\n }\n\n\n public static UndefinedNode createUndefinedNode() {\n return UNDEFINED;\n }\n\n public static PathNode createPathNode(CharSequence path, boolean existsCheck, boolean shouldExists) {\n return new PathNode(path, existsCheck, shouldExists);\n }\n\n public static ValueNode createPathNode(Path path) {\n return new PathNode(path);\n }\n\n\n}\n\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/filter/ValueNodes.java",
"content": "package com.jayway.jsonpath.internal.filter;\n\nimport java.math.BigDecimal;\nimport java.time.OffsetDateTime;\nimport java.util.*;\nimport java.util.regex.Pattern;\n\nimport com.jayway.jsonpath.Configuration;\nimport com.jayway.jsonpath.JsonPathException;\nimport com.jayway.jsonpath.Option;\nimport com.jayway.jsonpath.PathNotFoundException;\nimport com.jayway.jsonpath.Predicate;\nimport com.jayway.jsonpath.internal.Path;\nimport com.jayway.jsonpath.internal.Utils;\nimport com.jayway.jsonpath.internal.path.PathCompiler;\nimport com.jayway.jsonpath.internal.path.PredicateContextImpl;\nimport com.jayway.jsonpath.spi.json.JsonProvider;\nimport net.minidev.json.parser.JSONParser;\nimport net.minidev.json.parser.ParseException;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\n/**\n * Moved these nodes out of the ValueNode abstract class.\n * This is to avoid this possible issue:\n *\n * Classes that refer to their own subclasses in their static initializers or in static fields.\n * Such references can cause JVM-level deadlocks in multithreaded environment, when\n * one thread tries to load superclass and another thread tries to load subclass at the same time.\n */\npublic interface ValueNodes {\n\n NullNode NULL_NODE = new NullNode();\n BooleanNode TRUE = new BooleanNode(\"true\");\n BooleanNode FALSE = new BooleanNode(\"false\");\n UndefinedNode UNDEFINED = new UndefinedNode();\n\n //----------------------------------------------------\n //\n // ValueNode Implementations\n //\n //----------------------------------------------------\n class PatternNode extends ValueNode {\n private final String pattern;\n private final Pattern compiledPattern;\n private final String flags;\n\n PatternNode(CharSequence charSequence) {\n String tmp = charSequence.toString();\n int begin = tmp.indexOf('/');\n int end = tmp.lastIndexOf('/');\n this.pattern = tmp.substring(begin + 1, end);\n int flagsIndex = end + 1;\n this.flags = tmp.length() > flagsIndex ? tmp.substring(flagsIndex) : \"\";\n this.compiledPattern = Pattern.compile(pattern, PatternFlag.parseFlags(flags.toCharArray()));\n }\n\n PatternNode(Pattern pattern) {\n this.pattern = pattern.pattern();\n this.compiledPattern = pattern;\n this.flags = PatternFlag.parseFlags(pattern.flags());\n }\n\n\n Pattern getCompiledPattern() {\n return compiledPattern;\n }\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n return Void.TYPE;\n }\n\n public boolean isPatternNode() {\n return true;\n }\n\n public PatternNode asPatternNode() {\n return this;\n }\n\n @Override\n public String toString() {\n\n if(!pattern.startsWith(\"/\")){\n return \"/\" + pattern + \"/\" + flags;\n } else {\n return pattern;\n }\n }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof PatternNode)) return false;\n\n PatternNode that = (PatternNode) o;\n\n return !(compiledPattern != null ? !compiledPattern.equals(that.compiledPattern) : that.compiledPattern != null);\n\n }\n }\n\n class JsonNode extends ValueNode {\n private final Object json;\n private final boolean parsed;\n\n JsonNode(CharSequence charSequence) {\n json = charSequence.toString();\n parsed = false;\n }\n\n JsonNode(Object parsedJson) {\n json = parsedJson;\n parsed = true;\n }\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n if(isArray(ctx)) return List.class;\n else if(isMap(ctx)) return Map.class;\n else if(parse(ctx) instanceof Number) return Number.class;\n else if(parse(ctx) instanceof String) return String.class;\n else if(parse(ctx) instanceof Boolean) return Boolean.class;\n else return Void.class;\n }\n\n public boolean isJsonNode() {\n return true;\n }\n\n public JsonNode asJsonNode() {\n return this;\n }\n\n public ValueNode asValueListNode(Predicate.PredicateContext ctx){\n if(!isArray(ctx)){\n return UNDEFINED;\n } else {\n return new ValueListNode(Collections.unmodifiableList((List) parse(ctx)));\n }\n }\n\n public Object parse(Predicate.PredicateContext ctx){\n try {\n return parsed ? json : new JSONParser(JSONParser.MODE_PERMISSIVE).parse(json.toString());\n } catch (ParseException e) {\n throw new IllegalArgumentException(e);\n }\n }\n\n public boolean isParsed() {\n return parsed;\n }\n\n public Object getJson() {\n return json;\n }\n\n public boolean isArray(Predicate.PredicateContext ctx) {\n return parse(ctx) instanceof List;\n }\n\n public boolean isMap(Predicate.PredicateContext ctx) {\n return parse(ctx) instanceof Map;\n }\n\n public int length(Predicate.PredicateContext ctx) {\n return isArray(ctx) ? ((List) parse(ctx)).size() : -1;\n }\n\n public boolean isEmpty(Predicate.PredicateContext ctx) {\n if (isArray(ctx) || isMap(ctx)) return ((Collection) parse(ctx)).size() == 0;\n else if((parse(ctx) instanceof String)) return ((String)parse(ctx)).length() == 0;\n return true;\n }\n\n @Override\n public String toString() {\n return json.toString();\n }\n\n public boolean equals(JsonNode jsonNode, Predicate.PredicateContext ctx) {\n if (this == jsonNode) return true;\n return !(json != null ? !json.equals(jsonNode.parse(ctx)) : jsonNode.json != null);\n }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof JsonNode)) return false;\n\n JsonNode jsonNode = (JsonNode) o;\n\n return !(json != null ? !json.equals(jsonNode.json) : jsonNode.json != null);\n }\n }\n\n class StringNode extends ValueNode {\n private final String string;\n private boolean useSingleQuote = true;\n\n StringNode(CharSequence charSequence, boolean escape) {\n if (escape && charSequence.length() > 1) {\n char open = charSequence.charAt(0);\n char close = charSequence.charAt(charSequence.length()-1);\n if (open == '\\'' && close == '\\'') {\n charSequence = charSequence.subSequence(1, charSequence.length()-1);\n } else if (open == '\"' && close == '\"') {\n charSequence = charSequence.subSequence(1, charSequence.length()-1);\n useSingleQuote = false;\n }\n string = Utils.unescape(charSequence.toString());\n } else {\n string = charSequence.toString();\n }\n }\n\n @Override\n public NumberNode asNumberNode() {\n BigDecimal number = null;\n try {\n number = new BigDecimal(string);\n } catch (NumberFormatException nfe){\n return NumberNode.NAN;\n }\n return new NumberNode(number);\n }\n\n public String getString() {\n return string;\n }\n\n public int length(){\n return getString().length();\n }\n\n public boolean isEmpty(){\n return getString().isEmpty();\n }\n\n public boolean contains(String str) {\n return getString().contains(str);\n }\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n return String.class;\n }\n\n public boolean isStringNode() {\n return true;\n }\n\n public StringNode asStringNode() {\n return this;\n }\n\n @Override\n public String toString() {\n String quote = useSingleQuote ? \"'\" : \"\\\"\";\n return quote + Utils.escape(string, true) + quote;\n }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof StringNode) && !(o instanceof NumberNode)) return false;\n\n StringNode that = ((ValueNode) o).asStringNode();\n\n return !(string != null ? !string.equals(that.getString()) : that.getString() != null);\n\n }\n }\n\n class NumberNode extends ValueNode {\n\n public static NumberNode NAN = new NumberNode((BigDecimal)null);\n\n private final BigDecimal number;\n\n NumberNode(BigDecimal number) {\n this.number = number;\n }\n NumberNode(CharSequence num) {\n number = new BigDecimal(num.toString());\n }\n\n @Override\n public StringNode asStringNode() {\n return new StringNode(number.toString(), false);\n }\n\n public BigDecimal getNumber() {\n return number;\n }\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n return Number.class;\n }\n\n public boolean isNumberNode() {\n return true;\n }\n\n public NumberNode asNumberNode() {\n return this;\n }\n\n @Override\n public String toString() {\n return number.toString();\n }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof NumberNode) && !(o instanceof StringNode)) return false;\n\n NumberNode that = ((ValueNode)o).asNumberNode();\n\n if(that == NumberNode.NAN){\n return false;\n } else {\n return number.compareTo(that.number) == 0;\n }\n }\n }\n\n //workaround for issue: https://github.com/json-path/JsonPath/issues/613\n class OffsetDateTimeNode extends ValueNode {\n\n private final OffsetDateTime dateTime;\n\n\n OffsetDateTimeNode(OffsetDateTime dateTime) {\n this.dateTime = dateTime;\n }\n\n OffsetDateTimeNode(CharSequence date) {\n dateTime = OffsetDateTime.parse(date);\n }\n\n @Override\n public StringNode asStringNode() {\n return new StringNode(dateTime.toString(), false);\n }\n\n public OffsetDateTime getDate() {\n return dateTime;\n }\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n return OffsetDateTimeNode.class;\n }\n\n public boolean isOffsetDateTimeNode() {\n return true;\n }\n\n public OffsetDateTimeNode asOffsetDateTimeNode() {\n return this;\n }\n\n @Override\n public String toString() {\n return dateTime.toString();\n }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof OffsetDateTimeNode) && !(o instanceof StringNode)) return false;\n OffsetDateTimeNode that = ((ValueNode)o).asOffsetDateTimeNode();\n return dateTime.compareTo(that.dateTime) == 0;\n }\n }\n\n\n\n class BooleanNode extends ValueNode {\n private final Boolean value;\n\n private BooleanNode(CharSequence boolValue) {\n value = Boolean.parseBoolean(boolValue.toString());\n }\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n return Boolean.class;\n }\n\n public boolean isBooleanNode() {\n return true;\n }\n\n public BooleanNode asBooleanNode() {\n return this;\n }\n\n public boolean getBoolean() {\n return value;\n }\n\n @Override\n public String toString() {\n return value.toString();\n }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof BooleanNode)) return false;\n\n BooleanNode that = (BooleanNode) o;\n\n return !(value != null ? !value.equals(that.value) : that.value != null);\n }\n }\n\n\n\n\n\n class ClassNode extends ValueNode {\n private final Class clazz;\n\n ClassNode(Class clazz) {\n this.clazz = clazz;\n }\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n return Class.class;\n }\n\n public boolean isClassNode() {\n return true;\n }\n\n public ClassNode asClassNode() {\n return this;\n }\n\n public Class getClazz() {\n return clazz;\n }\n\n @Override\n public String toString() {\n return clazz.getName();\n }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof ClassNode)) return false;\n\n ClassNode that = (ClassNode) o;\n\n return !(clazz != null ? !clazz.equals(that.clazz) : that.clazz != null);\n }\n }\n\n class NullNode extends ValueNode {\n\n private NullNode() {}\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n return Void.class;\n }\n\n @Override\n public boolean isNullNode() {\n return true;\n }\n\n @Override\n public NullNode asNullNode() {\n return this;\n }\n\n @Override\n public String toString() {\n return \"null\";\n }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof NullNode)) return false;\n\n return true;\n }\n }\n\n class UndefinedNode extends ValueNode {\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n return Void.class;\n }\n\n public UndefinedNode asUndefinedNode() {\n return this;\n }\n\n public boolean isUndefinedNode() {\n return true;\n }\n\n @Override\n public boolean equals(Object o) {\n return false;\n }\n }\n\n class PredicateNode extends ValueNode {\n\n private final Predicate predicate;\n\n public PredicateNode(Predicate predicate) {\n this.predicate = predicate;\n }\n\n public Predicate getPredicate() {\n return predicate;\n }\n\n public PredicateNode asPredicateNode() {\n return this;\n }\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n return Void.class;\n }\n\n public boolean isPredicateNode() {\n return true;\n }\n\n @Override\n public boolean equals(Object o) {\n return false;\n }\n\n @Override\n public String toString() {\n return predicate.toString();\n }\n }\n\n class ValueListNode extends ValueNode implements Iterable {\n\n private List nodes = new ArrayList();\n\n public ValueListNode(Collection values) {\n for (Object value : values) {\n nodes.add(toValueNode(value));\n }\n }\n\n public boolean contains(ValueNode node){\n return nodes.contains(node);\n }\n\n public boolean subsetof(ValueListNode right) {\n for (ValueNode leftNode : nodes) {\n if (!right.nodes.contains(leftNode)) {\n return false;\n }\n }\n return true;\n }\n\n public List getNodes() {\n return Collections.unmodifiableList(nodes);\n }\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n return List.class;\n }\n\n public boolean isValueListNode() {\n return true;\n }\n\n public ValueListNode asValueListNode() {\n return this;\n }\n\n @Override\n public String toString() {\n return \"[\" + Utils.join(\",\", nodes) + \"]\";\n }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (!(o instanceof ValueListNode)) return false;\n\n ValueListNode that = (ValueListNode) o;\n\n return nodes.equals(that.nodes);\n }\n\n @Override\n public Iterator iterator() {\n return nodes.iterator();\n }\n }\n\n class PathNode extends ValueNode {\n\n private static final Logger logger = LoggerFactory.getLogger(PathNode.class);\n\n private final Path path;\n private final boolean existsCheck;\n private final boolean shouldExist;\n\n PathNode(Path path) {\n this(path, false, false);\n }\n\n PathNode(CharSequence charSequence, boolean existsCheck, boolean shouldExist) {\n this(PathCompiler.compile(charSequence.toString()), existsCheck, shouldExist);\n }\n\n PathNode(Path path, boolean existsCheck, boolean shouldExist) {\n this.path = path;\n this.existsCheck = existsCheck;\n this.shouldExist = shouldExist;\n logger.trace(\"PathNode {} existsCheck: {}\", path, existsCheck);\n }\n\n public Path getPath() {\n return path;\n }\n\n public boolean isExistsCheck() {\n return existsCheck;\n }\n\n public boolean shouldExists() {\n return shouldExist;\n }\n\n @Override\n public Class type(Predicate.PredicateContext ctx) {\n return Void.class;\n }\n\n public boolean isPathNode() {\n return true;\n }\n\n public PathNode asPathNode() {\n return this;\n }\n\n public PathNode asExistsCheck(boolean shouldExist) {\n return new PathNode(path, true, shouldExist);\n }\n\n @Override\n public String toString() {\n return existsCheck && ! shouldExist ? Utils.concat(\"!\" , path.toString()) : path.toString();\n }\n\n public ValueNode evaluate(Predicate.PredicateContext ctx) {\n if (isExistsCheck()) {\n try {\n Configuration c = Configuration.builder().jsonProvider(ctx.configuration().jsonProvider()).options(Option.REQUIRE_PROPERTIES).build();\n Object result = path.evaluate(ctx.item(), ctx.root(), c).getValue(false);\n return result == JsonProvider.UNDEFINED ? FALSE : TRUE;\n } catch (PathNotFoundException e) {\n return FALSE;\n }\n } else {\n try {\n Object res;\n if (ctx instanceof PredicateContextImpl) {\n //This will use cache for document ($) queries\n PredicateContextImpl ctxi = (PredicateContextImpl) ctx;\n res = ctxi.evaluate(path);\n } else {\n Object doc = path.isRootPath() ? ctx.root() : ctx.item();\n res = path.evaluate(doc, ctx.root(), ctx.configuration()).getValue();\n }\n res = ctx.configuration().jsonProvider().unwrap(res);\n\n if (res instanceof Number) return ValueNode.createNumberNode(res.toString());\n else if (res instanceof String) return ValueNode.createStringNode(res.toString(), false);\n else if (res instanceof Boolean) return ValueNode.createBooleanNode(res.toString());\n else if (res instanceof OffsetDateTime) return ValueNode.createOffsetDateTimeNode(res.toString()); //workaround for issue: https://github.com/json-path/JsonPath/issues/613\n else if (res == null) return NULL_NODE;\n else if (ctx.configuration().jsonProvider().isArray(res)) return ValueNode.createJsonNode(ctx.configuration().mappingProvider().map(res, List.class, ctx.configuration()));\n else if (ctx.configuration().jsonProvider().isMap(res)) return ValueNode.createJsonNode(ctx.configuration().mappingProvider().map(res, Map.class, ctx.configuration()));\n else throw new JsonPathException(\"Could not convert \" + res.getClass().toString()+\":\"+ res.toString() + \" to a ValueNode\");\n } catch (PathNotFoundException e) {\n return UNDEFINED;\n }\n }\n }\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/ParamType.java",
"content": "package com.jayway.jsonpath.internal.function;\n\n/**\n * Created by mgreenwood on 12/11/15.\n */\npublic enum ParamType {\n JSON,\n PATH\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/Parameter.java",
"content": "package com.jayway.jsonpath.internal.function;\n\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.Path;\nimport com.jayway.jsonpath.internal.function.latebinding.ILateBindingValue;\n\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.List;\n\n/**\n * Defines a parameter as passed to a function with late binding support for lazy evaluation.\n */\npublic class Parameter {\n private ParamType type;\n private Path path;\n private ILateBindingValue lateBinding;\n private Boolean evaluated = false;\n private String json;\n\n public Parameter() {}\n\n public Parameter(String json) {\n this.json = json;\n this.type = ParamType.JSON;\n }\n\n public Parameter(Path path) {\n this.path = path;\n this.type = ParamType.PATH;\n }\n\n public Object getValue() {\n return lateBinding.get();\n }\n\n public void setLateBinding(ILateBindingValue lateBinding) {\n this.lateBinding = lateBinding;\n }\n\n public Path getPath() {\n return path;\n }\n\n public void setEvaluated(Boolean evaluated) {\n this.evaluated = evaluated;\n }\n\n public boolean hasEvaluated() {\n return evaluated;\n }\n\n public ParamType getType() {\n return type;\n }\n\n public void setType(ParamType type) {\n this.type = type;\n }\n\n public void setPath(Path path) {\n this.path = path;\n }\n\n public String getJson() {\n return json;\n }\n\n public void setJson(String json) {\n this.json = json;\n }\n\n public ILateBindingValue getILateBingValue(){\n return lateBinding;\n }\n\n /**\n * Translate the collection of parameters into a collection of values of type T.\n *\n * @param type\n * The type to translate the collection into.\n *\n * @param ctx\n * Context.\n *\n * @param parameters\n * Collection of parameters.\n *\n * @param \n * Type T returned as a List of T.\n *\n * @return\n * List of T either empty or containing contents.\n */\n public static List toList(final Class type, final EvaluationContext ctx, final List parameters) {\n List values = new ArrayList();\n if (null != parameters) {\n for (Parameter param : parameters) {\n consume(type, ctx, values, param.getValue());\n }\n }\n return values;\n }\n\n /**\n * Either consume the object as an array and add each element to the collection, or alternatively add each element\n *\n * @param expectedType\n * the expected class type to consume, if null or not of this type the element is not added to the array.\n *\n * @param ctx\n * the JSON context to determine if this is an array or value.\n *\n * @param collection\n * The collection to append into.\n *\n * @param value\n * The value to evaluate.\n */\n public static void consume(Class expectedType, EvaluationContext ctx, Collection collection, Object value) {\n if (ctx.configuration().jsonProvider().isArray(value)) {\n for (Object o : ctx.configuration().jsonProvider().toIterable(value)) {\n if (o != null && expectedType.isAssignableFrom(o.getClass())) {\n collection.add(o);\n } else if (o != null && expectedType == String.class) {\n collection.add(o.toString());\n }\n }\n } else {\n if (value != null && expectedType.isAssignableFrom(value.getClass())) {\n collection.add(value);\n } else if (value != null && expectedType == String.class) {\n collection.add(value.toString());\n }\n }\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/PassthruPathFunction.java",
"content": "package com.jayway.jsonpath.internal.function;\n\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.PathRef;\n\nimport java.util.List;\n\n/**\n * Defines the default behavior which is to return the model that is provided as input as output\n *\n * Created by mattg on 6/26/15.\n */\npublic class PassthruPathFunction implements PathFunction {\n\n @Override\n public Object invoke(String currentPath, PathRef parent, Object model, EvaluationContext ctx, List parameters) {\n return model;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/PathFunction.java",
"content": "package com.jayway.jsonpath.internal.function;\n\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.PathRef;\n\nimport java.util.List;\n\n/**\n * Defines the pattern by which a function can be executed over the result set in the particular path\n * being grabbed. The Function's input is the content of the data from the json path selector and its output\n * is defined via the functions behavior. Thus transformations in types can take place. Additionally, functions\n * can accept multiple selectors in order to produce their output.\n *\n * Created by matt@mjgreenwood.net on 6/26/15.\n */\npublic interface PathFunction {\n\n /**\n * Invoke the function and output a JSON object (or scalar) value which will be the result of executing the path\n *\n * @param currentPath\n * The current path location inclusive of the function name\n * @param parent\n * The path location above the current function\n *\n * @param model\n * The JSON model as input to this particular function\n *\n * @param ctx\n * Eval context, state bag used as the path is traversed, maintains the result of executing\n *\n * @param parameters\n * @return result\n */\n Object invoke(String currentPath, PathRef parent, Object model, EvaluationContext ctx, List parameters);\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/PathFunctionFactory.java",
"content": "package com.jayway.jsonpath.internal.function;\n\nimport com.jayway.jsonpath.InvalidPathException;\nimport com.jayway.jsonpath.internal.function.json.Append;\nimport com.jayway.jsonpath.internal.function.json.KeySetFunction;\nimport com.jayway.jsonpath.internal.function.numeric.Average;\nimport com.jayway.jsonpath.internal.function.numeric.Max;\nimport com.jayway.jsonpath.internal.function.numeric.Min;\nimport com.jayway.jsonpath.internal.function.numeric.StandardDeviation;\nimport com.jayway.jsonpath.internal.function.numeric.Sum;\nimport com.jayway.jsonpath.internal.function.sequence.First;\nimport com.jayway.jsonpath.internal.function.sequence.Index;\nimport com.jayway.jsonpath.internal.function.sequence.Last;\nimport com.jayway.jsonpath.internal.function.text.Concatenate;\nimport com.jayway.jsonpath.internal.function.text.Length;\n\nimport java.util.Collections;\nimport java.util.HashMap;\nimport java.util.Map;\n\n/**\n * Implements a factory that given a name of the function will return the Function implementation, or null\n * if the value is not obtained.\n *\n * Leverages the function's name in order to determine which function to execute which is maintained internally\n * here via a static map\n *\n */\npublic class PathFunctionFactory {\n\n public static final Map FUNCTIONS;\n\n static {\n // New functions should be added here and ensure the name is not overridden\n Map map = new HashMap();\n\n // Math Functions\n map.put(\"avg\", Average.class);\n map.put(\"stddev\", StandardDeviation.class);\n map.put(\"sum\", Sum.class);\n map.put(\"min\", Min.class);\n map.put(\"max\", Max.class);\n\n // Text Functions\n map.put(\"concat\", Concatenate.class);\n\n // JSON Entity Functions\n map.put(Length.TOKEN_NAME, Length.class);\n map.put(\"size\", Length.class);\n map.put(\"append\", Append.class);\n map.put(\"keys\", KeySetFunction.class);\n \n // Sequential Functions\n map.put(\"first\", First.class);\n map.put(\"last\", Last.class);\n map.put(\"index\", Index.class);\n\n\n FUNCTIONS = Collections.unmodifiableMap(map);\n }\n\n /**\n * Returns the function by name or throws InvalidPathException if function not found.\n *\n * @see #FUNCTIONS\n * @see PathFunction\n *\n * @param name\n * The name of the function\n *\n * @return\n * The implementation of a function\n *\n * @throws InvalidPathException\n */\n public static PathFunction newFunction(String name) throws InvalidPathException {\n Class functionClazz = FUNCTIONS.get(name);\n if(functionClazz == null){\n throw new InvalidPathException(\"Function with name: \" + name + \" does not exist.\");\n } else {\n try {\n return (PathFunction)functionClazz.newInstance();\n } catch (Exception e) {\n throw new InvalidPathException(\"Function of name: \" + name + \" cannot be created\", e);\n }\n }\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/json/Append.java",
"content": "package com.jayway.jsonpath.internal.function.json;\n\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.internal.function.Parameter;\nimport com.jayway.jsonpath.internal.function.PathFunction;\nimport com.jayway.jsonpath.spi.json.JsonProvider;\n\nimport java.util.List;\n\n/**\n * Appends JSON structure to the current document so that you can utilize the JSON added thru another function call.\n * If there are multiple parameters then this function call will add each element that is json to the structure\n *\n * Created by mgreenwood on 12/14/15.\n */\npublic class Append implements PathFunction {\n @Override\n public Object invoke(String currentPath, PathRef parent, Object model, EvaluationContext ctx, List parameters) {\n JsonProvider jsonProvider = ctx.configuration().jsonProvider();\n if (parameters != null && parameters.size() > 0) {\n for (Parameter param : parameters) {\n if (jsonProvider.isArray(model)) {\n int len = jsonProvider.length(model);\n jsonProvider.setArrayIndex(model, len, param.getValue());\n }\n }\n }\n return model;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/json/KeySetFunction.java",
"content": "package com.jayway.jsonpath.internal.function.json;\n\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.internal.function.Parameter;\nimport com.jayway.jsonpath.internal.function.PathFunction;\n\nimport java.util.List;\n\n/**\n * Author: Sergey Saiyan sergey.sova42@gmail.com\n * Created at 21/02/2018.\n */\npublic class KeySetFunction implements PathFunction {\n\n @Override\n public Object invoke(String currentPath, PathRef parent, Object model, EvaluationContext ctx, List parameters) {\n if (ctx.configuration().jsonProvider().isMap(model)) {\n return ctx.configuration().jsonProvider().getPropertyKeys(model);\n }\n return null;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/latebinding/ILateBindingValue.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.function.latebinding;\n\n/**\n * Obtain the late binding value at runtime rather than storing the value in the cache thus trashing the cache\n *\n */\npublic interface ILateBindingValue {\n /**\n * Obtain the value of the parameter at runtime using the parameter state and invocation of other late binding values\n * rather than maintaining cached state which ends up in a global store and won't change as a result of external\n * reference changes.\n *\n * @return\n * The value of evaluating the context at runtime.\n */\n Object get();\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/latebinding/JsonLateBindingValue.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.function.latebinding;\n\nimport com.jayway.jsonpath.internal.function.Parameter;\nimport com.jayway.jsonpath.spi.json.JsonProvider;\n\n/**\n * Defines the JSON document Late binding approach to function arguments.\n *\n */\npublic class JsonLateBindingValue implements ILateBindingValue {\n private final JsonProvider jsonProvider;\n private final Parameter jsonParameter;\n\n public JsonLateBindingValue(JsonProvider jsonProvider, Parameter jsonParameter) {\n this.jsonProvider = jsonProvider;\n this.jsonParameter = jsonParameter;\n }\n\n /**\n * Evaluate the JSON document at the point of need using the JSON parameter and associated document model which may\n * itself originate from yet another function thus recursively invoking late binding methods.\n *\n * @return the late value\n */\n @Override\n public Object get() {\n return jsonProvider.parse(jsonParameter.getJson());\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/latebinding/PathLateBindingValue.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.function.latebinding;\n\nimport com.jayway.jsonpath.Configuration;\nimport com.jayway.jsonpath.internal.Path;\n\nimport java.util.Objects;\n\n/**\n * Defines the contract for late bindings, provides document state and enough context to perform the evaluation at a later\n * date such that we can operate on a dynamically changing value.\n *\n * Acts like a lambda function with references, but since we're supporting JDK 6+, we're left doing this...\n *\n */\npublic class PathLateBindingValue implements ILateBindingValue {\n private final Path path;\n private final String rootDocument;\n private final Configuration configuration;\n private final Object result;\n public PathLateBindingValue(final Path path, final Object rootDocument, final Configuration configuration) {\n this.path = path;\n this.rootDocument = rootDocument.toString();\n this.configuration = configuration;\n this.result = path.evaluate(rootDocument, rootDocument, configuration).getValue();\n }\n\n /**\n *\n * @return the late value\n */\n public Object get() {\n return result;\n }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (o == null || getClass() != o.getClass()) return false;\n PathLateBindingValue that = (PathLateBindingValue) o;\n return Objects.equals(path, that.path) &&\n rootDocument.equals(that.rootDocument) &&\n Objects.equals(configuration, that.configuration);\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/numeric/AbstractAggregation.java",
"content": "package com.jayway.jsonpath.internal.function.numeric;\n\nimport com.jayway.jsonpath.JsonPathException;\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.internal.function.Parameter;\nimport com.jayway.jsonpath.internal.function.PathFunction;\n\nimport java.util.List;\n\n/**\n * Defines the pattern for processing numerical values via an abstract implementation that iterates over the collection\n * of JSONArray entities and verifies that each is a numerical value and then passes that along the abstract methods\n *\n *\n * Created by mattg on 6/26/15.\n */\npublic abstract class AbstractAggregation implements PathFunction {\n\n /**\n * Defines the next value in the array to the mathmatical function\n *\n * @param value\n * The numerical value to process next\n */\n protected abstract void next(Number value);\n\n /**\n * Obtains the value generated via the series of next value calls\n *\n * @return\n * A numerical answer based on the input value provided\n */\n protected abstract Number getValue();\n\n @Override\n public Object invoke(String currentPath, PathRef parent, Object model, EvaluationContext ctx, List parameters) {\n int count = 0;\n if(ctx.configuration().jsonProvider().isArray(model)){\n\n Iterable objects = ctx.configuration().jsonProvider().toIterable(model);\n for (Object obj : objects) {\n if (obj instanceof Number) {\n Number value = (Number) obj;\n count++;\n next(value);\n }\n }\n }\n if (parameters != null) {\n for (Number value : Parameter.toList(Number.class, ctx, parameters)) {\n count++;\n next(value);\n }\n }\n if (count != 0) {\n return getValue();\n }\n throw new JsonPathException(\"Aggregation function attempted to calculate value using empty array\");\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/numeric/Average.java",
"content": "package com.jayway.jsonpath.internal.function.numeric;\n\n/**\n * Provides the average of a series of numbers in a JSONArray\n *\n * Created by mattg on 6/26/15.\n */\npublic class Average extends AbstractAggregation {\n\n private Double summation = 0d;\n private Double count = 0d;\n\n @Override\n protected void next(Number value) {\n count++;\n summation += value.doubleValue();\n }\n\n @Override\n protected Number getValue() {\n if (count != 0d) {\n return summation / count;\n }\n return 0d;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/numeric/Max.java",
"content": "package com.jayway.jsonpath.internal.function.numeric;\n\n/**\n * Defines the summation of a series of JSONArray numerical values\n *\n * Created by mattg on 6/26/15.\n */\npublic class Max extends AbstractAggregation {\n private Double max = Double.MIN_VALUE;\n\n @Override\n protected void next(Number value) {\n if (max < value.doubleValue()) {\n max = value.doubleValue();\n }\n }\n\n @Override\n protected Number getValue() {\n return max;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/numeric/Min.java",
"content": "package com.jayway.jsonpath.internal.function.numeric;\n\n/**\n * Defines the summation of a series of JSONArray numerical values\n *\n * Created by mattg on 6/26/15.\n */\npublic class Min extends AbstractAggregation {\n private Double min = Double.MAX_VALUE;\n\n @Override\n protected void next(Number value) {\n if (min > value.doubleValue()) {\n min = value.doubleValue();\n }\n }\n\n @Override\n protected Number getValue() {\n return min;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/numeric/StandardDeviation.java",
"content": "package com.jayway.jsonpath.internal.function.numeric;\n\n/**\n * Provides the standard deviation of a series of numbers\n *\n * Created by mattg on 6/27/15.\n */\npublic class StandardDeviation extends AbstractAggregation {\n private Double sumSq = 0d;\n private Double sum = 0d;\n private Double count = 0d;\n\n @Override\n protected void next(Number value) {\n sum += value.doubleValue();\n sumSq += value.doubleValue() * value.doubleValue();\n count++;\n }\n\n @Override\n protected Number getValue() {\n return Math.sqrt(sumSq/count - sum*sum/count/count);\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/numeric/Sum.java",
"content": "package com.jayway.jsonpath.internal.function.numeric;\n\n/**\n * Defines the summation of a series of JSONArray numerical values\n *\n * Created by mattg on 6/26/15.\n */\npublic class Sum extends AbstractAggregation {\n private Double summation = 0d;\n\n @Override\n protected void next(Number value) {\n summation += value.doubleValue();\n }\n\n @Override\n protected Number getValue() {\n return summation;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/sequence/AbstractSequenceAggregation.java",
"content": "package com.jayway.jsonpath.internal.function.sequence;\n\nimport com.jayway.jsonpath.JsonPathException;\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.internal.function.Parameter;\nimport com.jayway.jsonpath.internal.function.PathFunction;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\n/**\n * Defines the pattern for taking item from collection of JSONArray by index\n *\n * Created by git9527 on 6/11/22.\n */\npublic abstract class AbstractSequenceAggregation implements PathFunction {\n \n protected abstract int targetIndex(EvaluationContext ctx, List parameters);\n \n @Override\n public Object invoke(String currentPath, PathRef parent, Object model, EvaluationContext ctx, List parameters) {\n if(ctx.configuration().jsonProvider().isArray(model)){\n\n Iterable objects = ctx.configuration().jsonProvider().toIterable(model);\n List objectList = new ArrayList<>();\n objects.forEach(objectList::add);\n int targetIndex = this.targetIndex(ctx, parameters);\n if (targetIndex >= 0) {\n return objectList.get(targetIndex);\n } else {\n int realIndex = objectList.size() + targetIndex;\n if (realIndex > 0) {\n return objectList.get(realIndex);\n } else {\n throw new JsonPathException(\"Target index:\" + targetIndex + \" larger than object count:\" + objectList.size());\n }\n }\n }\n throw new JsonPathException(\"Aggregation function attempted to calculate value using empty array\");\n }\n \n protected int getIndexFromParameters(EvaluationContext ctx, List parameters) {\n List numbers = Parameter.toList(Number.class, ctx, parameters);\n return numbers.get(0).intValue();\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/sequence/First.java",
"content": "package com.jayway.jsonpath.internal.function.sequence;\n\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.function.Parameter;\n\nimport java.util.List;\n\n/**\n * Take the first item from collection of JSONArray\n *\n * Created by git9527 on 6/11/22.\n */\npublic class First extends AbstractSequenceAggregation {\n @Override\n protected int targetIndex(EvaluationContext ctx, List parameters) {\n return 0;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/sequence/Index.java",
"content": "package com.jayway.jsonpath.internal.function.sequence;\n\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.function.Parameter;\n\nimport java.util.List;\n\n/**\n * Take the index from first Parameter, then the item from collection of JSONArray by index\n *\n * Created by git9527 on 6/11/22.\n */\npublic class Index extends AbstractSequenceAggregation {\n @Override\n protected int targetIndex(EvaluationContext ctx, List parameters) {\n return getIndexFromParameters(ctx, parameters);\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/sequence/Last.java",
"content": "package com.jayway.jsonpath.internal.function.sequence;\n\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.function.Parameter;\n\nimport java.util.List;\n\n/**\n * Take the first item from collection of JSONArray\n *\n * Created by git9527 on 6/11/22.\n */\npublic class Last extends AbstractSequenceAggregation {\n @Override\n protected int targetIndex(EvaluationContext ctx, List parameters) {\n return -1;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/text/Concatenate.java",
"content": "package com.jayway.jsonpath.internal.function.text;\n\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.internal.function.Parameter;\nimport com.jayway.jsonpath.internal.function.PathFunction;\n\nimport java.util.List;\n\n/**\n * String function concat - simple takes a list of arguments and/or an array and concatenates them together to form a\n * single string\n *\n */\npublic class Concatenate implements PathFunction {\n @Override\n public Object invoke(String currentPath, PathRef parent, Object model, EvaluationContext ctx, List parameters) {\n StringBuilder result = new StringBuilder();\n if(ctx.configuration().jsonProvider().isArray(model)){\n Iterable objects = ctx.configuration().jsonProvider().toIterable(model);\n for (Object obj : objects) {\n if (obj instanceof String) {\n result.append(obj.toString());\n }\n }\n }\n if (parameters != null) {\n for (String value : Parameter.toList(String.class, ctx, parameters)) {\n result.append(value);\n }\n }\n return result.toString();\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/function/text/Length.java",
"content": "package com.jayway.jsonpath.internal.function.text;\n\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.Path;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.internal.function.Parameter;\nimport com.jayway.jsonpath.internal.function.PathFunction;\nimport com.jayway.jsonpath.internal.path.CompiledPath;\nimport com.jayway.jsonpath.internal.path.PathToken;\nimport com.jayway.jsonpath.internal.path.RootPathToken;\nimport com.jayway.jsonpath.internal.path.WildcardPathToken;\n\nimport java.util.List;\n\n/**\n * Provides the length of a JSONArray Object\n *\n * Created by mattg on 6/26/15.\n */\npublic class Length implements PathFunction {\n\n public static final String TOKEN_NAME = \"length\";\n\n /**\n * When we calculate the length of a path, what we're asking is given the node we land on how many children does it\n * have. Thus when we wrote the original query what we really wanted was $..book.length() or $.length($..book.*)\n *\n * @param currentPath\n * The current path location inclusive of the function name\n * @param parent\n * The path location above the current function\n *\n * @param model\n * The JSON model as input to this particular function\n *\n * @param ctx\n * Eval context, state bag used as the path is traversed, maintains the result of executing\n *\n * @param parameters\n * @return\n */\n @Override\n public Object invoke(String currentPath, PathRef parent, Object model, EvaluationContext ctx, List parameters) {\n if (null != parameters && parameters.size() > 0) {\n\n // Set the tail of the first parameter, when its not a function path parameter (which wouldn't make sense\n // for length - to the wildcard such that we request all of its children so we can get back an array and\n // take its length.\n Parameter lengthOfParameter = parameters.get(0);\n if (!lengthOfParameter.getPath().isFunctionPath()) {\n Path path = lengthOfParameter.getPath();\n if (path instanceof CompiledPath) {\n RootPathToken root = ((CompiledPath) path).getRoot();\n PathToken tail = root.getNext();\n while (null != tail && null != tail.getNext()) {\n tail = tail.getNext();\n }\n if (null != tail) {\n tail.setNext(new WildcardPathToken());\n }\n }\n }\n Object innerModel = parameters.get(0).getPath().evaluate(model, model, ctx.configuration()).getValue();\n if (ctx.configuration().jsonProvider().isArray(innerModel)) {\n return ctx.configuration().jsonProvider().length(innerModel);\n }\n }\n if (ctx.configuration().jsonProvider().isArray(model)) {\n return ctx.configuration().jsonProvider().length(model);\n } else if(ctx.configuration().jsonProvider().isMap(model)){\n return ctx.configuration().jsonProvider().length(model);\n }\n return null;\n }\n}"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/ArrayIndexOperation.java",
"content": "package com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.InvalidPathException;\nimport com.jayway.jsonpath.internal.Utils;\n\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.List;\nimport java.util.regex.Pattern;\n\nimport static java.lang.Character.isDigit;\n\npublic class ArrayIndexOperation {\n\n private final static Pattern COMMA = Pattern.compile(\"\\\\s*,\\\\s*\");\n\n private final List indexes;\n\n private ArrayIndexOperation(List indexes) {\n this.indexes = Collections.unmodifiableList(indexes);\n }\n\n public List indexes() {\n return indexes;\n }\n\n public boolean isSingleIndexOperation(){\n return indexes.size() == 1;\n }\n\n @Override\n public String toString() {\n StringBuilder sb = new StringBuilder();\n sb.append(\"[\");\n sb.append(Utils.join(\",\", indexes));\n sb.append(\"]\");\n\n return sb.toString();\n }\n\n public static ArrayIndexOperation parse(String operation) {\n //check valid chars\n for (int i = 0; i < operation.length(); i++) {\n char c = operation.charAt(i);\n if (!isDigit(c) && c != ',' && c != ' ' && c != '-') {\n throw new InvalidPathException(\"Failed to parse ArrayIndexOperation: \" + operation);\n }\n }\n String[] tokens = COMMA.split(operation, -1);\n\n List tempIndexes = new ArrayList(tokens.length);\n for (String token : tokens) {\n tempIndexes.add(parseInteger(token));\n }\n\n return new ArrayIndexOperation(tempIndexes);\n }\n\n private static Integer parseInteger(String token) {\n try {\n return Integer.parseInt(token);\n } catch (Exception e){\n throw new InvalidPathException(\"Failed to parse token in ArrayIndexOperation: \" + token, e);\n }\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/ArrayIndexToken.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.internal.PathRef;\n\nimport static java.lang.String.format;\n\npublic class ArrayIndexToken extends ArrayPathToken {\n\n private final ArrayIndexOperation arrayIndexOperation;\n\n ArrayIndexToken(final ArrayIndexOperation arrayIndexOperation) {\n this.arrayIndexOperation = arrayIndexOperation;\n }\n\n @Override\n public void evaluate(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) {\n if (!checkArrayModel(currentPath, model, ctx))\n return;\n if (arrayIndexOperation.isSingleIndexOperation()) {\n handleArrayIndex(arrayIndexOperation.indexes().get(0), currentPath, model, ctx);\n } else {\n for (Integer index : arrayIndexOperation.indexes()) {\n handleArrayIndex(index, currentPath, model, ctx);\n }\n }\n }\n\n @Override\n public String getPathFragment() {\n return arrayIndexOperation.toString();\n }\n\n @Override\n public boolean isTokenDefinite() {\n return arrayIndexOperation.isSingleIndexOperation();\n }\n\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/ArrayPathToken.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.InvalidPathException;\nimport com.jayway.jsonpath.Option;\nimport com.jayway.jsonpath.PathNotFoundException;\n\nimport static java.lang.String.format;\n\npublic abstract class ArrayPathToken extends PathToken {\n\n /**\n * Check if model is non-null and array.\n * @param currentPath\n * @param model\n * @param ctx\n * @return false if current evaluation call must be skipped, true otherwise\n * @throws PathNotFoundException if model is null and evaluation must be interrupted\n * @throws InvalidPathException if model is not an array and evaluation must be interrupted\n */\n protected boolean checkArrayModel(String currentPath, Object model, EvaluationContextImpl ctx) {\n if (model == null){\n if (!isUpstreamDefinite()\n || ctx.options().contains(Option.SUPPRESS_EXCEPTIONS)) {\n return false;\n } else {\n throw new PathNotFoundException(\"The path \" + currentPath + \" is null\");\n }\n }\n if (!ctx.jsonProvider().isArray(model)) {\n if (!isUpstreamDefinite()\n || ctx.options().contains(Option.SUPPRESS_EXCEPTIONS)) {\n return false;\n } else {\n throw new PathNotFoundException(format(\"Filter: %s can only be applied to arrays. Current context is: %s\", toString(), model));\n }\n }\n return true;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/ArraySliceOperation.java",
"content": "package com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.InvalidPathException;\n\nimport static java.lang.Character.isDigit;\n\npublic class ArraySliceOperation {\n\n public enum Operation {\n SLICE_FROM,\n SLICE_TO,\n SLICE_BETWEEN\n }\n\n private final Integer from;\n private final Integer to;\n private final Operation operation;\n\n private ArraySliceOperation(Integer from, Integer to, Operation operation) {\n this.from = from;\n this.to = to;\n this.operation = operation;\n }\n\n public Integer from() {\n return from;\n }\n\n public Integer to() {\n return to;\n }\n\n public Operation operation() {\n return operation;\n }\n\n @Override\n public String toString() {\n StringBuilder sb = new StringBuilder();\n sb.append(\"[\");\n sb.append(from == null ? \"\" : from.toString());\n sb.append(\":\");\n sb.append(to == null ? \"\" : to.toString());\n sb.append(\"]\");\n\n return sb.toString();\n }\n\n public static ArraySliceOperation parse(String operation){\n //check valid chars\n for (int i = 0; i < operation.length(); i++) {\n char c = operation.charAt(i);\n if( !isDigit(c) && c != '-' && c != ':'){\n throw new InvalidPathException(\"Failed to parse SliceOperation: \" + operation);\n }\n }\n String[] tokens = operation.split(\":\");\n\n Integer tempFrom = tryRead(tokens, 0);\n Integer tempTo = tryRead(tokens, 1);\n Operation tempOperation;\n\n if (tempFrom != null && tempTo == null) {\n tempOperation = Operation.SLICE_FROM;\n } else if (tempFrom != null) {\n tempOperation = Operation.SLICE_BETWEEN;\n } else if (tempTo != null) {\n tempOperation = Operation.SLICE_TO;\n } else {\n throw new InvalidPathException(\"Failed to parse SliceOperation: \" + operation);\n }\n\n return new ArraySliceOperation(tempFrom, tempTo, tempOperation);\n }\n\n private static Integer tryRead(String[] tokens, int idx){\n if(tokens.length > idx){\n if(tokens[idx].equals(\"\")){\n return null;\n }\n return Integer.parseInt(tokens[idx]);\n } else {\n return null;\n }\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/ArraySliceToken.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.internal.PathRef;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\npublic class ArraySliceToken extends ArrayPathToken {\n\n private static final Logger logger = LoggerFactory.getLogger(ArraySliceToken.class);\n\n private final ArraySliceOperation operation;\n\n ArraySliceToken(final ArraySliceOperation operation) {\n this.operation = operation;\n }\n\n @Override\n public void evaluate(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) {\n if (!checkArrayModel(currentPath, model, ctx))\n return;\n switch (operation.operation()) {\n case SLICE_FROM:\n sliceFrom(currentPath, parent, model, ctx);\n break;\n case SLICE_BETWEEN:\n sliceBetween(currentPath, parent, model, ctx);\n break;\n case SLICE_TO:\n sliceTo(currentPath, parent, model, ctx);\n break;\n }\n }\n\n private void sliceFrom(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) {\n int length = ctx.jsonProvider().length(model);\n int from = operation.from();\n if (from < 0) {\n //calculate slice start from array length\n from = length + from;\n }\n from = Math.max(0, from);\n\n logger.debug(\"Slice from index on array with length: {}. From index: {} to: {}. Input: {}\", length, from, length - 1, toString());\n\n if (length == 0 || from >= length) {\n return;\n }\n for (int i = from; i < length; i++) {\n handleArrayIndex(i, currentPath, model, ctx);\n }\n }\n\n private void sliceBetween(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) {\n int length = ctx.jsonProvider().length(model);\n int from = operation.from();\n int to = operation.to();\n\n to = Math.min(length, to);\n\n if (from >= to || length == 0) {\n return;\n }\n\n logger.debug(\"Slice between indexes on array with length: {}. From index: {} to: {}. Input: {}\", length, from, to, toString());\n\n for (int i = from; i < to; i++) {\n handleArrayIndex(i, currentPath, model, ctx);\n }\n }\n\n private void sliceTo(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) {\n int length = ctx.jsonProvider().length(model);\n if (length == 0) {\n return;\n }\n int to = operation.to();\n if (to < 0) {\n //calculate slice end from array length\n to = length + to;\n }\n to = Math.min(length, to);\n\n logger.debug(\"Slice to index on array with length: {}. From index: 0 to: {}. Input: {}\", length, to, toString());\n\n for (int i = 0; i < to; i++) {\n handleArrayIndex(i, currentPath, model, ctx);\n }\n }\n\n @Override\n public String getPathFragment() {\n return operation.toString();\n }\n\n @Override\n public boolean isTokenDefinite() {\n return false;\n }\n\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/CompiledPath.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.Configuration;\nimport com.jayway.jsonpath.internal.EvaluationAbortException;\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.Path;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.internal.function.ParamType;\nimport com.jayway.jsonpath.internal.function.Parameter;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\nimport java.util.Arrays;\n\npublic class CompiledPath implements Path {\n\n private static final Logger logger = LoggerFactory.getLogger(CompiledPath.class);\n\n private final RootPathToken root;\n\n private final boolean isRootPath;\n\n\n public CompiledPath(RootPathToken root, boolean isRootPath) {\n this.root = invertScannerFunctionRelationship(root);\n this.isRootPath = isRootPath;\n }\n\n @Override\n public boolean isRootPath() {\n return isRootPath;\n }\n\n\n\n /**\n * In the event the writer of the path referenced a function at the tail end of a scanner, augment the query such\n * that the root node is the function and the parameter to the function is the scanner. This way we maintain\n * relative sanity in the path expression, functions either evaluate scalar values or arrays, they're\n * not re-entrant nor should they maintain state, they do however take parameters.\n *\n * @param path\n * this is our old root path which will become a parameter (assuming there's a scanner terminated by a function\n *\n * @return\n * A function with the scanner as input, or if this situation doesn't exist just the input path\n */\n private RootPathToken invertScannerFunctionRelationship(final RootPathToken path) {\n if (path.isFunctionPath() && path.next() instanceof ScanPathToken) {\n PathToken token = path;\n PathToken prior = null;\n while (null != (token = token.next()) && !(token instanceof FunctionPathToken)) {\n prior = token;\n }\n // Invert the relationship $..path.function() to $.function($..path)\n if (token instanceof FunctionPathToken) {\n prior.setNext(null);\n path.setTail(prior);\n\n // Now generate a new parameter from our path\n Parameter parameter = new Parameter();\n parameter.setPath(new CompiledPath(path, true));\n parameter.setType(ParamType.PATH);\n ((FunctionPathToken)token).setParameters(Arrays.asList(parameter));\n RootPathToken functionRoot = new RootPathToken('$');\n functionRoot.setTail(token);\n functionRoot.setNext(token);\n\n // Define the function as the root\n return functionRoot;\n }\n }\n return path;\n }\n\n @Override\n public EvaluationContext evaluate(Object document, Object rootDocument, Configuration configuration, boolean forUpdate) {\n if (logger.isDebugEnabled()) {\n logger.debug(\"Evaluating path: {}\", toString());\n }\n\n EvaluationContextImpl ctx = new EvaluationContextImpl(this, rootDocument, configuration, forUpdate);\n try {\n PathRef op = ctx.forUpdate() ? PathRef.createRoot(rootDocument) : PathRef.NO_OP;\n root.evaluate(\"\", op, document, ctx);\n } catch (EvaluationAbortException abort) {}\n\n return ctx;\n }\n\n @Override\n public EvaluationContext evaluate(Object document, Object rootDocument, Configuration configuration){\n return evaluate(document, rootDocument, configuration, false);\n }\n\n @Override\n public boolean isDefinite() {\n return root.isPathDefinite();\n }\n\n @Override\n public boolean isFunctionPath() {\n return root.isFunctionPath();\n }\n\n @Override\n public String toString() {\n return root.toString();\n }\n\n public RootPathToken getRoot() {\n return root;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/EvaluationContextImpl.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.Configuration;\nimport com.jayway.jsonpath.EvaluationListener;\nimport com.jayway.jsonpath.Option;\nimport com.jayway.jsonpath.PathNotFoundException;\nimport com.jayway.jsonpath.internal.EvaluationAbortException;\nimport com.jayway.jsonpath.internal.EvaluationContext;\nimport com.jayway.jsonpath.internal.Path;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.spi.json.JsonProvider;\n\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.Collections;\nimport java.util.HashMap;\nimport java.util.List;\nimport java.util.Set;\n\nimport static com.jayway.jsonpath.internal.Utils.notNull;\n\n/**\n *\n */\npublic class EvaluationContextImpl implements EvaluationContext {\n\n private static final EvaluationAbortException ABORT_EVALUATION = new EvaluationAbortException();\n\n private final Configuration configuration;\n private final Object valueResult;\n private final Object pathResult;\n private final Path path;\n private final Object rootDocument;\n private final List updateOperations;\n private final HashMap documentEvalCache = new HashMap();\n private final boolean forUpdate;\n private final boolean suppressExceptions;\n private int resultIndex = 0;\n\n\n public RootPathToken getRoot(){\n return ((CompiledPath) path).getRoot();\n }\n\n public EvaluationContextImpl(Path path, Object rootDocument, Configuration configuration, boolean forUpdate) {\n notNull(path, \"path can not be null\");\n notNull(rootDocument, \"root can not be null\");\n notNull(configuration, \"configuration can not be null\");\n this.forUpdate = forUpdate;\n this.path = path;\n this.rootDocument = rootDocument;\n this.configuration = configuration;\n this.valueResult = configuration.jsonProvider().createArray();\n this.pathResult = configuration.jsonProvider().createArray();\n this.updateOperations = new ArrayList<>();\n this.suppressExceptions = configuration.containsOption(Option.SUPPRESS_EXCEPTIONS);\n }\n\n public HashMap documentEvalCache() {\n return documentEvalCache;\n }\n\n public boolean forUpdate(){\n return forUpdate;\n }\n\n public void addResult(String path, PathRef operation, Object model) {\n\n if(forUpdate) {\n updateOperations.add(operation);\n }\n\n configuration.jsonProvider().setArrayIndex(valueResult, resultIndex, model);\n configuration.jsonProvider().setArrayIndex(pathResult, resultIndex, path);\n resultIndex++;\n if(!configuration().getEvaluationListeners().isEmpty()){\n int idx = resultIndex - 1;\n for (EvaluationListener listener : configuration().getEvaluationListeners()) {\n EvaluationListener.EvaluationContinuation continuation = listener.resultFound(new FoundResultImpl(idx, path, model));\n if(EvaluationListener.EvaluationContinuation.ABORT == continuation){\n throw ABORT_EVALUATION;\n }\n }\n }\n }\n\n\n public JsonProvider jsonProvider() {\n return configuration.jsonProvider();\n }\n\n public Set options() {\n return configuration.getOptions();\n }\n\n @Override\n public Configuration configuration() {\n return configuration;\n }\n\n @Override\n public Object rootDocument() {\n return rootDocument;\n }\n\n public Collection updateOperations(){\n\n Collections.sort(updateOperations);\n\n return Collections.unmodifiableCollection(updateOperations);\n }\n\n\n @SuppressWarnings(\"unchecked\")\n @Override\n public T getValue() {\n return getValue(true);\n }\n\n @SuppressWarnings(\"unchecked\")\n @Override\n public T getValue(boolean unwrap) {\n if (path.isDefinite()) {\n if(resultIndex == 0) {\n if (suppressExceptions) {\n return null;\n }\n throw new PathNotFoundException(\"No results for path: \" + path.toString());\n }\n int len = jsonProvider().length(valueResult);\n Object value = (len > 0) ? jsonProvider().getArrayIndex(valueResult, len-1) : null;\n if (value != null && unwrap){\n value = jsonProvider().unwrap(value);\n }\n return (T) value;\n }\n return (T)valueResult;\n }\n\n @SuppressWarnings(\"unchecked\")\n @Override\n public T getPath() {\n if(resultIndex == 0) {\n if (suppressExceptions) {\n return null;\n }\n throw new PathNotFoundException(\"No results for path: \" + path.toString());\n }\n return (T)pathResult;\n }\n\n @Override\n public List getPathList() {\n List res = new ArrayList();\n if(resultIndex > 0){\n Iterable objects = configuration.jsonProvider().toIterable(pathResult);\n for (Object o : objects) {\n res.add((String)o);\n }\n }\n return res;\n }\n\n private static class FoundResultImpl implements EvaluationListener.FoundResult {\n\n private final int index;\n private final String path;\n private final Object result;\n\n private FoundResultImpl(int index, String path, Object result) {\n this.index = index;\n this.path = path;\n this.result = result;\n }\n\n @Override\n public int index() {\n return index;\n }\n\n @Override\n public String path() {\n return path;\n }\n\n @Override\n public Object result() {\n return result;\n }\n }\n\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/FunctionPathToken.java",
"content": "package com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.internal.Path;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.internal.function.Parameter;\nimport com.jayway.jsonpath.internal.function.PathFunction;\nimport com.jayway.jsonpath.internal.function.PathFunctionFactory;\nimport com.jayway.jsonpath.internal.function.latebinding.JsonLateBindingValue;\nimport com.jayway.jsonpath.internal.function.latebinding.PathLateBindingValue;\n\nimport java.util.List;\n\n/**\n * Token representing a Function call to one of the functions produced via the FunctionFactory\n *\n * @see PathFunctionFactory\n *\n * Created by mattg on 6/27/15.\n */\npublic class FunctionPathToken extends PathToken {\n\n private final String functionName;\n private final String pathFragment;\n private List functionParams;\n\n public FunctionPathToken(String pathFragment, List parameters) {\n this.pathFragment = pathFragment + ((parameters != null && parameters.size() > 0) ? \"(...)\" : \"()\");\n if(null != pathFragment){\n functionName = pathFragment;\n functionParams = parameters;\n } else {\n functionName = null;\n functionParams = null;\n }\n }\n\n @Override\n public void evaluate(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) {\n PathFunction pathFunction = PathFunctionFactory.newFunction(functionName);\n evaluateParameters(currentPath, parent, model, ctx);\n Object result = pathFunction.invoke(currentPath, parent, model, ctx, functionParams);\n ctx.addResult(currentPath + \".\" + functionName, parent, result);\n cleanWildcardPathToken();\n if (!isLeaf()) {\n next().evaluate(currentPath, parent, result, ctx);\n }\n }\n\n private void cleanWildcardPathToken() {\n if (null != functionParams && functionParams.size() > 0) {\n Path path = functionParams.get(0).getPath();\n if (null != path && !path.isFunctionPath() && path instanceof CompiledPath) {\n RootPathToken root = ((CompiledPath) path).getRoot();\n PathToken tail = root.getNext();\n while (null != tail && null != tail.getNext() ) {\n if(tail.getNext() instanceof WildcardPathToken){\n tail.setNext(tail.getNext().getNext());\n break;\n }\n tail = tail.getNext();\n }\n }\n }\n }\n\n private void evaluateParameters(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) {\n\n if (null != functionParams) {\n for (Parameter param : functionParams) {\n switch (param.getType()) {\n case PATH:\n PathLateBindingValue pathLateBindingValue = new PathLateBindingValue(param.getPath(), ctx.rootDocument(), ctx.configuration());\n if (!param.hasEvaluated()||!pathLateBindingValue.equals(param.getILateBingValue())) {\n param.setLateBinding(pathLateBindingValue);\n param.setEvaluated(true);\n }\n break;\n case JSON:\n if (!param.hasEvaluated()) {\n param.setLateBinding(new JsonLateBindingValue(ctx.configuration().jsonProvider(), param));\n param.setEvaluated(true);\n }\n break;\n }\n }\n }\n }\n\n /**\n * Return the actual value by indicating true. If this return was false then we'd return the value in an array which\n * isn't what is desired - true indicates the raw value is returned.\n *\n * @return true if token is definite\n */\n @Override\n public boolean isTokenDefinite() {\n return true;\n }\n\n @Override\n public String getPathFragment() {\n return \".\" + pathFragment;\n }\n\n\n public void setParameters(List parameters) {\n this.functionParams = parameters;\n }\n\n public List getParameters() {\n return this.functionParams;\n }\n public String getFunctionName() {\n return this.functionName;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/PathCompiler.java",
"content": "package com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.InvalidPathException;\nimport com.jayway.jsonpath.Predicate;\nimport com.jayway.jsonpath.internal.CharacterIndex;\nimport com.jayway.jsonpath.internal.Path;\nimport com.jayway.jsonpath.internal.Utils;\nimport com.jayway.jsonpath.internal.filter.FilterCompiler;\nimport com.jayway.jsonpath.internal.function.ParamType;\nimport com.jayway.jsonpath.internal.function.Parameter;\n\nimport java.util.ArrayList;\nimport java.util.Collection;\nimport java.util.LinkedList;\nimport java.util.List;\n\nimport static java.lang.Character.isDigit;\nimport static java.util.Arrays.asList;\n\npublic class PathCompiler {\n\n private static final char DOC_CONTEXT = '$';\n private static final char EVAL_CONTEXT = '@';\n\n private static final char OPEN_SQUARE_BRACKET = '[';\n private static final char CLOSE_SQUARE_BRACKET = ']';\n private static final char OPEN_PARENTHESIS = '(';\n private static final char CLOSE_PARENTHESIS = ')';\n private static final char OPEN_BRACE = '{';\n private static final char CLOSE_BRACE = '}';\n\n private static final char WILDCARD = '*';\n private static final char PERIOD = '.';\n private static final char SPACE = ' ';\n private static final char TAB = '\\t';\n private static final char CR = '\\r';\n private static final char LF = '\\n';\n private static final char BEGIN_FILTER = '?';\n private static final char COMMA = ',';\n private static final char SPLIT = ':';\n private static final char MINUS = '-';\n private static final char SINGLE_QUOTE = '\\'';\n private static final char DOUBLE_QUOTE = '\"';\n\n private final LinkedList filterStack;\n private final CharacterIndex path;\n\n private PathCompiler(String path, LinkedList filterStack){\n this(new CharacterIndex(path), filterStack);\n }\n\n private PathCompiler(CharacterIndex path, LinkedList filterStack){\n this.filterStack = filterStack;\n this.path = path;\n }\n\n private Path compile() {\n RootPathToken root = readContextToken();\n return new CompiledPath(root, root.getPathFragment().equals(\"$\"));\n }\n\n public static Path compile(String path, final Predicate... filters) {\n try {\n CharacterIndex ci = new CharacterIndex(path);\n ci.trim();\n\n if(!( ci.charAt(0) == DOC_CONTEXT) && !( ci.charAt(0) == EVAL_CONTEXT)){\n ci = new CharacterIndex(\"$.\" + path);\n ci.trim();\n }\n if(ci.lastCharIs('.')){\n fail(\"Path must not end with a '.' or '..'\");\n }\n LinkedList filterStack = new LinkedList(asList(filters));\n return new PathCompiler(ci, filterStack).compile();\n } catch (Exception e) {\n InvalidPathException ipe;\n if (e instanceof InvalidPathException) {\n ipe = (InvalidPathException) e;\n } else {\n ipe = new InvalidPathException(e);\n }\n throw ipe;\n }\n }\n\n private void readWhitespace() {\n while (path.inBounds()) {\n char c = path.currentChar();\n if (!isWhitespace(c)) {\n break;\n }\n path.incrementPosition(1);\n }\n }\n\n private Boolean isPathContext(char c) {\n return (c == DOC_CONTEXT || c == EVAL_CONTEXT);\n }\n\n //[$ | @]\n private RootPathToken readContextToken() {\n\n readWhitespace();\n\n if (!isPathContext(path.currentChar())) {\n throw new InvalidPathException(\"Path must start with '$' or '@'\");\n }\n\n RootPathToken pathToken = PathTokenFactory.createRootPathToken(path.currentChar());\n\n if (path.currentIsTail()) {\n return pathToken;\n }\n\n path.incrementPosition(1);\n\n if(path.currentChar() != PERIOD && path.currentChar() != OPEN_SQUARE_BRACKET){\n fail(\"Illegal character at position \" + path.position() + \" expected '.' or '['\");\n }\n\n PathTokenAppender appender = pathToken.getPathTokenAppender();\n readNextToken(appender);\n\n return pathToken;\n }\n\n //\n //\n //\n private boolean readNextToken(PathTokenAppender appender) {\n\n char c = path.currentChar();\n\n switch (c) {\n case OPEN_SQUARE_BRACKET:\n if (!readBracketPropertyToken(appender) && !readArrayToken(appender) && !readWildCardToken(appender)\n && !readFilterToken(appender) && !readPlaceholderToken(appender)) {\n fail(\"Could not parse token starting at position \" + path.position() + \". Expected ?, ', 0-9, * \");\n }\n return true;\n case PERIOD:\n if (!readDotToken(appender)) {\n fail(\"Could not parse token starting at position \" + path.position());\n }\n return true;\n case WILDCARD:\n if (!readWildCardToken(appender)) {\n fail(\"Could not parse token starting at position \" + path.position());\n }\n return true;\n default:\n if (!readPropertyOrFunctionToken(appender)) {\n fail(\"Could not parse token starting at position \" + path.position());\n }\n return true;\n }\n }\n\n //\n // . and ..\n //\n private boolean readDotToken(PathTokenAppender appender) {\n if (path.currentCharIs(PERIOD) && path.nextCharIs(PERIOD)) {\n appender.appendPathToken(PathTokenFactory.crateScanToken());\n path.incrementPosition(2);\n } else if (!path.hasMoreCharacters()) {\n throw new InvalidPathException(\"Path must not end with a '.\");\n } else {\n path.incrementPosition(1);\n }\n if(path.currentCharIs(PERIOD)){\n throw new InvalidPathException(\"Character '.' on position \" + path.position() + \" is not valid.\");\n }\n return readNextToken(appender);\n }\n\n //\n // fooBar or fooBar()\n //\n private boolean readPropertyOrFunctionToken(PathTokenAppender appender) {\n if (path.currentCharIs(OPEN_SQUARE_BRACKET) || path.currentCharIs(WILDCARD) || path.currentCharIs(PERIOD) || path.currentCharIs(SPACE)) {\n return false;\n }\n int startPosition = path.position();\n int readPosition = startPosition;\n int endPosition = 0;\n\n boolean isFunction = false;\n\n while (path.inBounds(readPosition)) {\n char c = path.charAt(readPosition);\n if (c == SPACE) {\n throw new InvalidPathException(\"Use bracket notion ['my prop'] if your property contains blank characters. position: \" + path.position());\n }\n else if (c == PERIOD || c == OPEN_SQUARE_BRACKET) {\n endPosition = readPosition;\n break;\n }\n else if (c == OPEN_PARENTHESIS) {\n isFunction = true;\n endPosition = readPosition;\n break;\n }\n readPosition++;\n }\n if (endPosition == 0) {\n endPosition = path.length();\n }\n\n\n List functionParameters = null;\n if (isFunction) {\n int parenthesis_count = 1;\n for(int i = readPosition + 1; i < path.length(); i++){\n if (path.charAt(i) == CLOSE_PARENTHESIS)\n parenthesis_count--;\n else if (path.charAt(i) == OPEN_PARENTHESIS)\n parenthesis_count++;\n if (parenthesis_count == 0)\n break;\n }\n\n if (parenthesis_count != 0){\n String functionName = path.subSequence(startPosition, endPosition).toString();\n throw new InvalidPathException(\"Arguments to function: '\" + functionName + \"' are not closed properly.\");\n }\n\n if (path.inBounds(readPosition+1)) {\n // read the next token to determine if we have a simple no-args function call\n char c = path.charAt(readPosition + 1);\n if (c != CLOSE_PARENTHESIS) {\n path.setPosition(endPosition+1);\n // parse the arguments of the function - arguments that are inner queries or JSON document(s)\n String functionName = path.subSequence(startPosition, endPosition).toString();\n functionParameters = parseFunctionParameters(functionName);\n } else {\n path.setPosition(readPosition + 1);\n }\n }\n else {\n path.setPosition(readPosition);\n }\n }\n else {\n path.setPosition(endPosition);\n }\n\n String property = path.subSequence(startPosition, endPosition).toString();\n if(isFunction){\n appender.appendPathToken(PathTokenFactory.createFunctionPathToken(property, functionParameters));\n } else {\n appender.appendPathToken(PathTokenFactory.createSinglePropertyPathToken(property, SINGLE_QUOTE));\n }\n\n return path.currentIsTail() || readNextToken(appender);\n }\n\n /**\n * Parse the parameters of a function call, either the caller has supplied JSON data, or the caller has supplied\n * another path expression which must be evaluated and in turn invoked against the root document. In this tokenizer\n * we're only concerned with parsing the path thus the output of this function is a list of parameters with the Path\n * set if the parameter is an expression. If the parameter is a JSON document then the value of the cachedValue is\n * set on the object.\n *\n * Sequence for parsing out the parameters:\n *\n * This code has its own tokenizer - it does some rudimentary level of lexing in that it can distinguish between JSON block parameters\n * and sub-JSON blocks - it effectively regex's out the parameters into string blocks that can then be passed along to the appropriate parser.\n * Since sub-jsonpath expressions can themselves contain other function calls this routine needs to be sensitive to token counting to\n * determine the boundaries. Since the Path parser isn't aware of JSON processing this uber routine is needed.\n *\n * Parameters are separated by COMMAs ','\n *\n * \n * doc = {\"numbers\": [1,2,3,4,5,6,7,8,9,10]}\n *\n * $.sum({10}, $.numbers.avg())\n * \n *\n * The above is a valid function call, we're first summing 10 + avg of 1...10 (5.5) so the total should be 15.5\n *\n * @return\n * An ordered list of parameters that are to processed via the function. Typically functions either process\n * an array of values and/or can consume parameters in addition to the values provided from the consumption of\n * an array.\n */\n private List parseFunctionParameters(String funcName) {\n ParamType type = null;\n\n // Parenthesis starts at 1 since we're marking the start of a function call, the close paren will denote the\n // last parameter boundary\n int groupParen = 1, groupBracket = 0, groupBrace = 0, groupQuote = 0;\n boolean endOfStream = false;\n char priorChar = 0;\n List parameters = new ArrayList();\n StringBuilder parameter = new StringBuilder();\n while (path.inBounds() && !endOfStream) {\n char c = path.currentChar();\n path.incrementPosition(1);\n\n // we're at the start of the stream, and don't know what type of parameter we have\n if (type == null) {\n if (isWhitespace(c)) {\n continue;\n }\n\n if (c == OPEN_BRACE || isDigit(c) || DOUBLE_QUOTE == c || MINUS == c) {\n type = ParamType.JSON;\n }\n else if (isPathContext(c)) {\n type = ParamType.PATH; // read until we reach a terminating comma and we've reset grouping to zero\n }\n }\n\n switch (c) {\n case DOUBLE_QUOTE:\n if (priorChar != '\\\\' && groupQuote > 0) {\n groupQuote--;\n }\n else {\n groupQuote++;\n }\n break;\n case OPEN_PARENTHESIS:\n groupParen++;\n break;\n case OPEN_BRACE:\n groupBrace++;\n break;\n case OPEN_SQUARE_BRACKET:\n groupBracket++;\n break;\n\n case CLOSE_BRACE:\n if (0 == groupBrace) {\n throw new InvalidPathException(\"Unexpected close brace '}' at character position: \" + path.position());\n }\n groupBrace--;\n break;\n case CLOSE_SQUARE_BRACKET:\n if (0 == groupBracket) {\n throw new InvalidPathException(\"Unexpected close bracket ']' at character position: \" + path.position());\n }\n groupBracket--;\n break;\n\n // In either the close paren case where we have zero paren groups left, capture the parameter, or where\n // we've encountered a COMMA do the same\n case CLOSE_PARENTHESIS:\n groupParen--;\n //CS304 Issue link: https://github.com/json-path/JsonPath/issues/620\n if (0 > groupParen || priorChar == '(') {\n parameter.append(c);\n }\n case COMMA:\n // In this state we've reach the end of a function parameter and we can pass along the parameter string\n // to the parser\n if ((0 == groupQuote && 0 == groupBrace && 0 == groupBracket\n && ((0 == groupParen && CLOSE_PARENTHESIS == c) || 1 == groupParen))) {\n endOfStream = (0 == groupParen);\n\n if (null != type) {\n Parameter param = null;\n switch (type) {\n case JSON:\n // parse the json and set the value\n param = new Parameter(parameter.toString());\n break;\n case PATH:\n LinkedList predicates = new LinkedList<>();\n PathCompiler compiler = new PathCompiler(parameter.toString(), predicates);\n param = new Parameter(compiler.compile());\n break;\n }\n if (null != param) {\n parameters.add(param);\n }\n parameter.delete(0, parameter.length());\n type = null;\n }\n }\n break;\n }\n\n if (type != null && !(c == COMMA && 0 == groupBrace && 0 == groupBracket && 1 == groupParen)) {\n parameter.append(c);\n }\n priorChar = c;\n }\n if (0 != groupBrace || 0 != groupParen || 0 != groupBracket) {\n throw new InvalidPathException(\"Arguments to function: '\" + funcName + \"' are not closed properly.\");\n }\n return parameters;\n }\n\n private boolean isWhitespace(char c) {\n return (c == SPACE || c == TAB || c == LF || c == CR);\n }\n\n //\n // [?], [?,?, ..]\n //\n private boolean readPlaceholderToken(PathTokenAppender appender) {\n\n if (!path.currentCharIs(OPEN_SQUARE_BRACKET)) {\n return false;\n }\n int questionmarkIndex = path.indexOfNextSignificantChar(BEGIN_FILTER);\n if (questionmarkIndex == -1) {\n return false;\n }\n char nextSignificantChar = path.nextSignificantChar(questionmarkIndex);\n if (nextSignificantChar != CLOSE_SQUARE_BRACKET && nextSignificantChar != COMMA) {\n return false;\n }\n\n int expressionBeginIndex = path.position() + 1;\n int expressionEndIndex = path.nextIndexOf(expressionBeginIndex, CLOSE_SQUARE_BRACKET);\n\n if (expressionEndIndex == -1) {\n return false;\n }\n\n String expression = path.subSequence(expressionBeginIndex, expressionEndIndex).toString();\n\n String[] tokens = expression.split(\",\");\n\n if (filterStack.size() < tokens.length) {\n throw new InvalidPathException(\"Not enough predicates supplied for filter [\" + expression + \"] at position \" + path.position());\n }\n\n Collection predicates = new ArrayList();\n for (String token : tokens) {\n token = token != null ? token.trim() : null;\n if (!\"?\".equals(token == null ? \"\" : token)) {\n throw new InvalidPathException(\"Expected '?' but found \" + token);\n }\n predicates.add(filterStack.pop());\n }\n\n appender.appendPathToken(PathTokenFactory.createPredicatePathToken(predicates));\n\n path.setPosition(expressionEndIndex + 1);\n\n return path.currentIsTail() || readNextToken(appender);\n }\n\n //\n // [?(...)]\n //\n private boolean readFilterToken(PathTokenAppender appender) {\n if (!path.currentCharIs(OPEN_SQUARE_BRACKET) && !path.nextSignificantCharIs(BEGIN_FILTER)) {\n return false;\n }\n\n int openStatementBracketIndex = path.position();\n int questionMarkIndex = path.indexOfNextSignificantChar(BEGIN_FILTER);\n if (questionMarkIndex == -1) {\n return false;\n }\n int openBracketIndex = path.indexOfNextSignificantChar(questionMarkIndex, OPEN_PARENTHESIS);\n if (openBracketIndex == -1) {\n return false;\n }\n int closeBracketIndex = path.indexOfClosingBracket(openBracketIndex, true, true);\n if (closeBracketIndex == -1) {\n return false;\n }\n if (!path.nextSignificantCharIs(closeBracketIndex, CLOSE_SQUARE_BRACKET)) {\n return false;\n }\n int closeStatementBracketIndex = path.indexOfNextSignificantChar(closeBracketIndex, CLOSE_SQUARE_BRACKET);\n\n String criteria = path.subSequence(openStatementBracketIndex, closeStatementBracketIndex + 1).toString();\n\n\n Predicate predicate = FilterCompiler.compile(criteria);\n appender.appendPathToken(PathTokenFactory.createPredicatePathToken(predicate));\n\n path.setPosition(closeStatementBracketIndex + 1);\n\n return path.currentIsTail() || readNextToken(appender);\n\n }\n\n //\n // [*]\n // *\n //\n private boolean readWildCardToken(PathTokenAppender appender) {\n\n boolean inBracket = path.currentCharIs(OPEN_SQUARE_BRACKET);\n\n if (inBracket && !path.nextSignificantCharIs(WILDCARD)) {\n return false;\n }\n if (!path.currentCharIs(WILDCARD) && path.isOutOfBounds(path.position() + 1)) {\n return false;\n }\n if (inBracket) {\n int wildCardIndex = path.indexOfNextSignificantChar(WILDCARD);\n if (!path.nextSignificantCharIs(wildCardIndex, CLOSE_SQUARE_BRACKET)) {\n int offset = wildCardIndex + 1;\n throw new InvalidPathException(\"Expected wildcard token to end with ']' on position \" + offset);\n }\n int bracketCloseIndex = path.indexOfNextSignificantChar(wildCardIndex, CLOSE_SQUARE_BRACKET);\n path.setPosition(bracketCloseIndex + 1);\n } else {\n path.incrementPosition(1);\n }\n\n appender.appendPathToken(PathTokenFactory.createWildCardPathToken());\n\n return path.currentIsTail() || readNextToken(appender);\n }\n\n //\n // [1], [1,2, n], [1:], [1:2], [:2]\n //\n private boolean readArrayToken(PathTokenAppender appender) {\n\n if (!path.currentCharIs(OPEN_SQUARE_BRACKET)) {\n return false;\n }\n char nextSignificantChar = path.nextSignificantChar();\n if (!isDigit(nextSignificantChar) && nextSignificantChar != MINUS && nextSignificantChar != SPLIT) {\n return false;\n }\n\n int expressionBeginIndex = path.position() + 1;\n int expressionEndIndex = path.nextIndexOf(expressionBeginIndex, CLOSE_SQUARE_BRACKET);\n\n if (expressionEndIndex == -1) {\n return false;\n }\n\n String expression = path.subSequence(expressionBeginIndex, expressionEndIndex).toString().trim();\n\n if (\"*\".equals(expression)) {\n return false;\n }\n\n //check valid chars\n for (int i = 0; i < expression.length(); i++) {\n char c = expression.charAt(i);\n if (!isDigit(c) && c != COMMA && c != MINUS && c != SPLIT && c != SPACE) {\n return false;\n }\n }\n\n boolean isSliceOperation = expression.contains(\":\");\n\n if (isSliceOperation) {\n ArraySliceOperation arraySliceOperation = ArraySliceOperation.parse(expression);\n appender.appendPathToken(PathTokenFactory.createSliceArrayPathToken(arraySliceOperation));\n } else {\n ArrayIndexOperation arrayIndexOperation = ArrayIndexOperation.parse(expression);\n appender.appendPathToken(PathTokenFactory.createIndexArrayPathToken(arrayIndexOperation));\n }\n\n path.setPosition(expressionEndIndex + 1);\n\n return path.currentIsTail() || readNextToken(appender);\n }\n\n //\n // ['foo']\n //\n private boolean readBracketPropertyToken(PathTokenAppender appender) {\n if (!path.currentCharIs(OPEN_SQUARE_BRACKET)) {\n return false;\n }\n char potentialStringDelimiter = path.nextSignificantChar();\n if (potentialStringDelimiter != SINGLE_QUOTE && potentialStringDelimiter != DOUBLE_QUOTE) {\n return false;\n }\n\n List properties = new ArrayList();\n\n int startPosition = path.position() + 1;\n int readPosition = startPosition;\n int endPosition = 0;\n boolean inProperty = false;\n boolean inEscape = false;\n boolean lastSignificantWasComma = false;\n\n while (path.inBounds(readPosition)) {\n char c = path.charAt(readPosition);\n\n if(inEscape){\n inEscape = false;\n } else if('\\\\' == c){\n inEscape = true;\n } else if (c == CLOSE_SQUARE_BRACKET && !inProperty) {\n if (lastSignificantWasComma){\n fail(\"Found empty property at index \"+readPosition);\n }\n break;\n } else if (c == potentialStringDelimiter) {\n if (inProperty) {\n char nextSignificantChar = path.nextSignificantChar(readPosition);\n if (nextSignificantChar != CLOSE_SQUARE_BRACKET && nextSignificantChar != COMMA) {\n fail(\"Property must be separated by comma or Property must be terminated close square bracket at index \"+readPosition);\n }\n endPosition = readPosition;\n String prop = path.subSequence(startPosition, endPosition).toString();\n properties.add(Utils.unescape(prop));\n inProperty = false;\n } else {\n startPosition = readPosition + 1;\n inProperty = true;\n lastSignificantWasComma = false;\n }\n } else if (c == COMMA && !inProperty) {\n if (lastSignificantWasComma){\n fail(\"Found empty property at index \"+readPosition);\n }\n lastSignificantWasComma = true;\n }\n readPosition++;\n }\n\n if (inProperty){\n fail(\"Property has not been closed - missing closing \" + potentialStringDelimiter);\n }\n\n int endBracketIndex = path.indexOfNextSignificantChar(endPosition, CLOSE_SQUARE_BRACKET);\n if(endBracketIndex == -1) {\n fail(\"Property has not been closed - missing closing ]\");\n }\n endBracketIndex++;\n\n path.setPosition(endBracketIndex);\n\n appender.appendPathToken(PathTokenFactory.createPropertyPathToken(properties, potentialStringDelimiter));\n\n return path.currentIsTail() || readNextToken(appender);\n }\n\n public static boolean fail(String message) {\n throw new InvalidPathException(message);\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/PathToken.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.Option;\nimport com.jayway.jsonpath.PathNotFoundException;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.internal.Utils;\nimport com.jayway.jsonpath.internal.function.PathFunction;\nimport com.jayway.jsonpath.spi.json.JsonProvider;\n\nimport java.util.List;\n\npublic abstract class PathToken {\n\n private PathToken prev;\n private PathToken next;\n private Boolean definite = null;\n private Boolean upstreamDefinite = null;\n private int upstreamArrayIndex = -1;\n\n\n public void setUpstreamArrayIndex(int idx){\n upstreamArrayIndex = idx;\n }\n\n PathToken appendTailToken(PathToken next) {\n this.next = next;\n this.next.prev = this;\n return next;\n }\n\n void handleObjectProperty(String currentPath, Object model, EvaluationContextImpl ctx, List properties) {\n\n if(properties.size() == 1) {\n String property = properties.get(0);\n String evalPath = Utils.concat(currentPath, \"['\", property, \"']\");\n Object propertyVal = readObjectProperty(property, model, ctx);\n if(propertyVal == JsonProvider.UNDEFINED){\n // Conditions below heavily depend on current token type (and its logic) and are not \"universal\",\n // so this code is quite dangerous (I'd rather rewrite it & move to PropertyPathToken and implemented\n // WildcardPathToken as a dynamic multi prop case of PropertyPathToken).\n // Better safe than sorry.\n assert this instanceof PropertyPathToken : \"only PropertyPathToken is supported\";\n\n if(isLeaf()) {\n if(ctx.options().contains(Option.DEFAULT_PATH_LEAF_TO_NULL)){\n propertyVal = null;\n } else {\n if(ctx.options().contains(Option.SUPPRESS_EXCEPTIONS) ||\n !ctx.options().contains(Option.REQUIRE_PROPERTIES)){\n return;\n } else {\n throw new PathNotFoundException(\"No results for path: \" + evalPath);\n }\n }\n } else {\n if (! (isUpstreamDefinite() && isTokenDefinite()) &&\n !ctx.options().contains(Option.REQUIRE_PROPERTIES) ||\n ctx.options().contains(Option.SUPPRESS_EXCEPTIONS)){\n // If there is some indefiniteness in the path and properties are not required - we'll ignore\n // absent property. And also in case of exception suppression - so that other path evaluation\n // branches could be examined.\n return;\n } else {\n throw new PathNotFoundException(\"Missing property in path \" + evalPath);\n }\n }\n }\n PathRef pathRef = ctx.forUpdate() ? PathRef.create(model, property) : PathRef.NO_OP;\n if (isLeaf()) {\n String idx = \"[\" + String.valueOf(upstreamArrayIndex) + \"]\";\n if(idx.equals(\"[-1]\") || ctx.getRoot().getTail().prev().getPathFragment().equals(idx)){\n ctx.addResult(evalPath, pathRef, propertyVal);\n }\n }\n else {\n next().evaluate(evalPath, pathRef, propertyVal, ctx);\n }\n } else {\n String evalPath = currentPath + \"[\" + Utils.join(\", \", \"'\", properties) + \"]\";\n\n assert isLeaf() : \"non-leaf multi props handled elsewhere\";\n\n Object merged = ctx.jsonProvider().createMap();\n for (String property : properties) {\n Object propertyVal;\n if(hasProperty(property, model, ctx)) {\n propertyVal = readObjectProperty(property, model, ctx);\n if(propertyVal == JsonProvider.UNDEFINED){\n if(ctx.options().contains(Option.DEFAULT_PATH_LEAF_TO_NULL)) {\n propertyVal = null;\n } else {\n continue;\n }\n }\n } else {\n if(ctx.options().contains(Option.DEFAULT_PATH_LEAF_TO_NULL)){\n propertyVal = null;\n } else if (ctx.options().contains(Option.REQUIRE_PROPERTIES)) {\n throw new PathNotFoundException(\"Missing property in path \" + evalPath);\n } else {\n continue;\n }\n }\n ctx.jsonProvider().setProperty(merged, property, propertyVal);\n }\n PathRef pathRef = ctx.forUpdate() ? PathRef.create(model, properties) : PathRef.NO_OP;\n ctx.addResult(evalPath, pathRef, merged);\n }\n }\n\n private static boolean hasProperty(String property, Object model, EvaluationContextImpl ctx) {\n return ctx.jsonProvider().getPropertyKeys(model).contains(property);\n }\n\n private static Object readObjectProperty(String property, Object model, EvaluationContextImpl ctx) {\n return ctx.jsonProvider().getMapValue(model, property);\n }\n\n\n protected void handleArrayIndex(int index, String currentPath, Object model, EvaluationContextImpl ctx) {\n String evalPath = Utils.concat(currentPath, \"[\", String.valueOf(index), \"]\");\n PathRef pathRef = ctx.forUpdate() ? PathRef.create(model, index) : PathRef.NO_OP;\n int effectiveIndex = index < 0 ? ctx.jsonProvider().length(model) + index : index;\n try {\n Object evalHit = ctx.jsonProvider().getArrayIndex(model, effectiveIndex);\n if (isLeaf()) {\n ctx.addResult(evalPath, pathRef, evalHit);\n } else {\n next().evaluate(evalPath, pathRef, evalHit, ctx);\n }\n } catch (IndexOutOfBoundsException e) {\n }\n }\n\n PathToken prev(){\n return prev;\n }\n\n PathToken next() {\n if (isLeaf()) {\n throw new IllegalStateException(\"Current path token is a leaf\");\n }\n return next;\n }\n\n boolean isLeaf() {\n return next == null;\n }\n\n boolean isRoot() {\n return prev == null;\n }\n\n boolean isUpstreamDefinite() {\n if (upstreamDefinite == null) {\n upstreamDefinite = isRoot() || prev.isTokenDefinite() && prev.isUpstreamDefinite();\n }\n return upstreamDefinite;\n }\n\n public int getTokenCount() {\n int cnt = 1;\n PathToken token = this;\n\n while (!token.isLeaf()){\n token = token.next();\n cnt++;\n }\n return cnt;\n }\n\n public boolean isPathDefinite() {\n if(definite != null){\n return definite.booleanValue();\n }\n boolean isDefinite = isTokenDefinite();\n if (isDefinite && !isLeaf()) {\n isDefinite = next.isPathDefinite();\n }\n definite = isDefinite;\n return isDefinite;\n }\n\n @Override\n public String toString() {\n if (isLeaf()) {\n return getPathFragment();\n } else {\n return getPathFragment() + next().toString();\n }\n }\n\n @Override\n public int hashCode() {\n return toString().hashCode();\n }\n\n @Override\n public boolean equals(Object obj) {\n return super.equals(obj);\n }\n\n public void invoke(PathFunction pathFunction, String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) {\n ctx.addResult(currentPath, parent, pathFunction.invoke(currentPath, parent, model, ctx, null));\n }\n\n public abstract void evaluate(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx);\n\n public abstract boolean isTokenDefinite();\n\n protected abstract String getPathFragment();\n\n public void setNext(final PathToken next) {\n this.next = next;\n }\n\n public PathToken getNext() {\n return this.next;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/PathTokenAppender.java",
"content": "package com.jayway.jsonpath.internal.path;\n\npublic interface PathTokenAppender {\n PathTokenAppender appendPathToken(PathToken next);\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/PathTokenFactory.java",
"content": "package com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.Predicate;\nimport com.jayway.jsonpath.internal.function.Parameter;\n\nimport java.util.Collection;\nimport java.util.List;\n\nimport static java.util.Collections.singletonList;\n\npublic class PathTokenFactory {\n\n public static RootPathToken createRootPathToken(char token) {\n return new RootPathToken(token);\n }\n\n public static PathToken createSinglePropertyPathToken(String property, char stringDelimiter) {\n return new PropertyPathToken(singletonList(property), stringDelimiter);\n }\n\n public static PathToken createPropertyPathToken(List properties, char stringDelimiter) {\n return new PropertyPathToken(properties, stringDelimiter);\n }\n\n public static PathToken createSliceArrayPathToken(final ArraySliceOperation arraySliceOperation) {\n return new ArraySliceToken(arraySliceOperation);\n }\n\n public static PathToken createIndexArrayPathToken(final ArrayIndexOperation arrayIndexOperation) {\n return new ArrayIndexToken(arrayIndexOperation);\n }\n\n public static PathToken createWildCardPathToken() {\n return new WildcardPathToken();\n }\n\n public static PathToken crateScanToken() {\n return new ScanPathToken();\n }\n\n public static PathToken createPredicatePathToken(Collection predicates) {\n return new PredicatePathToken(predicates);\n }\n\n public static PathToken createPredicatePathToken(Predicate predicate) {\n return new PredicatePathToken(predicate);\n }\n\n public static PathToken createFunctionPathToken(String function, List parameters) {\n return new FunctionPathToken(function, parameters);\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/PredicateContextImpl.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.Configuration;\nimport com.jayway.jsonpath.Predicate;\nimport com.jayway.jsonpath.internal.Path;\nimport com.jayway.jsonpath.spi.mapper.MappingException;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\nimport java.util.HashMap;\n\npublic class PredicateContextImpl implements Predicate.PredicateContext {\n\n private static final Logger logger = LoggerFactory.getLogger(PredicateContextImpl.class);\n\n private final Object contextDocument;\n private final Object rootDocument;\n private final Configuration configuration;\n private final HashMap documentPathCache;\n\n public PredicateContextImpl(Object contextDocument, Object rootDocument, Configuration configuration, HashMap documentPathCache) {\n this.contextDocument = contextDocument;\n this.rootDocument = rootDocument;\n this.configuration = configuration;\n this.documentPathCache = documentPathCache;\n }\n\n public Object evaluate(Path path){\n Object result;\n if(path.isRootPath()){\n if(documentPathCache.containsKey(path)){\n logger.debug(\"Using cached result for root path: \" + path.toString());\n result = documentPathCache.get(path);\n } else {\n result = path.evaluate(rootDocument, rootDocument, configuration).getValue();\n documentPathCache.put(path, result);\n }\n } else {\n result = path.evaluate(contextDocument, rootDocument, configuration).getValue();\n }\n return result;\n }\n\n public HashMap documentPathCache() {\n return documentPathCache;\n }\n\n @Override\n public Object item() {\n return contextDocument;\n }\n\n @Override\n public T item(Class clazz) throws MappingException {\n return configuration().mappingProvider().map(contextDocument, clazz, configuration);\n }\n\n @Override\n public Object root() {\n return rootDocument;\n }\n\n @Override\n public Configuration configuration() {\n return configuration;\n }\n\n}"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/PredicatePathToken.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.Configuration;\nimport com.jayway.jsonpath.InvalidPathException;\nimport com.jayway.jsonpath.Predicate;\nimport com.jayway.jsonpath.internal.PathRef;\n\nimport java.util.Collection;\nimport java.util.Collections;\n\nimport static java.lang.String.format;\nimport static java.util.Arrays.asList;\n\n/**\n *\n */\npublic class PredicatePathToken extends PathToken {\n\n\n private final Collection predicates;\n\n PredicatePathToken(Predicate filter) {\n this.predicates = Collections.singletonList(filter);\n }\n\n PredicatePathToken(Collection predicates) {\n this.predicates = predicates;\n }\n\n @Override\n public void evaluate(String currentPath, PathRef ref, Object model, EvaluationContextImpl ctx) {\n if (ctx.jsonProvider().isMap(model)) {\n if (accept(model, ctx.rootDocument(), ctx.configuration(), ctx)) {\n PathRef op = ctx.forUpdate() ? ref : PathRef.NO_OP;\n if (isLeaf()) {\n ctx.addResult(currentPath, op, model);\n } else {\n next().evaluate(currentPath, op, model, ctx);\n }\n }\n } else if (ctx.jsonProvider().isArray(model)){\n int idx = 0;\n Iterable objects = ctx.jsonProvider().toIterable(model);\n\n for (Object idxModel : objects) {\n if (accept(idxModel, ctx.rootDocument(), ctx.configuration(), ctx)) {\n handleArrayIndex(idx, currentPath, model, ctx);\n }\n idx++;\n }\n } else {\n if (isUpstreamDefinite()) {\n throw new InvalidPathException(format(\"Filter: %s can not be applied to primitives. Current context is: %s\", toString(), model));\n }\n }\n }\n\n public boolean accept(final Object obj, final Object root, final Configuration configuration, EvaluationContextImpl evaluationContext) {\n Predicate.PredicateContext ctx = new PredicateContextImpl(obj, root, configuration, evaluationContext.documentEvalCache());\n\n for (Predicate predicate : predicates) {\n try {\n if (!predicate.apply(ctx)) {\n return false;\n }\n } catch (InvalidPathException e) {\n return false;\n }\n }\n return true;\n }\n\n @Override\n public String getPathFragment() {\n StringBuilder sb = new StringBuilder();\n sb.append(\"[\");\n for(int i = 0; i < predicates.size(); i++){\n if(i != 0){\n sb.append(\",\");\n }\n sb.append(\"?\");\n }\n sb.append(\"]\");\n return sb.toString();\n }\n\n @Override\n public boolean isTokenDefinite() {\n return false;\n }\n\n\n\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/PropertyPathToken.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.InvalidPathException;\nimport com.jayway.jsonpath.Option;\nimport com.jayway.jsonpath.PathNotFoundException;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.internal.Utils;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\nimport static com.jayway.jsonpath.internal.Utils.onlyOneIsTrueNonThrow;\n\n/**\n *\n */\npublic class PropertyPathToken extends PathToken {\n\n private final List properties;\n private final String stringDelimiter;\n\n public PropertyPathToken(List properties, char stringDelimiter) {\n if (properties.isEmpty()) {\n throw new InvalidPathException(\"Empty properties\");\n }\n this.properties = properties;\n this.stringDelimiter = Character.toString(stringDelimiter);\n }\n\n public List getProperties() {\n return properties;\n }\n\n public boolean singlePropertyCase() {\n return properties.size() == 1;\n }\n\n public boolean multiPropertyMergeCase() {\n return isLeaf() && properties.size() > 1;\n }\n\n public boolean multiPropertyIterationCase() {\n // Semantics of this case is the same as semantics of ArrayPathToken with INDEX_SEQUENCE operation.\n return !isLeaf() && properties.size() > 1;\n }\n\n @Override\n public void evaluate(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) {\n // Can't assert it in ctor because isLeaf() could be changed later on.\n assert onlyOneIsTrueNonThrow(singlePropertyCase(), multiPropertyMergeCase(), multiPropertyIterationCase());\n\n if (!ctx.jsonProvider().isMap(model)) {\n if (!isUpstreamDefinite()\n || ctx.options().contains(Option.SUPPRESS_EXCEPTIONS)) {\n return;\n } else {\n String m = model == null ? \"null\" : model.getClass().getName();\n throw new PathNotFoundException(String.format(\n \"Expected to find an object with property %s in path %s but found '%s'. \" +\n \"This is not a json object according to the JsonProvider: '%s'.\",\n getPathFragment(), currentPath, m, ctx.configuration().jsonProvider().getClass().getName()));\n }\n }\n\n if (singlePropertyCase() || multiPropertyMergeCase()) {\n handleObjectProperty(currentPath, model, ctx, properties);\n return;\n }\n\n assert multiPropertyIterationCase();\n final List currentlyHandledProperty = new ArrayList(1);\n currentlyHandledProperty.add(null);\n for (final String property : properties) {\n currentlyHandledProperty.set(0, property);\n handleObjectProperty(currentPath, model, ctx, currentlyHandledProperty);\n }\n }\n\n @Override\n public boolean isTokenDefinite() {\n // in case of leaf multiprops will be merged, so it's kinda definite\n return singlePropertyCase() || multiPropertyMergeCase();\n }\n\n @Override\n public String getPathFragment() {\n return new StringBuilder()\n .append(\"[\")\n .append(Utils.join(\",\", stringDelimiter, properties))\n .append(\"]\").toString();\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/RootPathToken.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.internal.PathRef;\n\n/**\n *\n */\npublic class RootPathToken extends PathToken {\n\n private PathToken tail;\n private int tokenCount;\n private final String rootToken;\n\n\n RootPathToken(char rootToken) {\n this.rootToken = Character.toString(rootToken);\n this.tail = this;\n this.tokenCount = 1;\n }\n\n public PathToken getTail(){\n return this.tail;\n }\n\n @Override\n public int getTokenCount() {\n return tokenCount;\n }\n\n public RootPathToken append(PathToken next) {\n this.tail = tail.appendTailToken(next);\n this.tokenCount++;\n return this;\n }\n\n public PathTokenAppender getPathTokenAppender(){\n return new PathTokenAppender(){\n @Override\n public PathTokenAppender appendPathToken(PathToken next) {\n append(next);\n return this;\n }\n };\n }\n\n @Override\n public void evaluate(String currentPath, PathRef pathRef, Object model, EvaluationContextImpl ctx) {\n if (isLeaf()) {\n PathRef op = ctx.forUpdate() ? pathRef : PathRef.NO_OP;\n ctx.addResult(rootToken, op, model);\n } else {\n next().evaluate(rootToken, pathRef, model, ctx);\n }\n }\n\n @Override\n public String getPathFragment() {\n return rootToken;\n }\n\n @Override\n public boolean isTokenDefinite() {\n return true;\n }\n\n public boolean isFunctionPath() {\n return (tail instanceof FunctionPathToken);\n }\n\n public void setTail(PathToken token) {\n this.tail = token;\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/ScanPathToken.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport com.jayway.jsonpath.Option;\nimport com.jayway.jsonpath.internal.PathRef;\nimport com.jayway.jsonpath.spi.json.JsonProvider;\n\nimport java.util.Collection;\n\n/**\n *\n */\npublic class ScanPathToken extends PathToken {\n\n ScanPathToken() {\n }\n\n @Override\n public void evaluate(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) {\n\n PathToken pt = next();\n\n walk(pt, currentPath, parent, model, ctx, createScanPredicate(pt, ctx));\n }\n\n public static void walk(PathToken pt, String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx, Predicate predicate) {\n if (ctx.jsonProvider().isMap(model)) {\n walkObject(pt, currentPath, parent, model, ctx, predicate);\n } else if (ctx.jsonProvider().isArray(model)) {\n walkArray(pt, currentPath, parent, model, ctx, predicate);\n }\n }\n\n public static void walkArray(PathToken pt, String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx, Predicate predicate) {\n\n if (predicate.matches(model)) {\n if (pt.isLeaf()) {\n pt.evaluate(currentPath, parent, model, ctx);\n } else {\n PathToken next = pt.next();\n Iterable models = ctx.jsonProvider().toIterable(model);\n int idx = 0;\n for (Object evalModel : models) {\n String evalPath = currentPath + \"[\" + idx + \"]\";\n next.setUpstreamArrayIndex(idx);\n next.evaluate(evalPath, parent, evalModel, ctx);\n idx++;\n }\n }\n }\n\n Iterable models = ctx.jsonProvider().toIterable(model);\n int idx = 0;\n for (Object evalModel : models) {\n String evalPath = currentPath + \"[\" + idx + \"]\";\n walk(pt, evalPath, PathRef.create(model, idx), evalModel, ctx, predicate);\n idx++;\n }\n }\n\n public static void walkObject(PathToken pt, String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx, Predicate predicate) {\n\n if (predicate.matches(model)) {\n pt.evaluate(currentPath, parent, model, ctx);\n }\n Collection properties = ctx.jsonProvider().getPropertyKeys(model);\n\n for (String property : properties) {\n String evalPath = currentPath + \"['\" + property + \"']\";\n Object propertyModel = ctx.jsonProvider().getMapValue(model, property);\n if (propertyModel != JsonProvider.UNDEFINED) {\n walk(pt, evalPath, PathRef.create(model, property), propertyModel, ctx, predicate);\n }\n }\n }\n\n private static Predicate createScanPredicate(final PathToken target, final EvaluationContextImpl ctx) {\n if (target instanceof PropertyPathToken) {\n return new PropertyPathTokenPredicate(target, ctx);\n } else if (target instanceof ArrayPathToken) {\n return new ArrayPathTokenPredicate(ctx);\n } else if (target instanceof WildcardPathToken) {\n return new WildcardPathTokenPredicate();\n } else if (target instanceof PredicatePathToken) {\n return new FilterPathTokenPredicate(target, ctx);\n } else {\n return FALSE_PREDICATE;\n }\n }\n\n\n @Override\n public boolean isTokenDefinite() {\n return false;\n }\n\n @Override\n public String getPathFragment() {\n return \"..\";\n }\n\n private interface Predicate {\n boolean matches(Object model);\n }\n\n private static final Predicate FALSE_PREDICATE = new Predicate() {\n\n @Override\n public boolean matches(Object model) {\n return false;\n }\n };\n\n private static final class FilterPathTokenPredicate implements Predicate {\n private final EvaluationContextImpl ctx;\n private PredicatePathToken predicatePathToken;\n\n private FilterPathTokenPredicate(PathToken target, EvaluationContextImpl ctx) {\n this.ctx = ctx;\n predicatePathToken = (PredicatePathToken) target;\n }\n\n @Override\n public boolean matches(Object model) {\n return predicatePathToken.accept(model, ctx.rootDocument(), ctx.configuration(), ctx);\n }\n }\n\n private static final class WildcardPathTokenPredicate implements Predicate {\n\n @Override\n public boolean matches(Object model) {\n return true;\n }\n }\n\n private static final class ArrayPathTokenPredicate implements Predicate {\n private final EvaluationContextImpl ctx;\n\n private ArrayPathTokenPredicate(EvaluationContextImpl ctx) {\n this.ctx = ctx;\n }\n\n @Override\n public boolean matches(Object model) {\n return ctx.jsonProvider().isArray(model);\n }\n }\n\n private static final class PropertyPathTokenPredicate implements Predicate {\n private final EvaluationContextImpl ctx;\n private PropertyPathToken propertyPathToken;\n\n private PropertyPathTokenPredicate(PathToken target, EvaluationContextImpl ctx) {\n this.ctx = ctx;\n propertyPathToken = (PropertyPathToken) target;\n }\n\n @Override\n public boolean matches(Object model) {\n\n if (! ctx.jsonProvider().isMap(model)) {\n return false;\n }\n\n//\n// The commented code below makes it really hard understand, use and predict the result\n// of deep scanning operations. It might be correct but was decided to be\n// left out until the behavior of REQUIRE_PROPERTIES is more strictly defined\n// in a deep scanning scenario. For details read conversation in commit\n// https://github.com/jayway/JsonPath/commit/1a72fc078deb16995e323442bfb681bd715ce45a#commitcomment-14616092\n//\n// if (ctx.options().contains(Option.REQUIRE_PROPERTIES)) {\n// // Have to require properties defined in path when an indefinite path is evaluated,\n// // so have to go there and search for it.\n// return true;\n// }\n\n if (! propertyPathToken.isTokenDefinite()) {\n // It's responsibility of PropertyPathToken code to handle indefinite scenario of properties,\n // so we'll allow it to do its job.\n return true;\n }\n\n if (propertyPathToken.isLeaf() && ctx.options().contains(Option.DEFAULT_PATH_LEAF_TO_NULL)) {\n // In case of DEFAULT_PATH_LEAF_TO_NULL missing properties is not a problem.\n return true;\n }\n\n Collection keys = ctx.jsonProvider().getPropertyKeys(model);\n return keys.containsAll(propertyPathToken.getProperties());\n }\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/internal/path/WildcardPathToken.java",
"content": "/*\n * Copyright 2011 the original author or authors.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\npackage com.jayway.jsonpath.internal.path;\n\nimport java.util.Collections;\n\nimport com.jayway.jsonpath.Option;\nimport com.jayway.jsonpath.PathNotFoundException;\nimport com.jayway.jsonpath.internal.PathRef;\n\nimport static java.util.Arrays.asList;\n\n/**\n *\n */\npublic class WildcardPathToken extends PathToken {\n\n public WildcardPathToken() {\n }\n\n @Override\n public void evaluate(String currentPath, PathRef parent, Object model, EvaluationContextImpl ctx) {\n if (ctx.jsonProvider().isMap(model)) {\n for (String property : ctx.jsonProvider().getPropertyKeys(model)) {\n handleObjectProperty(currentPath, model, ctx, Collections.singletonList(property));\n }\n } else if (ctx.jsonProvider().isArray(model)) {\n for (int idx = 0; idx < ctx.jsonProvider().length(model); idx++) {\n try {\n handleArrayIndex(idx, currentPath, model, ctx);\n } catch (PathNotFoundException p){\n if(ctx.options().contains(Option.REQUIRE_PROPERTIES)){\n throw p;\n }\n }\n }\n }\n }\n\n\n @Override\n public boolean isTokenDefinite() {\n return false;\n }\n\n @Override\n public String getPathFragment() {\n return \"[*]\";\n }\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/spi/cache/Cache.java",
"content": "package com.jayway.jsonpath.spi.cache;\n\nimport com.jayway.jsonpath.InvalidJsonException;\nimport com.jayway.jsonpath.JsonPath;\n\npublic interface Cache {\n\n\t/**\n * Get the Cached JsonPath\n * @param key cache key to lookup the JsonPath\n * @return JsonPath\n */\n\t JsonPath get(String key);\n\t\n\t/**\n * Add JsonPath to the cache\n * @param key cache key to store the JsonPath\n * @param value JsonPath to be cached\n * @throws InvalidJsonException\n */\n\t void put(String key, JsonPath value);\n}\n"
},
{
"path": "json-path/src/main/java/com/jayway/jsonpath/spi/cache/CacheProvider.java",
"content": "package com.jayway.jsonpath.spi.cache;\n\nimport com.jayway.jsonpath.JsonPathException;\n\nimport java.util.concurrent.atomic.AtomicReferenceFieldUpdater;\n\nimport static com.jayway.jsonpath.internal.Utils.notNull;\n\npublic class CacheProvider {\n\n private static final AtomicReferenceFieldUpdater