From e19111976578cc97a1715a00bee053867d0bbdf4 Mon Sep 17 00:00:00 2001 From: hunterpayne Date: Thu, 10 Sep 2015 22:52:12 -0700 Subject: [PATCH] Splitting the predicate interface to allow it to be used in lambda calculus --- .../java/com/jayway/jsonpath/Criteria.java | 339 ++++++++++++++++-- .../main/java/com/jayway/jsonpath/Filter.java | 10 +- .../java/com/jayway/jsonpath/Predicate.java | 3 - .../jayway/jsonpath/StreamingPredicate.java | 25 ++ .../java/com/jayway/jsonpath/FilterTest.java | 2 +- .../com/jayway/jsonpath/PredicateTest.java | 2 +- .../com/jayway/jsonpath/old/FilterTest.java | 4 +- 7 files changed, 351 insertions(+), 34 deletions(-) create mode 100644 json-path/src/main/java/com/jayway/jsonpath/StreamingPredicate.java diff --git a/json-path/src/main/java/com/jayway/jsonpath/Criteria.java b/json-path/src/main/java/com/jayway/jsonpath/Criteria.java index c8a1a4ef..6b6081d9 100644 --- a/json-path/src/main/java/com/jayway/jsonpath/Criteria.java +++ b/json-path/src/main/java/com/jayway/jsonpath/Criteria.java @@ -35,7 +35,7 @@ import static com.jayway.jsonpath.internal.Utils.notNull; * */ @SuppressWarnings("unchecked") -public class Criteria implements Predicate { +public class Criteria implements StreamingPredicate { private static final Logger logger = LoggerFactory.getLogger(Criteria.class); @@ -65,30 +65,45 @@ public class Criteria implements Predicate { } @Override - public boolean check(TokenStackElement left, TokenStackElement right) { + public boolean check(TokenStackElement left, + TokenStackElement right) { + if (left.getType() == right.getType()) { switch (left.getType()) { case ARRAY_TOKEN: { ArrayToken leftT = (ArrayToken)left; ArrayToken rightT = (ArrayToken)right; - break; + return check(leftT.getValue(), right.getValue()); + //break; } case OBJECT_TOKEN: { - break; + ObjectToken leftT = (ObjectToken)left; + ObjectToken rightT = (ObjectToken)right; + return check(leftT.getValue(), right.getValue()); + //break; } case STRING_TOKEN: { - break; + StringToken leftT = (StringToken)left; + StringToken rightT = (StringToken)right; + if (leftT.value != null && rightT.value != null) { + return leftT.value.equals(rightT.value); + } + return leftT == rightT; } case FLOAT_TOKEN: { - break; + FloatToken leftT = (FloatToken)left; + FloatToken rightT = (FloatToken)right; + return leftT.value == rightT.value; } case INTEGER_TOKEN: { - break; + IntToken leftT = (IntToken)left; + IntToken rightT = (IntToken)right; + return leftT.value == rightT.value; } } } @@ -110,7 +125,7 @@ public class Criteria implements Predicate { @Override public boolean check(TokenStackElement left, TokenStackElement right) { - return false; + return !EQ.check(left, right); } @Override @@ -131,6 +146,46 @@ public class Criteria implements Predicate { @Override public boolean check(TokenStackElement left, TokenStackElement right) { + + if (left.getType() == right.getType()) { + switch (left.getType()) { + case ARRAY_TOKEN: + { + ArrayToken leftT = (ArrayToken)left; + ArrayToken rightT = (ArrayToken)right; + return check(leftT.getValue(), right.getValue()); + //break; + } + case OBJECT_TOKEN: + { + ObjectToken leftT = (ObjectToken)left; + ObjectToken rightT = (ObjectToken)right; + return check(leftT.getValue(), right.getValue()); + //break; + } + case STRING_TOKEN: + { + StringToken leftT = (StringToken)left; + StringToken rightT = (StringToken)right; + if (leftT.value != null && rightT.value != null) { + return leftT.value.equals(rightT.value); + } + break; + } + case FLOAT_TOKEN: + { + FloatToken leftT = (FloatToken)left; + FloatToken rightT = (FloatToken)right; + return leftT.value > rightT.value; + } + case INTEGER_TOKEN: + { + IntToken leftT = (IntToken)left; + IntToken rightT = (IntToken)right; + return leftT.value > rightT.value; + } + } + } return false; } @@ -151,7 +206,47 @@ public class Criteria implements Predicate { } @Override - public boolean check(TokenStackElement left, TokenStackElement right) { + public boolean check(TokenStackElement left, + TokenStackElement right) { + if (left.getType() == right.getType()) { + switch (left.getType()) { + case ARRAY_TOKEN: + { + ArrayToken leftT = (ArrayToken)left; + ArrayToken rightT = (ArrayToken)right; + return check(leftT.getValue(), right.getValue()); + //break; + } + case OBJECT_TOKEN: + { + ObjectToken leftT = (ObjectToken)left; + ObjectToken rightT = (ObjectToken)right; + return check(leftT.getValue(), right.getValue()); + //break; + } + case STRING_TOKEN: + { + StringToken leftT = (StringToken)left; + StringToken rightT = (StringToken)right; + if (leftT.value != null && rightT.value != null) { + return leftT.value.equals(rightT.value); + } + break; + } + case FLOAT_TOKEN: + { + FloatToken leftT = (FloatToken)left; + FloatToken rightT = (FloatToken)right; + return leftT.value >= rightT.value; + } + case INTEGER_TOKEN: + { + IntToken leftT = (IntToken)left; + IntToken rightT = (IntToken)right; + return leftT.value >= rightT.value; + } + } + } return false; } @@ -172,7 +267,48 @@ public class Criteria implements Predicate { } @Override - public boolean check(TokenStackElement left, TokenStackElement right) { + public boolean check(TokenStackElement left, + TokenStackElement right) { + + if (left.getType() == right.getType()) { + switch (left.getType()) { + case ARRAY_TOKEN: + { + ArrayToken leftT = (ArrayToken)left; + ArrayToken rightT = (ArrayToken)right; + return check(leftT.getValue(), right.getValue()); + //break; + } + case OBJECT_TOKEN: + { + ObjectToken leftT = (ObjectToken)left; + ObjectToken rightT = (ObjectToken)right; + return check(leftT.getValue(), right.getValue()); + //break; + } + case STRING_TOKEN: + { + StringToken leftT = (StringToken)left; + StringToken rightT = (StringToken)right; + if (leftT.value != null && rightT.value != null) { + return leftT.value.equals(rightT.value); + } + break; + } + case FLOAT_TOKEN: + { + FloatToken leftT = (FloatToken)left; + FloatToken rightT = (FloatToken)right; + return leftT.value < rightT.value; + } + case INTEGER_TOKEN: + { + IntToken leftT = (IntToken)left; + IntToken rightT = (IntToken)right; + return leftT.value < rightT.value; + } + } + } return false; } @@ -193,7 +329,48 @@ public class Criteria implements Predicate { } @Override - public boolean check(TokenStackElement left, TokenStackElement right) { + public boolean check(TokenStackElement left, + TokenStackElement right) { + + if (left.getType() == right.getType()) { + switch (left.getType()) { + case ARRAY_TOKEN: + { + ArrayToken leftT = (ArrayToken)left; + ArrayToken rightT = (ArrayToken)right; + return check(leftT.getValue(), right.getValue()); + //break; + } + case OBJECT_TOKEN: + { + ObjectToken leftT = (ObjectToken)left; + ObjectToken rightT = (ObjectToken)right; + return check(leftT.getValue(), right.getValue()); + //break; + } + case STRING_TOKEN: + { + StringToken leftT = (StringToken)left; + StringToken rightT = (StringToken)right; + if (leftT.value != null && rightT.value != null) { + return leftT.value.equals(rightT.value); + } + break; + } + case FLOAT_TOKEN: + { + FloatToken leftT = (FloatToken)left; + FloatToken rightT = (FloatToken)right; + return leftT.value < rightT.value; + } + case INTEGER_TOKEN: + { + IntToken leftT = (IntToken)left; + IntToken rightT = (IntToken)right; + return leftT.value < rightT.value; + } + } + } return false; } @@ -218,7 +395,21 @@ public class Criteria implements Predicate { } @Override - public boolean check(TokenStackElement left, TokenStackElement right) { + public boolean check(TokenStackElement left, + TokenStackElement right) { + + switch (left.getType()) { + case ARRAY_TOKEN: + { + ArrayToken leftT = (ArrayToken)left; + return (EQ.check(leftT.getValue(), right)); + } + case OBJECT_TOKEN: + case STRING_TOKEN: + case FLOAT_TOKEN: + case INTEGER_TOKEN: + break; + } return false; } }, @@ -232,7 +423,20 @@ public class Criteria implements Predicate { } @Override - public boolean check(TokenStackElement left, TokenStackElement right) { + public boolean check(TokenStackElement left, + TokenStackElement right) { + switch (left.getType()) { + case ARRAY_TOKEN: + { + ArrayToken leftT = (ArrayToken)left; + return (NE.check(leftT.getValue(), right)); + } + case OBJECT_TOKEN: + case STRING_TOKEN: + case FLOAT_TOKEN: + case INTEGER_TOKEN: + break; + } return false; } }, @@ -259,7 +463,46 @@ public class Criteria implements Predicate { } @Override - public boolean check(TokenStackElement left, TokenStackElement right) { + public boolean check(TokenStackElement left, + TokenStackElement right) { + + switch (right.getType()) { + case ARRAY_TOKEN: + { + ArrayToken token = (ArrayToken)right; + return (EQ.check(token.getValue(), left)); + } + case OBJECT_TOKEN: + { + ObjectToken token = (ObjectToken)right; + return (EQ.check(token.getValue(), left)); + } + case STRING_TOKEN: + { + if (left.getType() == TokenType.STRING_TOKEN) { + StringToken tokenL = (StringToken)right; + StringToken tokenR = (StringToken)left; + if (tokenL.value != null && tokenR.value != null) { + return tokenL.value.equals(tokenR.value); + } + } + break; + } + case FLOAT_TOKEN: + if (left.getType() == TokenType.FLOAT_TOKEN) { + FloatToken tokenL = (FloatToken)right; + FloatToken tokenR = (FloatToken)left; + return tokenL.value == tokenR.value; + } + break; + case INTEGER_TOKEN: + if (left.getType() == TokenType.INTEGER_TOKEN) { + IntToken tokenL = (IntToken)right; + IntToken tokenR = (IntToken)left; + return tokenL.value == tokenR.value; + } + break; + } return false; } }, @@ -292,7 +535,21 @@ public class Criteria implements Predicate { } @Override - public boolean check(TokenStackElement left, TokenStackElement right) { + public boolean check(TokenStackElement left, + TokenStackElement right) { + + switch (left.getType()) { + case ARRAY_TOKEN: + { + ArrayToken leftT = (ArrayToken)left; + return (EQ.check(leftT.getValue(), right)); + } + case OBJECT_TOKEN: + case STRING_TOKEN: + case FLOAT_TOKEN: + case INTEGER_TOKEN: + break; + } return false; } }, @@ -318,7 +575,27 @@ public class Criteria implements Predicate { } @Override - public boolean check(TokenStackElement left, TokenStackElement right) { + public boolean check(TokenStackElement left, + TokenStackElement right) { + if (left.getType() == TokenType.INTEGER_TOKEN) { + int size = ((IntToken)left).value; + switch (right.getType()) { + case ARRAY_TOKEN: + { + ArrayToken token = (ArrayToken)right; + return (token.getIndex() + 1) == size; + } + case STRING_TOKEN: + { + StringToken token = (StringToken)right; + return token.value.length() == size; + } + case OBJECT_TOKEN: + case FLOAT_TOKEN: + case INTEGER_TOKEN: + break; + } + } return false; } }, @@ -330,8 +607,9 @@ public class Criteria implements Predicate { } @Override - public boolean check(TokenStackElement left, TokenStackElement right) { - return false; + public boolean check(TokenStackElement left, + TokenStackElement right) { + throw new UnsupportedOperationException(); } }, TYPE { @@ -345,7 +623,7 @@ public class Criteria implements Predicate { @Override public boolean check(TokenStackElement left, TokenStackElement right) { - return false; + return (left.getType() == right.getType()); } }, REGEX { @@ -373,7 +651,7 @@ public class Criteria implements Predicate { @Override public boolean check(TokenStackElement left, TokenStackElement right) { - return false; + throw new UnsupportedOperationException(); } @Override @@ -391,7 +669,7 @@ public class Criteria implements Predicate { @Override public boolean check(TokenStackElement left, TokenStackElement right) { - return false; + throw new UnsupportedOperationException(); } }, NOT_EMPTY { @@ -413,7 +691,24 @@ public class Criteria implements Predicate { } @Override - public boolean check(TokenStackElement left, TokenStackElement right) { + public boolean check(TokenStackElement left, + TokenStackElement right) { + switch (right.getType()) { + case ARRAY_TOKEN: + { + ArrayToken token = (ArrayToken)right; + return token.getValue() != null; + } + case STRING_TOKEN: + { + StringToken token = (StringToken)right; + return token.value.length() > 0; + } + case OBJECT_TOKEN: + case FLOAT_TOKEN: + case INTEGER_TOKEN: + break; + } return false; } }; diff --git a/json-path/src/main/java/com/jayway/jsonpath/Filter.java b/json-path/src/main/java/com/jayway/jsonpath/Filter.java index 94a33aaa..59b210bf 100644 --- a/json-path/src/main/java/com/jayway/jsonpath/Filter.java +++ b/json-path/src/main/java/com/jayway/jsonpath/Filter.java @@ -29,7 +29,7 @@ import static java.util.Arrays.asList; /** * */ -public abstract class Filter implements Predicate { +public abstract class Filter implements StreamingPredicate { private static final Logger logger = LoggerFactory.getLogger(Filter.class); private static final Pattern OPERATOR_SPLIT = Pattern.compile("((?<=&&|\\|\\|)|(?=&&|\\|\\|))"); @@ -85,7 +85,7 @@ public abstract class Filter implements Predicate { @Override public boolean check(TokenStack stack, int idx) { - return predicate.check(stack, idx); + return ((StreamingPredicate)predicate).check(stack, idx); } @Override @@ -125,7 +125,7 @@ public abstract class Filter implements Predicate { @Override public boolean check(TokenStack stack, int idx) { for (Predicate predicate : predicates) { - if(!predicate.check(stack, idx)){ + if(!((StreamingPredicate)predicate).check(stack, idx)){ return false; } } @@ -160,8 +160,8 @@ public abstract class Filter implements Predicate { @Override public boolean check(TokenStack stack, int idx) { - boolean a = left.check(stack, idx); - return a || right.check(stack, idx); + boolean a = ((StreamingPredicate)left).check(stack, idx); + return a || ((StreamingPredicate)right).check(stack, idx); } @Override diff --git a/json-path/src/main/java/com/jayway/jsonpath/Predicate.java b/json-path/src/main/java/com/jayway/jsonpath/Predicate.java index a7e5525f..1d19991e 100644 --- a/json-path/src/main/java/com/jayway/jsonpath/Predicate.java +++ b/json-path/src/main/java/com/jayway/jsonpath/Predicate.java @@ -14,7 +14,6 @@ */ package com.jayway.jsonpath; -import com.jayway.jsonpath.internal.token.TokenStack; import com.jayway.jsonpath.spi.mapper.MappingException; /** @@ -24,8 +23,6 @@ public interface Predicate { boolean apply(PredicateContext ctx); - boolean check(TokenStack stack, int idx); - public interface PredicateContext { /** diff --git a/json-path/src/main/java/com/jayway/jsonpath/StreamingPredicate.java b/json-path/src/main/java/com/jayway/jsonpath/StreamingPredicate.java new file mode 100644 index 00000000..85508da1 --- /dev/null +++ b/json-path/src/main/java/com/jayway/jsonpath/StreamingPredicate.java @@ -0,0 +1,25 @@ +/* + * Copyright 2011 the original author or authors. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.jayway.jsonpath; + +import com.jayway.jsonpath.internal.token.TokenStack; + +/** + * + */ +public interface StreamingPredicate extends Predicate { + + boolean check(TokenStack stack, int idx); +} diff --git a/json-path/src/test/java/com/jayway/jsonpath/FilterTest.java b/json-path/src/test/java/com/jayway/jsonpath/FilterTest.java index 97106453..b4cd6f40 100644 --- a/json-path/src/test/java/com/jayway/jsonpath/FilterTest.java +++ b/json-path/src/test/java/com/jayway/jsonpath/FilterTest.java @@ -386,7 +386,7 @@ public class FilterTest extends BaseTest { return i == 1; } - @Override + //@Override public boolean check(TokenStack stack, int idx) { return false; } diff --git a/json-path/src/test/java/com/jayway/jsonpath/PredicateTest.java b/json-path/src/test/java/com/jayway/jsonpath/PredicateTest.java index d6b3afd4..1855122a 100644 --- a/json-path/src/test/java/com/jayway/jsonpath/PredicateTest.java +++ b/json-path/src/test/java/com/jayway/jsonpath/PredicateTest.java @@ -21,7 +21,7 @@ public class PredicateTest extends BaseTest { return ctx.item(Map.class).containsKey("isbn"); } - @Override + //@Override public boolean check(TokenStack stack, int idx) { return false; } diff --git a/json-path/src/test/java/com/jayway/jsonpath/old/FilterTest.java b/json-path/src/test/java/com/jayway/jsonpath/old/FilterTest.java index 63677c03..4636ccb2 100644 --- a/json-path/src/test/java/com/jayway/jsonpath/old/FilterTest.java +++ b/json-path/src/test/java/com/jayway/jsonpath/old/FilterTest.java @@ -347,7 +347,7 @@ public class FilterTest extends BaseTest { } return false; } - @Override + //@Override public boolean check(TokenStack stack, int idx) { return false; } @@ -371,7 +371,7 @@ public class FilterTest extends BaseTest { public boolean apply(PredicateContext ctx) { return 1 == (Integer)ctx.item(); } - @Override + //@Override public boolean check(TokenStack stack, int idx) { return false; }