diff --git a/.gitignore b/.gitignore index 3ba01b2..1098d81 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,6 @@ out/ ` gradle.properties + +*.DS_Store +**/.DS_Store diff --git a/README.md b/README.md index 2e32027..7b19564 100644 --- a/README.md +++ b/README.md @@ -1,190 +1,410 @@ # bool-parser-java -A Boolean Expression Parser for Java -The library can help parse complex and nested boolean expressions. -The expressions are in SQL-like syntax, where you can use boolean operators and parentheses to combine individual expressions. +A Boolean Expression Parser for Java that helps parse and evaluate complex boolean and arithmetic expressions. -An expression can be as simple as `name = Sidhant`. -A Complex expression is formed by combining these small expressions by logical operators and giving precedence using parenthesis +## Table of Contents -### Examples -#### Textual Equality +- [Overview](#overview) +- [Installation](#installation) +- [Basic Usage](#basic-usage) +- [Language Syntax Reference](#language-syntax-reference) + - [Data Types](#data-types) + - [Field References](#field-references) + - [Operators](#operators) + - [Expression Types](#expression-types) + - [Functions](#functions) + - [Advanced Usage](#advanced-usage) +- [Applications](#applications) + - [Boolean Expression Evaluator](#boolean-expression-evaluator) + - [Arithmetic Expression Evaluator](#arithmetic-expression-evaluator) +- [Node Types Post Parsing](#node-types-post-parsing) -Format: `${attributeName} = ${value}` +## Overview -Example: `name = john` +This library helps parse and evaluate complex and nested boolean expressions. The expressions use a SQL-like syntax, where you can use boolean operators and parentheses to combine individual expressions. -#### Numeric Comparisons +An expression can be as simple as `name = 'Sidhant'` or as complex as `(age >= 18 AND age <= 65) AND (status = 'active' OR status = 'pending')`. -Format: `${attributeName} ${operator} ${value}` +## Installation -Example: `price > 12.99` +### Maven +```xml + + + com.github.sidhant92 + bool-parser-java + 2.0.0 + + +``` + +### Gradle +``` +dependencies { + implementation "com.github.sidhant92:bool-parser-java:2.0.0" +} +``` + +## Basic Usage -The ${value} must be numeric. Supported operators are `<`, `<=`, `=`, `!=`, `>=` and `>`, with the same semantics as in virtually all programming languages. +```java +final BoolParser boolParser = new BoolParser(); +final Try nodeOptional = boolParser.parseExpression("name = 'test'"); +``` -#### Numeric Range +There are two implementations for the parser: +- `BoolParser`: Standard implementation +- `CachedBoolParser`: Takes input for the max cache size to improve performance -Format: `${attributeName} ${lowerBound} TO ${upperBound}` +## Language Syntax Reference -Example: `price 5.99 TO 100` +### Data Types -`${lowerBound}` and `${upperBound}` must be numeric. Both are inclusive. +The language supports the following data types: -#### Boolean operators +1. **String**: Text values enclosed in single (`'`) or double (`"`) quotes. Examples: `'hello'`, `"world"` +2. **Integer**: Whole numbers without decimal points. Examples: `42`, `-10` +3. **Long**: Large whole numbers. Example: `1611473334114` +4. **Decimal**: Numbers with decimal points (stored as BigDecimal). Examples: `3.14`, `-2.5` +5. **Boolean**: `true` or `false` (case-insensitive) +6. **Version**: Semantic version numbers. Examples: `1.0.6`, `2.3.1.5` +7. **Date**: Date values in YYYY-MM-DD format. Examples: `2023-12-25`, `2024-01-15` +8. **DateTime**: Date and time values in YYYY-MM-DD HH:MM:SS format. Examples: `2023-12-25 14:30:00`, `2024-01-15 09:15:30` +9. **Null**: Represented as `null` -Example: +### Field References -`price < 10 AND (category:Book OR NOT category:Ebook)` +Fields reference values in the data context: -Individual filters can be combined via boolean operators. The following operators are supported: +1. **Simple fields**: Direct reference to a field. Example: `age` +2. **Nested fields**: Access nested objects using dot notation. Example: `person.details.age` +3. **Default field**: When a default field is specified, operators can be used without explicitly naming the field. Example: `>= 18` (with "age" as default field) -* `OR`: must match any of the combined conditions (disjunction) -* `AND`: must match all of the combined conditions (conjunction) -* `NOT`: negate a filter +### Operators -Parentheses, `(` and `)`, can be used for grouping. +#### Comparison Operators -#### Usage Notes -* Phrases that includes quotes, like `content = "It's a wonderful day"` -* Phrases that includes quotes, like `attribute = 'She said "Hello World"'` -* For nested keys in data map you can use the dot notation, like `person.age` +| Operator | Description | Example | +|----------|-------------|---------| +| `=` | Equal to | `name = 'John'` | +| `!=` | Not equal to | `status != 'pending'` | +| `>` | Greater than | `age > 18` | +| `>=` | Greater than or equal to | `price >= 9.99` | +| `<` | Less than | `temperature < 32` | +| `<=` | Less than or equal to | `quantity <= 100` | + +#### Logical Operators + +| Operator | Description | Example | +|----------|-------------|---------| +| `AND` or `&&` | Logical AND | `age > 18 AND status = 'active'` | +| `OR` or `\|\|` | Logical OR | `category = 'book' OR category = 'ebook'` | +| `NOT` or `not` | Logical NOT | `NOT (price < 10)` | + +#### Arithmetic Operators + +| Operator | Description | Example | +|----------|-------------|---------| +| `+` | Addition | `price + tax` | +| `-` | Subtraction | `total - discount` | +| `*` | Multiplication | `quantity * price` | +| `/` | Division | `total / count` | +| `%` | Modulus | `id % 10` | +| `^` | Exponent | `2 ^ 3` | + +### Expression Types + +#### Comparison Expressions + +Compare field values against literals or other fields: -## Usage -POM -```xml - - - com.github.sidhant92 - bool-parser-java - 1.0.0 - - ``` -Gradle +age > 21 +name = 'Alice' +price < maxPrice ``` -dependencies { - implementation "com.github.sidhant92:bool-parser-java:1.0.0" -} + +#### Logical Expressions + +Combine expressions with logical operators: + +``` +(age > 21) AND (status = 'active') +category = 'book' OR category = 'ebook' +NOT (price > 100) ``` +#### Range Expressions + +Test if a value falls within a range (both bounds are inclusive): -Code ``` -final BoolParser boolParser = new BoolParser(); -final Try nodeOptional = boolParser.parseExpression("name = test"); +age 18 TO 65 +price 9.99 TO 49.99 ``` -### Node Types Post Parsing -#### -NumericNode +#### Membership Expressions + +Test if a value is in a set: + +``` +status IN ('pending', 'processing', 'shipped') +category NOT IN ('restricted', 'discontinued') ``` -private final String field; -private final Object value; +#### Array Operations -private final Operator operator; +Test if an array contains specific values: -private final DataType dataType; ``` +tags CONTAINS_ANY ('sale', 'new') +permissions CONTAINS_ALL ('read', 'write') +``` + +### Functions + +#### Arithmetic Functions + +| Function | Description | Example | +|----------|-------------|---------| +| `MIN` | Minimum value | `MIN(1, 2, 3)` or `MIN(numbers)` | +| `MAX` | Maximum value | `MAX(1, 2, 3)` or `MAX(numbers)` | +| `SUM` | Sum of values | `SUM(1, 2, 3)` or `SUM(numbers)` | +| `AVG` | Average of values | `AVG(1, 2, 3)` or `AVG(numbers)` | +| `MEAN` | Mean of values | `MEAN(1, 2, 3)` or `MEAN(numbers)` | +| `MEDIAN` | Median of values | `MEDIAN(1, 2, 3)` or `MEDIAN(numbers)` | +| `MODE` | Mode of values | `MODE(1, 1, 2, 3)` or `MODE(numbers)` | +| `LEN` | Length of string or array | `LEN('hello')` or `LEN(items)` | +| `INT` | Convert to integer | `INT(2.7)` or `INT(value)` | +| `DAYS_ELAPSED` | Number of days elapsed since a date | `DAYS_ELAPSED(2023-01-01)` or `DAYS_ELAPSED(startDate)` | + +Functions can be used in both boolean and arithmetic contexts: -#### -NumericRangeNode ``` -private final String field; +age > MIN(requiredAge, recommendedAge) +LEN(name) > 3 +``` -private final Object fromValue; +### Advanced Usage -private final Object toValue; +#### Combining Expressions -private final DataType fromDataType; +Complex conditions can be created by combining expressions: -private final DataType toDataType; ``` +(age >= 18 AND age <= 65) AND (status = 'active' OR status = 'pending') +``` + +#### Arithmetic in Boolean Expressions + +Arithmetic expressions can be used within boolean expressions: -#### -BooleanNode ``` -private Node left; +price > (basePrice + tax) +age > (minimumAge + 5) +``` -private Node right; +#### Function Nesting + +Functions can be nested: -private LogicalOperationType operator; ``` +MAX(1, 2, MIN(5, 7, 87)) +``` + +#### Null Checks + +Check if a field is null or not: -#### -UnaryNode ``` -private final DataType dataType; +lastLogin = null +email != null +``` + +#### Working with Arrays + +Arrays can be used with specific operators and functions: -private final Object value; ``` +// Check if the 'roles' array contains any of the specified values +roles CONTAINS_ANY ('admin', 'editor') + +// Check if the 'permissions' array contains all of the specified values +permissions CONTAINS_ALL ('read', 'write', 'delete') -#### -InNode +// Get the length of an array +LEN(items) > 0 ``` -private final String field; -private final List> items; +#### Working with Dates + +Date and DateTime values can be used in comparisons and with the DAYS_ELAPSED function: + +``` +// Date comparisons +startDate > 2023-01-01 +endDate <= 2024-12-31 + +// DateTime comparisons +lastLogin >= 2023-06-15 09:30:00 +createdAt < 2024-01-01 00:00:00 + +// Using DAYS_ELAPSED function +DAYS_ELAPSED(startDate) > 30 +DAYS_ELAPSED(2023-01-01) < 365 ``` +#### String Handling + +- Strings must be enclosed in single or double quotes +- Quotes within strings can be handled: + - `content = "It's a wonderful day"` + - `attribute = 'She said "Hello World"'` + +#### Case Sensitivity + +Operators and function names are case-insensitive: + +``` +// These are equivalent +name = 'John' AND age > 21 +NAME = 'John' and AGE > 21 +``` + +However, field names and string values are case-sensitive. ## Applications ### Boolean Expression Evaluator -The library can be used to evaluate a boolean expression. - -The following Data Types are supported: -1. String -2. Integer -3. Long -4. Decimal -5. Boolean -6. Semantic Version +The library can be used to evaluate boolean expressions against a data context. Usage examples: -Simple Numerical Comparison -``` -final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(); +#### Simple Numerical Comparison +```java +final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(new BoolParser()); final Map data = new HashMap<>(); data.put("age", 26); -final Try result = booleanExpressionEvaluator.evaluate("age >= 27", data); -assertTrue(booleanOptional.isPresent()); -assertFalse(booleanOptional.get()); +final Try resultOptional = booleanExpressionEvaluator.evaluate("age >= 27", data); +assertTrue(resultOptional.isSuccess()); +assertFalse(resultOptional.get()); ``` -Boolean Comparison -``` -final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(); + +#### Boolean Comparison +```java +final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(new BoolParser()); final Map data = new HashMap<>(); data.put("age", 25); data.put("name", "sid"); -final Try result = booleanExpressionEvaluator.evaluate("name = sid AND age = 25", data); -assertTrue(booleanOptional.isPresent()); -assertTrue(booleanOptional.get()); +final Try resultOptional = booleanExpressionEvaluator.evaluate("name = 'sid' AND age = 25", data); +assertTrue(resultOptional.isSuccess()); +assertTrue(resultOptional.get()); ``` -Nested Boolean Comparison -``` -final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(); + +#### Nested Boolean Comparison +```java +final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(new BoolParser()); final Map data = new HashMap<>(); data.put("age", 25); data.put("name", "sid"); data.put("num", 45); -final Try result = booleanExpressionEvaluator.evaluate("name:sid AND (age = 25 OR num = 44)", data); -assertTrue(booleanOptional.isPresent()); -assertTrue(booleanOptional.get()); +final Try resultOptional = booleanExpressionEvaluator.evaluate("name = 'sid' AND (age = 25 OR num = 44)", data); +assertTrue(resultOptional.isSuccess()); +assertTrue(resultOptional.get()); ``` -App Version Comparison -``` -final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(); + +#### App Version Comparison +```java +final BooleanExpressionEvaluator booleanExpressionEvaluator = new BooleanExpressionEvaluator(new BoolParser()); final Map data = new HashMap<>(); data.put("app_version", "1.5.9"); -final Try result = booleanExpressionEvaluator.evaluate("app_version < 1.5.10", data); -assertTrue(booleanOptional.isPresent()); -assertTrue(booleanOptional.get()); +final Try resultOptional = booleanExpressionEvaluator.evaluate("app_version < 1.5.10", data); +assertTrue(resultOptional.isSuccess()); +assertTrue(resultOptional.get()); ``` The return type is `Try`. Failure means that parsing has failed and any fallback can be used. +[For a complete list of examples please check out the test file](src/test/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluatorTest.java) + +### Arithmetic Expression Evaluator + +The library can also evaluate arithmetic expressions, supporting both literals and variables from the data context. + +#### Simple Addition Operation +```java +final ArithmeticExpressionEvaluator evaluator = new ArithmeticExpressionEvaluator(new BoolParser()); +final Map data = new HashMap<>(); +data.put("a", 10); +final Try resultOptional = evaluator.evaluate("a + 5", data); +assertTrue(resultOptional.isSuccess()); +assertEquals(resultOptional.get(), 15); +``` + +#### Complex Arithmetic Operation +```java +final ArithmeticExpressionEvaluator evaluator = new ArithmeticExpressionEvaluator(new BoolParser()); +final Map data = new HashMap<>(); +data.put("a", 10); +final Try resultOptional = evaluator.evaluate("((5 * 2) + a) * 2 + (1 + 3 * (a / 2))", data); +assertTrue(resultOptional.isSuccess()); +assertEquals(resultOptional.get(), 56); +``` + +#### Function Usage +```java +final ArithmeticExpressionEvaluator evaluator = new ArithmeticExpressionEvaluator(new BoolParser()); +final Map data = new HashMap<>(); +data.put("a", 10); +final Try resultOptional = evaluator.evaluate("min(1, 2, 3)", data); +assertTrue(resultOptional.isSuccess()); +assertEquals(resultOptional.get(), 1); +``` + +[For a complete list of examples please check out the test file](src/test/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluatorTest.java) + +## Node Types Post Parsing + +The parser produces different node types based on the expression: + +### ComparisonNode +```java +private final Node left; +private final Node right; +private final Operator operator; +private final DataType dataType; +``` + +### NumericRangeNode +```java +private final String field; +private final Object fromValue; +private final Object toValue; +private final DataType fromDataType; +private final DataType toDataType; +``` + +### BooleanNode +```java +private Node left; +private Node right; +private LogicalOperationType operator; +``` -[For a complete list of examples please check out the test file](src/test/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluatorTest.java) \ No newline at end of file +### UnaryNode +```java +private final DataType dataType; +private final Object value; +``` + +### FieldNode +```java +private final String field; +``` + +### InNode +```java +private final String field; +private final List items; +``` diff --git a/build.gradle b/build.gradle index 8b4cf82..f807b30 100644 --- a/build.gradle +++ b/build.gradle @@ -22,7 +22,7 @@ sourceCompatibility = 1.8 targetCompatibility = 1.8 group 'com.github.sidhant92' -version = "1.2.1" +version = "2.0.0" apply plugin: "com.dipien.semantic-version" @@ -31,12 +31,8 @@ repositories { } dependencies { - implementation 'ch.qos.logback:logback-classic:1.2.3' - implementation 'ch.qos.logback.contrib:logback-json-classic:0.1.5' - implementation 'ch.qos.logback.contrib:logback-jackson:0.1.5' - implementation 'net.logstash.logback:logstash-logback-encoder:5.2' implementation 'org.apache.maven:maven-artifact:3.5.2' - implementation 'org.antlr:antlr4-runtime:4.13.1' + implementation 'org.antlr:antlr4-runtime:4.13.2' implementation 'io.vavr:vavr:0.10.4' implementation 'com.github.ben-manes.caffeine:caffeine:2.9.3' implementation 'org.projectlombok:lombok:1.18.26' @@ -122,7 +118,7 @@ nexusPublishing { ext.genOutputDir = file("$buildDir/generated-resources") -task generateVersionTxt() { +task generateVersionTxt() { ext.outputFile = file("$genOutputDir/version.txt") outputs.file(outputFile) doLast { diff --git a/src/main/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluator.java b/src/main/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluator.java new file mode 100644 index 0000000..56f4e71 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluator.java @@ -0,0 +1,122 @@ +package com.github.sidhant92.boolparser.application; + +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.stream.Collectors; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.domain.FieldNode; +import com.github.sidhant92.boolparser.domain.arithmetic.UnaryNode; +import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticNode; +import com.github.sidhant92.boolparser.domain.logical.Node; +import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticFunctionNode; +import com.github.sidhant92.boolparser.exception.DataNotFoundException; +import com.github.sidhant92.boolparser.exception.UnsupportedToken; +import com.github.sidhant92.boolparser.function.FunctionEvaluatorService; +import com.github.sidhant92.boolparser.operator.OperatorService; +import com.github.sidhant92.boolparser.parser.BoolExpressionParser; +import com.github.sidhant92.boolparser.util.ValueUtils; +import io.vavr.control.Try; + +/** + * @author sidhant.aggarwal + * @since 15/03/2024 + */ +public class ArithmeticExpressionEvaluator { + private final BoolExpressionParser boolExpressionParser; + + private final OperatorService operatorService; + + private final FunctionEvaluatorService functionEvaluatorService; + + public ArithmeticExpressionEvaluator(final BoolExpressionParser boolExpressionParser) { + this.boolExpressionParser = boolExpressionParser; + operatorService = new OperatorService(); + functionEvaluatorService = new FunctionEvaluatorService(); + } + + public Try evaluate(final String expression, final Map data) { + final Try tokenOptional = boolExpressionParser.parseExpression(expression, null); + return tokenOptional.map(node -> evaluateToken(node, data)); + } + + protected Object evaluate(final Node node, final Map data) { + return evaluateToken(node, data); + } + + private Object evaluateToken(final Node node, final Map data) { + switch (node.getTokenType()) { + case ARITHMETIC: + return evaluateArithmeticToken((ArithmeticNode) node, data); + case ARITHMETIC_FUNCTION: + return evaluateArithmeticFunctionToken((ArithmeticFunctionNode) node, data); + case UNARY: + return evaluateUnaryToken((UnaryNode) node, data); + case FIELD: + return evaluateFieldToken((FieldNode) node, data); + default: + throw new UnsupportedToken(node.getTokenType().name()); + } + } + + private Object evaluateFieldToken(final FieldNode fieldNode, final Map data) { + final Optional value = ValueUtils.getValueFromMap(fieldNode.getField(), data); + if (!value.isPresent()) { + throw new DataNotFoundException(fieldNode.getField()); + } + return value.get(); + } + + private Object evaluateUnaryToken(final UnaryNode unaryNode, final Map data) { + return unaryNode.getValue(); + } + + private Object evaluateArithmeticFunctionToken(final ArithmeticFunctionNode arithmeticFunctionNode, final Map data) { + final List resolvedValues = arithmeticFunctionNode.getItems() + .stream() + .map(item -> evaluate(item, data)) + .collect(Collectors.toList()); + final List flattenedValues = ValueUtils.mapToEvaluatedNodes(resolvedValues); + return functionEvaluatorService.evaluateArithmeticFunction(arithmeticFunctionNode.getFunctionType(), flattenedValues); + } + + private Object evaluateArithmeticToken(final ArithmeticNode arithmeticNode, final Map data) { + final Object leftValue = evaluateToken(arithmeticNode.getLeft(), data); + if (arithmeticNode.getOperator().equals(Operator.UNARY)) { + if (leftValue instanceof EvaluatedNode) { + final EvaluatedNode left = (EvaluatedNode) leftValue; + return operatorService.evaluateArithmeticOperator(left.getValue(), left.getDataType(), null, null, arithmeticNode.getOperator(), + ContainerDataType.PRIMITIVE); + } else { + final DataType leftDataType = ValueUtils.getDataType(leftValue); + return operatorService.evaluateArithmeticOperator(leftValue, leftDataType, null, null, arithmeticNode.getOperator(), + ContainerDataType.PRIMITIVE); + } + } + final Object rightValue = evaluateToken(arithmeticNode.getRight(), data); + if (leftValue instanceof EvaluatedNode && rightValue instanceof EvaluatedNode) { + final EvaluatedNode left = (EvaluatedNode) leftValue; + final EvaluatedNode right = (EvaluatedNode) rightValue; + return operatorService.evaluateArithmeticOperator(left.getValue(), left.getDataType(), right.getValue(), right.getDataType(), + arithmeticNode.getOperator(), ContainerDataType.PRIMITIVE); + } else if (leftValue instanceof EvaluatedNode) { + final EvaluatedNode left = (EvaluatedNode) leftValue; + final DataType rightDataType = ValueUtils.getDataType(rightValue); + return operatorService.evaluateArithmeticOperator(left.getValue(), left.getDataType(), rightValue, rightDataType, + arithmeticNode.getOperator(), ContainerDataType.PRIMITIVE); + } else if (rightValue instanceof EvaluatedNode) { + final EvaluatedNode right = (EvaluatedNode) rightValue; + final DataType leftDataType = ValueUtils.getDataType(leftValue); + return operatorService.evaluateArithmeticOperator(leftValue, leftDataType, right.getValue(), right.getDataType(), + arithmeticNode.getOperator(), ContainerDataType.PRIMITIVE); + } else { + final DataType leftDataType = ValueUtils.getDataType(leftValue); + final DataType rightDataType = ValueUtils.getDataType(rightValue); + return operatorService.evaluateArithmeticOperator(leftValue, leftDataType, rightValue, rightDataType, arithmeticNode.getOperator(), + ContainerDataType.PRIMITIVE); + } + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluator.java b/src/main/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluator.java index ce6105d..55375a6 100644 --- a/src/main/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluator.java +++ b/src/main/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluator.java @@ -1,17 +1,25 @@ package com.github.sidhant92.boolparser.application; +import static com.github.sidhant92.boolparser.constant.NodeType.UNARY; +import java.util.Collections; +import java.util.List; import java.util.Map; +import java.util.Optional; +import java.util.stream.Collectors; import org.apache.commons.lang3.tuple.Pair; import com.github.sidhant92.boolparser.constant.ContainerDataType; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.Operator; -import com.github.sidhant92.boolparser.domain.ArrayNode; -import com.github.sidhant92.boolparser.domain.BooleanNode; -import com.github.sidhant92.boolparser.domain.InNode; -import com.github.sidhant92.boolparser.domain.NumericRangeNode; -import com.github.sidhant92.boolparser.domain.ComparisonNode; -import com.github.sidhant92.boolparser.domain.Node; -import com.github.sidhant92.boolparser.domain.UnaryNode; +import com.github.sidhant92.boolparser.domain.FieldNode; +import com.github.sidhant92.boolparser.domain.logical.ArrayNode; +import com.github.sidhant92.boolparser.domain.logical.BooleanNode; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.domain.logical.InNode; +import com.github.sidhant92.boolparser.domain.logical.NumericRangeNode; +import com.github.sidhant92.boolparser.domain.logical.ComparisonNode; +import com.github.sidhant92.boolparser.domain.logical.Node; +import com.github.sidhant92.boolparser.domain.arithmetic.UnaryNode; +import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticBaseNode; import com.github.sidhant92.boolparser.exception.DataNotFoundException; import com.github.sidhant92.boolparser.exception.HeterogeneousArrayException; import com.github.sidhant92.boolparser.exception.InvalidUnaryOperand; @@ -19,21 +27,22 @@ import com.github.sidhant92.boolparser.parser.BoolExpressionParser; import com.github.sidhant92.boolparser.util.ValueUtils; import io.vavr.control.Try; -import lombok.extern.slf4j.Slf4j; /** * @author sidhant.aggarwal * @since 07/02/2023 */ -@Slf4j public class BooleanExpressionEvaluator { private final BoolExpressionParser boolExpressionParser; private final OperatorService operatorService; + private final ArithmeticExpressionEvaluator arithmeticExpressionEvaluator; + public BooleanExpressionEvaluator(final BoolExpressionParser boolExpressionParser) { this.boolExpressionParser = boolExpressionParser; operatorService = new OperatorService(); + arithmeticExpressionEvaluator = new ArithmeticExpressionEvaluator(boolExpressionParser); } public Try evaluate(final String expression, final Map data, final String defaultField) { @@ -64,49 +73,96 @@ private boolean evaluateToken(final Node node, final Map data) { } } + private Optional getValue(final Node node, final Map data) { + switch (node.getTokenType()) { + case FIELD: + return ValueUtils.getValueFromMap(((FieldNode) node).getField(), data); + case UNARY: + final UnaryNode unaryNode = (UnaryNode) node; + return Optional.of(unaryNode.getValue()); + default: + if (node instanceof ArithmeticBaseNode) { + return Optional.of(arithmeticExpressionEvaluator.evaluate(node, data)); + } + return Optional.of(evaluateToken(node, data)); + } + } + private boolean evaluateComparisonToken(final ComparisonNode comparisonToken, final Map data) { - final Object fieldData = ValueUtils.getValueFromMap(comparisonToken.getField(), data).orElseThrow(DataNotFoundException::new); - return operatorService.evaluate(comparisonToken.getOperator(), ContainerDataType.PRIMITIVE, comparisonToken.getDataType(), fieldData, - comparisonToken.getValue()); + final Optional leftValueOptional = getValue(comparisonToken.getLeft(), data); + + final Object leftData = comparisonToken.isNullCheck() ? leftValueOptional.orElse("null") : leftValueOptional.orElseThrow( + () -> new DataNotFoundException(((FieldNode) comparisonToken.getLeft()).getField())); + final Object rightData = comparisonToken.isNullCheck() ? "null" : getValue(comparisonToken.getRight(), data).get(); + final DataType rightDataType = ValueUtils.getDataType(rightData); + final DataType leftDataType = ValueUtils.getDataType(leftData); + return operatorService.evaluateLogicalOperator(comparisonToken.getOperator(), ContainerDataType.PRIMITIVE, leftData, leftDataType, + Collections.singletonList(Pair.of(rightData, rightDataType))); } private boolean evaluateNumericRangeToken(final NumericRangeNode numericRangeToken, final Map data) { - final Object fieldData = ValueUtils.getValueFromMap(numericRangeToken.getField(), data).orElseThrow(DataNotFoundException::new); - return operatorService.evaluate(Operator.GREATER_THAN_EQUAL, ContainerDataType.PRIMITIVE, numericRangeToken.getFromDataType(), fieldData, - numericRangeToken.getFromValue()) && operatorService.evaluate(Operator.LESS_THAN_EQUAL, - ContainerDataType.PRIMITIVE, - numericRangeToken.getToDataType(), fieldData, - numericRangeToken.getToValue()); + final Object fieldData = ValueUtils.getValueFromMap(numericRangeToken.getField(), data) + .orElseThrow(() -> new DataNotFoundException(numericRangeToken.getField())); + final DataType fieldDataType = ValueUtils.getDataType(fieldData); + final List> fromValues = Collections.singletonList( + Pair.of(numericRangeToken.getFromValue(), numericRangeToken.getFromDataType())); + final List> toValues = Collections.singletonList( + Pair.of(numericRangeToken.getToValue(), numericRangeToken.getToDataType())); + final boolean leftResult = operatorService.evaluateLogicalOperator(Operator.GREATER_THAN_EQUAL, ContainerDataType.PRIMITIVE, fieldData, + fieldDataType, fromValues); + final boolean rightResult = operatorService.evaluateLogicalOperator(Operator.LESS_THAN_EQUAL, ContainerDataType.PRIMITIVE, fieldData, + fieldDataType, toValues); + return leftResult && rightResult; } private boolean evaluateInToken(final InNode inToken, final Map data) { - final Object fieldData = ValueUtils.getValueFromMap(inToken.getField(), data).orElseThrow(DataNotFoundException::new); - final DataType dataType = inToken.getItems().get(0).getLeft(); - final Object[] values = inToken.getItems() + final Object fieldData = ValueUtils.getValueFromMap(inToken.getField(), data) + .orElseThrow(() -> new DataNotFoundException(inToken.getField())); + final List items = resolveArrayElements(inToken.getItems(), data); + final DataType dataType = ValueUtils.getDataType(fieldData); + final List> values = items + .stream() + .map(item -> Pair.of(item.getValue(), item.getDataType())) + .collect(Collectors.toList()); + return operatorService.evaluateLogicalOperator(Operator.IN, ContainerDataType.PRIMITIVE, fieldData, dataType, values); + } + + private List resolveArrayElements(final List items, final Map data) { + final List resolvedValues = items .stream() - .map(Pair::getRight).toArray(); - return operatorService.evaluate(Operator.IN, ContainerDataType.PRIMITIVE, dataType, fieldData, values); + .map(item -> { + if (item instanceof ArithmeticBaseNode) { + return arithmeticExpressionEvaluator.evaluate(item, data); + } + return evaluateToken(item, data); + }) + .collect(Collectors.toList()); + return ValueUtils.mapToEvaluatedNodes(resolvedValues); } private boolean evaluateArrayToken(final ArrayNode arrayNode, final Map data) { - final Object fieldData = ValueUtils.getValueFromMap(arrayNode.getField(), data).orElseThrow(DataNotFoundException::new); - if (arrayNode.getItems() + final Object fieldData = ValueUtils.getValueFromMap(arrayNode.getField(), data) + .orElseThrow(() -> new DataNotFoundException(arrayNode.getField())); + final DataType fieldDataType = ValueUtils.getDataType(fieldData); + final List items = resolveArrayElements(arrayNode.getItems(), data); + if (items .stream() - .map(Pair::getLeft).distinct().count() > 1) { + .map(EvaluatedNode::getDataType).distinct().count() > 1) { throw new HeterogeneousArrayException(); } - final DataType dataType = arrayNode.getItems().get(0).getLeft(); - final Object[] values = arrayNode.getItems() + final List> values = items .stream() - .map(Pair::getRight).toArray(); - return operatorService.evaluate(arrayNode.getOperator(), ContainerDataType.LIST, dataType, fieldData, values); + .map(item -> Pair.of(item.getValue(), item.getDataType())) + .collect(Collectors.toList()); + return operatorService.evaluateLogicalOperator(arrayNode.getOperator(), ContainerDataType.LIST, fieldData, fieldDataType, values); } private boolean evaluateUnaryToken(final UnaryNode unaryToken, final Map data) { if (unaryToken.getDataType().equals(DataType.BOOLEAN)) { return (boolean) unaryToken.getValue(); } - final Object fieldData = ValueUtils.getValueFromMap(unaryToken.getValue().toString(), data).orElseThrow(DataNotFoundException::new); + final Object fieldData = ValueUtils.getValueFromMap(unaryToken.getValue().toString(), data) + .orElseThrow(() -> new DataNotFoundException(unaryToken.getValue().toString())); if (!(fieldData instanceof Boolean)) { throw new InvalidUnaryOperand(); } diff --git a/src/main/java/com/github/sidhant92/boolparser/constant/ContainerDataType.java b/src/main/java/com/github/sidhant92/boolparser/constant/ContainerDataType.java index 98c4e09..5f99aa9 100644 --- a/src/main/java/com/github/sidhant92/boolparser/constant/ContainerDataType.java +++ b/src/main/java/com/github/sidhant92/boolparser/constant/ContainerDataType.java @@ -10,7 +10,6 @@ import com.github.sidhant92.boolparser.exception.InvalidDataType; import lombok.AllArgsConstructor; import lombok.Getter; -import lombok.extern.slf4j.Slf4j; /** * @author sidhant.aggarwal @@ -18,14 +17,12 @@ */ @Getter @AllArgsConstructor -@Slf4j public enum ContainerDataType { PRIMITIVE() { @Override public Optional getValue(final DataType dataType, final Object value) { final Optional result = DataTypeFactory.getDataType(dataType).getValue(value); if (!result.isPresent()) { - log.error("Invalid data type for value {} for data type {}", value.toString(), dataType.name()); throw new InvalidDataType(String.format("Invalid data type for value %s for data type %s", value, dataType.name())); } return result; diff --git a/src/main/java/com/github/sidhant92/boolparser/constant/DataType.java b/src/main/java/com/github/sidhant92/boolparser/constant/DataType.java index 6c216a2..c3e44b4 100644 --- a/src/main/java/com/github/sidhant92/boolparser/constant/DataType.java +++ b/src/main/java/com/github/sidhant92/boolparser/constant/DataType.java @@ -1,14 +1,23 @@ package com.github.sidhant92.boolparser.constant; +import lombok.AllArgsConstructor; + /** * @author sidhant.aggarwal * @since 05/03/2023 */ +@AllArgsConstructor public enum DataType { - STRING, - INTEGER, - LONG, - DECIMAL, - VERSION, - BOOLEAN + STRING(8, false), + INTEGER(3, true), + LONG(4, true), + DECIMAL(5, true), + VERSION(2, true), + BOOLEAN(1, false), + DATE(6, false), + DATETIME(7, false); + + public final int priority; + + public final boolean numeric; } diff --git a/src/main/java/com/github/sidhant92/boolparser/constant/FunctionType.java b/src/main/java/com/github/sidhant92/boolparser/constant/FunctionType.java new file mode 100644 index 0000000..d47ff4b --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/constant/FunctionType.java @@ -0,0 +1,29 @@ +package com.github.sidhant92.boolparser.constant; + +import java.util.Arrays; +import java.util.Optional; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public enum FunctionType { + MIN, + MAX, + AVG, + SUM, + MEAN, + MODE, + MEDIAN, + INT, + LEN, + DAYS_ELAPSED; + + public static Optional getArrayFunctionFromSymbol(final String symbol) { + final String symbolUpperCase = symbol.toUpperCase(); + return Arrays + .stream(FunctionType.values()) + .filter(function -> function.name().equals(symbolUpperCase)) + .findFirst(); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/constant/NodeType.java b/src/main/java/com/github/sidhant92/boolparser/constant/NodeType.java index 7625f19..efe5169 100644 --- a/src/main/java/com/github/sidhant92/boolparser/constant/NodeType.java +++ b/src/main/java/com/github/sidhant92/boolparser/constant/NodeType.java @@ -10,5 +10,8 @@ public enum NodeType { NUMERIC_RANGE, IN, ARRAY, - UNARY + UNARY, + FIELD, + ARITHMETIC, + ARITHMETIC_FUNCTION } diff --git a/src/main/java/com/github/sidhant92/boolparser/constant/Operator.java b/src/main/java/com/github/sidhant92/boolparser/constant/Operator.java index 170e7d7..2ec58fd 100644 --- a/src/main/java/com/github/sidhant92/boolparser/constant/Operator.java +++ b/src/main/java/com/github/sidhant92/boolparser/constant/Operator.java @@ -1,7 +1,9 @@ package com.github.sidhant92.boolparser.constant; +import java.util.Arrays; +import java.util.List; import java.util.Optional; -import com.github.sidhant92.boolparser.operator.AbstractOperator; +import com.github.sidhant92.boolparser.operator.comparison.AbstractOperator; import com.github.sidhant92.boolparser.operator.OperatorFactory; import lombok.AccessLevel; import lombok.AllArgsConstructor; @@ -21,15 +23,36 @@ public enum Operator { LESS_THAN_EQUAL, NOT_EQUAL, IN, + + ADD, + SUBTRACT, + MULTIPLY, + DIVIDE, + MODULUS, + EXPONENT, + UNARY, + CONTAINS_ALL, CONTAINS_ANY; public static Optional getOperatorFromSymbol(final String symbol) { final String symbolLowerCase = symbol.toLowerCase(); - return OperatorFactory.getAllOperators() + final Optional operator = OperatorFactory.getAllLogicalOperators() .stream() - .filter(operator -> operator.getSymbol().toLowerCase().equals(symbolLowerCase)) + .filter(op -> op.getSymbol().toLowerCase().equals(symbolLowerCase)) .map(AbstractOperator::getOperator) .findFirst(); + if (operator.isPresent()) { + return operator; + } + return OperatorFactory.getAllArithmeticOperators() + .stream() + .filter(op -> op.getSymbol().toLowerCase().equals(symbolLowerCase)) + .map(com.github.sidhant92.boolparser.operator.arithmetic.AbstractOperator::getOperator) + .findFirst(); + } + + public static List getEqualityOperators() { + return Arrays.asList(EQUALS, NOT_EQUAL); } } diff --git a/src/main/java/com/github/sidhant92/boolparser/datatype/AbstractDataType.java b/src/main/java/com/github/sidhant92/boolparser/datatype/AbstractDataType.java index 0a3c22d..bdc8cd4 100644 --- a/src/main/java/com/github/sidhant92/boolparser/datatype/AbstractDataType.java +++ b/src/main/java/com/github/sidhant92/boolparser/datatype/AbstractDataType.java @@ -1,15 +1,12 @@ package com.github.sidhant92.boolparser.datatype; import java.util.Optional; -import com.fasterxml.jackson.databind.ObjectMapper; import com.github.sidhant92.boolparser.constant.DataType; -import lombok.extern.slf4j.Slf4j; /** * @author sidhant.aggarwal * @since 05/03/2023 */ -@Slf4j public abstract class AbstractDataType> { private final Class clazz; @@ -17,33 +14,17 @@ public AbstractDataType(final Class clazz) { this.clazz = clazz; } - protected boolean defaultIsValid(final Object value, final ObjectMapper objectMapper) { - return defaultIsValid(value, objectMapper, false); + protected boolean defaultIsValid(final Object value) { + return defaultIsValid(value, false); } - protected boolean defaultIsValid(final Object value, final ObjectMapper objectMapper, final boolean useStrictValidation) { - try { - if (clazz.isInstance(value)) { - return true; - } - if (useStrictValidation) { - return false; - } - return objectMapper.convertValue(value, clazz) != null; - } catch (final Exception ex) { - log.error("Unable to convert value = {} to type = {}", value, clazz); - } - return false; + protected boolean defaultIsValid(final Object value, final boolean useStrictValidation) { + return clazz.isInstance(value); } - protected Optional defaultGetValue(final Object value, final ObjectMapper objectMapper) { - try { - if (clazz.isInstance(value)) { - return Optional.of(clazz.cast(value)); - } - return Optional.of(objectMapper.convertValue(value, clazz)); - } catch (final Exception ex) { - log.error("Unable to convert value = {} to type = {}", value, clazz); + protected Optional defaultGetValue(final Object value) { + if (clazz.isInstance(value)) { + return Optional.of(clazz.cast(value)); } return Optional.empty(); } diff --git a/src/main/java/com/github/sidhant92/boolparser/datatype/BooleanDataType.java b/src/main/java/com/github/sidhant92/boolparser/datatype/BooleanDataType.java index 28ce325..2384f64 100644 --- a/src/main/java/com/github/sidhant92/boolparser/datatype/BooleanDataType.java +++ b/src/main/java/com/github/sidhant92/boolparser/datatype/BooleanDataType.java @@ -1,7 +1,6 @@ package com.github.sidhant92.boolparser.datatype; import java.util.Optional; -import com.fasterxml.jackson.databind.ObjectMapper; import com.github.sidhant92.boolparser.constant.DataType; /** @@ -9,11 +8,8 @@ * @since 05/03/2023 */ public class BooleanDataType extends AbstractDataType { - private final ObjectMapper objectMapper; - - public BooleanDataType(final ObjectMapper objectMapper) { + public BooleanDataType() { super(Boolean.class); - this.objectMapper = objectMapper; } @Override @@ -23,16 +19,31 @@ public DataType getDataType() { @Override public boolean isValid(final Object value) { - return super.defaultIsValid(value, objectMapper); + boolean isValid = super.defaultIsValid(value); + if (!isValid) { + final String lowercase = value.toString().toLowerCase(); + return lowercase.equals("true") || lowercase.equals("false"); + } + return true; } @Override public boolean isValid(final Object value, final boolean useStrictValidation) { - return super.defaultIsValid(value, objectMapper, useStrictValidation); + if (!useStrictValidation) { + return isValid(value); + } + return super.defaultIsValid(value); } @Override public Optional getValue(Object value) { - return defaultGetValue(value, objectMapper); + final Optional result = defaultGetValue(value); + if (result.isPresent()) { + return result; + } + if (this.isValid(value)) { + return Optional.of(Boolean.parseBoolean(value.toString())); + } + return Optional.empty(); } } diff --git a/src/main/java/com/github/sidhant92/boolparser/datatype/DataTypeFactory.java b/src/main/java/com/github/sidhant92/boolparser/datatype/DataTypeFactory.java index d165e3f..db19a1f 100644 --- a/src/main/java/com/github/sidhant92/boolparser/datatype/DataTypeFactory.java +++ b/src/main/java/com/github/sidhant92/boolparser/datatype/DataTypeFactory.java @@ -2,7 +2,6 @@ import java.util.EnumMap; import java.util.Map; -import com.fasterxml.jackson.databind.ObjectMapper; import com.github.sidhant92.boolparser.constant.DataType; /** @@ -17,13 +16,14 @@ private DataTypeFactory() { } public static void initialize() { - final ObjectMapper objectMapper = new ObjectMapper(); - abstractDataTypeMap.put(DataType.STRING, new StringDataType(objectMapper)); - abstractDataTypeMap.put(DataType.INTEGER, new IntegerDataType(objectMapper)); - abstractDataTypeMap.put(DataType.DECIMAL, new DecimalDataType(objectMapper)); - abstractDataTypeMap.put(DataType.LONG, new LongDataType(objectMapper)); - abstractDataTypeMap.put(DataType.VERSION, new VersionDataType(objectMapper)); - abstractDataTypeMap.put(DataType.BOOLEAN, new BooleanDataType(objectMapper)); + abstractDataTypeMap.put(DataType.STRING, new StringDataType()); + abstractDataTypeMap.put(DataType.INTEGER, new IntegerDataType()); + abstractDataTypeMap.put(DataType.DECIMAL, new DecimalDataType()); + abstractDataTypeMap.put(DataType.LONG, new LongDataType()); + abstractDataTypeMap.put(DataType.VERSION, new VersionDataType()); + abstractDataTypeMap.put(DataType.BOOLEAN, new BooleanDataType()); + abstractDataTypeMap.put(DataType.DATE, new DateDataType()); + abstractDataTypeMap.put(DataType.DATETIME, new DateTimeDataType()); } public static AbstractDataType getDataType(final DataType dataType) { diff --git a/src/main/java/com/github/sidhant92/boolparser/datatype/DateDataType.java b/src/main/java/com/github/sidhant92/boolparser/datatype/DateDataType.java new file mode 100644 index 0000000..999e616 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/datatype/DateDataType.java @@ -0,0 +1,58 @@ +package com.github.sidhant92.boolparser.datatype; + +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeParseException; +import java.util.Optional; +import com.github.sidhant92.boolparser.constant.DataType; + +/** + * @author sidhant.aggarwal + * @since 05/03/2023 + */ +public class DateDataType extends AbstractDataType { + private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + + public DateDataType() { + super(LocalDate.class); + } + + @Override + public DataType getDataType() { + return DataType.DATE; + } + + @Override + public boolean isValid(final Object value) { + boolean isValid = super.defaultIsValid(value); + if (!isValid) { + return parseDate(value.toString()).isPresent(); + } + return true; + } + + @Override + public boolean isValid(final Object value, final boolean useStrictValidation) { + if (!useStrictValidation) { + return isValid(value); + } + return super.defaultIsValid(value); + } + + @Override + public Optional getValue(Object value) { + final Optional result = defaultGetValue(value); + if (result.isPresent()) { + return result; + } + return parseDate(value.toString()); + } + + private Optional parseDate(String dateString) { + try { + return Optional.of(LocalDate.parse(dateString, DATE_FORMATTER)); + } catch (DateTimeParseException ignored) { + return Optional.empty(); + } + } +} \ No newline at end of file diff --git a/src/main/java/com/github/sidhant92/boolparser/datatype/DateTimeDataType.java b/src/main/java/com/github/sidhant92/boolparser/datatype/DateTimeDataType.java new file mode 100644 index 0000000..3418b46 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/datatype/DateTimeDataType.java @@ -0,0 +1,58 @@ +package com.github.sidhant92.boolparser.datatype; + +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeParseException; +import java.util.Optional; +import com.github.sidhant92.boolparser.constant.DataType; + +/** + * @author sidhant.aggarwal + * @since 05/03/2023 + */ +public class DateTimeDataType extends AbstractDataType { + private static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + + public DateTimeDataType() { + super(LocalDateTime.class); + } + + @Override + public DataType getDataType() { + return DataType.DATETIME; + } + + @Override + public boolean isValid(final Object value) { + boolean isValid = super.defaultIsValid(value); + if (!isValid) { + return parseDateTime(value.toString()).isPresent(); + } + return true; + } + + @Override + public boolean isValid(final Object value, final boolean useStrictValidation) { + if (!useStrictValidation) { + return isValid(value); + } + return super.defaultIsValid(value); + } + + @Override + public Optional getValue(Object value) { + final Optional result = defaultGetValue(value); + if (result.isPresent()) { + return result; + } + return parseDateTime(value.toString()); + } + + private Optional parseDateTime(String dateTimeString) { + try { + return Optional.of(LocalDateTime.parse(dateTimeString, DATETIME_FORMATTER)); + } catch (DateTimeParseException ignored) { + return Optional.empty(); + } + } +} \ No newline at end of file diff --git a/src/main/java/com/github/sidhant92/boolparser/datatype/DecimalDataType.java b/src/main/java/com/github/sidhant92/boolparser/datatype/DecimalDataType.java index 0b11cb5..0ef884c 100644 --- a/src/main/java/com/github/sidhant92/boolparser/datatype/DecimalDataType.java +++ b/src/main/java/com/github/sidhant92/boolparser/datatype/DecimalDataType.java @@ -1,19 +1,16 @@ package com.github.sidhant92.boolparser.datatype; +import java.math.BigDecimal; import java.util.Optional; -import com.fasterxml.jackson.databind.ObjectMapper; import com.github.sidhant92.boolparser.constant.DataType; /** * @author sidhant.aggarwal * @since 05/03/2023 */ -public class DecimalDataType extends AbstractDataType { - private final ObjectMapper objectMapper; - - public DecimalDataType(final ObjectMapper objectMapper) { - super(Double.class); - this.objectMapper = objectMapper; +public class DecimalDataType extends AbstractDataType { + public DecimalDataType() { + super(BigDecimal.class); } @Override @@ -23,16 +20,36 @@ public DataType getDataType() { @Override public boolean isValid(final Object value) { - return super.defaultIsValid(value, objectMapper); + boolean isValid = super.defaultIsValid(value); + if (!isValid) { + try { + new BigDecimal(value.toString()); + return true; + } catch (Exception ex) { + return false; + } + } + return true; } @Override public boolean isValid(final Object value, final boolean useStrictValidation) { - return super.defaultIsValid(value, objectMapper, useStrictValidation); + if (!useStrictValidation) { + return isValid(value); + } + return super.defaultIsValid(value); } @Override - public Optional getValue(Object value) { - return defaultGetValue(value, objectMapper); + public Optional getValue(Object value) { + final Optional result = defaultGetValue(value); + if (result.isPresent()) { + return result; + } + try { + return Optional.of(new BigDecimal(value.toString())); + } catch (final Exception ignored) { + } + return Optional.empty(); } } diff --git a/src/main/java/com/github/sidhant92/boolparser/datatype/IntegerDataType.java b/src/main/java/com/github/sidhant92/boolparser/datatype/IntegerDataType.java index 3195abe..9dcaa8b 100644 --- a/src/main/java/com/github/sidhant92/boolparser/datatype/IntegerDataType.java +++ b/src/main/java/com/github/sidhant92/boolparser/datatype/IntegerDataType.java @@ -1,7 +1,7 @@ package com.github.sidhant92.boolparser.datatype; +import java.math.BigDecimal; import java.util.Optional; -import com.fasterxml.jackson.databind.ObjectMapper; import com.github.sidhant92.boolparser.constant.DataType; /** @@ -9,11 +9,8 @@ * @since 05/03/2023 */ public class IntegerDataType extends AbstractDataType { - private final ObjectMapper objectMapper; - - public IntegerDataType(final ObjectMapper objectMapper) { + public IntegerDataType() { super(Integer.class); - this.objectMapper = objectMapper; } @Override @@ -23,16 +20,38 @@ public DataType getDataType() { @Override public boolean isValid(final Object value) { - return super.defaultIsValid(value, objectMapper); + boolean isValid = super.defaultIsValid(value); + if (!isValid) { + try { + BigDecimal number = new BigDecimal(value.toString()); + Integer.parseInt(number.stripTrailingZeros().toPlainString()); + return true; + } catch (Exception ex) { + return false; + } + } + return true; } @Override public boolean isValid(final Object value, final boolean useStrictValidation) { - return super.defaultIsValid(value, objectMapper, useStrictValidation); + if (!useStrictValidation) { + return isValid(value); + } + return super.defaultIsValid(value); } @Override public Optional getValue(Object value) { - return defaultGetValue(value, objectMapper); + final Optional result = defaultGetValue(value); + if (result.isPresent()) { + return result; + } + try { + BigDecimal number = new BigDecimal(value.toString()); + return Optional.of(Integer.parseInt(number.stripTrailingZeros().toPlainString())); + } catch (final Exception ignored) { + } + return Optional.empty(); } } diff --git a/src/main/java/com/github/sidhant92/boolparser/datatype/LongDataType.java b/src/main/java/com/github/sidhant92/boolparser/datatype/LongDataType.java index 7623dec..d68e242 100644 --- a/src/main/java/com/github/sidhant92/boolparser/datatype/LongDataType.java +++ b/src/main/java/com/github/sidhant92/boolparser/datatype/LongDataType.java @@ -1,7 +1,7 @@ package com.github.sidhant92.boolparser.datatype; +import java.math.BigDecimal; import java.util.Optional; -import com.fasterxml.jackson.databind.ObjectMapper; import com.github.sidhant92.boolparser.constant.DataType; /** @@ -9,11 +9,8 @@ * @since 05/03/2023 */ public class LongDataType extends AbstractDataType { - private final ObjectMapper objectMapper; - - public LongDataType(final ObjectMapper objectMapper) { + public LongDataType() { super(Long.class); - this.objectMapper = objectMapper; } @Override @@ -23,16 +20,38 @@ public DataType getDataType() { @Override public boolean isValid(final Object value) { - return super.defaultIsValid(value, objectMapper); + boolean isValid = super.defaultIsValid(value); + if (!isValid) { + try { + BigDecimal number = new BigDecimal(value.toString()); + Long.parseLong(number.stripTrailingZeros().toPlainString()); + return true; + } catch (Exception ex) { + return false; + } + } + return true; } @Override public boolean isValid(final Object value, final boolean useStrictValidation) { - return super.defaultIsValid(value, objectMapper, useStrictValidation); + if (!useStrictValidation) { + return isValid(value); + } + return super.defaultIsValid(value); } @Override public Optional getValue(Object value) { - return defaultGetValue(value, objectMapper); + final Optional result = defaultGetValue(value); + if (result.isPresent()) { + return result; + } + try { + BigDecimal number = new BigDecimal(value.toString()); + return Optional.of(Long.parseLong(number.stripTrailingZeros().toPlainString())); + } catch (final Exception ignored) { + } + return Optional.empty(); } } diff --git a/src/main/java/com/github/sidhant92/boolparser/datatype/StringDataType.java b/src/main/java/com/github/sidhant92/boolparser/datatype/StringDataType.java index 195c991..91f8d21 100644 --- a/src/main/java/com/github/sidhant92/boolparser/datatype/StringDataType.java +++ b/src/main/java/com/github/sidhant92/boolparser/datatype/StringDataType.java @@ -1,7 +1,6 @@ package com.github.sidhant92.boolparser.datatype; import java.util.Optional; -import com.fasterxml.jackson.databind.ObjectMapper; import com.github.sidhant92.boolparser.constant.DataType; /** @@ -9,11 +8,8 @@ * @since 05/03/2023 */ public class StringDataType extends AbstractDataType { - private final ObjectMapper objectMapper; - - public StringDataType(final ObjectMapper objectMapper) { + public StringDataType() { super(String.class); - this.objectMapper = objectMapper; } @Override @@ -23,16 +19,23 @@ public DataType getDataType() { @Override public boolean isValid(final Object value) { - return super.defaultIsValid(value, objectMapper); + return true; } @Override public boolean isValid(final Object value, final boolean useStrictValidation) { - return super.defaultIsValid(value, objectMapper, useStrictValidation); + if (!useStrictValidation) { + return isValid(value); + } + return super.defaultIsValid(value); } @Override public Optional getValue(Object value) { - return defaultGetValue(value, objectMapper); + final Optional result = defaultGetValue(value); + if (result.isPresent()) { + return result; + } + return Optional.of(value.toString()); } } diff --git a/src/main/java/com/github/sidhant92/boolparser/datatype/VersionDataType.java b/src/main/java/com/github/sidhant92/boolparser/datatype/VersionDataType.java index 4069148..aeaa782 100644 --- a/src/main/java/com/github/sidhant92/boolparser/datatype/VersionDataType.java +++ b/src/main/java/com/github/sidhant92/boolparser/datatype/VersionDataType.java @@ -2,7 +2,6 @@ import java.util.Optional; import org.apache.maven.artifact.versioning.ComparableVersion; -import com.fasterxml.jackson.databind.ObjectMapper; import com.github.sidhant92.boolparser.constant.DataType; /** @@ -10,11 +9,8 @@ * @since 05/03/2023 */ public class VersionDataType extends AbstractDataType { - private final ObjectMapper objectMapper; - - public VersionDataType(final ObjectMapper objectMapper) { + public VersionDataType() { super(ComparableVersion.class); - this.objectMapper = objectMapper; } @Override @@ -24,16 +20,36 @@ public DataType getDataType() { @Override public boolean isValid(final Object value) { - return super.defaultIsValid(value, objectMapper); + boolean isValid = super.defaultIsValid(value); + if (!isValid) { + try { + new ComparableVersion(value.toString()); + return true; + } catch (Exception ex) { + return false; + } + } + return true; } @Override public boolean isValid(final Object value, final boolean useStrictValidation) { - return super.defaultIsValid(value, objectMapper, useStrictValidation); + if (!useStrictValidation) { + return isValid(value); + } + return super.defaultIsValid(value); } @Override public Optional getValue(Object value) { - return defaultGetValue(value, objectMapper); + final Optional result = defaultGetValue(value); + if (result.isPresent()) { + return result; + } + try { + return Optional.of(new ComparableVersion(value.toString())); + } catch (final Exception ignored) { + } + return Optional.empty(); } } diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/EvaluatedNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/EvaluatedNode.java new file mode 100644 index 0000000..23babda --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/domain/EvaluatedNode.java @@ -0,0 +1,17 @@ +package com.github.sidhant92.boolparser.domain; + +import com.github.sidhant92.boolparser.constant.DataType; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; + +@AllArgsConstructor +@Getter +@Setter +@Builder +public class EvaluatedNode { + private final DataType dataType; + + private final Object value; +} diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/FieldNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/FieldNode.java new file mode 100644 index 0000000..2f9b214 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/domain/FieldNode.java @@ -0,0 +1,25 @@ +package com.github.sidhant92.boolparser.domain; + +import com.github.sidhant92.boolparser.constant.NodeType; +import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticBaseNode; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; + +@AllArgsConstructor +@Getter +@Setter +@Builder +public class FieldNode extends ArithmeticBaseNode { + private final String field; + + @Override + public NodeType getTokenType() { + return NodeType.FIELD; + } + + public boolean isNull() { + return this.field.equalsIgnoreCase("null"); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticBaseNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticBaseNode.java new file mode 100644 index 0000000..35fc90d --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticBaseNode.java @@ -0,0 +1,9 @@ +package com.github.sidhant92.boolparser.domain.arithmetic; + +import com.github.sidhant92.boolparser.domain.logical.Node; + +/** + * @author sidhant.aggarwal + * @since 16/03/2024 + */ +public abstract class ArithmeticBaseNode extends Node {} diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticFunctionNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticFunctionNode.java new file mode 100644 index 0000000..6e94661 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticFunctionNode.java @@ -0,0 +1,31 @@ +package com.github.sidhant92.boolparser.domain.arithmetic; + +import java.util.List; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.constant.NodeType; +import com.github.sidhant92.boolparser.domain.logical.Node; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +@AllArgsConstructor +@Getter +@Setter +@Builder +public class ArithmeticFunctionNode extends ArithmeticBaseNode { + private FunctionType functionType; + + + private final List items; + + + @Override + public NodeType getTokenType() { + return NodeType.ARITHMETIC_FUNCTION; + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticNode.java new file mode 100644 index 0000000..3a57e7e --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/ArithmeticNode.java @@ -0,0 +1,30 @@ +package com.github.sidhant92.boolparser.domain.arithmetic; + +import com.github.sidhant92.boolparser.constant.NodeType; +import com.github.sidhant92.boolparser.constant.Operator; +import com.github.sidhant92.boolparser.domain.logical.Node; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; + +/** + * @author sidhant.aggarwal + * @since 15/03/2024 + */ +@AllArgsConstructor +@Getter +@Setter +@Builder +public class ArithmeticNode extends ArithmeticBaseNode { + private Node left; + + private Node right; + + private final Operator operator; + + @Override + public NodeType getTokenType() { + return NodeType.ARITHMETIC; + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/UnaryNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/UnaryNode.java similarity index 79% rename from src/main/java/com/github/sidhant92/boolparser/domain/UnaryNode.java rename to src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/UnaryNode.java index 52b32cc..e37865f 100644 --- a/src/main/java/com/github/sidhant92/boolparser/domain/UnaryNode.java +++ b/src/main/java/com/github/sidhant92/boolparser/domain/arithmetic/UnaryNode.java @@ -1,4 +1,4 @@ -package com.github.sidhant92.boolparser.domain; +package com.github.sidhant92.boolparser.domain.arithmetic; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.NodeType; @@ -11,7 +11,7 @@ @Getter @Setter @Builder -public class UnaryNode extends Node { +public class UnaryNode extends ArithmeticBaseNode { private final DataType dataType; private final Object value; diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/ArrayNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/logical/ArrayNode.java similarity index 70% rename from src/main/java/com/github/sidhant92/boolparser/domain/ArrayNode.java rename to src/main/java/com/github/sidhant92/boolparser/domain/logical/ArrayNode.java index 06fd7f7..7117014 100644 --- a/src/main/java/com/github/sidhant92/boolparser/domain/ArrayNode.java +++ b/src/main/java/com/github/sidhant92/boolparser/domain/logical/ArrayNode.java @@ -1,8 +1,6 @@ -package com.github.sidhant92.boolparser.domain; +package com.github.sidhant92.boolparser.domain.logical; import java.util.List; -import org.apache.commons.lang3.tuple.Pair; -import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.NodeType; import com.github.sidhant92.boolparser.constant.Operator; import lombok.AllArgsConstructor; @@ -19,7 +17,7 @@ public class ArrayNode extends Node { private final Operator operator; - private final List> items; + private final List items; @Override public NodeType getTokenType() { return NodeType.ARRAY; diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/BooleanNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/logical/BooleanNode.java similarity index 90% rename from src/main/java/com/github/sidhant92/boolparser/domain/BooleanNode.java rename to src/main/java/com/github/sidhant92/boolparser/domain/logical/BooleanNode.java index b3590c8..6ffe5cf 100644 --- a/src/main/java/com/github/sidhant92/boolparser/domain/BooleanNode.java +++ b/src/main/java/com/github/sidhant92/boolparser/domain/logical/BooleanNode.java @@ -1,4 +1,4 @@ -package com.github.sidhant92.boolparser.domain; +package com.github.sidhant92.boolparser.domain.logical; import com.github.sidhant92.boolparser.constant.NodeType; import com.github.sidhant92.boolparser.constant.LogicalOperationType; diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/ComparisonNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/logical/ComparisonNode.java similarity index 58% rename from src/main/java/com/github/sidhant92/boolparser/domain/ComparisonNode.java rename to src/main/java/com/github/sidhant92/boolparser/domain/logical/ComparisonNode.java index 9638cb8..74e39c9 100644 --- a/src/main/java/com/github/sidhant92/boolparser/domain/ComparisonNode.java +++ b/src/main/java/com/github/sidhant92/boolparser/domain/logical/ComparisonNode.java @@ -1,8 +1,9 @@ -package com.github.sidhant92.boolparser.domain; +package com.github.sidhant92.boolparser.domain.logical; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.NodeType; import com.github.sidhant92.boolparser.constant.Operator; +import com.github.sidhant92.boolparser.domain.FieldNode; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Getter; @@ -17,9 +18,9 @@ @Setter @Builder public class ComparisonNode extends Node { - private final String field; + private final Node left; - private final Object value; + private final Node right; private final Operator operator; @@ -29,4 +30,8 @@ public class ComparisonNode extends Node { public NodeType getTokenType() { return NodeType.COMPARISON; } + + public boolean isNullCheck() { + return Operator.getEqualityOperators().contains(this.operator) && (this.right instanceof FieldNode && ((FieldNode) this.right).isNull() || this.left instanceof FieldNode && ((FieldNode) this.left).isNull()); + } } diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/InNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/logical/InNode.java similarity index 65% rename from src/main/java/com/github/sidhant92/boolparser/domain/InNode.java rename to src/main/java/com/github/sidhant92/boolparser/domain/logical/InNode.java index 188e305..225360a 100644 --- a/src/main/java/com/github/sidhant92/boolparser/domain/InNode.java +++ b/src/main/java/com/github/sidhant92/boolparser/domain/logical/InNode.java @@ -1,8 +1,6 @@ -package com.github.sidhant92.boolparser.domain; +package com.github.sidhant92.boolparser.domain.logical; import java.util.List; -import org.apache.commons.lang3.tuple.Pair; -import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.NodeType; import lombok.AllArgsConstructor; import lombok.Builder; @@ -16,7 +14,7 @@ public class InNode extends Node { private final String field; - private final List> items; + private final List items; @Override public NodeType getTokenType() { return NodeType.IN; diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/Node.java b/src/main/java/com/github/sidhant92/boolparser/domain/logical/Node.java similarity index 77% rename from src/main/java/com/github/sidhant92/boolparser/domain/Node.java rename to src/main/java/com/github/sidhant92/boolparser/domain/logical/Node.java index adb44ac..14ff7ca 100644 --- a/src/main/java/com/github/sidhant92/boolparser/domain/Node.java +++ b/src/main/java/com/github/sidhant92/boolparser/domain/logical/Node.java @@ -1,4 +1,4 @@ -package com.github.sidhant92.boolparser.domain; +package com.github.sidhant92.boolparser.domain.logical; import com.github.sidhant92.boolparser.constant.NodeType; diff --git a/src/main/java/com/github/sidhant92/boolparser/domain/NumericRangeNode.java b/src/main/java/com/github/sidhant92/boolparser/domain/logical/NumericRangeNode.java similarity index 92% rename from src/main/java/com/github/sidhant92/boolparser/domain/NumericRangeNode.java rename to src/main/java/com/github/sidhant92/boolparser/domain/logical/NumericRangeNode.java index 888a309..8be8dcd 100644 --- a/src/main/java/com/github/sidhant92/boolparser/domain/NumericRangeNode.java +++ b/src/main/java/com/github/sidhant92/boolparser/domain/logical/NumericRangeNode.java @@ -1,4 +1,4 @@ -package com.github.sidhant92.boolparser.domain; +package com.github.sidhant92.boolparser.domain.logical; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.NodeType; diff --git a/src/main/java/com/github/sidhant92/boolparser/exception/DataNotFoundException.java b/src/main/java/com/github/sidhant92/boolparser/exception/DataNotFoundException.java index ceca473..ad9fecd 100644 --- a/src/main/java/com/github/sidhant92/boolparser/exception/DataNotFoundException.java +++ b/src/main/java/com/github/sidhant92/boolparser/exception/DataNotFoundException.java @@ -1,8 +1,9 @@ package com.github.sidhant92.boolparser.exception; public class DataNotFoundException extends RuntimeException { - @Override - public String getMessage() { - return "Data not found"; + private static final String MESSAGE = "Data not found"; + + public DataNotFoundException(final String key) { + super(String.format(MESSAGE + " for the key %s", key)); } } diff --git a/src/main/java/com/github/sidhant92/boolparser/exception/InvalidContainerTypeException.java b/src/main/java/com/github/sidhant92/boolparser/exception/InvalidContainerTypeException.java index 4e1b292..f441197 100644 --- a/src/main/java/com/github/sidhant92/boolparser/exception/InvalidContainerTypeException.java +++ b/src/main/java/com/github/sidhant92/boolparser/exception/InvalidContainerTypeException.java @@ -8,9 +8,4 @@ public InvalidContainerTypeException(final String message) { public InvalidContainerTypeException() { super(); } - - @Override - public String getMessage() { - return "Invalid Container Type"; - } } diff --git a/src/main/java/com/github/sidhant92/boolparser/exception/InvalidDataType.java b/src/main/java/com/github/sidhant92/boolparser/exception/InvalidDataType.java index 81a5a5d..be71694 100644 --- a/src/main/java/com/github/sidhant92/boolparser/exception/InvalidDataType.java +++ b/src/main/java/com/github/sidhant92/boolparser/exception/InvalidDataType.java @@ -8,9 +8,4 @@ public InvalidDataType(final String message) { public InvalidDataType() { super(); } - - @Override - public String getMessage() { - return "Invalid Data Type"; - } } diff --git a/src/main/java/com/github/sidhant92/boolparser/exception/InvalidExpressionException.java b/src/main/java/com/github/sidhant92/boolparser/exception/InvalidExpressionException.java index 84c7849..353ad4f 100644 --- a/src/main/java/com/github/sidhant92/boolparser/exception/InvalidExpressionException.java +++ b/src/main/java/com/github/sidhant92/boolparser/exception/InvalidExpressionException.java @@ -1,8 +1,7 @@ package com.github.sidhant92.boolparser.exception; public class InvalidExpressionException extends RuntimeException { - @Override - public String getMessage() { - return "Invalid Expression"; + public InvalidExpressionException(final String message) { + super(message); } } diff --git a/src/main/java/com/github/sidhant92/boolparser/exception/InvalidFunctionArgument.java b/src/main/java/com/github/sidhant92/boolparser/exception/InvalidFunctionArgument.java new file mode 100644 index 0000000..7aafd4d --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/exception/InvalidFunctionArgument.java @@ -0,0 +1,11 @@ +package com.github.sidhant92.boolparser.exception; + +public class InvalidFunctionArgument extends RuntimeException { + public InvalidFunctionArgument(final String message) { + super(message); + } + + public InvalidFunctionArgument() { + super(); + } +} \ No newline at end of file diff --git a/src/main/java/com/github/sidhant92/boolparser/exception/UnsupportedToken.java b/src/main/java/com/github/sidhant92/boolparser/exception/UnsupportedToken.java new file mode 100644 index 0000000..545b461 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/exception/UnsupportedToken.java @@ -0,0 +1,13 @@ +package com.github.sidhant92.boolparser.exception; + +public class UnsupportedToken extends RuntimeException { + private static final String MESSAGE = "Unsupported Token"; + + public UnsupportedToken(final String token) { + super(String.format(MESSAGE + " %s", token)); + } + + public UnsupportedToken() { + super(); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/FunctionEvaluatorService.java b/src/main/java/com/github/sidhant92/boolparser/function/FunctionEvaluatorService.java new file mode 100644 index 0000000..83d10e2 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/FunctionEvaluatorService.java @@ -0,0 +1,47 @@ +package com.github.sidhant92.boolparser.function; + +import java.util.List; +import org.apache.commons.lang3.tuple.Pair; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.exception.InvalidContainerTypeException; +import com.github.sidhant92.boolparser.exception.InvalidDataType; +import com.github.sidhant92.boolparser.exception.InvalidExpressionException; +import com.github.sidhant92.boolparser.function.arithmetic.AbstractFunction; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public class FunctionEvaluatorService { + public FunctionEvaluatorService() { + FunctionFactory.initialize(); + } + + public Object evaluateArithmeticFunction(final FunctionType functionType, final List items) { + final AbstractFunction abstractFunction = FunctionFactory.getArithmeticFunction(functionType); + if (items.isEmpty()) { + throw new InvalidExpressionException("Empty items not allowed"); + } + final ContainerDataType containerDataType = items.size() > 1 ? ContainerDataType.LIST : ContainerDataType.PRIMITIVE; + if (!abstractFunction.getAllowedContainerTypes().contains(containerDataType)) { + throw new InvalidContainerTypeException( + String.format("Invalid container type %s for function %s", containerDataType, functionType.name())); + } + final boolean validDataType = items + .stream().allMatch(item -> abstractFunction.getAllowedDataTypes().contains(item.getDataType())); + if (!validDataType) { + throw new InvalidDataType(String.format("Invalid data type for function %s", functionType.name())); + } + + items.forEach(item -> { + if (!ContainerDataType.PRIMITIVE.isValid(item.getDataType(), item.getValue())) { + throw new InvalidDataType( + String.format("Validation failed for the function %s for the operand %s", functionType.name(), item.getValue())); + } + }); + return abstractFunction.evaluate(items); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/FunctionFactory.java b/src/main/java/com/github/sidhant92/boolparser/function/FunctionFactory.java new file mode 100644 index 0000000..6abfdf4 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/FunctionFactory.java @@ -0,0 +1,45 @@ +package com.github.sidhant92.boolparser.function; + +import java.util.EnumMap; +import java.util.Map; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.function.arithmetic.AbstractFunction; +import com.github.sidhant92.boolparser.function.arithmetic.AvgFunction; +import com.github.sidhant92.boolparser.function.arithmetic.DaysElapsedFunction; +import com.github.sidhant92.boolparser.function.arithmetic.IntFunction; +import com.github.sidhant92.boolparser.function.arithmetic.LenFunction; +import com.github.sidhant92.boolparser.function.arithmetic.MaxFunction; +import com.github.sidhant92.boolparser.function.arithmetic.MeanFunction; +import com.github.sidhant92.boolparser.function.arithmetic.MedianFunction; +import com.github.sidhant92.boolparser.function.arithmetic.MinFunction; +import com.github.sidhant92.boolparser.function.arithmetic.ModeFunction; +import com.github.sidhant92.boolparser.function.arithmetic.SumFunction; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public class FunctionFactory { + private static final Map arithmeticFunctionrMap = new EnumMap<>(FunctionType.class); + + private FunctionFactory() { + super(); + } + + public static void initialize() { + arithmeticFunctionrMap.put(FunctionType.MIN, new MinFunction()); + arithmeticFunctionrMap.put(FunctionType.MAX, new MaxFunction()); + arithmeticFunctionrMap.put(FunctionType.AVG, new AvgFunction()); + arithmeticFunctionrMap.put(FunctionType.SUM, new SumFunction()); + arithmeticFunctionrMap.put(FunctionType.MEAN, new MeanFunction()); + arithmeticFunctionrMap.put(FunctionType.MEDIAN, new MedianFunction()); + arithmeticFunctionrMap.put(FunctionType.MODE, new ModeFunction()); + arithmeticFunctionrMap.put(FunctionType.INT, new IntFunction()); + arithmeticFunctionrMap.put(FunctionType.LEN, new LenFunction()); + arithmeticFunctionrMap.put(FunctionType.DAYS_ELAPSED, new DaysElapsedFunction()); + } + + public static AbstractFunction getArithmeticFunction(final FunctionType functionType) { + return arithmeticFunctionrMap.get(functionType); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/AbstractFunction.java b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/AbstractFunction.java new file mode 100644 index 0000000..07e19df --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/AbstractFunction.java @@ -0,0 +1,23 @@ +package com.github.sidhant92.boolparser.function.arithmetic; + +import java.util.List; +import org.apache.commons.lang3.tuple.Pair; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticFunctionNode; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public abstract class AbstractFunction { + public abstract Object evaluate(final List items); + + public abstract FunctionType getFunctionType(); + + public abstract List getAllowedContainerTypes(); + + public abstract List getAllowedDataTypes(); +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/AvgFunction.java b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/AvgFunction.java new file mode 100644 index 0000000..909c11e --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/AvgFunction.java @@ -0,0 +1,58 @@ +package com.github.sidhant92.boolparser.function.arithmetic; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.datatype.DecimalDataType; +import com.github.sidhant92.boolparser.datatype.LongDataType; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.util.ValueUtils; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public class AvgFunction extends AbstractFunction { + @Override + public Object evaluate(final List items) { + if (items + .stream().anyMatch(a -> a.getDataType().equals(DataType.DECIMAL))) { + final DecimalDataType decimalDataType = (DecimalDataType) DataTypeFactory.getDataType(DataType.DECIMAL); + final List itemsConverted = items + .stream() + .map(item -> decimalDataType.getValue(item.getValue())) + .map(Optional::get) + .collect(Collectors.toList()); + final BigDecimal sum = itemsConverted + .stream().reduce(BigDecimal.ZERO, BigDecimal::add); + return ValueUtils.castDecimal(sum.divide(new BigDecimal(itemsConverted.size()), 3, RoundingMode.DOWN)); + } + final LongDataType longDataType = (LongDataType) DataTypeFactory.getDataType(DataType.LONG); + final long sum = items + .stream().mapToLong(a -> longDataType.getValue(a.getValue()).get()).sum(); + return ValueUtils.castDecimal(new BigDecimal(sum).divide(new BigDecimal(items.size()), 2, RoundingMode.UNNECESSARY)); + } + + @Override + public FunctionType getFunctionType() { + return FunctionType.AVG; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.LIST); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/DaysElapsedFunction.java b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/DaysElapsedFunction.java new file mode 100644 index 0000000..14955ed --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/DaysElapsedFunction.java @@ -0,0 +1,63 @@ +package com.github.sidhant92.boolparser.function.arithmetic; + +import java.time.LocalDate; +import java.time.temporal.ChronoUnit; +import java.util.Arrays; +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.exception.InvalidFunctionArgument; + +/** + * Function to calculate the number of days elapsed since a given date. + * Returns a positive number for dates in the past, negative for dates in the future. + * + * @author sidhant.aggarwal + * @since 05/03/2023 + */ +public class DaysElapsedFunction extends AbstractFunction { + + @Override + public Object evaluate(final List items) { + if (items.size() != 1) { + throw new InvalidFunctionArgument("DAYS_ELAPSED function requires exactly one argument"); + } + + final EvaluatedNode item = items.get(0); + final Object value = item.getValue(); + + LocalDate inputDate; + if (value instanceof LocalDate) { + inputDate = (LocalDate) value; + } else if (value instanceof String) { + // Try to parse string as date if the DataType detection missed it + try { + inputDate = LocalDate.parse((String) value); + } catch (Exception e) { + throw new InvalidFunctionArgument("DAYS_ELAPSED function requires a valid date argument, got: " + value); + } + } else { + throw new InvalidFunctionArgument("DAYS_ELAPSED function requires a date argument, got: " + value.getClass().getSimpleName()); + } + + final LocalDate today = LocalDate.now(); + return ChronoUnit.DAYS.between(inputDate, today); + } + + @Override + public FunctionType getFunctionType() { + return FunctionType.DAYS_ELAPSED; + } + + @Override + public List getAllowedContainerTypes() { + return Arrays.asList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.DATE); + } +} \ No newline at end of file diff --git a/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/IntFunction.java b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/IntFunction.java new file mode 100644 index 0000000..d3a28de --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/IntFunction.java @@ -0,0 +1,44 @@ +package com.github.sidhant92.boolparser.function.arithmetic; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public class IntFunction extends AbstractFunction { + @Override + public Object evaluate(final List items) { + final EvaluatedNode item = items.get(0); + if (item.getDataType() == DataType.DECIMAL) { + return ((BigDecimal) DataTypeFactory.getDataType(DataType.DECIMAL).getValue(item.getValue()).get()).intValue(); + } + if (item.getDataType() == DataType.LONG) { + return ((Long) item.getValue()).intValue(); + } + return item.getValue(); + } + + @Override + public FunctionType getFunctionType() { + return FunctionType.INT; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/LenFunction.java b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/LenFunction.java new file mode 100644 index 0000000..dda46f6 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/LenFunction.java @@ -0,0 +1,37 @@ +package com.github.sidhant92.boolparser.function.arithmetic; + +import java.util.Arrays; +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public class LenFunction extends AbstractFunction { + @Override + public Object evaluate(final List items) { + if (items.size() == 1 && items.get(0).getValue() instanceof String) { + return ((String) items.get(0).getValue()).length(); + } + return items.size(); + } + + @Override + public FunctionType getFunctionType() { + return FunctionType.LEN; + } + + @Override + public List getAllowedContainerTypes() { + return Arrays.asList(ContainerDataType.values()); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.values()); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MaxFunction.java b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MaxFunction.java new file mode 100644 index 0000000..5f3b8a8 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MaxFunction.java @@ -0,0 +1,64 @@ +package com.github.sidhant92.boolparser.function.arithmetic; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.datatype.DecimalDataType; +import com.github.sidhant92.boolparser.datatype.IntegerDataType; +import com.github.sidhant92.boolparser.datatype.LongDataType; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.util.ValueUtils; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public class MaxFunction extends AbstractFunction { + @Override + public Object evaluate(final List items) { + if (items + .stream().anyMatch(a -> a.getDataType().equals(DataType.DECIMAL))) { + final DecimalDataType decimalDataType = (DecimalDataType) DataTypeFactory.getDataType(DataType.DECIMAL); + final List itemsConverted = items + .stream() + .map(item -> decimalDataType.getValue(item.getValue())) + .map(Optional::get) + .collect(Collectors.toList()); + final BigDecimal max = itemsConverted + .stream().max(Comparator.naturalOrder()).get(); + return ValueUtils.castDecimal(max); + } + if (items + .stream().anyMatch(a -> a.getDataType().equals(DataType.LONG))) { + final LongDataType longDataType = (LongDataType) DataTypeFactory.getDataType(DataType.LONG); + return ValueUtils.castDecimal(items + .stream().mapToLong(a -> longDataType.getValue(a.getValue()).get()).max().getAsLong()); + } + final IntegerDataType integerDataType = (IntegerDataType) DataTypeFactory.getDataType(DataType.INTEGER); + return ValueUtils.castDecimal(items + .stream().mapToInt(a -> integerDataType.getValue(a.getValue()).get()).max().getAsInt()); + } + + @Override + public FunctionType getFunctionType() { + return FunctionType.MAX; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.LIST); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MeanFunction.java b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MeanFunction.java new file mode 100644 index 0000000..36ba128 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MeanFunction.java @@ -0,0 +1,36 @@ +package com.github.sidhant92.boolparser.function.arithmetic; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.function.FunctionFactory; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public class MeanFunction extends AbstractFunction { + @Override + public Object evaluate(final List items) { + return FunctionFactory.getArithmeticFunction(FunctionType.AVG).evaluate(items); + } + + @Override + public FunctionType getFunctionType() { + return FunctionType.MEAN; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.LIST); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MedianFunction.java b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MedianFunction.java new file mode 100644 index 0000000..90f0d12 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MedianFunction.java @@ -0,0 +1,57 @@ +package com.github.sidhant92.boolparser.function.arithmetic; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.datatype.DecimalDataType; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.util.ValueUtils; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public class MedianFunction extends AbstractFunction { + public MedianFunction() { + } + + @Override + public Object evaluate(final List items) { + final DecimalDataType decimalDataType = (DecimalDataType) DataTypeFactory.getDataType(DataType.DECIMAL); + final List itemsConverted = items + .stream() + .map(item -> decimalDataType.getValue(item.getValue())) + .map(Optional::get) + .collect(Collectors.toList()); + Collections.sort(itemsConverted); + if (items.size() % 2 == 0) { + final BigDecimal res = itemsConverted.get(items.size() / 2).add(itemsConverted.get(items.size() / 2 - 1)) + .divide(new BigDecimal("2"), 2, BigDecimal.ROUND_DOWN); + return ValueUtils.castDecimal(res); + } else { + return ValueUtils.castDecimal(itemsConverted.get(items.size() / 2)); + } + } + + @Override + public FunctionType getFunctionType() { + return FunctionType.MEDIAN; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.LIST); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MinFunction.java b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MinFunction.java new file mode 100644 index 0000000..b18bcb8 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/MinFunction.java @@ -0,0 +1,64 @@ +package com.github.sidhant92.boolparser.function.arithmetic; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.datatype.DecimalDataType; +import com.github.sidhant92.boolparser.datatype.IntegerDataType; +import com.github.sidhant92.boolparser.datatype.LongDataType; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.util.ValueUtils; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public class MinFunction extends AbstractFunction { + @Override + public Object evaluate(final List items) { + if (items + .stream().anyMatch(a -> a.getDataType().equals(DataType.DECIMAL))) { + final DecimalDataType decimalDataType = (DecimalDataType) DataTypeFactory.getDataType(DataType.DECIMAL); + final List itemsConverted = items + .stream() + .map(item -> decimalDataType.getValue(item.getValue())) + .map(Optional::get) + .collect(Collectors.toList()); + final BigDecimal min = itemsConverted + .stream().min(Comparator.naturalOrder()).get(); + return ValueUtils.castDecimal(min); + } + if (items + .stream().anyMatch(a -> a.getDataType().equals(DataType.LONG))) { + final LongDataType longDataType = (LongDataType) DataTypeFactory.getDataType(DataType.LONG); + return ValueUtils.castDecimal(items + .stream().mapToLong(a -> longDataType.getValue(a.getValue()).get()).min().getAsLong()); + } + final IntegerDataType integerDataType = (IntegerDataType) DataTypeFactory.getDataType(DataType.INTEGER); + return ValueUtils.castDecimal(items + .stream().mapToInt(a -> integerDataType.getValue(a.getValue()).get()).min().getAsInt()); + } + + @Override + public FunctionType getFunctionType() { + return FunctionType.MIN; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.LIST); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/ModeFunction.java b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/ModeFunction.java new file mode 100644 index 0000000..01f9945 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/ModeFunction.java @@ -0,0 +1,66 @@ +package com.github.sidhant92.boolparser.function.arithmetic; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.util.ValueUtils; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public class ModeFunction extends AbstractFunction { + @Override + public Object evaluate(final List items) { + Map hm = new HashMap(); + int max = 1; + Object temp = items.get(0).getValue(); + + for (int i = 0; i < items.size(); i++) { + final Object value = items.get(i).getValue(); + + if (hm.get(value) != null) { + + int count = hm.get(value); + count++; + hm.put(value, count); + + if (count > max) { + max = count; + temp = value; + } + } else { + hm.put(value, 1); + } + } + if (temp instanceof BigDecimal) { + return ValueUtils.castDecimal((BigDecimal) temp); + } + if (temp instanceof Long) { + return ValueUtils.castLong((Long) temp); + } + return temp; + } + + @Override + public FunctionType getFunctionType() { + return FunctionType.MODE; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.LIST); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/SumFunction.java b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/SumFunction.java new file mode 100644 index 0000000..455339c --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/function/arithmetic/SumFunction.java @@ -0,0 +1,57 @@ +package com.github.sidhant92.boolparser.function.arithmetic; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.FunctionType; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.datatype.DecimalDataType; +import com.github.sidhant92.boolparser.datatype.LongDataType; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; +import com.github.sidhant92.boolparser.util.ValueUtils; + +/** + * @author sidhant.aggarwal + * @since 21/05/2024 + */ +public class SumFunction extends AbstractFunction { + @Override + public Object evaluate(final List items) { + if (items + .stream().anyMatch(a -> a.getDataType().equals(DataType.DECIMAL))) { + final DecimalDataType decimalDataType = (DecimalDataType) DataTypeFactory.getDataType(DataType.DECIMAL); + final List itemsConverted = items + .stream() + .map(item -> decimalDataType.getValue(item.getValue())) + .map(Optional::get) + .collect(Collectors.toList()); + final BigDecimal sum = itemsConverted + .stream().reduce(BigDecimal.ZERO, BigDecimal::add); + return ValueUtils.castDecimal(sum); + } + final LongDataType longDataType = (LongDataType) DataTypeFactory.getDataType(DataType.LONG); + final long sum = items + .stream().mapToLong(a -> longDataType.getValue(a.getValue()).get()).sum(); + return ValueUtils.castDecimal(sum); + } + + @Override + public FunctionType getFunctionType() { + return FunctionType.SUM; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.LIST); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/GreaterThanEqualOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/GreaterThanEqualOperator.java deleted file mode 100644 index d26ae8d..0000000 --- a/src/main/java/com/github/sidhant92/boolparser/operator/GreaterThanEqualOperator.java +++ /dev/null @@ -1,43 +0,0 @@ -package com.github.sidhant92.boolparser.operator; - -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Optional; -import com.github.sidhant92.boolparser.constant.ContainerDataType; -import com.github.sidhant92.boolparser.constant.DataType; -import com.github.sidhant92.boolparser.constant.Operator; - -/** - * @author sidhant.aggarwal - * @since 05/03/2023 - */ -public class GreaterThanEqualOperator extends AbstractOperator { - @Override - public > boolean evaluate(final ContainerDataType containerDataType, final DataType dataType, - final Object leftOperand, final Object... rightOperands) { - final Optional leftValueOptional = containerDataType.getValue(dataType, leftOperand); - final Optional rightValueOptional = containerDataType.getValue(dataType, rightOperands[0]); - return leftValueOptional.flatMap(leftValue -> rightValueOptional.map(leftValue::compareTo).map(a -> a >= 0)).orElse(false); - } - - @Override - public Operator getOperator() { - return Operator.GREATER_THAN_EQUAL; - } - - @Override - public String getSymbol() { - return ">="; - } - - @Override - public List getAllowedContainerTypes() { - return Collections.singletonList(ContainerDataType.PRIMITIVE); - } - - @Override - public List getAllowedDataTypes() { - return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL, DataType.STRING, DataType.VERSION); - } -} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/GreaterThanOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/GreaterThanOperator.java deleted file mode 100644 index 720df54..0000000 --- a/src/main/java/com/github/sidhant92/boolparser/operator/GreaterThanOperator.java +++ /dev/null @@ -1,43 +0,0 @@ -package com.github.sidhant92.boolparser.operator; - -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Optional; -import com.github.sidhant92.boolparser.constant.ContainerDataType; -import com.github.sidhant92.boolparser.constant.DataType; -import com.github.sidhant92.boolparser.constant.Operator; - -/** - * @author sidhant.aggarwal - * @since 05/03/2023 - */ -public class GreaterThanOperator extends AbstractOperator { - @Override - public > boolean evaluate(final ContainerDataType containerDataType, final DataType dataType, - final Object leftOperand, final Object... rightOperands) { - final Optional leftValueOptional = containerDataType.getValue(dataType, leftOperand); - final Optional rightValueOptional = containerDataType.getValue(dataType, rightOperands[0]); - return leftValueOptional.flatMap(leftValue -> rightValueOptional.map(leftValue::compareTo).map(a -> a > 0)).orElse(false); - } - - @Override - public Operator getOperator() { - return Operator.GREATER_THAN; - } - - @Override - public String getSymbol() { - return ">"; - } - - @Override - public List getAllowedContainerTypes() { - return Collections.singletonList(ContainerDataType.PRIMITIVE); - } - - @Override - public List getAllowedDataTypes() { - return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL, DataType.STRING, DataType.VERSION); - } -} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/LessThanEqualOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/LessThanEqualOperator.java deleted file mode 100644 index 93307af..0000000 --- a/src/main/java/com/github/sidhant92/boolparser/operator/LessThanEqualOperator.java +++ /dev/null @@ -1,43 +0,0 @@ -package com.github.sidhant92.boolparser.operator; - -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Optional; -import com.github.sidhant92.boolparser.constant.ContainerDataType; -import com.github.sidhant92.boolparser.constant.DataType; -import com.github.sidhant92.boolparser.constant.Operator; - -/** - * @author sidhant.aggarwal - * @since 05/03/2023 - */ -public class LessThanEqualOperator extends AbstractOperator { - @Override - public > boolean evaluate(final ContainerDataType containerDataType, final DataType dataType, - final Object leftOperand, final Object... rightOperands) { - final Optional leftValueOptional = containerDataType.getValue(dataType, leftOperand); - final Optional rightValueOptional = containerDataType.getValue(dataType, rightOperands[0]); - return leftValueOptional.flatMap(leftValue -> rightValueOptional.map(leftValue::compareTo).map(a -> a <= 0)).orElse(false); - } - - @Override - public Operator getOperator() { - return Operator.LESS_THAN_EQUAL; - } - - @Override - public String getSymbol() { - return "<="; - } - - @Override - public List getAllowedContainerTypes() { - return Collections.singletonList(ContainerDataType.PRIMITIVE); - } - - @Override - public List getAllowedDataTypes() { - return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL, DataType.STRING, DataType.VERSION); - } -} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/LessThanOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/LessThanOperator.java deleted file mode 100644 index 1c43281..0000000 --- a/src/main/java/com/github/sidhant92/boolparser/operator/LessThanOperator.java +++ /dev/null @@ -1,43 +0,0 @@ -package com.github.sidhant92.boolparser.operator; - -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Optional; -import com.github.sidhant92.boolparser.constant.ContainerDataType; -import com.github.sidhant92.boolparser.constant.DataType; -import com.github.sidhant92.boolparser.constant.Operator; - -/** - * @author sidhant.aggarwal - * @since 05/03/2023 - */ -public class LessThanOperator extends AbstractOperator { - @Override - public > boolean evaluate(final ContainerDataType containerDataType, final DataType dataType, - final Object leftOperand, final Object... rightOperands) { - final Optional leftValueOptional = containerDataType.getValue(dataType, leftOperand); - final Optional rightValueOptional = containerDataType.getValue(dataType, rightOperands[0]); - return leftValueOptional.flatMap(leftValue -> rightValueOptional.map(leftValue::compareTo).map(a -> a < 0)).orElse(false); - } - - @Override - public Operator getOperator() { - return Operator.LESS_THAN; - } - - @Override - public String getSymbol() { - return "<"; - } - - @Override - public List getAllowedContainerTypes() { - return Collections.singletonList(ContainerDataType.PRIMITIVE); - } - - @Override - public List getAllowedDataTypes() { - return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL, DataType.STRING, DataType.VERSION); - } -} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/OperatorFactory.java b/src/main/java/com/github/sidhant92/boolparser/operator/OperatorFactory.java index cdf7833..f636993 100644 --- a/src/main/java/com/github/sidhant92/boolparser/operator/OperatorFactory.java +++ b/src/main/java/com/github/sidhant92/boolparser/operator/OperatorFactory.java @@ -5,13 +5,33 @@ import java.util.List; import java.util.Map; import com.github.sidhant92.boolparser.constant.Operator; +import com.github.sidhant92.boolparser.operator.arithmetic.AddOperator; +import com.github.sidhant92.boolparser.operator.arithmetic.DivideOperator; +import com.github.sidhant92.boolparser.operator.arithmetic.ExponentOperator; +import com.github.sidhant92.boolparser.operator.arithmetic.ModulusOperator; +import com.github.sidhant92.boolparser.operator.arithmetic.MultiplyOperator; +import com.github.sidhant92.boolparser.operator.arithmetic.SubtractOperator; +import com.github.sidhant92.boolparser.operator.arithmetic.UnaryOperator; +import com.github.sidhant92.boolparser.operator.comparison.AbstractOperator; +import com.github.sidhant92.boolparser.operator.comparison.ContainsAllOperator; +import com.github.sidhant92.boolparser.operator.comparison.ContainsAnyOperator; +import com.github.sidhant92.boolparser.operator.comparison.EqualsOperator; +import com.github.sidhant92.boolparser.operator.comparison.GreaterThanEqualOperator; +import com.github.sidhant92.boolparser.operator.comparison.GreaterThanOperator; +import com.github.sidhant92.boolparser.operator.comparison.InOperator; +import com.github.sidhant92.boolparser.operator.comparison.LessThanEqualOperator; +import com.github.sidhant92.boolparser.operator.comparison.LessThanOperator; +import com.github.sidhant92.boolparser.operator.comparison.NotEqualsOperator; /** * @author sidhant.aggarwal * @since 05/03/2023 */ public class OperatorFactory { - private static final Map operatorMap = new EnumMap<>(Operator.class); + private static final Map logicalOperatorMap = new EnumMap<>(Operator.class); + + private static final Map arithmeticOperatorMap = new EnumMap<>( + Operator.class); private OperatorFactory() { super(); @@ -20,26 +40,38 @@ private OperatorFactory() { public static void initialize() { final EqualsOperator equalsOperator = new EqualsOperator(); final InOperator inOperator = new InOperator(equalsOperator); - operatorMap.put(Operator.EQUALS, equalsOperator); - operatorMap.put(Operator.GREATER_THAN, new GreaterThanOperator()); - operatorMap.put(Operator.GREATER_THAN_EQUAL, new GreaterThanEqualOperator()); - operatorMap.put(Operator.LESS_THAN, new LessThanOperator()); - operatorMap.put(Operator.LESS_THAN_EQUAL, new LessThanEqualOperator()); - operatorMap.put(Operator.NOT_EQUAL, new NotEqualsOperator()); - operatorMap.put(Operator.IN, new InOperator(equalsOperator)); - operatorMap.put(Operator.CONTAINS_ALL, new ContainsAllOperator(inOperator)); - operatorMap.put(Operator.CONTAINS_ANY, new ContainsAnyOperator(inOperator)); + logicalOperatorMap.put(Operator.EQUALS, equalsOperator); + logicalOperatorMap.put(Operator.GREATER_THAN, new GreaterThanOperator()); + logicalOperatorMap.put(Operator.GREATER_THAN_EQUAL, new GreaterThanEqualOperator()); + logicalOperatorMap.put(Operator.LESS_THAN, new LessThanOperator()); + logicalOperatorMap.put(Operator.LESS_THAN_EQUAL, new LessThanEqualOperator()); + logicalOperatorMap.put(Operator.NOT_EQUAL, new NotEqualsOperator()); + logicalOperatorMap.put(Operator.IN, new InOperator(equalsOperator)); + logicalOperatorMap.put(Operator.CONTAINS_ALL, new ContainsAllOperator(inOperator)); + logicalOperatorMap.put(Operator.CONTAINS_ANY, new ContainsAnyOperator(inOperator)); + + arithmeticOperatorMap.put(Operator.ADD, new AddOperator()); + arithmeticOperatorMap.put(Operator.SUBTRACT, new SubtractOperator()); + arithmeticOperatorMap.put(Operator.DIVIDE, new DivideOperator()); + arithmeticOperatorMap.put(Operator.MULTIPLY, new MultiplyOperator()); + arithmeticOperatorMap.put(Operator.EXPONENT, new ExponentOperator()); + arithmeticOperatorMap.put(Operator.MODULUS, new ModulusOperator()); + arithmeticOperatorMap.put(Operator.UNARY, new UnaryOperator()); + } + + public static AbstractOperator getLogicalOperator(final Operator operator) { + return logicalOperatorMap.get(operator); } - public static AbstractOperator getOperator(final Operator operator) { - return operatorMap.get(operator); + public static com.github.sidhant92.boolparser.operator.arithmetic.AbstractOperator getArithmeticOperator(final Operator operator) { + return arithmeticOperatorMap.get(operator); } - public static List getAllOperators() { - return new ArrayList<>(operatorMap.values()); + public static List getAllLogicalOperators() { + return new ArrayList<>(logicalOperatorMap.values()); } - public static void register(final AbstractOperator abstractOperator) { - operatorMap.put(abstractOperator.getOperator(), abstractOperator); + public static List getAllArithmeticOperators() { + return new ArrayList<>(arithmeticOperatorMap.values()); } } diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/OperatorService.java b/src/main/java/com/github/sidhant92/boolparser/operator/OperatorService.java index bd31dd5..6c78ad3 100644 --- a/src/main/java/com/github/sidhant92/boolparser/operator/OperatorService.java +++ b/src/main/java/com/github/sidhant92/boolparser/operator/OperatorService.java @@ -1,39 +1,64 @@ package com.github.sidhant92.boolparser.operator; +import java.util.List; +import java.util.Objects; +import org.apache.commons.lang3.tuple.Pair; import com.github.sidhant92.boolparser.constant.ContainerDataType; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.Operator; import com.github.sidhant92.boolparser.datatype.DataTypeFactory; import com.github.sidhant92.boolparser.exception.InvalidContainerTypeException; import com.github.sidhant92.boolparser.exception.InvalidDataType; -import lombok.extern.slf4j.Slf4j; +import com.github.sidhant92.boolparser.operator.comparison.AbstractOperator; /** * @author sidhant.aggarwal * @since 05/03/2023 */ -@Slf4j public class OperatorService { public OperatorService() { DataTypeFactory.initialize(); OperatorFactory.initialize(); } - public boolean evaluate(final Operator operator, final ContainerDataType containerDataType, final DataType dataType, final Object leftOperand, - final Object... rightOperands) { - final AbstractOperator abstractOperator = OperatorFactory.getOperator(operator); + public boolean evaluateLogicalOperator(final Operator operator, final ContainerDataType containerDataType, final Object leftOperand, + final DataType leftOperandDataType, final List> rightOperands) { + final AbstractOperator abstractOperator = OperatorFactory.getLogicalOperator(operator); if (!abstractOperator.getAllowedContainerTypes().contains(containerDataType)) { - log.error("Invalid left container type {} for operator {}", containerDataType, operator); - throw new InvalidContainerTypeException(); + throw new InvalidContainerTypeException(String.format("Invalid left container type %s for operator %s", containerDataType, operator)); } - if (!abstractOperator.getAllowedDataTypes().contains(dataType)) { - log.error("Invalid left operand data type {} for operator {}", dataType, operator); - throw new InvalidDataType(); + if (!abstractOperator.getAllowedDataTypes().contains(leftOperandDataType)) { + throw new InvalidDataType(String.format("Invalid left operand data type %s for operator %s", leftOperandDataType, operator)); } - if (!containerDataType.isValid(dataType, leftOperand)) { - log.error("Validation failed for the operator {} for the operand {}", operator, leftOperand); - throw new InvalidDataType(); + if (!containerDataType.isValid(leftOperandDataType, leftOperand)) { + throw new InvalidDataType(String.format("Validation failed for the operator %s for the operand %s", operator, leftOperand)); } - return OperatorFactory.getOperator(operator).evaluate(containerDataType, dataType, leftOperand, rightOperands); + rightOperands.forEach(rightOperand -> { + if (!abstractOperator.getAllowedDataTypes().contains(rightOperand.getRight())) { + throw new InvalidDataType(String.format("Invalid right operand data type %s for operator %s", rightOperand.getRight(), operator)); + } + }); + return OperatorFactory.getLogicalOperator(operator).evaluate(containerDataType, leftOperand, leftOperandDataType, rightOperands); + } + + public Object evaluateArithmeticOperator(final Object leftOperand, final DataType leftDataType, final Object rightOperand, + final DataType rightDataType, final Operator operator, final ContainerDataType containerDataType) { + final com.github.sidhant92.boolparser.operator.arithmetic.AbstractOperator abstractOperator = OperatorFactory.getArithmeticOperator(operator); + if (!abstractOperator.getAllowedContainerTypes().contains(containerDataType)) { + throw new InvalidContainerTypeException(String.format("Invalid left container type %s for operator %s", containerDataType, operator)); + } + if (!abstractOperator.getAllowedDataTypes().contains(leftDataType)) { + throw new InvalidDataType(String.format("Invalid left operand data type %s for operator %s", leftDataType, operator)); + } + if (!containerDataType.isValid(leftDataType, leftOperand)) { + throw new InvalidDataType(String.format("Validation failed for the operator %s for the operand %s", operator, leftOperand)); + } + if (Objects.nonNull(rightDataType) && !abstractOperator.getAllowedDataTypes().contains(rightDataType)) { + throw new InvalidDataType(String.format("Invalid left operand data type %s for operator %s", rightDataType, operator)); + } + if (Objects.nonNull(rightOperand) && !containerDataType.isValid(rightDataType, rightOperand)) { + throw new InvalidDataType(String.format("Validation failed for the operator %s for the operand %s", operator, rightDataType)); + } + return OperatorFactory.getArithmeticOperator(operator).evaluate(leftOperand, leftDataType, rightOperand, rightDataType); } } diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/AbstractOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/AbstractOperator.java new file mode 100644 index 0000000..eda9c82 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/AbstractOperator.java @@ -0,0 +1,23 @@ +package com.github.sidhant92.boolparser.operator.arithmetic; + +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; + +/** + * @author sidhant.aggarwal + * @since 15/03/2024 + */ +public abstract class AbstractOperator { + public abstract Object evaluate(final Object leftOperand, final DataType leftOperandDataType, final Object rightOperand, + final DataType rightOperandDataType); + + public abstract Operator getOperator(); + + public abstract String getSymbol(); + + public abstract List getAllowedContainerTypes(); + + public abstract List getAllowedDataTypes(); +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/AddOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/AddOperator.java new file mode 100644 index 0000000..d26a62b --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/AddOperator.java @@ -0,0 +1,53 @@ +package com.github.sidhant92.boolparser.operator.arithmetic; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.datatype.DecimalDataType; +import com.github.sidhant92.boolparser.datatype.LongDataType; +import com.github.sidhant92.boolparser.util.ValueUtils; + +/** + * @author sidhant.aggarwal + * @since 15/03/2024 + */ +public class AddOperator extends AbstractOperator { + @Override + public Object evaluate(final Object leftOperand, final DataType leftOperandDataType, final Object rightOperand, + final DataType rightOperandDataType) { + final List stringTypes = Arrays.asList(DataType.STRING, DataType.VERSION, DataType.BOOLEAN); + if (stringTypes.contains(leftOperandDataType) || stringTypes.contains(rightOperandDataType)) { + return leftOperand + String.valueOf(rightOperand); + } + if (leftOperandDataType.equals(DataType.DECIMAL) || rightOperandDataType.equals(DataType.DECIMAL)) { + final DecimalDataType decimalDataType = (DecimalDataType) DataTypeFactory.getDataType(DataType.DECIMAL); + return decimalDataType.getValue(leftOperand).get().add(decimalDataType.getValue(rightOperand).get()); + } + final LongDataType longDataType = (LongDataType) DataTypeFactory.getDataType(DataType.LONG); + return ValueUtils.castLong(longDataType.getValue(leftOperand).get() + longDataType.getValue(rightOperand).get()); + } + + @Override + public Operator getOperator() { + return Operator.ADD; + } + + @Override + public String getSymbol() { + return "+"; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL, DataType.STRING, DataType.BOOLEAN, DataType.VERSION); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/DivideOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/DivideOperator.java new file mode 100644 index 0000000..e179f1b --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/DivideOperator.java @@ -0,0 +1,47 @@ +package com.github.sidhant92.boolparser.operator.arithmetic; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.datatype.DecimalDataType; +import com.github.sidhant92.boolparser.exception.InvalidDataType; +import com.github.sidhant92.boolparser.util.ValueUtils; + +/** + * @author sidhant.aggarwal + * @since 15/03/2024 + */ +public class DivideOperator extends AbstractOperator { + @Override + public Object evaluate(final Object leftOperand, final DataType leftOperandDataType, final Object rightOperand, + final DataType rightOperandDataType) { + final DecimalDataType decimalDataType = (DecimalDataType) DataTypeFactory.getDataType(DataType.DECIMAL); + return ValueUtils.castDecimal( + decimalDataType.getValue(leftOperand).get().divide(decimalDataType.getValue(rightOperand).get(), 3, BigDecimal.ROUND_DOWN)); + } + + @Override + public Operator getOperator() { + return Operator.DIVIDE; + } + + @Override + public String getSymbol() { + return "/"; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/ExponentOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/ExponentOperator.java new file mode 100644 index 0000000..b4c5239 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/ExponentOperator.java @@ -0,0 +1,50 @@ +package com.github.sidhant92.boolparser.operator.arithmetic; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.datatype.DecimalDataType; +import com.github.sidhant92.boolparser.datatype.LongDataType; +import com.github.sidhant92.boolparser.util.ValueUtils; + +/** + * @author sidhant.aggarwal + * @since 15/03/2024 + */ +public class ExponentOperator extends AbstractOperator { + @Override + public Object evaluate(final Object leftOperand, final DataType leftOperandDataType, final Object rightOperand, + final DataType rightOperandDataType) { + if (leftOperandDataType.equals(DataType.DECIMAL) || rightOperandDataType.equals(DataType.DECIMAL)) { + final DecimalDataType decimalDataType = (DecimalDataType) DataTypeFactory.getDataType(DataType.DECIMAL); + return ValueUtils.castDecimal( + Math.pow(decimalDataType.getValue(leftOperand).get().doubleValue(), decimalDataType.getValue(rightOperand).get().doubleValue())); + } + final LongDataType longDataType = (LongDataType) DataTypeFactory.getDataType(DataType.LONG); + return ValueUtils.castDecimal(Math.pow(longDataType.getValue(leftOperand).get(), longDataType.getValue(rightOperand).get())); + } + + @Override + public Operator getOperator() { + return Operator.EXPONENT; + } + + @Override + public String getSymbol() { + return "^"; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/ModulusOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/ModulusOperator.java new file mode 100644 index 0000000..f79dd32 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/ModulusOperator.java @@ -0,0 +1,49 @@ +package com.github.sidhant92.boolparser.operator.arithmetic; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.datatype.IntegerDataType; +import com.github.sidhant92.boolparser.datatype.LongDataType; +import com.github.sidhant92.boolparser.exception.InvalidDataType; + +/** + * @author sidhant.aggarwal + * @since 15/03/2024 + */ +public class ModulusOperator extends AbstractOperator { + @Override + public Object evaluate(final Object leftOperand, final DataType leftOperandDataType, final Object rightOperand, + final DataType rightOperandDataType) { + if (leftOperandDataType.equals(DataType.LONG) || rightOperandDataType.equals(DataType.LONG)) { + final LongDataType longDataType = (LongDataType) DataTypeFactory.getDataType(DataType.LONG); + return longDataType.getValue(leftOperand).get() % longDataType.getValue(rightOperand).get(); + } + final IntegerDataType integerDataType = (IntegerDataType) DataTypeFactory.getDataType(DataType.INTEGER); + return integerDataType.getValue(leftOperand).get() % integerDataType.getValue(rightOperand).get(); + } + + @Override + public Operator getOperator() { + return Operator.MODULUS; + } + + @Override + public String getSymbol() { + return "%"; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/MultiplyOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/MultiplyOperator.java new file mode 100644 index 0000000..931a3ff --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/MultiplyOperator.java @@ -0,0 +1,49 @@ +package com.github.sidhant92.boolparser.operator.arithmetic; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.datatype.DecimalDataType; +import com.github.sidhant92.boolparser.datatype.LongDataType; +import com.github.sidhant92.boolparser.util.ValueUtils; + +/** + * @author sidhant.aggarwal + * @since 15/03/2024 + */ +public class MultiplyOperator extends AbstractOperator { + @Override + public Object evaluate(final Object leftOperand, final DataType leftOperandDataType, final Object rightOperand, + final DataType rightOperandDataType) { + if (leftOperandDataType.equals(DataType.DECIMAL) || rightOperandDataType.equals(DataType.DECIMAL)) { + final DecimalDataType decimalDataType = (DecimalDataType) DataTypeFactory.getDataType(DataType.DECIMAL); + return decimalDataType.getValue(leftOperand).get().multiply(decimalDataType.getValue(rightOperand).get()); + } + final LongDataType longDataType = (LongDataType) DataTypeFactory.getDataType(DataType.LONG); + return ValueUtils.castLong(longDataType.getValue(leftOperand).get() * longDataType.getValue(rightOperand).get()); + } + + @Override + public Operator getOperator() { + return Operator.MULTIPLY; + } + + @Override + public String getSymbol() { + return "*"; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/SubtractOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/SubtractOperator.java new file mode 100644 index 0000000..fc4917c --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/SubtractOperator.java @@ -0,0 +1,53 @@ +package com.github.sidhant92.boolparser.operator.arithmetic; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; +import com.github.sidhant92.boolparser.datatype.DataTypeFactory; +import com.github.sidhant92.boolparser.datatype.DecimalDataType; +import com.github.sidhant92.boolparser.datatype.IntegerDataType; +import com.github.sidhant92.boolparser.datatype.LongDataType; + +/** + * @author sidhant.aggarwal + * @since 15/03/2024 + */ +public class SubtractOperator extends AbstractOperator { + @Override + public Object evaluate(final Object leftOperand, final DataType leftOperandDataType, final Object rightOperand, + final DataType rightOperandDataType) { + if (leftOperandDataType.equals(DataType.DECIMAL) || rightOperandDataType.equals(DataType.DECIMAL)) { + final DecimalDataType decimalDataType = (DecimalDataType) DataTypeFactory.getDataType(DataType.DECIMAL); + return decimalDataType.getValue(leftOperand).get().subtract(decimalDataType.getValue(rightOperand).get()); + } + if (leftOperandDataType.equals(DataType.LONG) || rightOperandDataType.equals(DataType.LONG)) { + final LongDataType longDataType = (LongDataType) DataTypeFactory.getDataType(DataType.LONG); + return longDataType.getValue(leftOperand).get() - longDataType.getValue(rightOperand).get(); + } + final IntegerDataType integerDataType = (IntegerDataType) DataTypeFactory.getDataType(DataType.INTEGER); + return integerDataType.getValue(leftOperand).get() - integerDataType.getValue(rightOperand).get(); + } + + @Override + public Operator getOperator() { + return Operator.SUBTRACT; + } + + @Override + public String getSymbol() { + return "-"; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/UnaryOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/UnaryOperator.java new file mode 100644 index 0000000..8c0675c --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/arithmetic/UnaryOperator.java @@ -0,0 +1,47 @@ +package com.github.sidhant92.boolparser.operator.arithmetic; + +import java.math.BigDecimal; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; + +/** + * @author sidhant.aggarwal + * @since 15/03/2024 + */ +public class UnaryOperator extends AbstractOperator { + @Override + public Object evaluate(final Object leftOperand, final DataType leftOperandDataType, final Object rightOperand, + final DataType rightOperandDataType) { + if (leftOperandDataType.equals(DataType.DECIMAL)) { + return ((BigDecimal) leftOperand).negate(); + } + if (leftOperandDataType.equals(DataType.LONG)) { + return -(long) leftOperand; + } + return -(int) leftOperand; + } + + @Override + public Operator getOperator() { + return Operator.UNARY; + } + + @Override + public String getSymbol() { + return "UNARY"; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/AbstractOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/AbstractOperator.java similarity index 65% rename from src/main/java/com/github/sidhant92/boolparser/operator/AbstractOperator.java rename to src/main/java/com/github/sidhant92/boolparser/operator/comparison/AbstractOperator.java index 2c95380..a5570bd 100644 --- a/src/main/java/com/github/sidhant92/boolparser/operator/AbstractOperator.java +++ b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/AbstractOperator.java @@ -1,6 +1,7 @@ -package com.github.sidhant92.boolparser.operator; +package com.github.sidhant92.boolparser.operator.comparison; import java.util.List; +import org.apache.commons.lang3.tuple.Pair; import com.github.sidhant92.boolparser.constant.ContainerDataType; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.Operator; @@ -10,8 +11,9 @@ * @since 05/03/2023 */ public abstract class AbstractOperator { - public abstract > boolean evaluate(final ContainerDataType containerDataType, final DataType dataType, - final Object leftOperand, final Object... rightOperands); + public abstract > boolean evaluate(final ContainerDataType containerDataType, final Object leftOperand, + final DataType leftOperandDataType, + final List> rightOperands); public abstract Operator getOperator(); diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/ContainsAllOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/ContainsAllOperator.java similarity index 54% rename from src/main/java/com/github/sidhant92/boolparser/operator/ContainsAllOperator.java rename to src/main/java/com/github/sidhant92/boolparser/operator/comparison/ContainsAllOperator.java index a7add0d..c87b0b8 100644 --- a/src/main/java/com/github/sidhant92/boolparser/operator/ContainsAllOperator.java +++ b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/ContainsAllOperator.java @@ -1,30 +1,32 @@ -package com.github.sidhant92.boolparser.operator; +package com.github.sidhant92.boolparser.operator.comparison; import java.util.Arrays; import java.util.Collections; import java.util.List; +import java.util.stream.Collectors; +import org.apache.commons.lang3.tuple.Pair; import com.github.sidhant92.boolparser.constant.ContainerDataType; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.Operator; import lombok.AllArgsConstructor; -import lombok.extern.slf4j.Slf4j; @AllArgsConstructor -@Slf4j public class ContainsAllOperator extends AbstractOperator { private final InOperator inOperator; @Override - public > boolean evaluate(final ContainerDataType containerDataType, final DataType dataType, - final Object leftOperand, final Object... rightOperands) { - if (!containerDataType.isValid(dataType, leftOperand)) { - log.error("Validation failed for any operator for the operand {}", leftOperand); + public > boolean evaluate(final ContainerDataType containerDataType, final Object leftOperand, + final DataType leftOperandDataType, final List> rightOperands) { + if (!containerDataType.isValid(leftOperandDataType, leftOperand)) { return false; } - final Object[] leftOperandArray = ((List) leftOperand).toArray(); - return Arrays - .stream(rightOperands) - .allMatch(rightOperand -> inOperator.evaluate(ContainerDataType.PRIMITIVE, dataType, rightOperand, leftOperandArray)); + final List> leftOperandArray = Arrays + .stream(((List) leftOperand).toArray()) + .map(a -> Pair.of(a, leftOperandDataType)) + .collect(Collectors.toList()); + return rightOperands + .stream().allMatch(rightOperand -> inOperator.evaluate(ContainerDataType.PRIMITIVE, rightOperand.getLeft(), rightOperand.getRight(), + leftOperandArray)); } @Override diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/ContainsAnyOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/ContainsAnyOperator.java similarity index 54% rename from src/main/java/com/github/sidhant92/boolparser/operator/ContainsAnyOperator.java rename to src/main/java/com/github/sidhant92/boolparser/operator/comparison/ContainsAnyOperator.java index 4cb81c9..917135a 100644 --- a/src/main/java/com/github/sidhant92/boolparser/operator/ContainsAnyOperator.java +++ b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/ContainsAnyOperator.java @@ -1,30 +1,32 @@ -package com.github.sidhant92.boolparser.operator; +package com.github.sidhant92.boolparser.operator.comparison; import java.util.Arrays; import java.util.Collections; import java.util.List; +import java.util.stream.Collectors; +import org.apache.commons.lang3.tuple.Pair; import com.github.sidhant92.boolparser.constant.ContainerDataType; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.Operator; import lombok.AllArgsConstructor; -import lombok.extern.slf4j.Slf4j; @AllArgsConstructor -@Slf4j public class ContainsAnyOperator extends AbstractOperator { private final InOperator inOperator; @Override - public > boolean evaluate(final ContainerDataType containerDataType, final DataType dataType, - final Object leftOperand, final Object... rightOperands) { - if (!containerDataType.isValid(dataType, leftOperand)) { - log.error("Validation failed for any operator for the operand {}", leftOperand); + public > boolean evaluate(final ContainerDataType containerDataType, final Object leftOperand, + final DataType leftOperandDataType, final List> rightOperands) { + if (!containerDataType.isValid(leftOperandDataType, leftOperand)) { return false; } - final Object[] leftOperandArray = ((List) leftOperand).toArray(); - return Arrays - .stream(rightOperands) - .anyMatch(rightOperand -> inOperator.evaluate(ContainerDataType.PRIMITIVE, dataType, rightOperand, leftOperandArray)); + final List> leftOperandArray = Arrays + .stream(((List) leftOperand).toArray()) + .map(a -> Pair.of(a, leftOperandDataType)) + .collect(Collectors.toList()); + return rightOperands + .stream().anyMatch(rightOperand -> inOperator.evaluate(ContainerDataType.PRIMITIVE, rightOperand.getLeft(), rightOperand.getRight(), + leftOperandArray)); } @Override diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/EqualsOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/EqualsOperator.java similarity index 50% rename from src/main/java/com/github/sidhant92/boolparser/operator/EqualsOperator.java rename to src/main/java/com/github/sidhant92/boolparser/operator/comparison/EqualsOperator.java index 5bc1044..d2befb8 100644 --- a/src/main/java/com/github/sidhant92/boolparser/operator/EqualsOperator.java +++ b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/EqualsOperator.java @@ -1,9 +1,10 @@ -package com.github.sidhant92.boolparser.operator; +package com.github.sidhant92.boolparser.operator.comparison; import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Optional; +import org.apache.commons.lang3.tuple.Pair; import com.github.sidhant92.boolparser.constant.ContainerDataType; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.Operator; @@ -14,11 +15,22 @@ */ public class EqualsOperator extends AbstractOperator { @Override - public > boolean evaluate(final ContainerDataType containerDataType, final DataType dataType, - final Object leftOperand, final Object... rightOperands) { - final Optional leftValueOptional = containerDataType.getValue(dataType, leftOperand); - final Optional rightValueOptional = containerDataType.getValue(dataType, rightOperands[0]); - return leftValueOptional.flatMap(leftValue -> rightValueOptional.map(leftValue::compareTo).map(a -> a == 0)).orElse(false); + public > boolean evaluate(final ContainerDataType containerDataType, final Object leftOperand, + final DataType leftOperandDataType, final List> rightOperands) { + final DataType comparisonType = getComparableDataType(leftOperandDataType, rightOperands.get(0).getRight()); + final Optional leftValueOptional = containerDataType.getValue(comparisonType, leftOperand); + final Optional rightValueOptional = containerDataType.getValue(comparisonType, rightOperands.get(0).getLeft()); + return leftValueOptional + .flatMap(leftValue -> rightValueOptional + .map(leftValue::compareTo) + .map(a -> a == 0)).orElse(false); + } + + private DataType getComparableDataType(final DataType leftOperandDataType, final DataType rightOperandDataType) { + if (leftOperandDataType.priority > rightOperandDataType.priority) { + return leftOperandDataType; + } + return rightOperandDataType; } @Override diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/comparison/GreaterThanEqualOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/GreaterThanEqualOperator.java new file mode 100644 index 0000000..4abde66 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/GreaterThanEqualOperator.java @@ -0,0 +1,49 @@ +package com.github.sidhant92.boolparser.operator.comparison; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import org.apache.commons.lang3.tuple.Pair; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; + +/** + * @author sidhant.aggarwal + * @since 05/03/2023 + */ +public class GreaterThanEqualOperator extends AbstractOperator implements NumericOperator { + @Override + public > boolean evaluate(final ContainerDataType containerDataType, final Object leftOperand, + final DataType leftOperandDataType, final List> rightOperands) { + validate(leftOperand, leftOperandDataType, rightOperands.get(0).getLeft(), rightOperands.get(0).getRight(), containerDataType); + final DataType comparisonType = getComparableDataType(leftOperandDataType, rightOperands.get(0).getRight()); + final Optional leftValueOptional = containerDataType.getValue(comparisonType, leftOperand); + final Optional rightValueOptional = containerDataType.getValue(comparisonType, rightOperands.get(0).getLeft()); + return leftValueOptional + .flatMap(leftValue -> rightValueOptional + .map(leftValue::compareTo) + .map(a -> a >= 0)).orElse(false); + } + + @Override + public Operator getOperator() { + return Operator.GREATER_THAN_EQUAL; + } + + @Override + public String getSymbol() { + return ">="; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL, DataType.STRING, DataType.VERSION, DataType.DATE, DataType.DATETIME); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/comparison/GreaterThanOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/GreaterThanOperator.java new file mode 100644 index 0000000..3ee9b61 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/GreaterThanOperator.java @@ -0,0 +1,49 @@ +package com.github.sidhant92.boolparser.operator.comparison; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import org.apache.commons.lang3.tuple.Pair; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; + +/** + * @author sidhant.aggarwal + * @since 05/03/2023 + */ +public class GreaterThanOperator extends AbstractOperator implements NumericOperator { + @Override + public > boolean evaluate(final ContainerDataType containerDataType, final Object leftOperand, + final DataType leftOperandDataType, final List> rightOperands) { + validate(leftOperand, leftOperandDataType, rightOperands.get(0).getLeft(), rightOperands.get(0).getRight(), containerDataType); + final DataType comparisonType = getComparableDataType(leftOperandDataType, rightOperands.get(0).getRight()); + final Optional leftValueOptional = containerDataType.getValue(comparisonType, leftOperand); + final Optional rightValueOptional = containerDataType.getValue(comparisonType, rightOperands.get(0).getLeft()); + return leftValueOptional + .flatMap(leftValue -> rightValueOptional + .map(leftValue::compareTo) + .map(a -> a > 0)).orElse(false); + } + + @Override + public Operator getOperator() { + return Operator.GREATER_THAN; + } + + @Override + public String getSymbol() { + return ">"; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL, DataType.STRING, DataType.VERSION, DataType.DATE, DataType.DATETIME); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/InOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/InOperator.java similarity index 70% rename from src/main/java/com/github/sidhant92/boolparser/operator/InOperator.java rename to src/main/java/com/github/sidhant92/boolparser/operator/comparison/InOperator.java index ef801ea..9689947 100644 --- a/src/main/java/com/github/sidhant92/boolparser/operator/InOperator.java +++ b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/InOperator.java @@ -1,8 +1,9 @@ -package com.github.sidhant92.boolparser.operator; +package com.github.sidhant92.boolparser.operator.comparison; import java.util.Arrays; import java.util.Collections; import java.util.List; +import org.apache.commons.lang3.tuple.Pair; import com.github.sidhant92.boolparser.constant.ContainerDataType; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.Operator; @@ -17,10 +18,10 @@ public class InOperator extends AbstractOperator { private final EqualsOperator equalsOperator; @Override - public > boolean evaluate(final ContainerDataType containerDataType, final DataType dataType, - final Object leftOperand, final Object... rightOperands) { - return Arrays - .stream(rightOperands).anyMatch(a -> equalsOperator.evaluate(containerDataType, dataType, leftOperand, a)); + public > boolean evaluate(final ContainerDataType containerDataType, final Object leftOperand, + final DataType leftOperandDataType, final List> rightOperands) { + return rightOperands + .stream().anyMatch(a -> equalsOperator.evaluate(containerDataType, leftOperand, leftOperandDataType, Collections.singletonList(a))); } @Override diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/comparison/LessThanEqualOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/LessThanEqualOperator.java new file mode 100644 index 0000000..edddb8b --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/LessThanEqualOperator.java @@ -0,0 +1,49 @@ +package com.github.sidhant92.boolparser.operator.comparison; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import org.apache.commons.lang3.tuple.Pair; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; + +/** + * @author sidhant.aggarwal + * @since 05/03/2023 + */ +public class LessThanEqualOperator extends AbstractOperator implements NumericOperator { + @Override + public > boolean evaluate(final ContainerDataType containerDataType, final Object leftOperand, + final DataType leftOperandDataType, final List> rightOperands) { + validate(leftOperand, leftOperandDataType, rightOperands.get(0).getLeft(), rightOperands.get(0).getRight(), containerDataType); + final DataType comparisonType = getComparableDataType(leftOperandDataType, rightOperands.get(0).getRight()); + final Optional leftValueOptional = containerDataType.getValue(comparisonType, leftOperand); + final Optional rightValueOptional = containerDataType.getValue(comparisonType, rightOperands.get(0).getLeft()); + return leftValueOptional + .flatMap(leftValue -> rightValueOptional + .map(leftValue::compareTo) + .map(a -> a <= 0)).orElse(false); + } + + @Override + public Operator getOperator() { + return Operator.LESS_THAN_EQUAL; + } + + @Override + public String getSymbol() { + return "<="; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL, DataType.STRING, DataType.VERSION, DataType.DATE, DataType.DATETIME); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/comparison/LessThanOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/LessThanOperator.java new file mode 100644 index 0000000..f7271e1 --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/LessThanOperator.java @@ -0,0 +1,49 @@ +package com.github.sidhant92.boolparser.operator.comparison; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import org.apache.commons.lang3.tuple.Pair; +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.constant.Operator; + +/** + * @author sidhant.aggarwal + * @since 05/03/2023 + */ +public class LessThanOperator extends AbstractOperator implements NumericOperator { + @Override + public > boolean evaluate(final ContainerDataType containerDataType, final Object leftOperand, + final DataType leftOperandDataType, final List> rightOperands) { + validate(leftOperand, leftOperandDataType, rightOperands.get(0).getLeft(), rightOperands.get(0).getRight(), containerDataType); + final DataType comparisonType = getComparableDataType(leftOperandDataType, rightOperands.get(0).getRight()); + final Optional leftValueOptional = containerDataType.getValue(comparisonType, leftOperand); + final Optional rightValueOptional = containerDataType.getValue(comparisonType, rightOperands.get(0).getLeft()); + return leftValueOptional + .flatMap(leftValue -> rightValueOptional + .map(leftValue::compareTo) + .map(a -> a < 0)).orElse(false); + } + + @Override + public Operator getOperator() { + return Operator.LESS_THAN; + } + + @Override + public String getSymbol() { + return "<"; + } + + @Override + public List getAllowedContainerTypes() { + return Collections.singletonList(ContainerDataType.PRIMITIVE); + } + + @Override + public List getAllowedDataTypes() { + return Arrays.asList(DataType.INTEGER, DataType.LONG, DataType.DECIMAL, DataType.STRING, DataType.VERSION, DataType.DATE, DataType.DATETIME); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/NotEqualsOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/NotEqualsOperator.java similarity index 50% rename from src/main/java/com/github/sidhant92/boolparser/operator/NotEqualsOperator.java rename to src/main/java/com/github/sidhant92/boolparser/operator/comparison/NotEqualsOperator.java index 42904e2..8e1da31 100644 --- a/src/main/java/com/github/sidhant92/boolparser/operator/NotEqualsOperator.java +++ b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/NotEqualsOperator.java @@ -1,9 +1,10 @@ -package com.github.sidhant92.boolparser.operator; +package com.github.sidhant92.boolparser.operator.comparison; import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Optional; +import org.apache.commons.lang3.tuple.Pair; import com.github.sidhant92.boolparser.constant.ContainerDataType; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.Operator; @@ -14,11 +15,22 @@ */ public class NotEqualsOperator extends AbstractOperator { @Override - public > boolean evaluate(final ContainerDataType containerDataType, final DataType dataType, - final Object leftOperand, final Object... rightOperands) { - final Optional leftValueOptional = containerDataType.getValue(dataType, leftOperand); - final Optional rightValueOptional = containerDataType.getValue(dataType, rightOperands[0]); - return leftValueOptional.flatMap(leftValue -> rightValueOptional.map(leftValue::compareTo).map(a -> a != 0)).orElse(false); + public > boolean evaluate(final ContainerDataType containerDataType, final Object leftOperand, + final DataType leftOperandDataType, final List> rightOperands) { + final DataType comparisonType = getComparableDataType(leftOperandDataType, rightOperands.get(0).getRight()); + final Optional leftValueOptional = containerDataType.getValue(comparisonType, leftOperand); + final Optional rightValueOptional = containerDataType.getValue(comparisonType, rightOperands.get(0).getLeft()); + return leftValueOptional + .flatMap(leftValue -> rightValueOptional + .map(leftValue::compareTo) + .map(a -> a != 0)).orElse(false); + } + + private DataType getComparableDataType(final DataType leftOperandDataType, final DataType rightOperandDataType) { + if (leftOperandDataType.priority > rightOperandDataType.priority) { + return leftOperandDataType; + } + return rightOperandDataType; } @Override diff --git a/src/main/java/com/github/sidhant92/boolparser/operator/comparison/NumericOperator.java b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/NumericOperator.java new file mode 100644 index 0000000..ce3df5f --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/operator/comparison/NumericOperator.java @@ -0,0 +1,33 @@ +package com.github.sidhant92.boolparser.operator.comparison; + +import com.github.sidhant92.boolparser.constant.ContainerDataType; +import com.github.sidhant92.boolparser.constant.DataType; +import com.github.sidhant92.boolparser.exception.InvalidDataType; + +public interface NumericOperator { + default DataType getComparableDataType(final DataType leftOperandDataType, final DataType rightOperandDataType) { + if ((leftOperandDataType.numeric && !rightOperandDataType.numeric) || (!leftOperandDataType.numeric && rightOperandDataType.numeric)) { + return leftOperandDataType.numeric ? leftOperandDataType : rightOperandDataType; + } + if (leftOperandDataType.priority > rightOperandDataType.priority) { + return leftOperandDataType; + } + return rightOperandDataType; + } + + default void validate(final Object leftOperand, final DataType leftOperandDataType, final Object rightOperand, + final DataType rightOperandDataType, final ContainerDataType containerDataType) { + if (!leftOperandDataType.numeric && !rightOperandDataType.numeric) { + return; + } + if (leftOperandDataType.numeric && rightOperandDataType.numeric) { + return; + } + if (!leftOperandDataType.numeric && !containerDataType.isValid(rightOperandDataType, leftOperand)) { + throw new InvalidDataType(String.format("Incompatible data types %s and %s", leftOperandDataType, rightOperandDataType)); + } + if (!rightOperandDataType.numeric && !containerDataType.isValid(leftOperandDataType, rightOperand)) { + throw new InvalidDataType(String.format("Incompatible data types %s and %s", leftOperandDataType, rightOperandDataType)); + } + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/parser/BoolExpressionParser.java b/src/main/java/com/github/sidhant92/boolparser/parser/BoolExpressionParser.java index c9aee89..a7c1eac 100644 --- a/src/main/java/com/github/sidhant92/boolparser/parser/BoolExpressionParser.java +++ b/src/main/java/com/github/sidhant92/boolparser/parser/BoolExpressionParser.java @@ -1,6 +1,6 @@ package com.github.sidhant92.boolparser.parser; -import com.github.sidhant92.boolparser.domain.Node; +import com.github.sidhant92.boolparser.domain.logical.Node; import io.vavr.control.Try; /** diff --git a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BoolParser.java b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BoolParser.java index 52c3b04..29f4454 100644 --- a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BoolParser.java +++ b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BoolParser.java @@ -4,30 +4,18 @@ import org.antlr.v4.runtime.CommonTokenStream; import org.antlr.v4.runtime.tree.ParseTree; import org.antlr.v4.runtime.tree.ParseTreeWalker; -import com.github.benmanes.caffeine.cache.Cache; -import com.github.benmanes.caffeine.cache.Caffeine; -import com.github.sidhant92.boolparser.domain.Node; +import com.github.sidhant92.boolparser.domain.logical.Node; import com.github.sidhant92.boolparser.operator.OperatorFactory; import com.github.sidhant92.boolparser.parser.BoolExpressionParser; import io.vavr.control.Try; public class BoolParser implements BoolExpressionParser { - private boolean useCache; - - private Cache cache; - private final ParseTreeWalker parseTreeWalker = new ParseTreeWalker(); public BoolParser() { OperatorFactory.initialize(); } - public BoolParser(final int maxCacheSize) { - OperatorFactory.initialize(); - this.useCache = true; - this.cache = Caffeine.newBuilder().maximumSize(maxCacheSize).build(); - } - @Override public Try parseExpression(final String expression, final String defaultField) { return Try.of(() -> getNode(expression, defaultField)); @@ -39,13 +27,10 @@ public Try parseExpression(final String expression) { } private Node getNode(final String expression, final String defaultField) { - if (useCache) { - return cache.get(expression, ex -> parse(ex, defaultField)); - } return parse(expression, defaultField); } - private Node parse(final String expression, final String defaultField) { + protected Node parse(final String expression, final String defaultField) { final BooleanExpressionLexer filterLexer = new BooleanExpressionLexer(CharStreams.fromString(expression)); final CommonTokenStream commonTokenStream = new CommonTokenStream(filterLexer); final BooleanExpressionParser filterParser = new BooleanExpressionParser(commonTokenStream); diff --git a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionBaseListener.java b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionBaseListener.java index 4fafed6..6336796 100644 --- a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionBaseListener.java +++ b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionBaseListener.java @@ -1,4 +1,5 @@ -package com.github.sidhant92.boolparser.parser.antlr;// Generated from /Users/sid/Desktop/filter1/BooleanExpression.g4 by ANTLR 4.13.1 +// Generated from /Users/sidhantaggarwal/bool-parser-java/src/main/java/resources/BooleanExpression.g4 by ANTLR 4.13.2 +package com.github.sidhant92.boolparser.parser.antlr; import org.antlr.v4.runtime.ParserRuleContext; import org.antlr.v4.runtime.tree.ErrorNode; @@ -23,6 +24,18 @@ public class BooleanExpressionBaseListener implements BooleanExpressionListener *

The default implementation does nothing.

*/ @Override public void exitParse(BooleanExpressionParser.ParseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUnaryArithmeticExpression(BooleanExpressionParser.UnaryArithmeticExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUnaryArithmeticExpression(BooleanExpressionParser.UnaryArithmeticExpressionContext ctx) { } /** * {@inheritDoc} * @@ -83,6 +96,18 @@ public class BooleanExpressionBaseListener implements BooleanExpressionListener *

The default implementation does nothing.

*/ @Override public void exitToExpression(BooleanExpressionParser.ToExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArithmeticFunctionExpression(BooleanExpressionParser.ArithmeticFunctionExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArithmeticFunctionExpression(BooleanExpressionParser.ArithmeticFunctionExpressionContext ctx) { } /** * {@inheritDoc} * @@ -95,6 +120,18 @@ public class BooleanExpressionBaseListener implements BooleanExpressionListener *

The default implementation does nothing.

*/ @Override public void exitNotExpression(BooleanExpressionParser.NotExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArithmeticExpression(BooleanExpressionParser.ArithmeticExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArithmeticExpression(BooleanExpressionParser.ArithmeticExpressionContext ctx) { } /** * {@inheritDoc} * @@ -131,6 +168,30 @@ public class BooleanExpressionBaseListener implements BooleanExpressionListener *

The default implementation does nothing.

*/ @Override public void exitComparator(BooleanExpressionParser.ComparatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArithmeticOperator(BooleanExpressionParser.ArithmeticOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArithmeticOperator(BooleanExpressionParser.ArithmeticOperatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArithmeticFunction(BooleanExpressionParser.ArithmeticFunctionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArithmeticFunction(BooleanExpressionParser.ArithmeticFunctionContext ctx) { } /** * {@inheritDoc} * diff --git a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionLexer.java b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionLexer.java index 559e5c4..6b10f3f 100644 --- a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionLexer.java +++ b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionLexer.java @@ -1,4 +1,5 @@ -package com.github.sidhant92.boolparser.parser.antlr;// Generated from /Users/sid/Desktop/filter1/BooleanExpression.g4 by ANTLR 4.13.1 +// Generated from /Users/sidhantaggarwal/bool-parser-java/src/main/java/resources/BooleanExpression.g4 by ANTLR 4.13.2 +package com.github.sidhant92.boolparser.parser.antlr; import org.antlr.v4.runtime.Lexer; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.Token; @@ -10,16 +11,19 @@ @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) public class BooleanExpressionLexer extends Lexer { - static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } + static { RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int T__0=1, IN=2, TO=3, AND=4, OR=5, NOT=6, TRUE=7, FALSE=8, CONTAINS_ALL=9, - CONTAINS_ANY=10, NE=11, GT=12, GE=13, LT=14, LE=15, EQ=16, LPAREN=17, - RPAREN=18, DECIMAL=19, APP_VERSION=20, INTEGER=21, WS=22, WORD=23, ALPHANUMERIC=24, - SQ=25, DQ=26; + CONTAINS_ANY=10, MIN=11, MAX=12, AVG=13, SUM=14, MEAN=15, MODE=16, MEDIAN=17, + LEN=18, INT=19, DAYS_ELAPSED=20, ADD=21, SUBTRACT=22, MULTIPLY=23, DIVIDE=24, + MODULUS=25, EXPONENT=26, NE=27, GT=28, GE=29, LT=30, LE=31, EQ=32, LPAREN=33, + RPAREN=34, DECIMAL=35, APP_VERSION=36, INTEGER=37, DATE=38, DATETIME=39, + WS=40, WORD=41, SQSTR=42, DQSTR=43, FIELD=44, ALPHANUMERIC=45, SQ=46, + DQ=47; public static String[] channelNames = { "DEFAULT_TOKEN_CHANNEL", "HIDDEN" }; @@ -31,26 +35,33 @@ public class BooleanExpressionLexer extends Lexer { private static String[] makeRuleNames() { return new String[] { "T__0", "IN", "TO", "AND", "OR", "NOT", "TRUE", "FALSE", "CONTAINS_ALL", - "CONTAINS_ANY", "NE", "GT", "GE", "LT", "LE", "EQ", "LPAREN", "RPAREN", - "DECIMAL", "APP_VERSION", "INTEGER", "WS", "WORD", "ALPHANUMERIC", "SQ", - "DQ" + "CONTAINS_ANY", "MIN", "MAX", "AVG", "SUM", "MEAN", "MODE", "MEDIAN", + "LEN", "INT", "DAYS_ELAPSED", "ADD", "SUBTRACT", "MULTIPLY", "DIVIDE", + "MODULUS", "EXPONENT", "NE", "GT", "GE", "LT", "LE", "EQ", "LPAREN", + "RPAREN", "DECIMAL", "APP_VERSION", "INTEGER", "DATE", "DATETIME", "WS", + "WORD", "SQSTR", "DQSTR", "FIELD", "ALPHANUMERIC", "SQ", "DQ", "DATE_PATTERN", + "DATETIME_PATTERN" }; } public static final String[] ruleNames = makeRuleNames(); private static String[] makeLiteralNames() { return new String[] { - null, "','", null, null, null, null, null, null, null, null, null, "'!='", - "'>'", "'>='", "'<'", "'<='", "'='", "'('", "')'" + null, "','", null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, "'+'", "'-'", "'*'", + "'/'", "'%'", "'^'", "'!='", "'>'", "'>='", "'<'", "'<='", "'='", "'('", + "')'" }; } private static final String[] _LITERAL_NAMES = makeLiteralNames(); private static String[] makeSymbolicNames() { return new String[] { null, null, "IN", "TO", "AND", "OR", "NOT", "TRUE", "FALSE", "CONTAINS_ALL", - "CONTAINS_ANY", "NE", "GT", "GE", "LT", "LE", "EQ", "LPAREN", "RPAREN", - "DECIMAL", "APP_VERSION", "INTEGER", "WS", "WORD", "ALPHANUMERIC", "SQ", - "DQ" + "CONTAINS_ANY", "MIN", "MAX", "AVG", "SUM", "MEAN", "MODE", "MEDIAN", + "LEN", "INT", "DAYS_ELAPSED", "ADD", "SUBTRACT", "MULTIPLY", "DIVIDE", + "MODULUS", "EXPONENT", "NE", "GT", "GE", "LT", "LE", "EQ", "LPAREN", + "RPAREN", "DECIMAL", "APP_VERSION", "INTEGER", "DATE", "DATETIME", "WS", + "WORD", "SQSTR", "DQSTR", "FIELD", "ALPHANUMERIC", "SQ", "DQ" }; } private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); @@ -112,161 +123,298 @@ public BooleanExpressionLexer(CharStream input) { public ATN getATN() { return _ATN; } public static final String _serializedATN = - "\u0004\u0000\u001a\u00f4\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002"+ - "\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002"+ - "\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002"+ - "\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002"+ - "\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e"+ - "\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011"+ - "\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014"+ - "\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017"+ - "\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0001\u0000\u0001\u0000"+ - "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u0001<\b\u0001"+ - "\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0003\u0002B\b\u0002"+ - "\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+ - "\u0001\u0003\u0001\u0003\u0003\u0003L\b\u0003\u0001\u0004\u0001\u0004"+ - "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0003\u0004T\b\u0004"+ - "\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005"+ - "\u0003\u0005\\\b\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006"+ - "\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003\u0006f\b\u0006"+ + "\u0004\u0000/\u01d1\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002\u0001"+ + "\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004"+ + "\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007"+ + "\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b"+ + "\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002"+ + "\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002"+ + "\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002"+ + "\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002"+ + "\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002"+ + "\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002"+ + "\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007"+ + "!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007"+ + "&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007"+ + "+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u0007"+ + "0\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ + "\u0003\u0001j\b\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+ + "\u0003\u0002p\b\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+ + "\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0003\u0003z\b\u0003"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+ + "\u0003\u0004\u0082\b\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005"+ + "\u0001\u0005\u0001\u0005\u0003\u0005\u008a\b\u0005\u0001\u0006\u0001\u0006"+ + "\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006"+ + "\u0003\u0006\u0094\b\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+ "\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007"+ - "\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0003\u0007r\b\u0007"+ - "\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+ + "\u0003\u0007\u00a0\b\u0007\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+ "\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+ - "\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0003\b\u008c\b\b\u0001"+ - "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001"+ + "\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+ + "\b\u0003\b\u00ba\b\b\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001"+ "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001"+ - "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u00a6\b\t\u0001\n\u0001"+ - "\n\u0001\n\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001\r\u0001"+ - "\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001\u000f\u0001\u0010"+ - "\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0012\u0004\u0012\u00bc\b\u0012"+ - "\u000b\u0012\f\u0012\u00bd\u0001\u0012\u0001\u0012\u0004\u0012\u00c2\b"+ - "\u0012\u000b\u0012\f\u0012\u00c3\u0001\u0013\u0001\u0013\u0001\u0013\u0004"+ - "\u0013\u00c9\b\u0013\u000b\u0013\f\u0013\u00ca\u0001\u0014\u0004\u0014"+ - "\u00ce\b\u0014\u000b\u0014\f\u0014\u00cf\u0001\u0015\u0004\u0015\u00d3"+ - "\b\u0015\u000b\u0015\f\u0015\u00d4\u0001\u0015\u0001\u0015\u0001\u0016"+ - "\u0001\u0016\u0001\u0016\u0001\u0016\u0004\u0016\u00dd\b\u0016\u000b\u0016"+ - "\f\u0016\u00de\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0005\u0018"+ - "\u00e5\b\u0018\n\u0018\f\u0018\u00e8\t\u0018\u0001\u0018\u0001\u0018\u0001"+ - "\u0019\u0001\u0019\u0005\u0019\u00ee\b\u0019\n\u0019\f\u0019\u00f1\t\u0019"+ - "\u0001\u0019\u0001\u0019\u0002\u00e6\u00ef\u0000\u001a\u0001\u0001\u0003"+ - "\u0002\u0005\u0003\u0007\u0004\t\u0005\u000b\u0006\r\u0007\u000f\b\u0011"+ - "\t\u0013\n\u0015\u000b\u0017\f\u0019\r\u001b\u000e\u001d\u000f\u001f\u0010"+ - "!\u0011#\u0012%\u0013\'\u0014)\u0015+\u0016-\u0017/\u00181\u00193\u001a"+ - "\u0001\u0000\u0004\u0001\u000009\u0003\u0000\t\n\f\r \u0002\u0000-._"+ - "_\u0003\u000009AZaz\u0109\u0000\u0001\u0001\u0000\u0000\u0000\u0000\u0003"+ - "\u0001\u0000\u0000\u0000\u0000\u0005\u0001\u0000\u0000\u0000\u0000\u0007"+ - "\u0001\u0000\u0000\u0000\u0000\t\u0001\u0000\u0000\u0000\u0000\u000b\u0001"+ - "\u0000\u0000\u0000\u0000\r\u0001\u0000\u0000\u0000\u0000\u000f\u0001\u0000"+ - "\u0000\u0000\u0000\u0011\u0001\u0000\u0000\u0000\u0000\u0013\u0001\u0000"+ - "\u0000\u0000\u0000\u0015\u0001\u0000\u0000\u0000\u0000\u0017\u0001\u0000"+ - "\u0000\u0000\u0000\u0019\u0001\u0000\u0000\u0000\u0000\u001b\u0001\u0000"+ - "\u0000\u0000\u0000\u001d\u0001\u0000\u0000\u0000\u0000\u001f\u0001\u0000"+ - "\u0000\u0000\u0000!\u0001\u0000\u0000\u0000\u0000#\u0001\u0000\u0000\u0000"+ - "\u0000%\u0001\u0000\u0000\u0000\u0000\'\u0001\u0000\u0000\u0000\u0000"+ - ")\u0001\u0000\u0000\u0000\u0000+\u0001\u0000\u0000\u0000\u0000-\u0001"+ - "\u0000\u0000\u0000\u0000/\u0001\u0000\u0000\u0000\u00001\u0001\u0000\u0000"+ - "\u0000\u00003\u0001\u0000\u0000\u0000\u00015\u0001\u0000\u0000\u0000\u0003"+ - ";\u0001\u0000\u0000\u0000\u0005A\u0001\u0000\u0000\u0000\u0007K\u0001"+ - "\u0000\u0000\u0000\tS\u0001\u0000\u0000\u0000\u000b[\u0001\u0000\u0000"+ - "\u0000\re\u0001\u0000\u0000\u0000\u000fq\u0001\u0000\u0000\u0000\u0011"+ - "\u008b\u0001\u0000\u0000\u0000\u0013\u00a5\u0001\u0000\u0000\u0000\u0015"+ - "\u00a7\u0001\u0000\u0000\u0000\u0017\u00aa\u0001\u0000\u0000\u0000\u0019"+ - "\u00ac\u0001\u0000\u0000\u0000\u001b\u00af\u0001\u0000\u0000\u0000\u001d"+ - "\u00b1\u0001\u0000\u0000\u0000\u001f\u00b4\u0001\u0000\u0000\u0000!\u00b6"+ - "\u0001\u0000\u0000\u0000#\u00b8\u0001\u0000\u0000\u0000%\u00bb\u0001\u0000"+ - "\u0000\u0000\'\u00c5\u0001\u0000\u0000\u0000)\u00cd\u0001\u0000\u0000"+ - "\u0000+\u00d2\u0001\u0000\u0000\u0000-\u00dc\u0001\u0000\u0000\u0000/"+ - "\u00e0\u0001\u0000\u0000\u00001\u00e2\u0001\u0000\u0000\u00003\u00eb\u0001"+ - "\u0000\u0000\u000056\u0005,\u0000\u00006\u0002\u0001\u0000\u0000\u0000"+ - "78\u0005I\u0000\u00008<\u0005N\u0000\u00009:\u0005i\u0000\u0000:<\u0005"+ - "n\u0000\u0000;7\u0001\u0000\u0000\u0000;9\u0001\u0000\u0000\u0000<\u0004"+ - "\u0001\u0000\u0000\u0000=>\u0005T\u0000\u0000>B\u0005O\u0000\u0000?@\u0005"+ - "t\u0000\u0000@B\u0005o\u0000\u0000A=\u0001\u0000\u0000\u0000A?\u0001\u0000"+ - "\u0000\u0000B\u0006\u0001\u0000\u0000\u0000CD\u0005A\u0000\u0000DE\u0005"+ - "N\u0000\u0000EL\u0005D\u0000\u0000FG\u0005a\u0000\u0000GH\u0005n\u0000"+ - "\u0000HL\u0005d\u0000\u0000IJ\u0005&\u0000\u0000JL\u0005&\u0000\u0000"+ - "KC\u0001\u0000\u0000\u0000KF\u0001\u0000\u0000\u0000KI\u0001\u0000\u0000"+ - "\u0000L\b\u0001\u0000\u0000\u0000MN\u0005O\u0000\u0000NT\u0005R\u0000"+ - "\u0000OP\u0005o\u0000\u0000PT\u0005r\u0000\u0000QR\u0005|\u0000\u0000"+ - "RT\u0005|\u0000\u0000SM\u0001\u0000\u0000\u0000SO\u0001\u0000\u0000\u0000"+ - "SQ\u0001\u0000\u0000\u0000T\n\u0001\u0000\u0000\u0000UV\u0005N\u0000\u0000"+ - "VW\u0005O\u0000\u0000W\\\u0005T\u0000\u0000XY\u0005n\u0000\u0000YZ\u0005"+ - "o\u0000\u0000Z\\\u0005t\u0000\u0000[U\u0001\u0000\u0000\u0000[X\u0001"+ - "\u0000\u0000\u0000\\\f\u0001\u0000\u0000\u0000]^\u0005T\u0000\u0000^_"+ - "\u0005R\u0000\u0000_`\u0005U\u0000\u0000`f\u0005E\u0000\u0000ab\u0005"+ - "t\u0000\u0000bc\u0005r\u0000\u0000cd\u0005u\u0000\u0000df\u0005e\u0000"+ - "\u0000e]\u0001\u0000\u0000\u0000ea\u0001\u0000\u0000\u0000f\u000e\u0001"+ - "\u0000\u0000\u0000gh\u0005F\u0000\u0000hi\u0005A\u0000\u0000ij\u0005L"+ - "\u0000\u0000jk\u0005S\u0000\u0000kr\u0005E\u0000\u0000lm\u0005f\u0000"+ - "\u0000mn\u0005a\u0000\u0000no\u0005l\u0000\u0000op\u0005s\u0000\u0000"+ - "pr\u0005e\u0000\u0000qg\u0001\u0000\u0000\u0000ql\u0001\u0000\u0000\u0000"+ - "r\u0010\u0001\u0000\u0000\u0000st\u0005C\u0000\u0000tu\u0005O\u0000\u0000"+ - "uv\u0005N\u0000\u0000vw\u0005T\u0000\u0000wx\u0005A\u0000\u0000xy\u0005"+ - "I\u0000\u0000yz\u0005N\u0000\u0000z{\u0005S\u0000\u0000{|\u0005_\u0000"+ - "\u0000|}\u0005A\u0000\u0000}~\u0005L\u0000\u0000~\u008c\u0005L\u0000\u0000"+ - "\u007f\u0080\u0005c\u0000\u0000\u0080\u0081\u0005o\u0000\u0000\u0081\u0082"+ - "\u0005n\u0000\u0000\u0082\u0083\u0005t\u0000\u0000\u0083\u0084\u0005a"+ - "\u0000\u0000\u0084\u0085\u0005i\u0000\u0000\u0085\u0086\u0005n\u0000\u0000"+ - "\u0086\u0087\u0005s\u0000\u0000\u0087\u0088\u0005_\u0000\u0000\u0088\u0089"+ - "\u0005a\u0000\u0000\u0089\u008a\u0005l\u0000\u0000\u008a\u008c\u0005l"+ - "\u0000\u0000\u008bs\u0001\u0000\u0000\u0000\u008b\u007f\u0001\u0000\u0000"+ - "\u0000\u008c\u0012\u0001\u0000\u0000\u0000\u008d\u008e\u0005C\u0000\u0000"+ - "\u008e\u008f\u0005O\u0000\u0000\u008f\u0090\u0005N\u0000\u0000\u0090\u0091"+ - "\u0005T\u0000\u0000\u0091\u0092\u0005A\u0000\u0000\u0092\u0093\u0005I"+ - "\u0000\u0000\u0093\u0094\u0005N\u0000\u0000\u0094\u0095\u0005S\u0000\u0000"+ - "\u0095\u0096\u0005_\u0000\u0000\u0096\u0097\u0005A\u0000\u0000\u0097\u0098"+ - "\u0005N\u0000\u0000\u0098\u00a6\u0005Y\u0000\u0000\u0099\u009a\u0005c"+ - "\u0000\u0000\u009a\u009b\u0005o\u0000\u0000\u009b\u009c\u0005n\u0000\u0000"+ - "\u009c\u009d\u0005t\u0000\u0000\u009d\u009e\u0005a\u0000\u0000\u009e\u009f"+ - "\u0005i\u0000\u0000\u009f\u00a0\u0005n\u0000\u0000\u00a0\u00a1\u0005s"+ - "\u0000\u0000\u00a1\u00a2\u0005_\u0000\u0000\u00a2\u00a3\u0005a\u0000\u0000"+ - "\u00a3\u00a4\u0005n\u0000\u0000\u00a4\u00a6\u0005y\u0000\u0000\u00a5\u008d"+ - "\u0001\u0000\u0000\u0000\u00a5\u0099\u0001\u0000\u0000\u0000\u00a6\u0014"+ - "\u0001\u0000\u0000\u0000\u00a7\u00a8\u0005!\u0000\u0000\u00a8\u00a9\u0005"+ - "=\u0000\u0000\u00a9\u0016\u0001\u0000\u0000\u0000\u00aa\u00ab\u0005>\u0000"+ - "\u0000\u00ab\u0018\u0001\u0000\u0000\u0000\u00ac\u00ad\u0005>\u0000\u0000"+ - "\u00ad\u00ae\u0005=\u0000\u0000\u00ae\u001a\u0001\u0000\u0000\u0000\u00af"+ - "\u00b0\u0005<\u0000\u0000\u00b0\u001c\u0001\u0000\u0000\u0000\u00b1\u00b2"+ - "\u0005<\u0000\u0000\u00b2\u00b3\u0005=\u0000\u0000\u00b3\u001e\u0001\u0000"+ - "\u0000\u0000\u00b4\u00b5\u0005=\u0000\u0000\u00b5 \u0001\u0000\u0000\u0000"+ - "\u00b6\u00b7\u0005(\u0000\u0000\u00b7\"\u0001\u0000\u0000\u0000\u00b8"+ - "\u00b9\u0005)\u0000\u0000\u00b9$\u0001\u0000\u0000\u0000\u00ba\u00bc\u0007"+ - "\u0000\u0000\u0000\u00bb\u00ba\u0001\u0000\u0000\u0000\u00bc\u00bd\u0001"+ - "\u0000\u0000\u0000\u00bd\u00bb\u0001\u0000\u0000\u0000\u00bd\u00be\u0001"+ - "\u0000\u0000\u0000\u00be\u00bf\u0001\u0000\u0000\u0000\u00bf\u00c1\u0005"+ - ".\u0000\u0000\u00c0\u00c2\u0007\u0000\u0000\u0000\u00c1\u00c0\u0001\u0000"+ - "\u0000\u0000\u00c2\u00c3\u0001\u0000\u0000\u0000\u00c3\u00c1\u0001\u0000"+ - "\u0000\u0000\u00c3\u00c4\u0001\u0000\u0000\u0000\u00c4&\u0001\u0000\u0000"+ - "\u0000\u00c5\u00c8\u0007\u0000\u0000\u0000\u00c6\u00c7\u0005.\u0000\u0000"+ - "\u00c7\u00c9\u0003)\u0014\u0000\u00c8\u00c6\u0001\u0000\u0000\u0000\u00c9"+ - "\u00ca\u0001\u0000\u0000\u0000\u00ca\u00c8\u0001\u0000\u0000\u0000\u00ca"+ - "\u00cb\u0001\u0000\u0000\u0000\u00cb(\u0001\u0000\u0000\u0000\u00cc\u00ce"+ - "\u0007\u0000\u0000\u0000\u00cd\u00cc\u0001\u0000\u0000\u0000\u00ce\u00cf"+ - "\u0001\u0000\u0000\u0000\u00cf\u00cd\u0001\u0000\u0000\u0000\u00cf\u00d0"+ - "\u0001\u0000\u0000\u0000\u00d0*\u0001\u0000\u0000\u0000\u00d1\u00d3\u0007"+ - "\u0001\u0000\u0000\u00d2\u00d1\u0001\u0000\u0000\u0000\u00d3\u00d4\u0001"+ - "\u0000\u0000\u0000\u00d4\u00d2\u0001\u0000\u0000\u0000\u00d4\u00d5\u0001"+ - "\u0000\u0000\u0000\u00d5\u00d6\u0001\u0000\u0000\u0000\u00d6\u00d7\u0006"+ - "\u0015\u0000\u0000\u00d7,\u0001\u0000\u0000\u0000\u00d8\u00dd\u0003/\u0017"+ - "\u0000\u00d9\u00dd\u0007\u0002\u0000\u0000\u00da\u00dd\u00031\u0018\u0000"+ - "\u00db\u00dd\u00033\u0019\u0000\u00dc\u00d8\u0001\u0000\u0000\u0000\u00dc"+ - "\u00d9\u0001\u0000\u0000\u0000\u00dc\u00da\u0001\u0000\u0000\u0000\u00dc"+ - "\u00db\u0001\u0000\u0000\u0000\u00dd\u00de\u0001\u0000\u0000\u0000\u00de"+ - "\u00dc\u0001\u0000\u0000\u0000\u00de\u00df\u0001\u0000\u0000\u0000\u00df"+ - ".\u0001\u0000\u0000\u0000\u00e0\u00e1\u0007\u0003\u0000\u0000\u00e10\u0001"+ - "\u0000\u0000\u0000\u00e2\u00e6\u0005\'\u0000\u0000\u00e3\u00e5\t\u0000"+ - "\u0000\u0000\u00e4\u00e3\u0001\u0000\u0000\u0000\u00e5\u00e8\u0001\u0000"+ - "\u0000\u0000\u00e6\u00e7\u0001\u0000\u0000\u0000\u00e6\u00e4\u0001\u0000"+ - "\u0000\u0000\u00e7\u00e9\u0001\u0000\u0000\u0000\u00e8\u00e6\u0001\u0000"+ - "\u0000\u0000\u00e9\u00ea\u0005\'\u0000\u0000\u00ea2\u0001\u0000\u0000"+ - "\u0000\u00eb\u00ef\u0005\"\u0000\u0000\u00ec\u00ee\t\u0000\u0000\u0000"+ - "\u00ed\u00ec\u0001\u0000\u0000\u0000\u00ee\u00f1\u0001\u0000\u0000\u0000"+ - "\u00ef\u00f0\u0001\u0000\u0000\u0000\u00ef\u00ed\u0001\u0000\u0000\u0000"+ - "\u00f0\u00f2\u0001\u0000\u0000\u0000\u00f1\u00ef\u0001\u0000\u0000\u0000"+ - "\u00f2\u00f3\u0005\"\u0000\u0000\u00f34\u0001\u0000\u0000\u0000\u0013"+ - "\u0000;AKS[eq\u008b\u00a5\u00bd\u00c3\u00ca\u00cf\u00d4\u00dc\u00de\u00e6"+ - "\u00ef\u0001\u0006\u0000\u0000"; + "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003"+ + "\t\u00d4\b\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0003\n\u00dc"+ + "\b\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ + "\u000b\u0003\u000b\u00e4\b\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001"+ + "\f\u0001\f\u0003\f\u00ec\b\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+ + "\r\u0003\r\u00f4\b\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ + "\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0003\u000e\u00fe\b\u000e\u0001"+ + "\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+ + "\u000f\u0001\u000f\u0003\u000f\u0108\b\u000f\u0001\u0010\u0001\u0010\u0001"+ + "\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+ + "\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0003\u0010\u0116\b\u0010\u0001"+ + "\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0003"+ + "\u0011\u011e\b\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+ + "\u0012\u0001\u0012\u0003\u0012\u0126\b\u0012\u0001\u0013\u0001\u0013\u0001"+ + "\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+ + "\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+ + "\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+ + "\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u0140\b\u0013\u0001"+ + "\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001"+ + "\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001"+ + "\u001a\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001"+ + "\u001e\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001!\u0001!\u0001\"\u0004"+ + "\"\u0162\b\"\u000b\"\f\"\u0163\u0001\"\u0001\"\u0004\"\u0168\b\"\u000b"+ + "\"\f\"\u0169\u0001#\u0001#\u0001#\u0004#\u016f\b#\u000b#\f#\u0170\u0001"+ + "$\u0004$\u0174\b$\u000b$\f$\u0175\u0001%\u0001%\u0001&\u0001&\u0001\'"+ + "\u0004\'\u017d\b\'\u000b\'\f\'\u017e\u0001\'\u0001\'\u0001(\u0001(\u0003"+ + "(\u0185\b(\u0001)\u0001)\u0005)\u0189\b)\n)\f)\u018c\t)\u0001)\u0001)"+ + "\u0001*\u0001*\u0005*\u0192\b*\n*\f*\u0195\t*\u0001*\u0001*\u0001+\u0001"+ + "+\u0004+\u019b\b+\u000b+\f+\u019c\u0001,\u0001,\u0001-\u0001-\u0005-\u01a3"+ + "\b-\n-\f-\u01a6\t-\u0001-\u0001-\u0001.\u0001.\u0005.\u01ac\b.\n.\f.\u01af"+ + "\t.\u0001.\u0001.\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+ + "/\u0001/\u0001/\u0001/\u00010\u00010\u00010\u00010\u00010\u00010\u0001"+ + "0\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u00010\u0001"+ + "0\u00010\u00010\u00010\u0004\u018a\u0193\u01a4\u01ad\u00001\u0001\u0001"+ + "\u0003\u0002\u0005\u0003\u0007\u0004\t\u0005\u000b\u0006\r\u0007\u000f"+ + "\b\u0011\t\u0013\n\u0015\u000b\u0017\f\u0019\r\u001b\u000e\u001d\u000f"+ + "\u001f\u0010!\u0011#\u0012%\u0013\'\u0014)\u0015+\u0016-\u0017/\u0018"+ + "1\u00193\u001a5\u001b7\u001c9\u001d;\u001e=\u001f? A!C\"E#G$I%K&M\'O("+ + "Q)S*U+W,Y-[.]/_\u0000a\u0000\u0001\u0000\u0004\u0001\u000009\u0003\u0000"+ + "\t\n\f\r \u0002\u0000..__\u0003\u000009AZaz\u01ef\u0000\u0001\u0001\u0000"+ + "\u0000\u0000\u0000\u0003\u0001\u0000\u0000\u0000\u0000\u0005\u0001\u0000"+ + "\u0000\u0000\u0000\u0007\u0001\u0000\u0000\u0000\u0000\t\u0001\u0000\u0000"+ + "\u0000\u0000\u000b\u0001\u0000\u0000\u0000\u0000\r\u0001\u0000\u0000\u0000"+ + "\u0000\u000f\u0001\u0000\u0000\u0000\u0000\u0011\u0001\u0000\u0000\u0000"+ + "\u0000\u0013\u0001\u0000\u0000\u0000\u0000\u0015\u0001\u0000\u0000\u0000"+ + "\u0000\u0017\u0001\u0000\u0000\u0000\u0000\u0019\u0001\u0000\u0000\u0000"+ + "\u0000\u001b\u0001\u0000\u0000\u0000\u0000\u001d\u0001\u0000\u0000\u0000"+ + "\u0000\u001f\u0001\u0000\u0000\u0000\u0000!\u0001\u0000\u0000\u0000\u0000"+ + "#\u0001\u0000\u0000\u0000\u0000%\u0001\u0000\u0000\u0000\u0000\'\u0001"+ + "\u0000\u0000\u0000\u0000)\u0001\u0000\u0000\u0000\u0000+\u0001\u0000\u0000"+ + "\u0000\u0000-\u0001\u0000\u0000\u0000\u0000/\u0001\u0000\u0000\u0000\u0000"+ + "1\u0001\u0000\u0000\u0000\u00003\u0001\u0000\u0000\u0000\u00005\u0001"+ + "\u0000\u0000\u0000\u00007\u0001\u0000\u0000\u0000\u00009\u0001\u0000\u0000"+ + "\u0000\u0000;\u0001\u0000\u0000\u0000\u0000=\u0001\u0000\u0000\u0000\u0000"+ + "?\u0001\u0000\u0000\u0000\u0000A\u0001\u0000\u0000\u0000\u0000C\u0001"+ + "\u0000\u0000\u0000\u0000E\u0001\u0000\u0000\u0000\u0000G\u0001\u0000\u0000"+ + "\u0000\u0000I\u0001\u0000\u0000\u0000\u0000K\u0001\u0000\u0000\u0000\u0000"+ + "M\u0001\u0000\u0000\u0000\u0000O\u0001\u0000\u0000\u0000\u0000Q\u0001"+ + "\u0000\u0000\u0000\u0000S\u0001\u0000\u0000\u0000\u0000U\u0001\u0000\u0000"+ + "\u0000\u0000W\u0001\u0000\u0000\u0000\u0000Y\u0001\u0000\u0000\u0000\u0000"+ + "[\u0001\u0000\u0000\u0000\u0000]\u0001\u0000\u0000\u0000\u0001c\u0001"+ + "\u0000\u0000\u0000\u0003i\u0001\u0000\u0000\u0000\u0005o\u0001\u0000\u0000"+ + "\u0000\u0007y\u0001\u0000\u0000\u0000\t\u0081\u0001\u0000\u0000\u0000"+ + "\u000b\u0089\u0001\u0000\u0000\u0000\r\u0093\u0001\u0000\u0000\u0000\u000f"+ + "\u009f\u0001\u0000\u0000\u0000\u0011\u00b9\u0001\u0000\u0000\u0000\u0013"+ + "\u00d3\u0001\u0000\u0000\u0000\u0015\u00db\u0001\u0000\u0000\u0000\u0017"+ + "\u00e3\u0001\u0000\u0000\u0000\u0019\u00eb\u0001\u0000\u0000\u0000\u001b"+ + "\u00f3\u0001\u0000\u0000\u0000\u001d\u00fd\u0001\u0000\u0000\u0000\u001f"+ + "\u0107\u0001\u0000\u0000\u0000!\u0115\u0001\u0000\u0000\u0000#\u011d\u0001"+ + "\u0000\u0000\u0000%\u0125\u0001\u0000\u0000\u0000\'\u013f\u0001\u0000"+ + "\u0000\u0000)\u0141\u0001\u0000\u0000\u0000+\u0143\u0001\u0000\u0000\u0000"+ + "-\u0145\u0001\u0000\u0000\u0000/\u0147\u0001\u0000\u0000\u00001\u0149"+ + "\u0001\u0000\u0000\u00003\u014b\u0001\u0000\u0000\u00005\u014d\u0001\u0000"+ + "\u0000\u00007\u0150\u0001\u0000\u0000\u00009\u0152\u0001\u0000\u0000\u0000"+ + ";\u0155\u0001\u0000\u0000\u0000=\u0157\u0001\u0000\u0000\u0000?\u015a"+ + "\u0001\u0000\u0000\u0000A\u015c\u0001\u0000\u0000\u0000C\u015e\u0001\u0000"+ + "\u0000\u0000E\u0161\u0001\u0000\u0000\u0000G\u016b\u0001\u0000\u0000\u0000"+ + "I\u0173\u0001\u0000\u0000\u0000K\u0177\u0001\u0000\u0000\u0000M\u0179"+ + "\u0001\u0000\u0000\u0000O\u017c\u0001\u0000\u0000\u0000Q\u0184\u0001\u0000"+ + "\u0000\u0000S\u0186\u0001\u0000\u0000\u0000U\u018f\u0001\u0000\u0000\u0000"+ + "W\u019a\u0001\u0000\u0000\u0000Y\u019e\u0001\u0000\u0000\u0000[\u01a0"+ + "\u0001\u0000\u0000\u0000]\u01a9\u0001\u0000\u0000\u0000_\u01b2\u0001\u0000"+ + "\u0000\u0000a\u01bd\u0001\u0000\u0000\u0000cd\u0005,\u0000\u0000d\u0002"+ + "\u0001\u0000\u0000\u0000ef\u0005I\u0000\u0000fj\u0005N\u0000\u0000gh\u0005"+ + "i\u0000\u0000hj\u0005n\u0000\u0000ie\u0001\u0000\u0000\u0000ig\u0001\u0000"+ + "\u0000\u0000j\u0004\u0001\u0000\u0000\u0000kl\u0005T\u0000\u0000lp\u0005"+ + "O\u0000\u0000mn\u0005t\u0000\u0000np\u0005o\u0000\u0000ok\u0001\u0000"+ + "\u0000\u0000om\u0001\u0000\u0000\u0000p\u0006\u0001\u0000\u0000\u0000"+ + "qr\u0005A\u0000\u0000rs\u0005N\u0000\u0000sz\u0005D\u0000\u0000tu\u0005"+ + "a\u0000\u0000uv\u0005n\u0000\u0000vz\u0005d\u0000\u0000wx\u0005&\u0000"+ + "\u0000xz\u0005&\u0000\u0000yq\u0001\u0000\u0000\u0000yt\u0001\u0000\u0000"+ + "\u0000yw\u0001\u0000\u0000\u0000z\b\u0001\u0000\u0000\u0000{|\u0005O\u0000"+ + "\u0000|\u0082\u0005R\u0000\u0000}~\u0005o\u0000\u0000~\u0082\u0005r\u0000"+ + "\u0000\u007f\u0080\u0005|\u0000\u0000\u0080\u0082\u0005|\u0000\u0000\u0081"+ + "{\u0001\u0000\u0000\u0000\u0081}\u0001\u0000\u0000\u0000\u0081\u007f\u0001"+ + "\u0000\u0000\u0000\u0082\n\u0001\u0000\u0000\u0000\u0083\u0084\u0005N"+ + "\u0000\u0000\u0084\u0085\u0005O\u0000\u0000\u0085\u008a\u0005T\u0000\u0000"+ + "\u0086\u0087\u0005n\u0000\u0000\u0087\u0088\u0005o\u0000\u0000\u0088\u008a"+ + "\u0005t\u0000\u0000\u0089\u0083\u0001\u0000\u0000\u0000\u0089\u0086\u0001"+ + "\u0000\u0000\u0000\u008a\f\u0001\u0000\u0000\u0000\u008b\u008c\u0005T"+ + "\u0000\u0000\u008c\u008d\u0005R\u0000\u0000\u008d\u008e\u0005U\u0000\u0000"+ + "\u008e\u0094\u0005E\u0000\u0000\u008f\u0090\u0005t\u0000\u0000\u0090\u0091"+ + "\u0005r\u0000\u0000\u0091\u0092\u0005u\u0000\u0000\u0092\u0094\u0005e"+ + "\u0000\u0000\u0093\u008b\u0001\u0000\u0000\u0000\u0093\u008f\u0001\u0000"+ + "\u0000\u0000\u0094\u000e\u0001\u0000\u0000\u0000\u0095\u0096\u0005F\u0000"+ + "\u0000\u0096\u0097\u0005A\u0000\u0000\u0097\u0098\u0005L\u0000\u0000\u0098"+ + "\u0099\u0005S\u0000\u0000\u0099\u00a0\u0005E\u0000\u0000\u009a\u009b\u0005"+ + "f\u0000\u0000\u009b\u009c\u0005a\u0000\u0000\u009c\u009d\u0005l\u0000"+ + "\u0000\u009d\u009e\u0005s\u0000\u0000\u009e\u00a0\u0005e\u0000\u0000\u009f"+ + "\u0095\u0001\u0000\u0000\u0000\u009f\u009a\u0001\u0000\u0000\u0000\u00a0"+ + "\u0010\u0001\u0000\u0000\u0000\u00a1\u00a2\u0005C\u0000\u0000\u00a2\u00a3"+ + "\u0005O\u0000\u0000\u00a3\u00a4\u0005N\u0000\u0000\u00a4\u00a5\u0005T"+ + "\u0000\u0000\u00a5\u00a6\u0005A\u0000\u0000\u00a6\u00a7\u0005I\u0000\u0000"+ + "\u00a7\u00a8\u0005N\u0000\u0000\u00a8\u00a9\u0005S\u0000\u0000\u00a9\u00aa"+ + "\u0005_\u0000\u0000\u00aa\u00ab\u0005A\u0000\u0000\u00ab\u00ac\u0005L"+ + "\u0000\u0000\u00ac\u00ba\u0005L\u0000\u0000\u00ad\u00ae\u0005c\u0000\u0000"+ + "\u00ae\u00af\u0005o\u0000\u0000\u00af\u00b0\u0005n\u0000\u0000\u00b0\u00b1"+ + "\u0005t\u0000\u0000\u00b1\u00b2\u0005a\u0000\u0000\u00b2\u00b3\u0005i"+ + "\u0000\u0000\u00b3\u00b4\u0005n\u0000\u0000\u00b4\u00b5\u0005s\u0000\u0000"+ + "\u00b5\u00b6\u0005_\u0000\u0000\u00b6\u00b7\u0005a\u0000\u0000\u00b7\u00b8"+ + "\u0005l\u0000\u0000\u00b8\u00ba\u0005l\u0000\u0000\u00b9\u00a1\u0001\u0000"+ + "\u0000\u0000\u00b9\u00ad\u0001\u0000\u0000\u0000\u00ba\u0012\u0001\u0000"+ + "\u0000\u0000\u00bb\u00bc\u0005C\u0000\u0000\u00bc\u00bd\u0005O\u0000\u0000"+ + "\u00bd\u00be\u0005N\u0000\u0000\u00be\u00bf\u0005T\u0000\u0000\u00bf\u00c0"+ + "\u0005A\u0000\u0000\u00c0\u00c1\u0005I\u0000\u0000\u00c1\u00c2\u0005N"+ + "\u0000\u0000\u00c2\u00c3\u0005S\u0000\u0000\u00c3\u00c4\u0005_\u0000\u0000"+ + "\u00c4\u00c5\u0005A\u0000\u0000\u00c5\u00c6\u0005N\u0000\u0000\u00c6\u00d4"+ + "\u0005Y\u0000\u0000\u00c7\u00c8\u0005c\u0000\u0000\u00c8\u00c9\u0005o"+ + "\u0000\u0000\u00c9\u00ca\u0005n\u0000\u0000\u00ca\u00cb\u0005t\u0000\u0000"+ + "\u00cb\u00cc\u0005a\u0000\u0000\u00cc\u00cd\u0005i\u0000\u0000\u00cd\u00ce"+ + "\u0005n\u0000\u0000\u00ce\u00cf\u0005s\u0000\u0000\u00cf\u00d0\u0005_"+ + "\u0000\u0000\u00d0\u00d1\u0005a\u0000\u0000\u00d1\u00d2\u0005n\u0000\u0000"+ + "\u00d2\u00d4\u0005y\u0000\u0000\u00d3\u00bb\u0001\u0000\u0000\u0000\u00d3"+ + "\u00c7\u0001\u0000\u0000\u0000\u00d4\u0014\u0001\u0000\u0000\u0000\u00d5"+ + "\u00d6\u0005M\u0000\u0000\u00d6\u00d7\u0005I\u0000\u0000\u00d7\u00dc\u0005"+ + "N\u0000\u0000\u00d8\u00d9\u0005m\u0000\u0000\u00d9\u00da\u0005i\u0000"+ + "\u0000\u00da\u00dc\u0005n\u0000\u0000\u00db\u00d5\u0001\u0000\u0000\u0000"+ + "\u00db\u00d8\u0001\u0000\u0000\u0000\u00dc\u0016\u0001\u0000\u0000\u0000"+ + "\u00dd\u00de\u0005M\u0000\u0000\u00de\u00df\u0005A\u0000\u0000\u00df\u00e4"+ + "\u0005X\u0000\u0000\u00e0\u00e1\u0005m\u0000\u0000\u00e1\u00e2\u0005a"+ + "\u0000\u0000\u00e2\u00e4\u0005x\u0000\u0000\u00e3\u00dd\u0001\u0000\u0000"+ + "\u0000\u00e3\u00e0\u0001\u0000\u0000\u0000\u00e4\u0018\u0001\u0000\u0000"+ + "\u0000\u00e5\u00e6\u0005A\u0000\u0000\u00e6\u00e7\u0005V\u0000\u0000\u00e7"+ + "\u00ec\u0005G\u0000\u0000\u00e8\u00e9\u0005a\u0000\u0000\u00e9\u00ea\u0005"+ + "v\u0000\u0000\u00ea\u00ec\u0005g\u0000\u0000\u00eb\u00e5\u0001\u0000\u0000"+ + "\u0000\u00eb\u00e8\u0001\u0000\u0000\u0000\u00ec\u001a\u0001\u0000\u0000"+ + "\u0000\u00ed\u00ee\u0005S\u0000\u0000\u00ee\u00ef\u0005U\u0000\u0000\u00ef"+ + "\u00f4\u0005M\u0000\u0000\u00f0\u00f1\u0005s\u0000\u0000\u00f1\u00f2\u0005"+ + "u\u0000\u0000\u00f2\u00f4\u0005m\u0000\u0000\u00f3\u00ed\u0001\u0000\u0000"+ + "\u0000\u00f3\u00f0\u0001\u0000\u0000\u0000\u00f4\u001c\u0001\u0000\u0000"+ + "\u0000\u00f5\u00f6\u0005M\u0000\u0000\u00f6\u00f7\u0005E\u0000\u0000\u00f7"+ + "\u00f8\u0005A\u0000\u0000\u00f8\u00fe\u0005N\u0000\u0000\u00f9\u00fa\u0005"+ + "m\u0000\u0000\u00fa\u00fb\u0005e\u0000\u0000\u00fb\u00fc\u0005a\u0000"+ + "\u0000\u00fc\u00fe\u0005n\u0000\u0000\u00fd\u00f5\u0001\u0000\u0000\u0000"+ + "\u00fd\u00f9\u0001\u0000\u0000\u0000\u00fe\u001e\u0001\u0000\u0000\u0000"+ + "\u00ff\u0100\u0005M\u0000\u0000\u0100\u0101\u0005O\u0000\u0000\u0101\u0102"+ + "\u0005D\u0000\u0000\u0102\u0108\u0005E\u0000\u0000\u0103\u0104\u0005m"+ + "\u0000\u0000\u0104\u0105\u0005o\u0000\u0000\u0105\u0106\u0005d\u0000\u0000"+ + "\u0106\u0108\u0005e\u0000\u0000\u0107\u00ff\u0001\u0000\u0000\u0000\u0107"+ + "\u0103\u0001\u0000\u0000\u0000\u0108 \u0001\u0000\u0000\u0000\u0109\u010a"+ + "\u0005M\u0000\u0000\u010a\u010b\u0005E\u0000\u0000\u010b\u010c\u0005D"+ + "\u0000\u0000\u010c\u010d\u0005I\u0000\u0000\u010d\u010e\u0005A\u0000\u0000"+ + "\u010e\u0116\u0005N\u0000\u0000\u010f\u0110\u0005m\u0000\u0000\u0110\u0111"+ + "\u0005e\u0000\u0000\u0111\u0112\u0005d\u0000\u0000\u0112\u0113\u0005i"+ + "\u0000\u0000\u0113\u0114\u0005a\u0000\u0000\u0114\u0116\u0005n\u0000\u0000"+ + "\u0115\u0109\u0001\u0000\u0000\u0000\u0115\u010f\u0001\u0000\u0000\u0000"+ + "\u0116\"\u0001\u0000\u0000\u0000\u0117\u0118\u0005L\u0000\u0000\u0118"+ + "\u0119\u0005E\u0000\u0000\u0119\u011e\u0005N\u0000\u0000\u011a\u011b\u0005"+ + "l\u0000\u0000\u011b\u011c\u0005e\u0000\u0000\u011c\u011e\u0005n\u0000"+ + "\u0000\u011d\u0117\u0001\u0000\u0000\u0000\u011d\u011a\u0001\u0000\u0000"+ + "\u0000\u011e$\u0001\u0000\u0000\u0000\u011f\u0120\u0005I\u0000\u0000\u0120"+ + "\u0121\u0005N\u0000\u0000\u0121\u0126\u0005T\u0000\u0000\u0122\u0123\u0005"+ + "i\u0000\u0000\u0123\u0124\u0005n\u0000\u0000\u0124\u0126\u0005t\u0000"+ + "\u0000\u0125\u011f\u0001\u0000\u0000\u0000\u0125\u0122\u0001\u0000\u0000"+ + "\u0000\u0126&\u0001\u0000\u0000\u0000\u0127\u0128\u0005D\u0000\u0000\u0128"+ + "\u0129\u0005A\u0000\u0000\u0129\u012a\u0005Y\u0000\u0000\u012a\u012b\u0005"+ + "S\u0000\u0000\u012b\u012c\u0005_\u0000\u0000\u012c\u012d\u0005E\u0000"+ + "\u0000\u012d\u012e\u0005L\u0000\u0000\u012e\u012f\u0005A\u0000\u0000\u012f"+ + "\u0130\u0005P\u0000\u0000\u0130\u0131\u0005S\u0000\u0000\u0131\u0132\u0005"+ + "E\u0000\u0000\u0132\u0140\u0005D\u0000\u0000\u0133\u0134\u0005d\u0000"+ + "\u0000\u0134\u0135\u0005a\u0000\u0000\u0135\u0136\u0005y\u0000\u0000\u0136"+ + "\u0137\u0005s\u0000\u0000\u0137\u0138\u0005_\u0000\u0000\u0138\u0139\u0005"+ + "e\u0000\u0000\u0139\u013a\u0005l\u0000\u0000\u013a\u013b\u0005a\u0000"+ + "\u0000\u013b\u013c\u0005p\u0000\u0000\u013c\u013d\u0005s\u0000\u0000\u013d"+ + "\u013e\u0005e\u0000\u0000\u013e\u0140\u0005d\u0000\u0000\u013f\u0127\u0001"+ + "\u0000\u0000\u0000\u013f\u0133\u0001\u0000\u0000\u0000\u0140(\u0001\u0000"+ + "\u0000\u0000\u0141\u0142\u0005+\u0000\u0000\u0142*\u0001\u0000\u0000\u0000"+ + "\u0143\u0144\u0005-\u0000\u0000\u0144,\u0001\u0000\u0000\u0000\u0145\u0146"+ + "\u0005*\u0000\u0000\u0146.\u0001\u0000\u0000\u0000\u0147\u0148\u0005/"+ + "\u0000\u0000\u01480\u0001\u0000\u0000\u0000\u0149\u014a\u0005%\u0000\u0000"+ + "\u014a2\u0001\u0000\u0000\u0000\u014b\u014c\u0005^\u0000\u0000\u014c4"+ + "\u0001\u0000\u0000\u0000\u014d\u014e\u0005!\u0000\u0000\u014e\u014f\u0005"+ + "=\u0000\u0000\u014f6\u0001\u0000\u0000\u0000\u0150\u0151\u0005>\u0000"+ + "\u0000\u01518\u0001\u0000\u0000\u0000\u0152\u0153\u0005>\u0000\u0000\u0153"+ + "\u0154\u0005=\u0000\u0000\u0154:\u0001\u0000\u0000\u0000\u0155\u0156\u0005"+ + "<\u0000\u0000\u0156<\u0001\u0000\u0000\u0000\u0157\u0158\u0005<\u0000"+ + "\u0000\u0158\u0159\u0005=\u0000\u0000\u0159>\u0001\u0000\u0000\u0000\u015a"+ + "\u015b\u0005=\u0000\u0000\u015b@\u0001\u0000\u0000\u0000\u015c\u015d\u0005"+ + "(\u0000\u0000\u015dB\u0001\u0000\u0000\u0000\u015e\u015f\u0005)\u0000"+ + "\u0000\u015fD\u0001\u0000\u0000\u0000\u0160\u0162\u0007\u0000\u0000\u0000"+ + "\u0161\u0160\u0001\u0000\u0000\u0000\u0162\u0163\u0001\u0000\u0000\u0000"+ + "\u0163\u0161\u0001\u0000\u0000\u0000\u0163\u0164\u0001\u0000\u0000\u0000"+ + "\u0164\u0165\u0001\u0000\u0000\u0000\u0165\u0167\u0005.\u0000\u0000\u0166"+ + "\u0168\u0007\u0000\u0000\u0000\u0167\u0166\u0001\u0000\u0000\u0000\u0168"+ + "\u0169\u0001\u0000\u0000\u0000\u0169\u0167\u0001\u0000\u0000\u0000\u0169"+ + "\u016a\u0001\u0000\u0000\u0000\u016aF\u0001\u0000\u0000\u0000\u016b\u016e"+ + "\u0007\u0000\u0000\u0000\u016c\u016d\u0005.\u0000\u0000\u016d\u016f\u0003"+ + "I$\u0000\u016e\u016c\u0001\u0000\u0000\u0000\u016f\u0170\u0001\u0000\u0000"+ + "\u0000\u0170\u016e\u0001\u0000\u0000\u0000\u0170\u0171\u0001\u0000\u0000"+ + "\u0000\u0171H\u0001\u0000\u0000\u0000\u0172\u0174\u0007\u0000\u0000\u0000"+ + "\u0173\u0172\u0001\u0000\u0000\u0000\u0174\u0175\u0001\u0000\u0000\u0000"+ + "\u0175\u0173\u0001\u0000\u0000\u0000\u0175\u0176\u0001\u0000\u0000\u0000"+ + "\u0176J\u0001\u0000\u0000\u0000\u0177\u0178\u0003_/\u0000\u0178L\u0001"+ + "\u0000\u0000\u0000\u0179\u017a\u0003a0\u0000\u017aN\u0001\u0000\u0000"+ + "\u0000\u017b\u017d\u0007\u0001\u0000\u0000\u017c\u017b\u0001\u0000\u0000"+ + "\u0000\u017d\u017e\u0001\u0000\u0000\u0000\u017e\u017c\u0001\u0000\u0000"+ + "\u0000\u017e\u017f\u0001\u0000\u0000\u0000\u017f\u0180\u0001\u0000\u0000"+ + "\u0000\u0180\u0181\u0006\'\u0000\u0000\u0181P\u0001\u0000\u0000\u0000"+ + "\u0182\u0185\u0003S)\u0000\u0183\u0185\u0003U*\u0000\u0184\u0182\u0001"+ + "\u0000\u0000\u0000\u0184\u0183\u0001\u0000\u0000\u0000\u0185R\u0001\u0000"+ + "\u0000\u0000\u0186\u018a\u0005\'\u0000\u0000\u0187\u0189\t\u0000\u0000"+ + "\u0000\u0188\u0187\u0001\u0000\u0000\u0000\u0189\u018c\u0001\u0000\u0000"+ + "\u0000\u018a\u018b\u0001\u0000\u0000\u0000\u018a\u0188\u0001\u0000\u0000"+ + "\u0000\u018b\u018d\u0001\u0000\u0000\u0000\u018c\u018a\u0001\u0000\u0000"+ + "\u0000\u018d\u018e\u0005\'\u0000\u0000\u018eT\u0001\u0000\u0000\u0000"+ + "\u018f\u0193\u0005\"\u0000\u0000\u0190\u0192\t\u0000\u0000\u0000\u0191"+ + "\u0190\u0001\u0000\u0000\u0000\u0192\u0195\u0001\u0000\u0000\u0000\u0193"+ + "\u0194\u0001\u0000\u0000\u0000\u0193\u0191\u0001\u0000\u0000\u0000\u0194"+ + "\u0196\u0001\u0000\u0000\u0000\u0195\u0193\u0001\u0000\u0000\u0000\u0196"+ + "\u0197\u0005\"\u0000\u0000\u0197V\u0001\u0000\u0000\u0000\u0198\u019b"+ + "\u0003Y,\u0000\u0199\u019b\u0007\u0002\u0000\u0000\u019a\u0198\u0001\u0000"+ + "\u0000\u0000\u019a\u0199\u0001\u0000\u0000\u0000\u019b\u019c\u0001\u0000"+ + "\u0000\u0000\u019c\u019a\u0001\u0000\u0000\u0000\u019c\u019d\u0001\u0000"+ + "\u0000\u0000\u019dX\u0001\u0000\u0000\u0000\u019e\u019f\u0007\u0003\u0000"+ + "\u0000\u019fZ\u0001\u0000\u0000\u0000\u01a0\u01a4\u0005\'\u0000\u0000"+ + "\u01a1\u01a3\t\u0000\u0000\u0000\u01a2\u01a1\u0001\u0000\u0000\u0000\u01a3"+ + "\u01a6\u0001\u0000\u0000\u0000\u01a4\u01a5\u0001\u0000\u0000\u0000\u01a4"+ + "\u01a2\u0001\u0000\u0000\u0000\u01a5\u01a7\u0001\u0000\u0000\u0000\u01a6"+ + "\u01a4\u0001\u0000\u0000\u0000\u01a7\u01a8\u0005\'\u0000\u0000\u01a8\\"+ + "\u0001\u0000\u0000\u0000\u01a9\u01ad\u0005\"\u0000\u0000\u01aa\u01ac\t"+ + "\u0000\u0000\u0000\u01ab\u01aa\u0001\u0000\u0000\u0000\u01ac\u01af\u0001"+ + "\u0000\u0000\u0000\u01ad\u01ae\u0001\u0000\u0000\u0000\u01ad\u01ab\u0001"+ + "\u0000\u0000\u0000\u01ae\u01b0\u0001\u0000\u0000\u0000\u01af\u01ad\u0001"+ + "\u0000\u0000\u0000\u01b0\u01b1\u0005\"\u0000\u0000\u01b1^\u0001\u0000"+ + "\u0000\u0000\u01b2\u01b3\u0007\u0000\u0000\u0000\u01b3\u01b4\u0007\u0000"+ + "\u0000\u0000\u01b4\u01b5\u0007\u0000\u0000\u0000\u01b5\u01b6\u0007\u0000"+ + "\u0000\u0000\u01b6\u01b7\u0005-\u0000\u0000\u01b7\u01b8\u0007\u0000\u0000"+ + "\u0000\u01b8\u01b9\u0007\u0000\u0000\u0000\u01b9\u01ba\u0005-\u0000\u0000"+ + "\u01ba\u01bb\u0007\u0000\u0000\u0000\u01bb\u01bc\u0007\u0000\u0000\u0000"+ + "\u01bc`\u0001\u0000\u0000\u0000\u01bd\u01be\u0007\u0000\u0000\u0000\u01be"+ + "\u01bf\u0007\u0000\u0000\u0000\u01bf\u01c0\u0007\u0000\u0000\u0000\u01c0"+ + "\u01c1\u0007\u0000\u0000\u0000\u01c1\u01c2\u0005-\u0000\u0000\u01c2\u01c3"+ + "\u0007\u0000\u0000\u0000\u01c3\u01c4\u0007\u0000\u0000\u0000\u01c4\u01c5"+ + "\u0005-\u0000\u0000\u01c5\u01c6\u0007\u0000\u0000\u0000\u01c6\u01c7\u0007"+ + "\u0000\u0000\u0000\u01c7\u01c8\u0005 \u0000\u0000\u01c8\u01c9\u0007\u0000"+ + "\u0000\u0000\u01c9\u01ca\u0007\u0000\u0000\u0000\u01ca\u01cb\u0005:\u0000"+ + "\u0000\u01cb\u01cc\u0007\u0000\u0000\u0000\u01cc\u01cd\u0007\u0000\u0000"+ + "\u0000\u01cd\u01ce\u0005:\u0000\u0000\u01ce\u01cf\u0007\u0000\u0000\u0000"+ + "\u01cf\u01d0\u0007\u0000\u0000\u0000\u01d0b\u0001\u0000\u0000\u0000 \u0000"+ + "ioy\u0081\u0089\u0093\u009f\u00b9\u00d3\u00db\u00e3\u00eb\u00f3\u00fd"+ + "\u0107\u0115\u011d\u0125\u013f\u0163\u0169\u0170\u0175\u017e\u0184\u018a"+ + "\u0193\u019a\u019c\u01a4\u01ad\u0001\u0006\u0000\u0000"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); static { diff --git a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionListener.java b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionListener.java index c66abe2..9015db0 100644 --- a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionListener.java +++ b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionListener.java @@ -1,4 +1,5 @@ -package com.github.sidhant92.boolparser.parser.antlr;// Generated from /Users/sid/Desktop/filter1/BooleanExpression.g4 by ANTLR 4.13.1 +// Generated from /Users/sidhantaggarwal/bool-parser-java/src/main/java/resources/BooleanExpression.g4 by ANTLR 4.13.2 +package com.github.sidhant92.boolparser.parser.antlr; import org.antlr.v4.runtime.tree.ParseTreeListener; /** @@ -16,6 +17,18 @@ public interface BooleanExpressionListener extends ParseTreeListener { * @param ctx the parse tree */ void exitParse(BooleanExpressionParser.ParseContext ctx); + /** + * Enter a parse tree produced by the {@code unaryArithmeticExpression} + * labeled alternative in {@link BooleanExpressionParser#expression}. + * @param ctx the parse tree + */ + void enterUnaryArithmeticExpression(BooleanExpressionParser.UnaryArithmeticExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code unaryArithmeticExpression} + * labeled alternative in {@link BooleanExpressionParser#expression}. + * @param ctx the parse tree + */ + void exitUnaryArithmeticExpression(BooleanExpressionParser.UnaryArithmeticExpressionContext ctx); /** * Enter a parse tree produced by the {@code binaryExpression} * labeled alternative in {@link BooleanExpressionParser#expression}. @@ -76,6 +89,18 @@ public interface BooleanExpressionListener extends ParseTreeListener { * @param ctx the parse tree */ void exitToExpression(BooleanExpressionParser.ToExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code arithmeticFunctionExpression} + * labeled alternative in {@link BooleanExpressionParser#expression}. + * @param ctx the parse tree + */ + void enterArithmeticFunctionExpression(BooleanExpressionParser.ArithmeticFunctionExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code arithmeticFunctionExpression} + * labeled alternative in {@link BooleanExpressionParser#expression}. + * @param ctx the parse tree + */ + void exitArithmeticFunctionExpression(BooleanExpressionParser.ArithmeticFunctionExpressionContext ctx); /** * Enter a parse tree produced by the {@code notExpression} * labeled alternative in {@link BooleanExpressionParser#expression}. @@ -88,6 +113,18 @@ public interface BooleanExpressionListener extends ParseTreeListener { * @param ctx the parse tree */ void exitNotExpression(BooleanExpressionParser.NotExpressionContext ctx); + /** + * Enter a parse tree produced by the {@code arithmeticExpression} + * labeled alternative in {@link BooleanExpressionParser#expression}. + * @param ctx the parse tree + */ + void enterArithmeticExpression(BooleanExpressionParser.ArithmeticExpressionContext ctx); + /** + * Exit a parse tree produced by the {@code arithmeticExpression} + * labeled alternative in {@link BooleanExpressionParser#expression}. + * @param ctx the parse tree + */ + void exitArithmeticExpression(BooleanExpressionParser.ArithmeticExpressionContext ctx); /** * Enter a parse tree produced by the {@code comparatorExpression} * labeled alternative in {@link BooleanExpressionParser#expression}. @@ -122,6 +159,26 @@ public interface BooleanExpressionListener extends ParseTreeListener { * @param ctx the parse tree */ void exitComparator(BooleanExpressionParser.ComparatorContext ctx); + /** + * Enter a parse tree produced by {@link BooleanExpressionParser#arithmeticOperator}. + * @param ctx the parse tree + */ + void enterArithmeticOperator(BooleanExpressionParser.ArithmeticOperatorContext ctx); + /** + * Exit a parse tree produced by {@link BooleanExpressionParser#arithmeticOperator}. + * @param ctx the parse tree + */ + void exitArithmeticOperator(BooleanExpressionParser.ArithmeticOperatorContext ctx); + /** + * Enter a parse tree produced by {@link BooleanExpressionParser#arithmeticFunction}. + * @param ctx the parse tree + */ + void enterArithmeticFunction(BooleanExpressionParser.ArithmeticFunctionContext ctx); + /** + * Exit a parse tree produced by {@link BooleanExpressionParser#arithmeticFunction}. + * @param ctx the parse tree + */ + void exitArithmeticFunction(BooleanExpressionParser.ArithmeticFunctionContext ctx); /** * Enter a parse tree produced by {@link BooleanExpressionParser#wordlist}. * @param ctx the parse tree diff --git a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionParser.java b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionParser.java index 21438de..9ce4e3c 100644 --- a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionParser.java +++ b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanExpressionParser.java @@ -1,4 +1,5 @@ -package com.github.sidhant92.boolparser.parser.antlr;// Generated from /Users/sid/Desktop/filter1/BooleanExpression.g4 by ANTLR 4.13.1 +// Generated from /Users/sidhantaggarwal/bool-parser-java/src/main/java/resources/BooleanExpression.g4 by ANTLR 4.13.2 +package com.github.sidhant92.boolparser.parser.antlr; import org.antlr.v4.runtime.atn.*; import org.antlr.v4.runtime.dfa.DFA; import org.antlr.v4.runtime.*; @@ -8,43 +9,50 @@ import java.util.Iterator; import java.util.ArrayList; -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue", "this-escape"}) public class BooleanExpressionParser extends Parser { - static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } + static { RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int T__0=1, IN=2, TO=3, AND=4, OR=5, NOT=6, TRUE=7, FALSE=8, CONTAINS_ALL=9, - CONTAINS_ANY=10, NE=11, GT=12, GE=13, LT=14, LE=15, EQ=16, LPAREN=17, - RPAREN=18, DECIMAL=19, APP_VERSION=20, INTEGER=21, WS=22, WORD=23, ALPHANUMERIC=24, - SQ=25, DQ=26; + CONTAINS_ANY=10, MIN=11, MAX=12, AVG=13, SUM=14, MEAN=15, MODE=16, MEDIAN=17, + LEN=18, INT=19, DAYS_ELAPSED=20, ADD=21, SUBTRACT=22, MULTIPLY=23, DIVIDE=24, + MODULUS=25, EXPONENT=26, NE=27, GT=28, GE=29, LT=30, LE=31, EQ=32, LPAREN=33, + RPAREN=34, DECIMAL=35, APP_VERSION=36, INTEGER=37, DATE=38, DATETIME=39, + WS=40, WORD=41, SQSTR=42, DQSTR=43, FIELD=44, ALPHANUMERIC=45, SQ=46, + DQ=47; public static final int - RULE_parse = 0, RULE_expression = 1, RULE_comparator = 2, RULE_wordlist = 3, - RULE_arrayOperators = 4, RULE_numericTypes = 5, RULE_types = 6, RULE_binary = 7, - RULE_bool = 8; + RULE_parse = 0, RULE_expression = 1, RULE_comparator = 2, RULE_arithmeticOperator = 3, + RULE_arithmeticFunction = 4, RULE_wordlist = 5, RULE_arrayOperators = 6, + RULE_numericTypes = 7, RULE_types = 8, RULE_binary = 9, RULE_bool = 10; private static String[] makeRuleNames() { return new String[] { - "parse", "expression", "comparator", "wordlist", "arrayOperators", "numericTypes", - "types", "binary", "bool" + "parse", "expression", "comparator", "arithmeticOperator", "arithmeticFunction", + "wordlist", "arrayOperators", "numericTypes", "types", "binary", "bool" }; } public static final String[] ruleNames = makeRuleNames(); private static String[] makeLiteralNames() { return new String[] { - null, "','", null, null, null, null, null, null, null, null, null, "'!='", - "'>'", "'>='", "'<'", "'<='", "'='", "'('", "')'" + null, "','", null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, "'+'", "'-'", "'*'", + "'/'", "'%'", "'^'", "'!='", "'>'", "'>='", "'<'", "'<='", "'='", "'('", + "')'" }; } private static final String[] _LITERAL_NAMES = makeLiteralNames(); private static String[] makeSymbolicNames() { return new String[] { null, null, "IN", "TO", "AND", "OR", "NOT", "TRUE", "FALSE", "CONTAINS_ALL", - "CONTAINS_ANY", "NE", "GT", "GE", "LT", "LE", "EQ", "LPAREN", "RPAREN", - "DECIMAL", "APP_VERSION", "INTEGER", "WS", "WORD", "ALPHANUMERIC", "SQ", - "DQ" + "CONTAINS_ANY", "MIN", "MAX", "AVG", "SUM", "MEAN", "MODE", "MEDIAN", + "LEN", "INT", "DAYS_ELAPSED", "ADD", "SUBTRACT", "MULTIPLY", "DIVIDE", + "MODULUS", "EXPONENT", "NE", "GT", "GE", "LT", "LE", "EQ", "LPAREN", + "RPAREN", "DECIMAL", "APP_VERSION", "INTEGER", "DATE", "DATETIME", "WS", + "WORD", "SQSTR", "DQSTR", "FIELD", "ALPHANUMERIC", "SQ", "DQ" }; } private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); @@ -124,9 +132,9 @@ public final ParseContext parse() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(18); + setState(22); expression(0); - setState(19); + setState(23); match(EOF); } } @@ -154,6 +162,24 @@ public void copyFrom(ExpressionContext ctx) { } } @SuppressWarnings("CheckReturnValue") + public static class UnaryArithmeticExpressionContext extends ExpressionContext { + public Token op; + public ExpressionContext exp; + public TerminalNode SUBTRACT() { return getToken(BooleanExpressionParser.SUBTRACT, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public UnaryArithmeticExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof BooleanExpressionListener ) ((BooleanExpressionListener)listener).enterUnaryArithmeticExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof BooleanExpressionListener ) ((BooleanExpressionListener)listener).exitUnaryArithmeticExpression(this); + } + } + @SuppressWarnings("CheckReturnValue") public static class BinaryExpressionContext extends ExpressionContext { public ExpressionContext left; public BinaryContext op; @@ -201,7 +227,7 @@ public static class InExpressionContext extends ExpressionContext { public WordlistContext wordlist() { return getRuleContext(WordlistContext.class,0); } - public TerminalNode WORD() { return getToken(BooleanExpressionParser.WORD, 0); } + public TerminalNode FIELD() { return getToken(BooleanExpressionParser.FIELD, 0); } public TerminalNode NOT() { return getToken(BooleanExpressionParser.NOT, 0); } public InExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } @Override @@ -224,7 +250,7 @@ public ArrayOperatorsContext arrayOperators() { public WordlistContext wordlist() { return getRuleContext(WordlistContext.class,0); } - public TerminalNode WORD() { return getToken(BooleanExpressionParser.WORD, 0); } + public TerminalNode FIELD() { return getToken(BooleanExpressionParser.FIELD, 0); } public ArrayExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } @Override public void enterRule(ParseTreeListener listener) { @@ -247,7 +273,7 @@ public List numericTypes() { public NumericTypesContext numericTypes(int i) { return getRuleContext(NumericTypesContext.class,i); } - public TerminalNode WORD() { return getToken(BooleanExpressionParser.WORD, 0); } + public TerminalNode FIELD() { return getToken(BooleanExpressionParser.FIELD, 0); } public ToExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } @Override public void enterRule(ParseTreeListener listener) { @@ -259,6 +285,26 @@ public void exitRule(ParseTreeListener listener) { } } @SuppressWarnings("CheckReturnValue") + public static class ArithmeticFunctionExpressionContext extends ExpressionContext { + public ArithmeticFunctionContext left; + public WordlistContext data; + public ArithmeticFunctionContext arithmeticFunction() { + return getRuleContext(ArithmeticFunctionContext.class,0); + } + public WordlistContext wordlist() { + return getRuleContext(WordlistContext.class,0); + } + public ArithmeticFunctionExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof BooleanExpressionListener ) ((BooleanExpressionListener)listener).enterArithmeticFunctionExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof BooleanExpressionListener ) ((BooleanExpressionListener)listener).exitArithmeticFunctionExpression(this); + } + } + @SuppressWarnings("CheckReturnValue") public static class NotExpressionContext extends ExpressionContext { public TerminalNode NOT() { return getToken(BooleanExpressionParser.NOT, 0); } public ExpressionContext expression() { @@ -275,6 +321,33 @@ public void exitRule(ParseTreeListener listener) { } } @SuppressWarnings("CheckReturnValue") + public static class ArithmeticExpressionContext extends ExpressionContext { + public ExpressionContext left; + public Token op; + public ExpressionContext right; + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode EXPONENT() { return getToken(BooleanExpressionParser.EXPONENT, 0); } + public TerminalNode DIVIDE() { return getToken(BooleanExpressionParser.DIVIDE, 0); } + public TerminalNode MULTIPLY() { return getToken(BooleanExpressionParser.MULTIPLY, 0); } + public TerminalNode MODULUS() { return getToken(BooleanExpressionParser.MODULUS, 0); } + public TerminalNode ADD() { return getToken(BooleanExpressionParser.ADD, 0); } + public TerminalNode SUBTRACT() { return getToken(BooleanExpressionParser.SUBTRACT, 0); } + public ArithmeticExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof BooleanExpressionListener ) ((BooleanExpressionListener)listener).enterArithmeticExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof BooleanExpressionListener ) ((BooleanExpressionListener)listener).exitArithmeticExpression(this); + } + } + @SuppressWarnings("CheckReturnValue") public static class ComparatorExpressionContext extends ExpressionContext { public ExpressionContext left; public ComparatorContext op; @@ -332,20 +405,20 @@ private ExpressionContext expression(int _p) throws RecognitionException { int _alt; enterOuterAlt(_localctx, 1); { - setState(50); + setState(53); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) { case 1: { _localctx = new ParentExpressionContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(22); + setState(26); match(LPAREN); - setState(23); + setState(27); expression(0); - setState(24); + setState(28); match(RPAREN); } break; @@ -354,141 +427,223 @@ private ExpressionContext expression(int _p) throws RecognitionException { _localctx = new NotExpressionContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(26); + setState(30); match(NOT); - setState(27); - expression(7); + setState(31); + expression(15); } break; case 3: + { + _localctx = new UnaryArithmeticExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(32); + ((UnaryArithmeticExpressionContext)_localctx).op = match(SUBTRACT); + setState(33); + ((UnaryArithmeticExpressionContext)_localctx).exp = expression(13); + } + break; + case 4: + { + _localctx = new ArithmeticFunctionExpressionContext(_localctx); + _ctx = _localctx; + _prevctx = _localctx; + setState(34); + ((ArithmeticFunctionExpressionContext)_localctx).left = arithmeticFunction(); + setState(35); + ((ArithmeticFunctionExpressionContext)_localctx).data = wordlist(); + } + break; + case 5: { _localctx = new TypesExpressionContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(28); + setState(37); types(); } break; - case 4: + case 6: { _localctx = new ToExpressionContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(30); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WORD) { - { - setState(29); - ((ToExpressionContext)_localctx).field = match(WORD); - } + { + setState(38); + ((ToExpressionContext)_localctx).field = match(FIELD); } - - setState(32); + setState(39); ((ToExpressionContext)_localctx).lower = numericTypes(); - setState(33); + setState(40); match(TO); - setState(34); + setState(41); ((ToExpressionContext)_localctx).upper = numericTypes(); } break; - case 5: + case 7: { _localctx = new InExpressionContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(37); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WORD) { - { - setState(36); - ((InExpressionContext)_localctx).field = match(WORD); - } + { + setState(43); + ((InExpressionContext)_localctx).field = match(FIELD); } - - setState(40); + setState(45); _errHandler.sync(this); _la = _input.LA(1); if (_la==NOT) { { - setState(39); + setState(44); ((InExpressionContext)_localctx).not = match(NOT); } } - setState(42); + setState(47); match(IN); - setState(43); + setState(48); ((InExpressionContext)_localctx).data = wordlist(); } break; - case 6: + case 8: { _localctx = new ArrayExpressionContext(_localctx); _ctx = _localctx; _prevctx = _localctx; - setState(45); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==WORD) { - { - setState(44); - ((ArrayExpressionContext)_localctx).field = match(WORD); - } + { + setState(49); + ((ArrayExpressionContext)_localctx).field = match(FIELD); } - - setState(47); + setState(50); ((ArrayExpressionContext)_localctx).op = arrayOperators(); - setState(48); + setState(51); ((ArrayExpressionContext)_localctx).data = wordlist(); } break; } _ctx.stop = _input.LT(-1); - setState(62); + setState(83); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,6,_ctx); + _alt = getInterpreter().adaptivePredict(_input,3,_ctx); while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; { - setState(60); + setState(81); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) { case 1: { _localctx = new ComparatorExpressionContext(new ExpressionContext(_parentctx, _parentState)); ((ComparatorExpressionContext)_localctx).left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(52); - if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); - setState(53); + setState(55); + if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)"); + setState(56); ((ComparatorExpressionContext)_localctx).op = comparator(); - setState(54); - ((ComparatorExpressionContext)_localctx).right = expression(7); + setState(57); + ((ComparatorExpressionContext)_localctx).right = expression(15); } break; case 2: + { + _localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState)); + ((ArithmeticExpressionContext)_localctx).left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(59); + if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); + setState(60); + ((ArithmeticExpressionContext)_localctx).op = match(EXPONENT); + setState(61); + ((ArithmeticExpressionContext)_localctx).right = expression(13); + } + break; + case 3: + { + _localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState)); + ((ArithmeticExpressionContext)_localctx).left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(62); + if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); + setState(63); + ((ArithmeticExpressionContext)_localctx).op = match(DIVIDE); + setState(64); + ((ArithmeticExpressionContext)_localctx).right = expression(12); + } + break; + case 4: + { + _localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState)); + ((ArithmeticExpressionContext)_localctx).left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(65); + if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); + setState(66); + ((ArithmeticExpressionContext)_localctx).op = match(MULTIPLY); + setState(67); + ((ArithmeticExpressionContext)_localctx).right = expression(11); + } + break; + case 5: + { + _localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState)); + ((ArithmeticExpressionContext)_localctx).left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(68); + if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); + setState(69); + ((ArithmeticExpressionContext)_localctx).op = match(MODULUS); + setState(70); + ((ArithmeticExpressionContext)_localctx).right = expression(10); + } + break; + case 6: + { + _localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState)); + ((ArithmeticExpressionContext)_localctx).left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(71); + if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); + setState(72); + ((ArithmeticExpressionContext)_localctx).op = match(ADD); + setState(73); + ((ArithmeticExpressionContext)_localctx).right = expression(9); + } + break; + case 7: + { + _localctx = new ArithmeticExpressionContext(new ExpressionContext(_parentctx, _parentState)); + ((ArithmeticExpressionContext)_localctx).left = _prevctx; + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(74); + if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); + setState(75); + ((ArithmeticExpressionContext)_localctx).op = match(SUBTRACT); + setState(76); + ((ArithmeticExpressionContext)_localctx).right = expression(8); + } + break; + case 8: { _localctx = new BinaryExpressionContext(new ExpressionContext(_parentctx, _parentState)); ((BinaryExpressionContext)_localctx).left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(56); + setState(77); if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); - setState(57); + setState(78); ((BinaryExpressionContext)_localctx).op = binary(); - setState(58); + setState(79); ((BinaryExpressionContext)_localctx).right = expression(6); } break; } } } - setState(64); + setState(85); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,6,_ctx); + _alt = getInterpreter().adaptivePredict(_input,3,_ctx); } } } @@ -532,9 +687,117 @@ public final ComparatorContext comparator() throws RecognitionException { try { enterOuterAlt(_localctx, 1); { - setState(65); + setState(86); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 8455716864L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArithmeticOperatorContext extends ParserRuleContext { + public TerminalNode MULTIPLY() { return getToken(BooleanExpressionParser.MULTIPLY, 0); } + public TerminalNode DIVIDE() { return getToken(BooleanExpressionParser.DIVIDE, 0); } + public TerminalNode ADD() { return getToken(BooleanExpressionParser.ADD, 0); } + public TerminalNode SUBTRACT() { return getToken(BooleanExpressionParser.SUBTRACT, 0); } + public TerminalNode MODULUS() { return getToken(BooleanExpressionParser.MODULUS, 0); } + public TerminalNode EXPONENT() { return getToken(BooleanExpressionParser.EXPONENT, 0); } + public ArithmeticOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arithmeticOperator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof BooleanExpressionListener ) ((BooleanExpressionListener)listener).enterArithmeticOperator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof BooleanExpressionListener ) ((BooleanExpressionListener)listener).exitArithmeticOperator(this); + } + } + + public final ArithmeticOperatorContext arithmeticOperator() throws RecognitionException { + ArithmeticOperatorContext _localctx = new ArithmeticOperatorContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_arithmeticOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(88); _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 129024L) != 0)) ) { + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 132120576L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class ArithmeticFunctionContext extends ParserRuleContext { + public TerminalNode MIN() { return getToken(BooleanExpressionParser.MIN, 0); } + public TerminalNode MAX() { return getToken(BooleanExpressionParser.MAX, 0); } + public TerminalNode SUM() { return getToken(BooleanExpressionParser.SUM, 0); } + public TerminalNode AVG() { return getToken(BooleanExpressionParser.AVG, 0); } + public TerminalNode MEAN() { return getToken(BooleanExpressionParser.MEAN, 0); } + public TerminalNode MODE() { return getToken(BooleanExpressionParser.MODE, 0); } + public TerminalNode LEN() { return getToken(BooleanExpressionParser.LEN, 0); } + public TerminalNode MEDIAN() { return getToken(BooleanExpressionParser.MEDIAN, 0); } + public TerminalNode INT() { return getToken(BooleanExpressionParser.INT, 0); } + public TerminalNode DAYS_ELAPSED() { return getToken(BooleanExpressionParser.DAYS_ELAPSED, 0); } + public ArithmeticFunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arithmeticFunction; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof BooleanExpressionListener ) ((BooleanExpressionListener)listener).enterArithmeticFunction(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof BooleanExpressionListener ) ((BooleanExpressionListener)listener).exitArithmeticFunction(this); + } + } + + public final ArithmeticFunctionContext arithmeticFunction() throws RecognitionException { + ArithmeticFunctionContext _localctx = new ArithmeticFunctionContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_arithmeticFunction); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(90); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 2095104L) != 0)) ) { _errHandler.recoverInline(this); } else { @@ -557,15 +820,15 @@ public final ComparatorContext comparator() throws RecognitionException { @SuppressWarnings("CheckReturnValue") public static class WordlistContext extends ParserRuleContext { - public TypesContext first; - public TypesContext rest; + public ExpressionContext first; + public ExpressionContext rest; public TerminalNode LPAREN() { return getToken(BooleanExpressionParser.LPAREN, 0); } public TerminalNode RPAREN() { return getToken(BooleanExpressionParser.RPAREN, 0); } - public List types() { - return getRuleContexts(TypesContext.class); + public List expression() { + return getRuleContexts(ExpressionContext.class); } - public TypesContext types(int i) { - return getRuleContext(TypesContext.class,i); + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); } public List WS() { return getTokens(BooleanExpressionParser.WS); } public TerminalNode WS(int i) { @@ -587,93 +850,93 @@ public void exitRule(ParseTreeListener listener) { public final WordlistContext wordlist() throws RecognitionException { WordlistContext _localctx = new WordlistContext(_ctx, getState()); - enterRule(_localctx, 6, RULE_wordlist); + enterRule(_localctx, 10, RULE_wordlist); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { - setState(67); + setState(92); match(LPAREN); - setState(71); + setState(96); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,7,_ctx); + _alt = getInterpreter().adaptivePredict(_input,4,_ctx); while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(68); + setState(93); match(WS); } } } - setState(73); + setState(98); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,7,_ctx); + _alt = getInterpreter().adaptivePredict(_input,4,_ctx); } - setState(74); - ((WordlistContext)_localctx).first = types(); - setState(78); + setState(99); + ((WordlistContext)_localctx).first = expression(0); + setState(103); _errHandler.sync(this); _la = _input.LA(1); while (_la==WS) { { { - setState(75); + setState(100); match(WS); } } - setState(80); + setState(105); _errHandler.sync(this); _la = _input.LA(1); } - setState(97); + setState(122); _errHandler.sync(this); _la = _input.LA(1); while (_la==T__0) { { { - setState(81); + setState(106); match(T__0); - setState(85); + setState(110); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,9,_ctx); + _alt = getInterpreter().adaptivePredict(_input,6,_ctx); while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(82); + setState(107); match(WS); } } } - setState(87); + setState(112); _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,9,_ctx); + _alt = getInterpreter().adaptivePredict(_input,6,_ctx); } - setState(88); - ((WordlistContext)_localctx).rest = types(); - setState(92); + setState(113); + ((WordlistContext)_localctx).rest = expression(0); + setState(117); _errHandler.sync(this); _la = _input.LA(1); while (_la==WS) { { { - setState(89); + setState(114); match(WS); } } - setState(94); + setState(119); _errHandler.sync(this); _la = _input.LA(1); } } } - setState(99); + setState(124); _errHandler.sync(this); _la = _input.LA(1); } - setState(100); + setState(125); match(RPAREN); } } @@ -708,12 +971,12 @@ public void exitRule(ParseTreeListener listener) { public final ArrayOperatorsContext arrayOperators() throws RecognitionException { ArrayOperatorsContext _localctx = new ArrayOperatorsContext(_ctx, getState()); - enterRule(_localctx, 8, RULE_arrayOperators); + enterRule(_localctx, 12, RULE_arrayOperators); int _la; try { enterOuterAlt(_localctx, 1); { - setState(102); + setState(127); _la = _input.LA(1); if ( !(_la==CONTAINS_ALL || _la==CONTAINS_ANY) ) { _errHandler.recoverInline(this); @@ -756,12 +1019,12 @@ public void exitRule(ParseTreeListener listener) { public final NumericTypesContext numericTypes() throws RecognitionException { NumericTypesContext _localctx = new NumericTypesContext(_ctx, getState()); - enterRule(_localctx, 10, RULE_numericTypes); + enterRule(_localctx, 14, RULE_numericTypes); int _la; try { enterOuterAlt(_localctx, 1); { - setState(104); + setState(129); _la = _input.LA(1); if ( !(_la==DECIMAL || _la==INTEGER) ) { _errHandler.recoverInline(this); @@ -793,6 +1056,9 @@ public BoolContext bool() { return getRuleContext(BoolContext.class,0); } public TerminalNode WORD() { return getToken(BooleanExpressionParser.WORD, 0); } + public TerminalNode FIELD() { return getToken(BooleanExpressionParser.FIELD, 0); } + public TerminalNode DATE() { return getToken(BooleanExpressionParser.DATE, 0); } + public TerminalNode DATETIME() { return getToken(BooleanExpressionParser.DATETIME, 0); } public TypesContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -809,49 +1075,70 @@ public void exitRule(ParseTreeListener listener) { public final TypesContext types() throws RecognitionException { TypesContext _localctx = new TypesContext(_ctx, getState()); - enterRule(_localctx, 12, RULE_types); + enterRule(_localctx, 16, RULE_types); try { - setState(112); + setState(140); _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { + switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(106); + setState(131); match(INTEGER); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(107); + setState(132); match(DECIMAL); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(108); + setState(133); match(APP_VERSION); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(109); + setState(134); bool(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(110); + setState(135); match(WORD); } break; case 6: enterOuterAlt(_localctx, 6); { + setState(136); + match(FIELD); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(137); + match(DATE); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(138); + match(DATETIME); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { } break; } @@ -887,12 +1174,12 @@ public void exitRule(ParseTreeListener listener) { public final BinaryContext binary() throws RecognitionException { BinaryContext _localctx = new BinaryContext(_ctx, getState()); - enterRule(_localctx, 14, RULE_binary); + enterRule(_localctx, 18, RULE_binary); int _la; try { enterOuterAlt(_localctx, 1); { - setState(114); + setState(142); _la = _input.LA(1); if ( !(_la==AND || _la==OR) ) { _errHandler.recoverInline(this); @@ -935,12 +1222,12 @@ public void exitRule(ParseTreeListener listener) { public final BoolContext bool() throws RecognitionException { BoolContext _localctx = new BoolContext(_ctx, getState()); - enterRule(_localctx, 16, RULE_bool); + enterRule(_localctx, 20, RULE_bool); int _la; try { enterOuterAlt(_localctx, 1); { - setState(116); + setState(144); _la = _input.LA(1); if ( !(_la==TRUE || _la==FALSE) ) { _errHandler.recoverInline(this); @@ -973,86 +1260,116 @@ public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { switch (predIndex) { case 0: - return precpred(_ctx, 6); + return precpred(_ctx, 14); case 1: + return precpred(_ctx, 12); + case 2: + return precpred(_ctx, 11); + case 3: + return precpred(_ctx, 10); + case 4: + return precpred(_ctx, 9); + case 5: + return precpred(_ctx, 8); + case 6: + return precpred(_ctx, 7); + case 7: return precpred(_ctx, 5); } return true; } public static final String _serializedATN = - "\u0004\u0001\u001aw\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+ + "\u0004\u0001/\u0093\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+ "\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+ "\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+ - "\b\u0007\b\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001"+ + "\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0001\u0000\u0001\u0000\u0001"+ + "\u0000\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0001\u0001\u0001\u0003\u0001.\b\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u00016\b"+ + "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0001\u0003\u0001\u001f\b\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0001\u0001\u0001\u0003\u0001&\b\u0001\u0001\u0001\u0003\u0001"+ - ")\b\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u0001.\b\u0001\u0001"+ - "\u0001\u0001\u0001\u0001\u0001\u0003\u00013\b\u0001\u0001\u0001\u0001"+ "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ - "\u0001\u0005\u0001=\b\u0001\n\u0001\f\u0001@\t\u0001\u0001\u0002\u0001"+ - "\u0002\u0001\u0003\u0001\u0003\u0005\u0003F\b\u0003\n\u0003\f\u0003I\t"+ - "\u0003\u0001\u0003\u0001\u0003\u0005\u0003M\b\u0003\n\u0003\f\u0003P\t"+ - "\u0003\u0001\u0003\u0001\u0003\u0005\u0003T\b\u0003\n\u0003\f\u0003W\t"+ - "\u0003\u0001\u0003\u0001\u0003\u0005\u0003[\b\u0003\n\u0003\f\u0003^\t"+ - "\u0003\u0005\u0003`\b\u0003\n\u0003\f\u0003c\t\u0003\u0001\u0003\u0001"+ - "\u0003\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0006\u0001"+ - "\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003\u0006q\b"+ - "\u0006\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0000\u0001\u0002"+ - "\t\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0000\u0005\u0001\u0000\u000b"+ - "\u0010\u0001\u0000\t\n\u0002\u0000\u0013\u0013\u0015\u0015\u0001\u0000"+ - "\u0004\u0005\u0001\u0000\u0007\b\u0082\u0000\u0012\u0001\u0000\u0000\u0000"+ - "\u00022\u0001\u0000\u0000\u0000\u0004A\u0001\u0000\u0000\u0000\u0006C"+ - "\u0001\u0000\u0000\u0000\bf\u0001\u0000\u0000\u0000\nh\u0001\u0000\u0000"+ - "\u0000\fp\u0001\u0000\u0000\u0000\u000er\u0001\u0000\u0000\u0000\u0010"+ - "t\u0001\u0000\u0000\u0000\u0012\u0013\u0003\u0002\u0001\u0000\u0013\u0014"+ - "\u0005\u0000\u0000\u0001\u0014\u0001\u0001\u0000\u0000\u0000\u0015\u0016"+ - "\u0006\u0001\uffff\uffff\u0000\u0016\u0017\u0005\u0011\u0000\u0000\u0017"+ - "\u0018\u0003\u0002\u0001\u0000\u0018\u0019\u0005\u0012\u0000\u0000\u0019"+ - "3\u0001\u0000\u0000\u0000\u001a\u001b\u0005\u0006\u0000\u0000\u001b3\u0003"+ - "\u0002\u0001\u0007\u001c3\u0003\f\u0006\u0000\u001d\u001f\u0005\u0017"+ - "\u0000\u0000\u001e\u001d\u0001\u0000\u0000\u0000\u001e\u001f\u0001\u0000"+ - "\u0000\u0000\u001f \u0001\u0000\u0000\u0000 !\u0003\n\u0005\u0000!\"\u0005"+ - "\u0003\u0000\u0000\"#\u0003\n\u0005\u0000#3\u0001\u0000\u0000\u0000$&"+ - "\u0005\u0017\u0000\u0000%$\u0001\u0000\u0000\u0000%&\u0001\u0000\u0000"+ - "\u0000&(\u0001\u0000\u0000\u0000\')\u0005\u0006\u0000\u0000(\'\u0001\u0000"+ - "\u0000\u0000()\u0001\u0000\u0000\u0000)*\u0001\u0000\u0000\u0000*+\u0005"+ - "\u0002\u0000\u0000+3\u0003\u0006\u0003\u0000,.\u0005\u0017\u0000\u0000"+ - "-,\u0001\u0000\u0000\u0000-.\u0001\u0000\u0000\u0000./\u0001\u0000\u0000"+ - "\u0000/0\u0003\b\u0004\u000001\u0003\u0006\u0003\u000013\u0001\u0000\u0000"+ - "\u00002\u0015\u0001\u0000\u0000\u00002\u001a\u0001\u0000\u0000\u00002"+ - "\u001c\u0001\u0000\u0000\u00002\u001e\u0001\u0000\u0000\u00002%\u0001"+ - "\u0000\u0000\u00002-\u0001\u0000\u0000\u00003>\u0001\u0000\u0000\u0000"+ - "45\n\u0006\u0000\u000056\u0003\u0004\u0002\u000067\u0003\u0002\u0001\u0007"+ - "7=\u0001\u0000\u0000\u000089\n\u0005\u0000\u00009:\u0003\u000e\u0007\u0000"+ - ":;\u0003\u0002\u0001\u0006;=\u0001\u0000\u0000\u0000<4\u0001\u0000\u0000"+ - "\u0000<8\u0001\u0000\u0000\u0000=@\u0001\u0000\u0000\u0000><\u0001\u0000"+ - "\u0000\u0000>?\u0001\u0000\u0000\u0000?\u0003\u0001\u0000\u0000\u0000"+ - "@>\u0001\u0000\u0000\u0000AB\u0007\u0000\u0000\u0000B\u0005\u0001\u0000"+ - "\u0000\u0000CG\u0005\u0011\u0000\u0000DF\u0005\u0016\u0000\u0000ED\u0001"+ - "\u0000\u0000\u0000FI\u0001\u0000\u0000\u0000GE\u0001\u0000\u0000\u0000"+ - "GH\u0001\u0000\u0000\u0000HJ\u0001\u0000\u0000\u0000IG\u0001\u0000\u0000"+ - "\u0000JN\u0003\f\u0006\u0000KM\u0005\u0016\u0000\u0000LK\u0001\u0000\u0000"+ - "\u0000MP\u0001\u0000\u0000\u0000NL\u0001\u0000\u0000\u0000NO\u0001\u0000"+ - "\u0000\u0000Oa\u0001\u0000\u0000\u0000PN\u0001\u0000\u0000\u0000QU\u0005"+ - "\u0001\u0000\u0000RT\u0005\u0016\u0000\u0000SR\u0001\u0000\u0000\u0000"+ - "TW\u0001\u0000\u0000\u0000US\u0001\u0000\u0000\u0000UV\u0001\u0000\u0000"+ - "\u0000VX\u0001\u0000\u0000\u0000WU\u0001\u0000\u0000\u0000X\\\u0003\f"+ - "\u0006\u0000Y[\u0005\u0016\u0000\u0000ZY\u0001\u0000\u0000\u0000[^\u0001"+ - "\u0000\u0000\u0000\\Z\u0001\u0000\u0000\u0000\\]\u0001\u0000\u0000\u0000"+ - "]`\u0001\u0000\u0000\u0000^\\\u0001\u0000\u0000\u0000_Q\u0001\u0000\u0000"+ - "\u0000`c\u0001\u0000\u0000\u0000a_\u0001\u0000\u0000\u0000ab\u0001\u0000"+ - "\u0000\u0000bd\u0001\u0000\u0000\u0000ca\u0001\u0000\u0000\u0000de\u0005"+ - "\u0012\u0000\u0000e\u0007\u0001\u0000\u0000\u0000fg\u0007\u0001\u0000"+ - "\u0000g\t\u0001\u0000\u0000\u0000hi\u0007\u0002\u0000\u0000i\u000b\u0001"+ - "\u0000\u0000\u0000jq\u0005\u0015\u0000\u0000kq\u0005\u0013\u0000\u0000"+ - "lq\u0005\u0014\u0000\u0000mq\u0003\u0010\b\u0000nq\u0005\u0017\u0000\u0000"+ - "oq\u0001\u0000\u0000\u0000pj\u0001\u0000\u0000\u0000pk\u0001\u0000\u0000"+ - "\u0000pl\u0001\u0000\u0000\u0000pm\u0001\u0000\u0000\u0000pn\u0001\u0000"+ - "\u0000\u0000po\u0001\u0000\u0000\u0000q\r\u0001\u0000\u0000\u0000rs\u0007"+ - "\u0003\u0000\u0000s\u000f\u0001\u0000\u0000\u0000tu\u0007\u0004\u0000"+ - "\u0000u\u0011\u0001\u0000\u0000\u0000\r\u001e%(-2<>GNU\\ap"; + "\u0001\u0001\u0001\u0001\u0001\u0005\u0001R\b\u0001\n\u0001\f\u0001U\t"+ + "\u0001\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0004\u0001"+ + "\u0004\u0001\u0005\u0001\u0005\u0005\u0005_\b\u0005\n\u0005\f\u0005b\t"+ + "\u0005\u0001\u0005\u0001\u0005\u0005\u0005f\b\u0005\n\u0005\f\u0005i\t"+ + "\u0005\u0001\u0005\u0001\u0005\u0005\u0005m\b\u0005\n\u0005\f\u0005p\t"+ + "\u0005\u0001\u0005\u0001\u0005\u0005\u0005t\b\u0005\n\u0005\f\u0005w\t"+ + "\u0005\u0005\u0005y\b\u0005\n\u0005\f\u0005|\t\u0005\u0001\u0005\u0001"+ + "\u0005\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\b\u0001\b"+ + "\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0003\b\u008d"+ + "\b\b\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0000\u0001\u0002\u000b\u0000"+ + "\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0000\u0007\u0001\u0000"+ + "\u001b \u0001\u0000\u0015\u001a\u0001\u0000\u000b\u0014\u0001\u0000\t"+ + "\n\u0002\u0000##%%\u0001\u0000\u0004\u0005\u0001\u0000\u0007\b\u00a4\u0000"+ + "\u0016\u0001\u0000\u0000\u0000\u00025\u0001\u0000\u0000\u0000\u0004V\u0001"+ + "\u0000\u0000\u0000\u0006X\u0001\u0000\u0000\u0000\bZ\u0001\u0000\u0000"+ + "\u0000\n\\\u0001\u0000\u0000\u0000\f\u007f\u0001\u0000\u0000\u0000\u000e"+ + "\u0081\u0001\u0000\u0000\u0000\u0010\u008c\u0001\u0000\u0000\u0000\u0012"+ + "\u008e\u0001\u0000\u0000\u0000\u0014\u0090\u0001\u0000\u0000\u0000\u0016"+ + "\u0017\u0003\u0002\u0001\u0000\u0017\u0018\u0005\u0000\u0000\u0001\u0018"+ + "\u0001\u0001\u0000\u0000\u0000\u0019\u001a\u0006\u0001\uffff\uffff\u0000"+ + "\u001a\u001b\u0005!\u0000\u0000\u001b\u001c\u0003\u0002\u0001\u0000\u001c"+ + "\u001d\u0005\"\u0000\u0000\u001d6\u0001\u0000\u0000\u0000\u001e\u001f"+ + "\u0005\u0006\u0000\u0000\u001f6\u0003\u0002\u0001\u000f !\u0005\u0016"+ + "\u0000\u0000!6\u0003\u0002\u0001\r\"#\u0003\b\u0004\u0000#$\u0003\n\u0005"+ + "\u0000$6\u0001\u0000\u0000\u0000%6\u0003\u0010\b\u0000&\'\u0005,\u0000"+ + "\u0000\'(\u0003\u000e\u0007\u0000()\u0005\u0003\u0000\u0000)*\u0003\u000e"+ + "\u0007\u0000*6\u0001\u0000\u0000\u0000+-\u0005,\u0000\u0000,.\u0005\u0006"+ + "\u0000\u0000-,\u0001\u0000\u0000\u0000-.\u0001\u0000\u0000\u0000./\u0001"+ + "\u0000\u0000\u0000/0\u0005\u0002\u0000\u000006\u0003\n\u0005\u000012\u0005"+ + ",\u0000\u000023\u0003\f\u0006\u000034\u0003\n\u0005\u000046\u0001\u0000"+ + "\u0000\u00005\u0019\u0001\u0000\u0000\u00005\u001e\u0001\u0000\u0000\u0000"+ + "5 \u0001\u0000\u0000\u00005\"\u0001\u0000\u0000\u00005%\u0001\u0000\u0000"+ + "\u00005&\u0001\u0000\u0000\u00005+\u0001\u0000\u0000\u000051\u0001\u0000"+ + "\u0000\u00006S\u0001\u0000\u0000\u000078\n\u000e\u0000\u000089\u0003\u0004"+ + "\u0002\u00009:\u0003\u0002\u0001\u000f:R\u0001\u0000\u0000\u0000;<\n\f"+ + "\u0000\u0000<=\u0005\u001a\u0000\u0000=R\u0003\u0002\u0001\r>?\n\u000b"+ + "\u0000\u0000?@\u0005\u0018\u0000\u0000@R\u0003\u0002\u0001\fAB\n\n\u0000"+ + "\u0000BC\u0005\u0017\u0000\u0000CR\u0003\u0002\u0001\u000bDE\n\t\u0000"+ + "\u0000EF\u0005\u0019\u0000\u0000FR\u0003\u0002\u0001\nGH\n\b\u0000\u0000"+ + "HI\u0005\u0015\u0000\u0000IR\u0003\u0002\u0001\tJK\n\u0007\u0000\u0000"+ + "KL\u0005\u0016\u0000\u0000LR\u0003\u0002\u0001\bMN\n\u0005\u0000\u0000"+ + "NO\u0003\u0012\t\u0000OP\u0003\u0002\u0001\u0006PR\u0001\u0000\u0000\u0000"+ + "Q7\u0001\u0000\u0000\u0000Q;\u0001\u0000\u0000\u0000Q>\u0001\u0000\u0000"+ + "\u0000QA\u0001\u0000\u0000\u0000QD\u0001\u0000\u0000\u0000QG\u0001\u0000"+ + "\u0000\u0000QJ\u0001\u0000\u0000\u0000QM\u0001\u0000\u0000\u0000RU\u0001"+ + "\u0000\u0000\u0000SQ\u0001\u0000\u0000\u0000ST\u0001\u0000\u0000\u0000"+ + "T\u0003\u0001\u0000\u0000\u0000US\u0001\u0000\u0000\u0000VW\u0007\u0000"+ + "\u0000\u0000W\u0005\u0001\u0000\u0000\u0000XY\u0007\u0001\u0000\u0000"+ + "Y\u0007\u0001\u0000\u0000\u0000Z[\u0007\u0002\u0000\u0000[\t\u0001\u0000"+ + "\u0000\u0000\\`\u0005!\u0000\u0000]_\u0005(\u0000\u0000^]\u0001\u0000"+ + "\u0000\u0000_b\u0001\u0000\u0000\u0000`^\u0001\u0000\u0000\u0000`a\u0001"+ + "\u0000\u0000\u0000ac\u0001\u0000\u0000\u0000b`\u0001\u0000\u0000\u0000"+ + "cg\u0003\u0002\u0001\u0000df\u0005(\u0000\u0000ed\u0001\u0000\u0000\u0000"+ + "fi\u0001\u0000\u0000\u0000ge\u0001\u0000\u0000\u0000gh\u0001\u0000\u0000"+ + "\u0000hz\u0001\u0000\u0000\u0000ig\u0001\u0000\u0000\u0000jn\u0005\u0001"+ + "\u0000\u0000km\u0005(\u0000\u0000lk\u0001\u0000\u0000\u0000mp\u0001\u0000"+ + "\u0000\u0000nl\u0001\u0000\u0000\u0000no\u0001\u0000\u0000\u0000oq\u0001"+ + "\u0000\u0000\u0000pn\u0001\u0000\u0000\u0000qu\u0003\u0002\u0001\u0000"+ + "rt\u0005(\u0000\u0000sr\u0001\u0000\u0000\u0000tw\u0001\u0000\u0000\u0000"+ + "us\u0001\u0000\u0000\u0000uv\u0001\u0000\u0000\u0000vy\u0001\u0000\u0000"+ + "\u0000wu\u0001\u0000\u0000\u0000xj\u0001\u0000\u0000\u0000y|\u0001\u0000"+ + "\u0000\u0000zx\u0001\u0000\u0000\u0000z{\u0001\u0000\u0000\u0000{}\u0001"+ + "\u0000\u0000\u0000|z\u0001\u0000\u0000\u0000}~\u0005\"\u0000\u0000~\u000b"+ + "\u0001\u0000\u0000\u0000\u007f\u0080\u0007\u0003\u0000\u0000\u0080\r\u0001"+ + "\u0000\u0000\u0000\u0081\u0082\u0007\u0004\u0000\u0000\u0082\u000f\u0001"+ + "\u0000\u0000\u0000\u0083\u008d\u0005%\u0000\u0000\u0084\u008d\u0005#\u0000"+ + "\u0000\u0085\u008d\u0005$\u0000\u0000\u0086\u008d\u0003\u0014\n\u0000"+ + "\u0087\u008d\u0005)\u0000\u0000\u0088\u008d\u0005,\u0000\u0000\u0089\u008d"+ + "\u0005&\u0000\u0000\u008a\u008d\u0005\'\u0000\u0000\u008b\u008d\u0001"+ + "\u0000\u0000\u0000\u008c\u0083\u0001\u0000\u0000\u0000\u008c\u0084\u0001"+ + "\u0000\u0000\u0000\u008c\u0085\u0001\u0000\u0000\u0000\u008c\u0086\u0001"+ + "\u0000\u0000\u0000\u008c\u0087\u0001\u0000\u0000\u0000\u008c\u0088\u0001"+ + "\u0000\u0000\u0000\u008c\u0089\u0001\u0000\u0000\u0000\u008c\u008a\u0001"+ + "\u0000\u0000\u0000\u008c\u008b\u0001\u0000\u0000\u0000\u008d\u0011\u0001"+ + "\u0000\u0000\u0000\u008e\u008f\u0007\u0005\u0000\u0000\u008f\u0013\u0001"+ + "\u0000\u0000\u0000\u0090\u0091\u0007\u0006\u0000\u0000\u0091\u0015\u0001"+ + "\u0000\u0000\u0000\n-5QS`gnuz\u008c"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); static { diff --git a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterListener.java b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterListener.java index 4e7f7d0..92c3423 100644 --- a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterListener.java +++ b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterListener.java @@ -4,25 +4,28 @@ import java.util.Objects; import java.util.Stack; import java.util.stream.Collectors; +import org.antlr.v4.runtime.CommonToken; import org.antlr.v4.runtime.Token; import org.antlr.v4.runtime.tree.ParseTree; +import org.antlr.v4.runtime.tree.TerminalNodeImpl; import org.apache.commons.lang3.StringUtils; -import org.apache.commons.lang3.tuple.Pair; +import com.github.sidhant92.boolparser.constant.FunctionType; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.LogicalOperationType; import com.github.sidhant92.boolparser.constant.Operator; -import com.github.sidhant92.boolparser.domain.ArrayNode; -import com.github.sidhant92.boolparser.domain.BooleanNode; -import com.github.sidhant92.boolparser.domain.InNode; -import com.github.sidhant92.boolparser.domain.Node; -import com.github.sidhant92.boolparser.domain.NumericRangeNode; -import com.github.sidhant92.boolparser.domain.ComparisonNode; -import com.github.sidhant92.boolparser.domain.UnaryNode; +import com.github.sidhant92.boolparser.domain.FieldNode; +import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticFunctionNode; +import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticNode; +import com.github.sidhant92.boolparser.domain.logical.ArrayNode; +import com.github.sidhant92.boolparser.domain.logical.BooleanNode; +import com.github.sidhant92.boolparser.domain.logical.InNode; +import com.github.sidhant92.boolparser.domain.logical.Node; +import com.github.sidhant92.boolparser.domain.logical.NumericRangeNode; +import com.github.sidhant92.boolparser.domain.logical.ComparisonNode; +import com.github.sidhant92.boolparser.domain.arithmetic.UnaryNode; import com.github.sidhant92.boolparser.exception.InvalidExpressionException; import com.github.sidhant92.boolparser.util.ValueUtils; -import lombok.extern.slf4j.Slf4j; -@Slf4j public class BooleanFilterListener extends BooleanExpressionBaseListener { private Node node; @@ -30,7 +33,9 @@ public class BooleanFilterListener extends BooleanExpressionBaseListener { private org.antlr.v4.runtime.Token lastToken; - private String defaultField; + private int tokenCount; + + private final String defaultField; public BooleanFilterListener(final String defaultField) { this.defaultField = defaultField; @@ -45,22 +50,27 @@ public Node getNode() { @Override public void exitComparatorExpression(BooleanExpressionParser.ComparatorExpressionContext ctx) { - final String variableName = getField(ctx.left.getText()); - final DataType dataType = getDataType(ctx.right.getStart()); - final Operator operator = Operator.getOperatorFromSymbol(ctx.op.getText()).orElse(Operator.EQUALS); - currentNodes.add(new ComparisonNode(variableName, ValueUtils.convertValue(ctx.right.getText(), dataType), operator, dataType)); + currentNodes.add(mapComparatorExpressionContext(ctx)); super.enterComparatorExpression(ctx); } + @Override + public void exitArithmeticExpression(BooleanExpressionParser.ArithmeticExpressionContext ctx) { + currentNodes.add(mapArithmeticExpressionContext(ctx)); + super.exitArithmeticExpression(ctx); + } + + @Override + public void exitUnaryArithmeticExpression(BooleanExpressionParser.UnaryArithmeticExpressionContext ctx) { + final Node leafNode = !currentNodes.isEmpty() && currentNodes.peek() instanceof ArithmeticNode ? currentNodes.pop() : mapTypesExpressionContext( + (BooleanExpressionParser.TypesExpressionContext) ctx.exp); + currentNodes.add(ArithmeticNode.builder().left(leafNode).operator(Operator.UNARY).build()); + super.enterUnaryArithmeticExpression(ctx); + } + @Override public void exitToExpression(BooleanExpressionParser.ToExpressionContext ctx) { - validateField(ctx.field, ctx.getText()); - final String field = getField(ctx.field.getText()); - final DataType lowerDataType = getDataType(ctx.lower.start); - final Object lowerValue = ValueUtils.convertValue(ctx.lower.start.getText(), lowerDataType); - final DataType upperDataType = getDataType(ctx.upper.start); - final Object upperValue = ValueUtils.convertValue(ctx.upper.getText(), upperDataType); - currentNodes.add(new NumericRangeNode(field, lowerValue, upperValue, lowerDataType, upperDataType)); + currentNodes.add(mapToExpressionContext(ctx)); super.exitToExpression(ctx); } @@ -68,43 +78,150 @@ public void exitToExpression(BooleanExpressionParser.ToExpressionContext ctx) { public void exitArrayExpression(BooleanExpressionParser.ArrayExpressionContext ctx) { validateField(ctx.field, ctx.getText()); final String field = getField(ctx.field.getText()); - final List> items = getArrayElements(ctx.data.children); + final List items = getArrayElements(ctx.data.children); final Operator operator = Operator.getOperatorFromSymbol(ctx.op.getText()).orElse(Operator.EQUALS); currentNodes.add(new ArrayNode(field, operator, items)); super.exitArrayExpression(ctx); } + @Override + public void exitArithmeticFunctionExpression(BooleanExpressionParser.ArithmeticFunctionExpressionContext ctx) { + final Node node = mapArithmeticFunctionExpressionContext(ctx); + currentNodes.add(node); + super.exitArithmeticFunctionExpression(ctx); + } + @Override public void exitInExpression(BooleanExpressionParser.InExpressionContext ctx) { + currentNodes.add(mapInExpressionContext(ctx)); + super.exitInExpression(ctx); + } + + private List getArrayElements(final List trees) { + return trees + .stream() + .filter(child -> !(child instanceof TerminalNodeImpl)) + .map(this::mapContextToNode) + .collect(Collectors.toList()); + } + + private Node mapContextToNode(final ParseTree ctx) { + if (ctx instanceof BooleanExpressionParser.ArithmeticExpressionContext) { + return mapArithmeticExpressionContext((BooleanExpressionParser.ArithmeticExpressionContext) ctx); + } else if (ctx instanceof BooleanExpressionParser.InExpressionContext) { + return mapInExpressionContext((BooleanExpressionParser.InExpressionContext) ctx); + } else if (ctx instanceof BooleanExpressionParser.ArithmeticFunctionExpressionContext) { + return mapArithmeticFunctionExpressionContext((BooleanExpressionParser.ArithmeticFunctionExpressionContext) ctx); + } else if (ctx instanceof BooleanExpressionParser.ComparatorExpressionContext) { + return mapComparatorExpressionContext((BooleanExpressionParser.ComparatorExpressionContext) ctx); + } else if (ctx instanceof BooleanExpressionParser.ToExpressionContext) { + return mapToExpressionContext((BooleanExpressionParser.ToExpressionContext) ctx); + } else if (ctx instanceof BooleanExpressionParser.TypesExpressionContext && ((BooleanExpressionParser.TypesExpressionContext) ctx).start.getType() == BooleanExpressionLexer.FIELD) { + return mapTypesExpressionContextField((BooleanExpressionParser.TypesExpressionContext) ctx); + } else if (ctx instanceof BooleanExpressionParser.TypesExpressionContext) { + return mapTypesExpressionContext((BooleanExpressionParser.TypesExpressionContext) ctx); + } else { + throw new InvalidExpressionException(String.format("Array does not support this expression %s", ctx.getText())); + } + } + + private FieldNode mapTypesExpressionContextField(BooleanExpressionParser.TypesExpressionContext ctx) { + final String value = StringUtils.isBlank(ctx.getText()) ? defaultField : ctx.getText(); + return new FieldNode(value); + } + + private Node mapTypesExpressionContext(BooleanExpressionParser.TypesExpressionContext ctx) { + if (ctx.start.getType() == BooleanExpressionLexer.FIELD) { + return mapTypesExpressionContextField(ctx); + } + if (StringUtils.isBlank(ctx.getText())) { + return mapTypesExpressionContextField(ctx); + } + final DataType dataType = getDataType(ctx.start); + final Object value = ValueUtils.convertValue(ctx.start.getText(), dataType); + return new UnaryNode(dataType, value); + } + + private ArithmeticFunctionNode mapArithmeticFunctionExpressionContext(BooleanExpressionParser.ArithmeticFunctionExpressionContext ctx) { + if (ctx.data.exception != null) { + throw new InvalidExpressionException(String.format("Error parsing expression for the string %s", ctx.getText())); + } + final FunctionType functionType = FunctionType.getArrayFunctionFromSymbol(ctx.left.getText()).orElseThrow(() -> { + return new InvalidExpressionException(String.format("Error parsing expression for the string %s", ctx.getText())); + }); + final List items = getArrayElements(ctx.data.children); + return new ArithmeticFunctionNode(functionType, items); + } + + private ComparisonNode mapComparatorExpressionContext(BooleanExpressionParser.ComparatorExpressionContext ctx) { + final Operator operator = Operator.getOperatorFromSymbol(ctx.op.getText()).orElse(Operator.EQUALS); + + if (!currentNodes.isEmpty() && ((ctx.right instanceof BooleanExpressionParser.ParentExpressionContext || ctx.left instanceof BooleanExpressionParser.ParentExpressionContext) || !(currentNodes.peek() instanceof ComparisonNode || currentNodes.peek() instanceof BooleanNode))) { + if (ctx.left instanceof BooleanExpressionParser.TypesExpressionContext) { + final DataType dataType = getDataType(ctx.left.getStart()); + final Node value = mapContextToNode(ctx.left); + return new ComparisonNode(value, currentNodes.pop(), operator, dataType); + } else if (ctx.right instanceof BooleanExpressionParser.TypesExpressionContext) { + final DataType dataType = getDataType(ctx.right.getStart()); + final Node value = mapContextToNode(ctx.right); + return new ComparisonNode(currentNodes.pop(), value, operator, dataType); + } + } + + final DataType dataType = getDataType(ctx.right.getStart()); + final Node value = mapContextToNode(ctx.right); + return new ComparisonNode(mapContextToNode(ctx.left), value, operator, dataType); + } + + private ArithmeticNode mapArithmeticExpressionContext(BooleanExpressionParser.ArithmeticExpressionContext ctx) { + final Operator operator = Operator.getOperatorFromSymbol(ctx.op.getText()).orElse(Operator.EQUALS); + if (ctx.left instanceof BooleanExpressionParser.TypesExpressionContext && ctx.right instanceof BooleanExpressionParser.TypesExpressionContext) { + final Node left = mapTypesExpressionContext((BooleanExpressionParser.TypesExpressionContext) ctx.left); + final Node right = mapTypesExpressionContext((BooleanExpressionParser.TypesExpressionContext) ctx.right); + return ArithmeticNode.builder().left(left).right(right).operator(operator).build(); + } else if (ctx.left instanceof BooleanExpressionParser.TypesExpressionContext) { + final Node left = mapTypesExpressionContext((BooleanExpressionParser.TypesExpressionContext) ctx.left); + final Node right = currentNodes.pop(); + return ArithmeticNode.builder().left(left).right(right).operator(operator).build(); + } else if (ctx.right instanceof BooleanExpressionParser.TypesExpressionContext) { + final Node right = mapTypesExpressionContext((BooleanExpressionParser.TypesExpressionContext) ctx.right); + final Node left = currentNodes.pop(); + return ArithmeticNode.builder().left(left).right(right).operator(operator).build(); + } else { + if (currentNodes.size() < 2) { + throw new InvalidExpressionException(String.format("Error parsing expression for the string %s", ctx.getText())); + } + final Node right = currentNodes.pop(); + final Node left = currentNodes.pop(); + return ArithmeticNode.builder().left(left).right(right).operator(operator).build(); + } + } + + private Node mapInExpressionContext(BooleanExpressionParser.InExpressionContext ctx) { validateField(ctx.field, ctx.getText()); final String field = getField(ctx.field.getText()); - final List> items = getArrayElements(ctx.data.children); + final List items = getArrayElements(ctx.data.children); final InNode inNode = new InNode(field, items); if (Objects.isNull(ctx.not)) { - currentNodes.add(inNode); + return inNode; } else { - final BooleanNode booleanNode = new BooleanNode(inNode, null, LogicalOperationType.NOT); - currentNodes.add(booleanNode); + return new BooleanNode(inNode, null, LogicalOperationType.NOT); } - super.exitInExpression(ctx); } - private List> getArrayElements(final List trees) { - return trees - .stream() - .filter(child -> child instanceof BooleanExpressionParser.TypesContext) - .map(child -> { - final DataType dataType = getDataType(((BooleanExpressionParser.TypesContext) child).start); - final Object value = ValueUtils.convertValue(child.getText(), dataType); - return Pair.of(dataType, value); - }) - .collect(Collectors.toList()); + private NumericRangeNode mapToExpressionContext(BooleanExpressionParser.ToExpressionContext ctx) { + validateField(ctx.field, ctx.getText()); + final String field = getField(ctx.field.getText()); + final DataType lowerDataType = getDataType(ctx.lower.start); + final Object lowerValue = ValueUtils.convertValue(ctx.lower.start.getText(), lowerDataType); + final DataType upperDataType = getDataType(ctx.upper.start); + final Object upperValue = ValueUtils.convertValue(ctx.upper.getText(), upperDataType); + return new NumericRangeNode(field, lowerValue, upperValue, lowerDataType, upperDataType); } private void validateField(final Token token, final String text) { if (Objects.isNull(token) || (StringUtils.isBlank(token.getText()) && StringUtils.isBlank(this.defaultField))) { - log.error("Error parsing expression (missing field) for the string {}", text); - throw new InvalidExpressionException(); + throw new InvalidExpressionException(String.format("Error parsing expression (missing field) for the string %s", text)); } } @@ -123,6 +240,10 @@ private DataType getDataType(final org.antlr.v4.runtime.Token token) { case BooleanExpressionLexer.TRUE: case BooleanExpressionLexer.FALSE: return DataType.BOOLEAN; + case BooleanExpressionLexer.DATE: + return DataType.DATE; + case BooleanExpressionLexer.DATETIME: + return DataType.DATETIME; default: return DataType.STRING; } @@ -141,11 +262,15 @@ private LogicalOperationType getLogicalOperator(final org.antlr.v4.runtime.Token @Override public void exitParse(BooleanExpressionParser.ParseContext ctx) { - if (this.node == null && this.currentNodes.size() == 1) { + if (this.node == null && !this.currentNodes.isEmpty()) { this.node = currentNodes.pop(); - } else { - log.error("Error parsing expression for the string {}", ctx.getText()); - throw new InvalidExpressionException(); + } + if (this.node == null && tokenCount == 1 && lastToken instanceof CommonToken) { + this.node = lastToken.getType() == BooleanExpressionLexer.FIELD ? FieldNode.builder().field(lastToken.getText()).build() : UnaryNode + .builder().dataType(DataType.STRING).value(ValueUtils.convertValue(lastToken.getText(), DataType.STRING).toString()).build(); + } + if (this.node == null) { + throw new InvalidExpressionException(String.format("Error parsing expression for the string %s", ctx.getText())); } super.exitParse(ctx); } @@ -154,8 +279,7 @@ public void exitParse(BooleanExpressionParser.ParseContext ctx) { public void exitNotExpression(BooleanExpressionParser.NotExpressionContext ctx) { if (currentNodes.isEmpty()) { if (lastToken == null) { - log.error("Error parsing not expression for the string {}", ctx.getText()); - throw new InvalidExpressionException(); + throw new InvalidExpressionException(String.format("Error parsing not expression for the string %s", ctx.getText())); } final DataType dataType = getDataType(lastToken); final Object value = ValueUtils.convertValue(lastToken.getText(), dataType); @@ -168,14 +292,14 @@ public void exitNotExpression(BooleanExpressionParser.NotExpressionContext ctx) @Override public void exitTypesExpression(BooleanExpressionParser.TypesExpressionContext ctx) { + tokenCount++; this.lastToken = ctx.start; } @Override public void exitBinaryExpression(BooleanExpressionParser.BinaryExpressionContext ctx) { if (currentNodes.size() < 2) { - log.error("Error parsing binary expression for the string {}", ctx.getText()); - throw new InvalidExpressionException(); + throw new InvalidExpressionException(String.format("Error parsing binary expression for the string %s", ctx.getText())); } final Node firstNode = currentNodes.pop(); final Node secondNode = currentNodes.pop(); diff --git a/src/main/java/com/github/sidhant92/boolparser/parser/antlr/CachedBoolParser.java b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/CachedBoolParser.java new file mode 100644 index 0000000..2c6289f --- /dev/null +++ b/src/main/java/com/github/sidhant92/boolparser/parser/antlr/CachedBoolParser.java @@ -0,0 +1,32 @@ +package com.github.sidhant92.boolparser.parser.antlr; + +import java.util.Optional; +import com.github.benmanes.caffeine.cache.Cache; +import com.github.benmanes.caffeine.cache.Caffeine; +import com.github.sidhant92.boolparser.domain.logical.Node; +import com.github.sidhant92.boolparser.operator.OperatorFactory; +import io.vavr.control.Try; + +public class CachedBoolParser extends BoolParser { + private final Cache cache; + + public CachedBoolParser(final int maxCacheSize) { + OperatorFactory.initialize(); + this.cache = Caffeine.newBuilder().maximumSize(maxCacheSize).build(); + } + + @Override + public Try parseExpression(final String expression, final String defaultField) { + return Try.of(() -> getNode(expression, defaultField)); + } + + @Override + public Try parseExpression(final String expression) { + return Try.of(() -> getNode(expression, null)); + } + + private Node getNode(final String expression, final String defaultField) { + final String cacheKey = expression + "_" + Optional.ofNullable(defaultField).orElse(""); + return cache.get(cacheKey, ex -> super.parse(expression, defaultField)); + } +} diff --git a/src/main/java/com/github/sidhant92/boolparser/util/ValueUtils.java b/src/main/java/com/github/sidhant92/boolparser/util/ValueUtils.java index 15232e0..7e9e377 100644 --- a/src/main/java/com/github/sidhant92/boolparser/util/ValueUtils.java +++ b/src/main/java/com/github/sidhant92/boolparser/util/ValueUtils.java @@ -1,14 +1,21 @@ package com.github.sidhant92.boolparser.util; +import java.math.BigDecimal; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeParseException; +import java.util.ArrayList; import java.util.Arrays; +import java.util.Collection; +import java.util.List; import java.util.Map; import java.util.Optional; import java.util.stream.Collectors; import org.apache.maven.artifact.versioning.ComparableVersion; import com.github.sidhant92.boolparser.constant.DataType; -import lombok.extern.slf4j.Slf4j; +import com.github.sidhant92.boolparser.domain.EvaluatedNode; -@Slf4j public class ValueUtils { public static Optional getValueFromMap(final String key, final Map data) { final String[] keys = key.split("\\."); @@ -27,10 +34,31 @@ public static Optional getValueFromMap(final String key, final Map mapToEvaluatedNodes(final List items) { + final List flattenedValues = new ArrayList<>(); + items.forEach(value -> { + if (value instanceof EvaluatedNode) { + final EvaluatedNode node = (EvaluatedNode) value; + if (node.getValue() instanceof Collection) { + ((Collection) node.getValue()).forEach( + v -> flattenedValues.add(EvaluatedNode.builder().value(v).dataType(ValueUtils.getDataType(v)).build())); + } else { + flattenedValues.add(node); + } + } + if (value instanceof Collection) { + ((Collection) value).forEach( + v -> flattenedValues.add(EvaluatedNode.builder().value(v).dataType(ValueUtils.getDataType(v)).build())); + } else { + flattenedValues.add(EvaluatedNode.builder().value(value).dataType(ValueUtils.getDataType(value)).build()); + } + }); + return flattenedValues; + } + public static Object convertValue(final String value, final DataType dataType) { switch (dataType) { case INTEGER: @@ -38,11 +66,15 @@ public static Object convertValue(final String value, final DataType dataType) { case LONG: return Long.parseLong(value); case DECIMAL: - return Double.parseDouble(value); + return new BigDecimal(value); case BOOLEAN: return Boolean.parseBoolean(value); case VERSION: - new ComparableVersion(value); + return new ComparableVersion(value); + case DATE: + return parseDate(value).orElse(null); + case DATETIME: + return parseDateTime(value).orElse(null); default: if (value.startsWith("'") && value.endsWith("'")) { return value.substring(1, value.length() - 1); @@ -54,6 +86,27 @@ public static Object convertValue(final String value, final DataType dataType) { } } + public static Object castDecimal(final double value) { + if ((int) value == value) { + return (int) value; + } + return new BigDecimal(value); + } + + public static Object castLong(final long value) { + if ((int) value == value) { + return (int) value; + } + return value; + } + + public static Object castDecimal(final BigDecimal value) { + if (value.signum() == 0 || value.scale() <= 0 || value.stripTrailingZeros().scale() <= 0) { + return value.intValueExact(); + } + return value; + } + public static DataType getNumericDataType(final String value) { final Optional integerOptional = parseInteger(value); return integerOptional.isPresent() ? DataType.INTEGER : DataType.LONG; @@ -66,4 +119,59 @@ public static Optional parseInteger(final String number) { return Optional.empty(); } } + + public static DataType getDataType(final Object value) { + if (value instanceof Boolean) { + return DataType.BOOLEAN; + } + if (value instanceof Float || value instanceof Double || value instanceof BigDecimal) { + return DataType.DECIMAL; + } + if (value instanceof Integer) { + return DataType.INTEGER; + } + if (value instanceof Long) { + return DataType.LONG; + } + if (value instanceof ComparableVersion) { + return DataType.VERSION; + } + if (value instanceof LocalDate) { + return DataType.DATE; + } + if (value instanceof LocalDateTime) { + return DataType.DATETIME; + } + if (value instanceof String) { + String stringValue = (String) value; + // Check if string represents a datetime first (more specific) + if (parseDateTime(stringValue).isPresent()) { + return DataType.DATETIME; + } + // Then check if it's a date + if (parseDate(stringValue).isPresent()) { + return DataType.DATE; + } + } + return DataType.STRING; + } + + private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + private static final DateTimeFormatter DATETIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + + private static Optional parseDate(String dateString) { + try { + return Optional.of(LocalDate.parse(dateString, DATE_FORMATTER)); + } catch (DateTimeParseException ignored) { + return Optional.empty(); + } + } + + private static Optional parseDateTime(String dateTimeString) { + try { + return Optional.of(LocalDateTime.parse(dateTimeString, DATETIME_FORMATTER)); + } catch (DateTimeParseException ignored) { + return Optional.empty(); + } + } } diff --git a/src/main/java/resources/BooleanExpression.g4 b/src/main/java/resources/BooleanExpression.g4 index 3c2bbba..6b84f66 100644 --- a/src/main/java/resources/BooleanExpression.g4 +++ b/src/main/java/resources/BooleanExpression.g4 @@ -8,20 +8,49 @@ expression : LPAREN expression RPAREN #parentExpression | NOT expression #notExpression | left=expression op=comparator right=expression #comparatorExpression + | op=SUBTRACT exp=expression #unaryArithmeticExpression + | left=expression op= EXPONENT right=expression #arithmeticExpression + | left=expression op= DIVIDE right=expression #arithmeticExpression + | left=expression op= MULTIPLY right=expression #arithmeticExpression + | left=expression op= MODULUS right=expression #arithmeticExpression + | left=expression op= ADD right=expression #arithmeticExpression + | left=expression op= SUBTRACT right=expression #arithmeticExpression + | left=arithmeticFunction data=wordlist #arithmeticFunctionExpression | left=expression op=binary right=expression #binaryExpression | types #typesExpression - | (field=WORD)? lower=numericTypes TO upper=numericTypes #toExpression - | (field=WORD)? (not=NOT)? IN data=wordlist #inExpression - | (field=WORD)? op=arrayOperators data=wordlist #arrayExpression + | (field=FIELD) lower=numericTypes TO upper=numericTypes #toExpression + | (field=FIELD) (not=NOT)? IN data=wordlist #inExpression + | (field=FIELD) op=arrayOperators data=wordlist #arrayExpression ; comparator : GT | GE | LT | LE | EQ | NE ; +arithmeticOperator + : MULTIPLY + | DIVIDE + | ADD + | SUBTRACT + | MODULUS + | EXPONENT + ; + +arithmeticFunction + : MIN + | MAX + | SUM + | AVG + | MEAN + | MODE + | LEN + | MEDIAN + | INT + | DAYS_ELAPSED + ; wordlist - : LPAREN WS* first=types WS* (',' WS* rest=types WS*)* RPAREN + : LPAREN WS* first=expression WS* (',' WS* rest=expression WS*)* RPAREN ; arrayOperators @@ -34,7 +63,7 @@ comparator ; types - : INTEGER | DECIMAL | APP_VERSION | bool | WORD | + : INTEGER | DECIMAL | APP_VERSION | bool | WORD | FIELD | DATE | DATETIME | ; @@ -56,6 +85,22 @@ TRUE : 'TRUE' | 'true'; FALSE : 'FALSE' | 'false'; CONTAINS_ALL : 'CONTAINS_ALL' | 'contains_all'; CONTAINS_ANY : 'CONTAINS_ANY' | 'contains_any'; +MIN : 'MIN' | 'min'; +MAX : 'MAX' | 'max'; +AVG : 'AVG' | 'avg'; +SUM : 'SUM' | 'sum'; +MEAN : 'MEAN' | 'mean'; +MODE : 'MODE' | 'mode'; +MEDIAN : 'MEDIAN' | 'median'; +LEN : 'LEN' | 'len'; +INT : 'INT' | 'int'; +DAYS_ELAPSED : 'DAYS_ELAPSED' | 'days_elapsed'; +ADD : '+'; +SUBTRACT : '-' ; +MULTIPLY : '*' ; +DIVIDE : '/' ; +MODULUS : '%' ; +EXPONENT : '^' ; NE : '!='; GT : '>' ; GE : '>=' ; @@ -67,8 +112,21 @@ RPAREN : ')' ; DECIMAL : [0-9]+ '.' [0-9]+; APP_VERSION : [0-9] ('.' INTEGER)+; INTEGER : [0-9]+; +DATE : DATE_PATTERN; +DATETIME : DATETIME_PATTERN; WS : [ \r\t\u000C\n]+ -> skip; -WORD : (ALPHANUMERIC | '_' | '-' | '.' | SQ | DQ)+; +WORD : SQSTR | DQSTR; +SQSTR : '\'' .*? '\''; +DQSTR : '"' .*? '"'; +FIELD : (ALPHANUMERIC | '_' | '.')+; ALPHANUMERIC : [a-zA-Z0-9]; SQ : '\''.*? '\''; DQ : '"'.*? '"'; + +fragment DATE_PATTERN + : [0-9][0-9][0-9][0-9]'-'[0-9][0-9]'-'[0-9][0-9] // YYYY-MM-DD + ; + +fragment DATETIME_PATTERN + : [0-9][0-9][0-9][0-9]'-'[0-9][0-9]'-'[0-9][0-9]' '[0-9][0-9]':'[0-9][0-9]':'[0-9][0-9] // YYYY-MM-DD HH:MM:SS + ; diff --git a/src/test/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluatorTest.java b/src/test/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluatorTest.java new file mode 100644 index 0000000..7f2ff5c --- /dev/null +++ b/src/test/java/com/github/sidhant92/boolparser/application/ArithmeticExpressionEvaluatorTest.java @@ -0,0 +1,419 @@ +package com.github.sidhant92.boolparser.application; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.Test; +import com.github.sidhant92.boolparser.exception.DataNotFoundException; +import com.github.sidhant92.boolparser.exception.InvalidDataType; +import com.github.sidhant92.boolparser.exception.InvalidExpressionException; +import com.github.sidhant92.boolparser.exception.InvalidUnaryOperand; +import com.github.sidhant92.boolparser.exception.UnsupportedToken; +import com.github.sidhant92.boolparser.parser.antlr.BoolParser; +import io.vavr.control.Try; + +/** + * @author sidhant.aggarwal + * @since 07/02/2023 + */ +public class ArithmeticExpressionEvaluatorTest { + private final ArithmeticExpressionEvaluator arithmeticExpressionEvaluator = new ArithmeticExpressionEvaluator(new BoolParser()); + + @Test + public void testSimpleAddOperationWithoutVariable() { + final Map data = new HashMap<>(); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("5 + 5", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 10); + } + + @Test + public void testSimpleSubtractOperationWithoutVariable() { + final Map data = new HashMap<>(); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("5 - 4", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 1); + } + + @Test + public void testSimpleMultiplyOperationWithoutVariable() { + final Map data = new HashMap<>(); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("5 * 5", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 25); + } + + @Test + public void testSimpleDivideOperationWithoutVariable() { + final Map data = new HashMap<>(); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("5 / 5", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 1); + } + + @Test + public void testSimpleDivideOperationWithoutVariable1() { + final Map data = new HashMap<>(); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("5 / 4", data); + assertTrue(resultOptional.isSuccess()); + assertTrue(((BigDecimal)resultOptional.get()).compareTo(new BigDecimal("1.25")) == 0); + } + + @Test + public void testSimpleModulusOperationWithoutVariable() { + final Map data = new HashMap<>(); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("10 % 4", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 2); + } + + @Test + public void testSimpleExponentOperationWithoutVariable() { + final Map data = new HashMap<>(); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("2 ^ 4", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 16); + } + + @Test + public void testSimpleAddOperationWithVariable() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("a + 5", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 15); + } + + @Test + public void testSimpleSubtractOperationWithVariable() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("a - 5", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 5); + } + + @Test + public void testSimpleSubtractOperationWithTwoVariable() { + final Map data = new HashMap<>(); + data.put("a", 10); + data.put("b", 5); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("a-b", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 5); + } + + @Test + public void testStringEvaluation() { + final Map data = new HashMap<>(); + data.put("a", 10); + data.put("b", 5); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("\"a-b\"", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), "a-b"); + } + + @Test + public void testSimpleMultiplyOperationWithVariable() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("a * 5", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 50); + } + + @Test + public void testSimpleDivideOperationWithVariable() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("a / 5", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 2); + } + + @Test + public void testSimpleModulusOperationWithVariable() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("a % 5", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 0); + } + + @Test + public void testSimpleExponentOperationWithVariable() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("a ^ 5", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 100000); + } + + @Test + public void testStringConcatenation() { + final Map data = new HashMap<>(); + data.put("a", "first"); + data.put("b", "second"); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("a + \" \" + b", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), "first second"); + } + + @Test + public void testExpressionWithParenthesisNoVariable() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("((5 * 2) + 10) * 2 + (1 + 3 * (10 / 2))", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 56); + } + + @Test + public void testExpressionWithParenthesisWithVariable() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("((5 * 2) + a) * 2 + (1 + 3 * (a / 2))", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 56); + } + + @Test + public void testExpressionWithComparison() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("(a > (4 + 1))", data); + assertTrue(resultOptional.isFailure()); + assertTrue(resultOptional.getCause() instanceof UnsupportedToken); + } + + @Test + public void testExpressionWithUnaryNode() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("- a", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), -10); + } + + @Test + public void testExpressionWithNestedUnaryNode() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("- (a + 5)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), -15); + } + + @Test + public void testExpressionWithNestedUnaryNode1() { + final Map data = new HashMap<>(); + data.put("a", "test"); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("a", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), "test"); + } + + @Test + public void testUnaryNode() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("-a", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), -10); + } + + @Test + public void testDoubleUnaryNode() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("--a", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 10); + } + + @Test + public void testMinArithmeticFunctionInteger() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("min (1,2,3)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 1); + } + + @Test + public void testMinArithmeticFunctionDouble() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("min (1,2,3,4.5)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 1); + } + + @Test + public void testMaxArithmeticFunctionInteger() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("max (1,2,3)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 3); + } + + @Test + public void testMaxArithmeticFunctionDouble() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("max (1,2,3,4.5)", data); + assertTrue(resultOptional.isSuccess()); + assertTrue(((BigDecimal)resultOptional.get()).compareTo(new BigDecimal("4.5")) == 0); + } + + @Test + public void testAvgArithmeticFunctionInteger() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("avg (1,2,3)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 2); + } + + @Test + public void testAvgArithmeticFunctionDouble() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("avg (1,2,3,4.5)", data); + assertTrue(resultOptional.isSuccess()); + assertTrue(((BigDecimal) resultOptional.get()).compareTo(new BigDecimal("2.625")) == 0); + } + + @Test + public void testSumArithmeticFunctionInteger() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("sum (1,2,3)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 6); + } + + @Test + public void testSumArithmeticFunctionDouble() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("sum (1,2,3,4.5)", data); + assertTrue(resultOptional.isSuccess()); + assertTrue(((BigDecimal)resultOptional.get()).compareTo(new BigDecimal("10.5")) == 0); + } + + @Test + public void testMeanArithmeticFunctionInteger() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("mean (1,2,3)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 2); + } + + @Test + public void testMeanArithmeticFunctionDouble() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("mean (1,2,3,4.5)", data); + assertTrue(resultOptional.isSuccess()); + assertTrue(((BigDecimal)resultOptional.get()).compareTo(new BigDecimal("2.625")) == 0); + } + + @Test + public void testModeArithmeticFunctionIntegerVariable() { + final Map data = new HashMap<>(); + final List numbers = new ArrayList<>(); + numbers.add(1); + numbers.add(1); + numbers.add(2); + numbers.add(3); + data.put("a", numbers); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("mode (a)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 1); + } + + @Test + public void testModeArithmeticFunctionDouble() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("mode (1,2,3,4.5)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 1); + } + + @Test + public void testMedianArithmeticFunctionInteger() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("median (3, 13, 2, 34, 11, 17, 27, 47)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 15); + } + + @Test + public void testIntArithmeticFunction() { + final Map data = new HashMap<>(); + data.put("a", 10); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("int (2.7)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 2); + } + + @Test + public void testIntArithmeticFunctionWithVariable() { + final Map data = new HashMap<>(); + data.put("a", 2.7); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("int (a)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 2); + } + + @Test + public void testLenArithmeticFunctionString() { + final Map data = new HashMap<>(); + data.put("a", "lorem"); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("len (a)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 5); + } + + @Test + public void testLenArithmeticFunctionIntegerVariable() { + final Map data = new HashMap<>(); + final List numbers = new ArrayList<>(); + numbers.add(1); + numbers.add(1); + numbers.add(2); + numbers.add(3); + data.put("a", numbers); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("len (a)", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 4); + } + + @Test + public void testNestedFunctions() { + final Map data = new HashMap<>(); + data.put("a", 2.7); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("max(1,2,min(5,7,87))", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 5); + } + + @Test + public void testNestedFunctions1() { + final Map data = new HashMap<>(); + data.put("a", 2.7); + final Try resultOptional = arithmeticExpressionEvaluator.evaluate("max(1,2,min(5,7,87,min(1,2)))", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), 2); + } +} diff --git a/src/test/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluatorTest.java b/src/test/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluatorTest.java index ca99377..c3c4625 100644 --- a/src/test/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluatorTest.java +++ b/src/test/java/com/github/sidhant92/boolparser/application/BooleanExpressionEvaluatorTest.java @@ -3,6 +3,8 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; +import java.time.LocalDate; +import java.time.LocalDateTime; import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -53,7 +55,7 @@ public void testInvalidUnaryOperation() { public void testSimpleTrueCorrectExpression() { final Map data = new HashMap<>(); data.put("name", "abc"); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = abc", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = 'abc'", data); assertTrue(booleanOptional.isSuccess()); assertTrue(booleanOptional.get()); } @@ -62,7 +64,7 @@ public void testSimpleTrueCorrectExpression() { public void testSimpleTrueCorrectExpressions() { final Map data = new HashMap<>(); data.put("name", "abc-"); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = abc-", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = 'abc-'", data); assertTrue(booleanOptional.isSuccess()); assertTrue(booleanOptional.get()); } @@ -80,7 +82,7 @@ public void testInvalidDataType() { public void testSimpleFalseIncorrectExpression() { final Map data = new HashMap<>(); data.put("name", "def"); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = abc", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = 'abc'", data); assertTrue(booleanOptional.isSuccess()); assertFalse(booleanOptional.get()); } @@ -112,6 +114,25 @@ public void testNumericGreaterThanCorrectExpression() { assertTrue(booleanOptional.get()); } + @Test + public void testNumericGreaterThanCorrectExpressionInverted() { + final Map data = new HashMap<>(); + data.put("age", 24); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("20 < age", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testNumericGreaterThanCorrectExpressionWithField() { + final Map data = new HashMap<>(); + data.put("age", 24); + data.put("b", 20); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("age > b", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + @Test public void testNestedField() { final Map data = new HashMap<>(); @@ -156,6 +177,15 @@ public void testNumericGreaterThanIncorrectExpression() { assertFalse(booleanOptional.get()); } + @Test + public void testDifferentDataTypesComparison() { + final Map data = new HashMap<>(); + data.put("age", 26.6); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("age > 20", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + @Test public void testNumericGreaterThanEqualCorrectExpression() { final Map data = new HashMap<>(); @@ -214,7 +244,7 @@ public void testNumericNotEqualIncorrectExpression() { public void testSimpleNotStringExpression() { final Map data = new HashMap<>(); data.put("name", "abc"); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("NOT (name = abc)", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("NOT (name = 'abc')", data); assertTrue(booleanOptional.isSuccess()); assertFalse(booleanOptional.get()); } @@ -233,7 +263,7 @@ public void testComplexAndCorrectExpression() { final Map data = new HashMap<>(); data.put("age", 25); data.put("name", "sid"); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = sid AND age = 25", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = 'sid' AND age = 25", data); assertTrue(booleanOptional.isSuccess()); assertTrue(booleanOptional.get()); } @@ -243,7 +273,7 @@ public void testComplexAndIncorrectExpression() { final Map data = new HashMap<>(); data.put("age", 25); data.put("name", "sid"); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = sid AND age = 23", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = 'sid' AND age = 23", data); assertTrue(booleanOptional.isSuccess()); assertFalse(booleanOptional.get()); } @@ -253,7 +283,7 @@ public void testComplexORCorrectExpression() { final Map data = new HashMap<>(); data.put("age", 25); data.put("name", "sid"); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = sid OR age = 23", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = 'sid' OR age = 23", data); assertTrue(booleanOptional.isSuccess()); assertTrue(booleanOptional.get()); } @@ -263,7 +293,7 @@ public void testComplexORIncorrectExpression() { final Map data = new HashMap<>(); data.put("age", 25); data.put("name", "sidh"); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = sid OR age = 23", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = 'sid' OR age = 23", data); assertTrue(booleanOptional.isSuccess()); assertFalse(booleanOptional.get()); } @@ -274,7 +304,7 @@ public void testCorrectComplexExpressionWithParenthesis() { data.put("age", 25); data.put("name", "sid"); data.put("num", 45); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = sid AND (age = 25 OR num = 44)", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = 'sid' AND (age = 25 OR num = 44)", data); assertTrue(booleanOptional.isSuccess()); assertTrue(booleanOptional.get()); } @@ -288,6 +318,16 @@ public void testNegativeInClauseForIntegers() { assertFalse(booleanOptional.get()); } + @Test + public void testNegativeInClauseForIntegersWithField() { + final Map data = new HashMap<>(); + data.put("age", 25); + data.put("a", 25); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("age in (26,56,34,a)", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + @Test public void testNotInClauseForIntegers() { final Map data = new HashMap<>(); @@ -319,7 +359,7 @@ public void testPositiveInClauseForDecimals() { public void testNegativeInClauseForStrings() { final Map data = new HashMap<>(); data.put("name", "test"); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name in (tes, abc)", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name in ('tes', 'abc')", data); assertTrue(booleanOptional.isSuccess()); assertFalse(booleanOptional.get()); } @@ -328,7 +368,7 @@ public void testNegativeInClauseForStrings() { public void testPositiveInClauseForStrings() { final Map data = new HashMap<>(); data.put("name", "test"); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name in (abc, test)", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name in ('abc', 'test')", data); assertTrue(booleanOptional.isSuccess()); assertTrue(booleanOptional.get()); } @@ -339,7 +379,7 @@ public void testCorrectComplexExpressionWithParenthesis1() { data.put("age", 25); data.put("name", "sid"); data.put("num", 45); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = sidh OR (age = 25 AND num = 45)", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = 'sidh' OR (age = 25 AND num = 45)", data); assertTrue(booleanOptional.isSuccess()); assertTrue(booleanOptional.get()); } @@ -350,7 +390,7 @@ public void testIncorrectComplexExpressionWithParenthesis() { data.put("age", 25); data.put("name", "sid"); data.put("num", 45); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = sid AND (age = 23 OR num = 44)", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("name = 'sid' AND (age = 23 OR num = 44)", data); assertTrue(booleanOptional.isSuccess()); assertFalse(booleanOptional.get()); } @@ -359,7 +399,7 @@ public void testIncorrectComplexExpressionWithParenthesis() { public void testWrongDataType() { final Map data = new HashMap<>(); data.put("age", 24); - final Try booleanOptional = booleanExpressionEvaluator.evaluate("age = dsf", data); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("age = 'dsf'", data); assertTrue(booleanOptional.isSuccess()); assertFalse(booleanOptional.get()); } @@ -369,8 +409,8 @@ public void testWrongDataType1() { final Map data = new HashMap<>(); data.put("age", "sf"); final Try booleanOptional = booleanExpressionEvaluator.evaluate("age = 24", data); - assertTrue(booleanOptional.isFailure()); - assertTrue(booleanOptional.getCause() instanceof InvalidDataType); + assertTrue(booleanOptional.isSuccess()); + assertFalse(booleanOptional.get()); } @Test @@ -514,4 +554,380 @@ public void testContainsAllFalseCondition() { assertTrue(booleanOptional.isSuccess()); assertFalse(booleanOptional.get()); } + + @Test + public void testComparisonWithArithmeticTrueCondition() { + final Map data = new HashMap<>(); + data.put("age", "20"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("age > (5 + 10)", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testComparisonWithArithmeticTrueConditionInverted() { + final Map data = new HashMap<>(); + data.put("age", "20"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("(5 + 10) < age", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testComparisonWithArithmeticFunction() { + final Map data = new HashMap<>(); + data.put("age", "20"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("age > min (18, 25, 30)", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testComparisonWithArithmeticVariableFunction() { + final Map data = new HashMap<>(); + final List numbers = new ArrayList<>(); + numbers.add(1); + numbers.add(1); + numbers.add(2); + numbers.add(30); + data.put("age", "20"); + data.put("numbers", numbers); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("age > max (numbers)", data); + assertTrue(booleanOptional.isSuccess()); + assertFalse(booleanOptional.get()); + } + + @Test + public void testComparisonWithArithmeticFalseCondition() { + final Map data = new HashMap<>(); + data.put("age", "20"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("age > (5 + 20)", data); + assertTrue(booleanOptional.isSuccess()); + assertFalse(booleanOptional.get()); + } + + @Test + public void testComparisonWithArithmeticFalseCondition1() { + final Map data = new HashMap<>(); + data.put("age", "20"); + data.put("a", 20); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("age > (5 + a)", data); + assertTrue(booleanOptional.isSuccess()); + assertFalse(booleanOptional.get()); + } + + @Test + public void testBooleanComparison() { + final Map data = new HashMap<>(); + data.put("age", true); + data.put("a", 20); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("age = (5 > 3)", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testNegativeComparison() { + final Map data = new HashMap<>(); + data.put("a", -6); + final Try resultOptional = booleanExpressionEvaluator.evaluate("a > -10 AND a < -2", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), true); + } + + @Test + public void testNullCheck() { + final Map data = new HashMap<>(); + data.put("a", 2.7); + final Try resultOptional = booleanExpressionEvaluator.evaluate("b = null", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), true); + } + + @Test + public void testNullCheckInverted() { + final Map data = new HashMap<>(); + data.put("a", 2.7); + final Try resultOptional = booleanExpressionEvaluator.evaluate("null = b", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), true); + } + + @Test + public void testNullCheck1() { + final Map data = new HashMap<>(); + data.put("a", 2.7); + final Try resultOptional = booleanExpressionEvaluator.evaluate("a = null", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), false); + } + + @Test + public void testNotNullCheck() { + final Map data = new HashMap<>(); + data.put("a", 2.7); + final Try resultOptional = booleanExpressionEvaluator.evaluate("a != null", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), true); + } + + @Test + public void testBooleanNullCheck() { + final Map data = new HashMap<>(); + data.put("a", 3); + final Try resultOptional = booleanExpressionEvaluator.evaluate("b = null && a > 2", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), true); + } + + @Test + public void testArithmeticFunctionAndComparison() { + final Map data = new HashMap<>(); + data.put("a", "test"); + final Try resultOptional = booleanExpressionEvaluator.evaluate("len(a) = 4", data); + assertTrue(resultOptional.isSuccess()); + assertEquals(resultOptional.get(), true); + } + + @Test + public void testDateEqualityCorrectExpression() { + final Map data = new HashMap<>(); + data.put("created_date", LocalDate.of(2023, 3, 5)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("created_date = 2023-03-05", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDateEqualityIncorrectExpression() { + final Map data = new HashMap<>(); + data.put("created_date", LocalDate.of(2023, 3, 5)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("created_date = 2023-03-06", data); + assertTrue(booleanOptional.isSuccess()); + assertFalse(booleanOptional.get()); + } + + @Test + public void testDateGreaterThanCorrectExpression() { + final Map data = new HashMap<>(); + data.put("event_date", LocalDate.of(2023, 6, 15)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("event_date > 2023-03-05", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDateLessThanCorrectExpression() { + final Map data = new HashMap<>(); + data.put("birth_date", LocalDate.of(1990, 1, 1)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("birth_date < 2000-01-01", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDateTimeEqualityCorrectExpression() { + final Map data = new HashMap<>(); + data.put("timestamp", LocalDateTime.of(2023, 3, 5, 14, 30, 0)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("timestamp = 2023-03-05 14:30:00", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDateTimeEqualityIncorrectExpression() { + final Map data = new HashMap<>(); + data.put("timestamp", LocalDateTime.of(2023, 3, 5, 14, 30, 0)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("timestamp = 2023-03-05 14:31:00", data); + assertTrue(booleanOptional.isSuccess()); + assertFalse(booleanOptional.get()); + } + + @Test + public void testDateTimeGreaterThanCorrectExpression() { + final Map data = new HashMap<>(); + data.put("last_modified", LocalDateTime.of(2023, 6, 15, 10, 30, 0)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("last_modified > 2023-03-05 14:30:00", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDateTimeLessThanCorrectExpression() { + final Map data = new HashMap<>(); + data.put("created_at", LocalDateTime.of(2023, 1, 1, 9, 0, 0)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("created_at < 2023-03-05 14:30:00", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDateInClause() { + final Map data = new HashMap<>(); + data.put("holiday", LocalDate.of(2023, 12, 25)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("holiday in (2023-12-24, 2023-12-25, 2023-12-26)", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDateTimeInClause() { + final Map data = new HashMap<>(); + data.put("meeting_time", LocalDateTime.of(2023, 3, 5, 14, 30, 0)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("meeting_time in (2023-03-05 13:30:00, 2023-03-05 14:30:00, 2023-03-05 15:30:00)", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testComplexDateTimeExpression() { + final Map data = new HashMap<>(); + data.put("start_date", LocalDate.of(2023, 1, 1)); + data.put("end_date", LocalDate.of(2023, 12, 31)); + data.put("current_date", LocalDate.of(2023, 6, 15)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("current_date >= start_date AND current_date <= end_date", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDateEqualityWithStringData() { + final Map data = new HashMap<>(); + data.put("created_date", "2023-03-05"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("created_date = 2023-03-05", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDateComparisonWithStringData() { + final Map data = new HashMap<>(); + data.put("event_date", "2023-06-15"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("event_date > 2023-03-05", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDateTimeEqualityWithStringData() { + final Map data = new HashMap<>(); + data.put("timestamp", "2023-03-05 14:30:00"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("timestamp = 2023-03-05 14:30:00", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDateTimeComparisonWithStringData() { + final Map data = new HashMap<>(); + data.put("last_modified", "2023-06-15 10:30:00"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("last_modified > 2023-03-05 14:30:00", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testMixedDateTypesComparison() { + final Map data = new HashMap<>(); + data.put("string_date", "2023-06-15"); + data.put("object_date", LocalDate.of(2023, 3, 5)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("string_date > object_date", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testMixedDateTimeTypesComparison() { + final Map data = new HashMap<>(); + data.put("string_datetime", "2023-06-15 10:30:00"); + data.put("object_datetime", LocalDateTime.of(2023, 3, 5, 14, 30, 0)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("string_datetime > object_datetime", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testInvalidDateStringFormat() { + final Map data = new HashMap<>(); + data.put("bad_date", "03/05/2023"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("bad_date = 2023-03-05", data); + assertTrue(booleanOptional.isSuccess()); + assertFalse(booleanOptional.get()); + } + + @Test + public void testInvalidDateTimeStringFormat() { + final Map data = new HashMap<>(); + data.put("bad_datetime", "2023-03-05T14:30:00"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("bad_datetime = 2023-03-05 14:30:00", data); + assertTrue(booleanOptional.isSuccess()); + assertFalse(booleanOptional.get()); + } + + @Test + public void testStringDateAutoDetection() { + final Map data = new HashMap<>(); + data.put("date_string", "2023-03-05"); + data.put("regular_string", "hello world"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("date_string > 2023-01-01", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testStringDateTimeAutoDetection() { + final Map data = new HashMap<>(); + data.put("datetime_string", "2023-03-05 14:30:00"); + data.put("regular_string", "hello world"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("datetime_string > 2023-01-01 10:00:00", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testAutoDetectionInComplexExpressions() { + final Map data = new HashMap<>(); + data.put("start_date_str", "2023-01-01"); + data.put("end_date_str", "2023-12-31"); + data.put("current_date_str", "2023-06-15"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("current_date_str >= start_date_str AND current_date_str <= end_date_str", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDaysElapsedFunction() { + final Map data = new HashMap<>(); + data.put("created_date", LocalDate.of(2023, 1, 1)); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("days_elapsed(created_date) > 0", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDaysElapsedFunctionWithStringDate() { + final Map data = new HashMap<>(); + data.put("created_date", "2023-01-01"); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("days_elapsed(created_date) > 300", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDaysElapsedFunctionWithDirectDate() { + final Map data = new HashMap<>(); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("days_elapsed(2023-01-01) > 300", data); + assertTrue(booleanOptional.isSuccess()); + assertTrue(booleanOptional.get()); + } + + @Test + public void testDaysElapsedFunctionInComparison() { + final Map data = new HashMap<>(); + data.put("event_date", LocalDate.of(2023, 6, 15)); + data.put("threshold_days", 100); + final Try booleanOptional = booleanExpressionEvaluator.evaluate("days_elapsed(event_date) <= threshold_days", data); + assertTrue(booleanOptional.isSuccess()); + // This will depend on current date, so we just check it executes successfully + } } diff --git a/src/test/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterBoolParserTest.java b/src/test/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterBoolParserTest.java index e16eda7..1ef4499 100644 --- a/src/test/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterBoolParserTest.java +++ b/src/test/java/com/github/sidhant92/boolparser/parser/antlr/BooleanFilterBoolParserTest.java @@ -4,19 +4,24 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertTrue; +import java.math.BigDecimal; +import java.time.LocalDate; +import java.time.LocalDateTime; import org.junit.jupiter.api.Test; import com.github.sidhant92.boolparser.constant.DataType; import com.github.sidhant92.boolparser.constant.LogicalOperationType; import com.github.sidhant92.boolparser.constant.NodeType; import com.github.sidhant92.boolparser.constant.Operator; -import com.github.sidhant92.boolparser.domain.ArrayNode; -import com.github.sidhant92.boolparser.domain.BooleanNode; -import com.github.sidhant92.boolparser.domain.InNode; -import com.github.sidhant92.boolparser.domain.Node; -import com.github.sidhant92.boolparser.domain.NumericRangeNode; -import com.github.sidhant92.boolparser.domain.ComparisonNode; -import com.github.sidhant92.boolparser.domain.UnaryNode; -import com.github.sidhant92.boolparser.exception.InvalidExpressionException; +import com.github.sidhant92.boolparser.domain.FieldNode; +import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticFunctionNode; +import com.github.sidhant92.boolparser.domain.arithmetic.ArithmeticNode; +import com.github.sidhant92.boolparser.domain.logical.ArrayNode; +import com.github.sidhant92.boolparser.domain.logical.BooleanNode; +import com.github.sidhant92.boolparser.domain.logical.InNode; +import com.github.sidhant92.boolparser.domain.logical.Node; +import com.github.sidhant92.boolparser.domain.logical.NumericRangeNode; +import com.github.sidhant92.boolparser.domain.logical.ComparisonNode; +import com.github.sidhant92.boolparser.domain.arithmetic.UnaryNode; import io.vavr.control.Try; /** @@ -48,58 +53,58 @@ public void testUnaryTokenString() { @Test public void testSingleStringToken() { - final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = test"); + final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = 'test'"); assertTrue(nodeOptional.isSuccess()); - assertEquals(nodeOptional.get().getTokenType().name(), NodeType.COMPARISON.name()); - verifyStringToken((ComparisonNode) nodeOptional.get(), "name", "test"); + verifyComparisonToken(nodeOptional.get(), "name", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), "test", DataType.STRING); } @Test public void testSingleStringTokenWithSingleQuotes() { final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = \"te\'st\""); assertTrue(nodeOptional.isSuccess()); - assertEquals(nodeOptional.get().getTokenType().name(), NodeType.COMPARISON.name()); - verifyStringToken((ComparisonNode) nodeOptional.get(), "name", "te\'st"); + verifyComparisonToken(nodeOptional.get(), "name", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), "te'st", DataType.STRING); } @Test public void testSingleStringTokenWithDoubleQuotes() { final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = 'te\"st'"); assertTrue(nodeOptional.isSuccess()); - assertEquals(nodeOptional.get().getTokenType().name(), NodeType.COMPARISON.name()); - verifyStringToken((ComparisonNode) nodeOptional.get(), "name", "te\"st"); + verifyComparisonToken(nodeOptional.get(), "name", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), "te\"st", DataType.STRING); } @Test public void testSingleStringTokenWithSpace() { final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = \"first second\""); assertTrue(nodeOptional.isSuccess()); - assertEquals(nodeOptional.get().getTokenType().name(), NodeType.COMPARISON.name()); - verifyStringToken((ComparisonNode) nodeOptional.get(), "name", "first second"); + verifyComparisonToken(nodeOptional.get(), "name", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), "first second", DataType.STRING); } @Test public void testSingleIntToken() { final Try nodeOptional = boolExpressionBoolParser.parseExpression("age=44"); assertTrue(nodeOptional.isSuccess()); - assertEquals(nodeOptional.get().getTokenType().name(), NodeType.COMPARISON.name()); - verifyNumericToken((ComparisonNode) nodeOptional.get(), "age", 44, Operator.EQUALS); + verifyComparisonToken(nodeOptional.get(), "age", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), 44, DataType.INTEGER); } @Test public void testSingleLongToken() { final Try nodeOptional = boolExpressionBoolParser.parseExpression("age=1611473334114"); assertTrue(nodeOptional.isSuccess()); - assertEquals(nodeOptional.get().getTokenType().name(), NodeType.COMPARISON.name()); - verifyNumericToken((ComparisonNode) nodeOptional.get(), "age", 1611473334114L, Operator.EQUALS); + verifyComparisonToken(nodeOptional.get(), "age", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), 1611473334114L, DataType.LONG); } @Test public void testSingleDecimalToken() { final Try nodeOptional = boolExpressionBoolParser.parseExpression("age=44.34"); assertTrue(nodeOptional.isSuccess()); - assertEquals(nodeOptional.get().getTokenType().name(), NodeType.COMPARISON.name()); - verifyNumericToken((ComparisonNode) nodeOptional.get(), "age", 44.34, Operator.EQUALS); + verifyComparisonToken(nodeOptional.get(), "age", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), new BigDecimal("44.34"), DataType.DECIMAL); } @Test @@ -114,8 +119,16 @@ public void testSingleIntRangeToken() { public void testGreaterThan() { final Try nodeOptional = boolExpressionBoolParser.parseExpression("age > 18"); assertTrue(nodeOptional.isSuccess()); - assertEquals(nodeOptional.get().getTokenType().name(), NodeType.COMPARISON.name()); - verifyNumericToken((ComparisonNode) nodeOptional.get(), "age", 18, Operator.GREATER_THAN); + verifyComparisonToken(nodeOptional.get(), "age", Operator.GREATER_THAN); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), 18, DataType.INTEGER); + } + + @Test + public void testGreaterThanWithField() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("age > a"); + assertTrue(nodeOptional.isSuccess()); + verifyComparisonToken(nodeOptional.get(), "age", Operator.GREATER_THAN); + verifyFieldToken(((ComparisonNode) nodeOptional.get()).getRight(), "a"); } @Test @@ -123,12 +136,12 @@ public void testSingleDecimalRangeToken() { final Try nodeOptional = boolExpressionBoolParser.parseExpression("age 18.4 TO 44.2"); assertTrue(nodeOptional.isSuccess()); assertEquals(nodeOptional.get().getTokenType().name(), NodeType.NUMERIC_RANGE.name()); - verifyNumericRangeToken((NumericRangeNode) nodeOptional.get(), "age", 18.4, 44.2); + verifyNumericRangeToken((NumericRangeNode) nodeOptional.get(), "age", new BigDecimal("18.4"), new BigDecimal("44.2")); } @Test public void testSimpleOrCondition() { - final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = test OR age=33"); + final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = 'test' OR age=33"); assertTrue(nodeOptional.isSuccess()); assertEquals(nodeOptional.get().getTokenType().name(), NodeType.BOOLEAN.name()); final BooleanNode booleanToken = (BooleanNode) nodeOptional.get(); @@ -137,13 +150,15 @@ public void testSimpleOrCondition() { assertEquals(booleanToken.getOperator(), LogicalOperationType.OR); assertEquals(booleanToken.getLeft().getTokenType().name(), NodeType.COMPARISON.name()); assertEquals(booleanToken.getRight().getTokenType().name(), NodeType.COMPARISON.name()); - verifyStringToken((ComparisonNode) booleanToken.getLeft(), "name", "test"); - verifyNumericToken((ComparisonNode) booleanToken.getRight(), "age", 33, Operator.EQUALS); + verifyComparisonToken(((BooleanNode) nodeOptional.get()).getLeft(), "name", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)((BooleanNode) nodeOptional.get()).getLeft()).getRight(), "test", DataType.STRING); + verifyComparisonToken(((BooleanNode) nodeOptional.get()).getRight(), "age", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)((BooleanNode) nodeOptional.get()).getRight()).getRight(), 33, DataType.INTEGER); } @Test public void testSimpleAndCondition() { - final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = test AND age=33"); + final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = 'test' AND age=33"); assertTrue(nodeOptional.isSuccess()); assertEquals(nodeOptional.get().getTokenType().name(), NodeType.BOOLEAN.name()); final BooleanNode booleanToken = (BooleanNode) nodeOptional.get(); @@ -152,13 +167,15 @@ public void testSimpleAndCondition() { assertEquals(booleanToken.getOperator(), LogicalOperationType.AND); assertEquals(booleanToken.getLeft().getTokenType().name(), NodeType.COMPARISON.name()); assertEquals(booleanToken.getRight().getTokenType().name(), NodeType.COMPARISON.name()); - verifyStringToken((ComparisonNode) booleanToken.getLeft(), "name", "test"); - verifyNumericToken((ComparisonNode) booleanToken.getRight(), "age", 33, Operator.EQUALS); + verifyComparisonToken(((BooleanNode) nodeOptional.get()).getLeft(), "name", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)((BooleanNode) nodeOptional.get()).getLeft()).getRight(), "test", DataType.STRING); + verifyComparisonToken(((BooleanNode) nodeOptional.get()).getRight(), "age", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)((BooleanNode) nodeOptional.get()).getRight()).getRight(), 33, DataType.INTEGER); } @Test public void testSimpleNotCondition() { - final Try nodeOptional = boolExpressionBoolParser.parseExpression("NOT (name = test)"); + final Try nodeOptional = boolExpressionBoolParser.parseExpression("NOT (name = 'test')"); assertTrue(nodeOptional.isSuccess()); assertEquals(nodeOptional.get().getTokenType().name(), NodeType.BOOLEAN.name()); final BooleanNode booleanToken = (BooleanNode) nodeOptional.get(); @@ -166,12 +183,13 @@ public void testSimpleNotCondition() { assertNull(booleanToken.getRight()); assertEquals(booleanToken.getOperator(), LogicalOperationType.NOT); assertEquals(booleanToken.getLeft().getTokenType().name(), NodeType.COMPARISON.name()); - verifyStringToken((ComparisonNode) booleanToken.getLeft(), "name", "test"); + verifyComparisonToken(((BooleanNode) nodeOptional.get()).getLeft(), "name", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)((BooleanNode) nodeOptional.get()).getLeft()).getRight(), "test", DataType.STRING); } @Test public void testNestedAndCondition() { - final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = test OR (age=33 AND city = dummy)"); + final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = 'test' OR (age=33 AND city = 'dummy')"); assertTrue(nodeOptional.isSuccess()); assertEquals(nodeOptional.get().getTokenType().name(), NodeType.BOOLEAN.name()); final BooleanNode booleanToken = (BooleanNode) nodeOptional.get(); @@ -180,20 +198,23 @@ public void testNestedAndCondition() { assertEquals(booleanToken.getOperator(), LogicalOperationType.OR); assertEquals(booleanToken.getLeft().getTokenType().name(), NodeType.COMPARISON.name()); assertEquals(booleanToken.getRight().getTokenType().name(), NodeType.BOOLEAN.name()); - verifyStringToken((ComparisonNode) booleanToken.getLeft(), "name", "test"); + verifyComparisonToken(booleanToken.getLeft(), "name", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)((BooleanNode) nodeOptional.get()).getLeft()).getRight(), "test", DataType.STRING); final BooleanNode nestedBooleanExpression = (BooleanNode) booleanToken.getRight(); assertNotNull(nestedBooleanExpression.getLeft()); assertNotNull(nestedBooleanExpression.getRight()); assertEquals(nestedBooleanExpression.getOperator(), LogicalOperationType.AND); assertEquals(nestedBooleanExpression.getLeft().getTokenType().name(), NodeType.COMPARISON.name()); assertEquals(nestedBooleanExpression.getRight().getTokenType().name(), NodeType.COMPARISON.name()); - verifyNumericToken((ComparisonNode) nestedBooleanExpression.getLeft(), "age", 33, Operator.EQUALS); - verifyStringToken((ComparisonNode) nestedBooleanExpression.getRight(), "city", "dummy"); + verifyComparisonToken(nestedBooleanExpression.getLeft(), "age", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode) nestedBooleanExpression.getLeft()).getRight(), 33, DataType.INTEGER); + verifyComparisonToken(nestedBooleanExpression.getRight(), "city", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode) nestedBooleanExpression.getRight()).getRight(), "dummy", DataType.STRING); } @Test public void testNestedAndCondition1() { - final Try nodeOptional = boolExpressionBoolParser.parseExpression("(agel=44 AND cityl = abc) OR (ager=33 AND cityr = dummy)"); + final Try nodeOptional = boolExpressionBoolParser.parseExpression("(agel=44 AND cityl = 'abc') OR (ager=33 AND cityr = 'dummy')"); assertTrue(nodeOptional.isSuccess()); assertEquals(nodeOptional.get().getTokenType().name(), NodeType.BOOLEAN.name()); final BooleanNode booleanToken = (BooleanNode) nodeOptional.get(); @@ -208,21 +229,25 @@ public void testNestedAndCondition1() { assertEquals(nestedLeftBooleanExpression.getOperator(), LogicalOperationType.AND); assertEquals(nestedLeftBooleanExpression.getLeft().getTokenType().name(), NodeType.COMPARISON.name()); assertEquals(nestedLeftBooleanExpression.getRight().getTokenType().name(), NodeType.COMPARISON.name()); - verifyNumericToken((ComparisonNode) nestedLeftBooleanExpression.getLeft(), "agel", 44, Operator.EQUALS); - verifyStringToken((ComparisonNode) nestedLeftBooleanExpression.getRight(), "cityl", "abc"); + verifyComparisonToken(nestedLeftBooleanExpression.getLeft(), "agel", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)nestedLeftBooleanExpression.getLeft()).getRight(), 44, DataType.INTEGER); + verifyComparisonToken(nestedLeftBooleanExpression.getRight(), "cityl", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)nestedLeftBooleanExpression.getRight()).getRight(), "abc", DataType.STRING); final BooleanNode nestedRightBooleanExpression = (BooleanNode) booleanToken.getRight(); assertNotNull(nestedRightBooleanExpression.getLeft()); assertNotNull(nestedRightBooleanExpression.getRight()); assertEquals(nestedRightBooleanExpression.getOperator(), LogicalOperationType.AND); assertEquals(nestedRightBooleanExpression.getLeft().getTokenType().name(), NodeType.COMPARISON.name()); assertEquals(nestedRightBooleanExpression.getRight().getTokenType().name(), NodeType.COMPARISON.name()); - verifyNumericToken((ComparisonNode) nestedRightBooleanExpression.getLeft(), "ager", 33, Operator.EQUALS); - verifyStringToken((ComparisonNode) nestedRightBooleanExpression.getRight(), "cityr", "dummy"); + verifyComparisonToken(nestedRightBooleanExpression.getLeft(), "ager", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)nestedRightBooleanExpression.getLeft()).getRight(), 33, DataType.INTEGER); + verifyComparisonToken(nestedRightBooleanExpression.getRight(), "cityr", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)nestedRightBooleanExpression.getRight()).getRight(), "dummy", DataType.STRING); } @Test public void testNestedOrCondition() { - final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = test AND (age=33 OR city = dummy)"); + final Try nodeOptional = boolExpressionBoolParser.parseExpression("name = 'test' AND (age=33 OR city = 'dummy')"); assertTrue(nodeOptional.isSuccess()); assertEquals(nodeOptional.get().getTokenType().name(), NodeType.BOOLEAN.name()); final BooleanNode booleanToken = (BooleanNode) nodeOptional.get(); @@ -231,15 +256,18 @@ public void testNestedOrCondition() { assertEquals(booleanToken.getOperator(), LogicalOperationType.AND); assertEquals(booleanToken.getLeft().getTokenType().name(), NodeType.COMPARISON.name()); assertEquals(booleanToken.getRight().getTokenType().name(), NodeType.BOOLEAN.name()); - verifyStringToken((ComparisonNode) booleanToken.getLeft(), "name", "test"); + verifyComparisonToken(booleanToken.getLeft(), "name", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)booleanToken.getLeft()).getRight(), "test", DataType.STRING); final BooleanNode nestedBooleanExpression = (BooleanNode) booleanToken.getRight(); assertNotNull(nestedBooleanExpression.getLeft()); assertNotNull(nestedBooleanExpression.getRight()); assertEquals(nestedBooleanExpression.getOperator(), LogicalOperationType.OR); assertEquals(nestedBooleanExpression.getLeft().getTokenType().name(), NodeType.COMPARISON.name()); assertEquals(nestedBooleanExpression.getRight().getTokenType().name(), NodeType.COMPARISON.name()); - verifyNumericToken((ComparisonNode) nestedBooleanExpression.getLeft(), "age", 33, Operator.EQUALS); - verifyStringToken((ComparisonNode) nestedBooleanExpression.getRight(), "city", "dummy"); + verifyComparisonToken(nestedBooleanExpression.getLeft(), "age", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)nestedBooleanExpression.getLeft()).getRight(), 33, DataType.INTEGER); + verifyComparisonToken(nestedBooleanExpression.getRight(), "city", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode)nestedBooleanExpression.getRight()).getRight(), "dummy", DataType.STRING); } @Test @@ -250,10 +278,10 @@ public void testIntegerList() { final InNode inToken = (InNode) nodeOptional.get(); assertEquals(inToken.getItems().size(), 2); assertEquals(inToken.getField(), "age"); - assertEquals(inToken.getItems().get(0).getKey(), DataType.INTEGER); - assertEquals(inToken.getItems().get(1).getKey(), DataType.INTEGER); - assertEquals(inToken.getItems().get(0).getValue(), 12); - assertEquals(inToken.getItems().get(1).getValue(), 45); + assertEquals(((UnaryNode)inToken.getItems().get(0)).getDataType(), DataType.INTEGER); + assertEquals(((UnaryNode)inToken.getItems().get(1)).getDataType(), DataType.INTEGER); + assertEquals(((UnaryNode)inToken.getItems().get(0)).getValue(), 12); + assertEquals(((UnaryNode)inToken.getItems().get(1)).getValue(), 45); } @Test @@ -261,78 +289,72 @@ public void testNotIntegerList() { final Try nodeOptional = boolExpressionBoolParser.parseExpression("age not IN (12,45)"); assertTrue(nodeOptional.isSuccess()); assertEquals(nodeOptional.get().getTokenType().name(), NodeType.BOOLEAN.name()); - assertNotNull(((BooleanNode)nodeOptional.get()).getLeft()); - assertNull(((BooleanNode)nodeOptional.get()).getRight()); - assertEquals(((BooleanNode)nodeOptional.get()).getOperator(), LogicalOperationType.NOT); - final InNode inToken = (InNode) ((BooleanNode)nodeOptional.get()).getLeft(); + assertNotNull(((BooleanNode) nodeOptional.get()).getLeft()); + assertNull(((BooleanNode) nodeOptional.get()).getRight()); + assertEquals(((BooleanNode) nodeOptional.get()).getOperator(), LogicalOperationType.NOT); + final InNode inToken = (InNode) ((BooleanNode) nodeOptional.get()).getLeft(); assertEquals(inToken.getItems().size(), 2); assertEquals(inToken.getField(), "age"); - assertEquals(inToken.getItems().get(0).getKey(), DataType.INTEGER); - assertEquals(inToken.getItems().get(1).getKey(), DataType.INTEGER); - assertEquals(inToken.getItems().get(0).getValue(), 12); - assertEquals(inToken.getItems().get(1).getValue(), 45); + assertEquals(((UnaryNode)inToken.getItems().get(0)).getDataType(), DataType.INTEGER); + assertEquals(((UnaryNode)inToken.getItems().get(1)).getDataType(), DataType.INTEGER); + assertEquals(((UnaryNode)inToken.getItems().get(0)).getValue(), 12); + assertEquals(((UnaryNode)inToken.getItems().get(1)).getValue(), 45); } @Test public void testStringList() { - final Try nodeOptional = boolExpressionBoolParser.parseExpression("name IN (abc, def, 'abc def')"); + final Try nodeOptional = boolExpressionBoolParser.parseExpression("name IN ('abc', 'def', 'abc def')"); assertTrue(nodeOptional.isSuccess()); assertEquals(nodeOptional.get().getTokenType().name(), NodeType.IN.name()); final InNode inToken = (InNode) nodeOptional.get(); assertEquals(inToken.getItems().size(), 3); assertEquals(inToken.getField(), "name"); - assertEquals(inToken.getItems().get(0).getKey(), DataType.STRING); - assertEquals(inToken.getItems().get(1).getKey(), DataType.STRING); - assertEquals(inToken.getItems().get(2).getKey(), DataType.STRING); - assertEquals(inToken.getItems().get(0).getValue(), "abc"); - assertEquals(inToken.getItems().get(1).getValue(), "def"); - assertEquals(inToken.getItems().get(2).getValue(), "abc def"); + assertEquals(((UnaryNode)inToken.getItems().get(0)).getDataType(), DataType.STRING); + assertEquals(((UnaryNode)inToken.getItems().get(1)).getDataType(), DataType.STRING); + assertEquals(((UnaryNode)inToken.getItems().get(2)).getDataType(), DataType.STRING); + assertEquals(((UnaryNode)inToken.getItems().get(0)).getValue(), "abc"); + assertEquals(((UnaryNode)inToken.getItems().get(1)).getValue(), "def"); + assertEquals(((UnaryNode)inToken.getItems().get(2)).getValue(), "abc def"); } @Test public void testStringList1() { - final Try nodeOptional = boolExpressionBoolParser.parseExpression("name IN (abc, def, 'abc, def')"); + final Try nodeOptional = boolExpressionBoolParser.parseExpression("name IN ('abc', 'def', 'abc, def')"); assertTrue(nodeOptional.isSuccess()); assertEquals(nodeOptional.get().getTokenType().name(), NodeType.IN.name()); final InNode inToken = (InNode) nodeOptional.get(); assertEquals(inToken.getItems().size(), 3); assertEquals(inToken.getField(), "name"); - assertEquals(inToken.getItems().get(0).getKey(), DataType.STRING); - assertEquals(inToken.getItems().get(1).getKey(), DataType.STRING); - assertEquals(inToken.getItems().get(2).getKey(), DataType.STRING); - assertEquals(inToken.getItems().get(0).getValue(), "abc"); - assertEquals(inToken.getItems().get(1).getValue(), "def"); - assertEquals(inToken.getItems().get(2).getValue(), "abc, def"); + assertEquals(((UnaryNode)inToken.getItems().get(0)).getDataType(), DataType.STRING); + assertEquals(((UnaryNode)inToken.getItems().get(1)).getDataType(), DataType.STRING); + assertEquals(((UnaryNode)inToken.getItems().get(2)).getDataType(), DataType.STRING); + assertEquals(((UnaryNode)inToken.getItems().get(0)).getValue(), "abc"); + assertEquals(((UnaryNode)inToken.getItems().get(1)).getValue(), "def"); + assertEquals(((UnaryNode)inToken.getItems().get(2)).getValue(), "abc, def"); } @Test public void testStringList2() { - final Try nodeOptional = boolExpressionBoolParser.parseExpression("name IN (abc, def, 'ab\"c')"); + final Try nodeOptional = boolExpressionBoolParser.parseExpression("name IN ('abc', 'def', 'ab\"c')"); assertTrue(nodeOptional.isSuccess()); assertEquals(nodeOptional.get().getTokenType().name(), NodeType.IN.name()); final InNode inToken = (InNode) nodeOptional.get(); assertEquals(inToken.getItems().size(), 3); assertEquals(inToken.getField(), "name"); - assertEquals(inToken.getItems().get(0).getKey(), DataType.STRING); - assertEquals(inToken.getItems().get(1).getKey(), DataType.STRING); - assertEquals(inToken.getItems().get(2).getKey(), DataType.STRING); - assertEquals(inToken.getItems().get(0).getValue(), "abc"); - assertEquals(inToken.getItems().get(1).getValue(), "def"); - assertEquals(inToken.getItems().get(2).getValue(), "ab\"c"); + assertEquals(((UnaryNode)inToken.getItems().get(0)).getDataType(), DataType.STRING); + assertEquals(((UnaryNode)inToken.getItems().get(1)).getDataType(), DataType.STRING); + assertEquals(((UnaryNode)inToken.getItems().get(2)).getDataType(), DataType.STRING); + assertEquals(((UnaryNode)inToken.getItems().get(0)).getValue(), "abc"); + assertEquals(((UnaryNode)inToken.getItems().get(1)).getValue(), "def"); + assertEquals(((UnaryNode)inToken.getItems().get(2)).getValue(), "ab\"c"); } @Test - public void testInvalidExpression() { + public void testSingleToken() { final Try nodeOptional = boolExpressionBoolParser.parseExpression("a"); - assertTrue(nodeOptional.isFailure()); - assertTrue(nodeOptional.getCause() instanceof InvalidExpressionException); - } - - @Test - public void testInvalidNotExpression() { - final Try nodeOptional = boolExpressionBoolParser.parseExpression("not a > 5"); - assertTrue(nodeOptional.isFailure()); - assertTrue(nodeOptional.getCause() instanceof InvalidExpressionException); + assertTrue(nodeOptional.isSuccess()); + assertTrue(nodeOptional.get() instanceof FieldNode); + assertEquals(((FieldNode) nodeOptional.get()).getField(), "a"); } @Test @@ -355,17 +377,144 @@ public void testContainsAll() { assertEquals(((ArrayNode) nodeOptional.get()).getItems().size(), 2); } - private void verifyStringToken(final ComparisonNode stringToken, final String field, final String value) { - assertEquals(stringToken.getTokenType().name(), NodeType.COMPARISON.name()); - assertEquals(stringToken.getField(), field); - assertEquals(stringToken.getValue(), value); + @Test + public void testAddOperatorString() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("a + b"); + assertTrue(nodeOptional.isSuccess()); + assertEquals(nodeOptional.get().getTokenType(), NodeType.ARITHMETIC); + assertEquals(((FieldNode) ((ArithmeticNode) nodeOptional.get()).getLeft()).getField(), "a"); + assertEquals(((FieldNode) ((ArithmeticNode) nodeOptional.get()).getRight()).getField(), "b"); + assertEquals(((ArithmeticNode) nodeOptional.get()).getOperator(), Operator.ADD); + } + + @Test + public void testAddOperatorInt() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("20 + 5"); + assertTrue(nodeOptional.isSuccess()); + assertEquals(nodeOptional.get().getTokenType(), NodeType.ARITHMETIC); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getLeft()).getValue(), 20); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getLeft()).getDataType(), DataType.INTEGER); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getRight()).getValue(), 5); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getRight()).getDataType(), DataType.INTEGER); + assertEquals(((ArithmeticNode) nodeOptional.get()).getOperator(), Operator.ADD); + } + + @Test + public void testAddOperatorDecimal() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("20.5 + 5"); + assertTrue(nodeOptional.isSuccess()); + assertEquals(nodeOptional.get().getTokenType(), NodeType.ARITHMETIC); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getLeft()).getValue(), new BigDecimal("20.5")); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getLeft()).getDataType(), DataType.DECIMAL); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getRight()).getValue(), 5); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getRight()).getDataType(), DataType.INTEGER); + assertEquals(((ArithmeticNode) nodeOptional.get()).getOperator(), Operator.ADD); + } + + @Test + public void testArithmeticArrayFunction() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("min (1,2,3)"); + assertTrue(nodeOptional.isSuccess()); + assertEquals(nodeOptional.get().getTokenType(), NodeType.ARITHMETIC_FUNCTION); + assertEquals(((ArithmeticFunctionNode) nodeOptional.get()).getFunctionType().name(), "MIN"); + assertEquals(((ArithmeticFunctionNode) nodeOptional.get()).getItems().size(), 3); + assertEquals(((UnaryNode) ((ArithmeticFunctionNode) nodeOptional.get()).getItems().get(0)).getDataType(), DataType.INTEGER); + assertEquals(((UnaryNode) ((ArithmeticFunctionNode) nodeOptional.get()).getItems().get(0)).getValue(), 1); + assertEquals(((UnaryNode) ((ArithmeticFunctionNode) nodeOptional.get()).getItems().get(1)).getDataType(), DataType.INTEGER); + assertEquals(((UnaryNode) ((ArithmeticFunctionNode) nodeOptional.get()).getItems().get(1)).getValue(), 2); + assertEquals(((UnaryNode) ((ArithmeticFunctionNode) nodeOptional.get()).getItems().get(2)).getDataType(), DataType.INTEGER); + assertEquals(((UnaryNode) ((ArithmeticFunctionNode) nodeOptional.get()).getItems().get(2)).getValue(), 3); + } + + @Test + public void testArithmeticArrayFunctionWithSubstitution() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("min(abc)"); + assertTrue(nodeOptional.isSuccess()); + assertEquals(nodeOptional.get().getTokenType(), NodeType.ARITHMETIC_FUNCTION); + assertEquals(((ArithmeticFunctionNode) nodeOptional.get()).getFunctionType().name(), "MIN"); + assertEquals(((ArithmeticFunctionNode) nodeOptional.get()).getItems().size(), 1); + assertEquals(((FieldNode) ((ArithmeticFunctionNode) nodeOptional.get()).getItems().get(0)).getField(), "abc"); + } + + @Test + public void testArithmeticArrayFunctionWithError() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("min abc"); + assertTrue(nodeOptional.isFailure()); + } + + @Test + public void testAddOperatorBool() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("false + 5"); + assertTrue(nodeOptional.isSuccess()); + assertEquals(nodeOptional.get().getTokenType(), NodeType.ARITHMETIC); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getLeft()).getValue(), false); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getLeft()).getDataType(), DataType.BOOLEAN); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getRight()).getValue(), 5); + assertEquals(((UnaryNode) ((ArithmeticNode) nodeOptional.get()).getRight()).getDataType(), DataType.INTEGER); + assertEquals(((ArithmeticNode) nodeOptional.get()).getOperator(), Operator.ADD); + } + + @Test + public void testComparisonWithArithmetic() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("a > (10 + 20)"); + assertTrue(nodeOptional.isSuccess()); + assertEquals(nodeOptional.get().getTokenType(), NodeType.COMPARISON); + assertEquals(((FieldNode)(((ComparisonNode) nodeOptional.get()).getLeft())).getField(), "a"); + final ArithmeticNode arithmeticNode = (ArithmeticNode) ((ComparisonNode) nodeOptional.get()).getRight(); + assertEquals(((UnaryNode) (arithmeticNode.getLeft())).getValue(), 10); + assertEquals(((UnaryNode) (arithmeticNode.getLeft())).getDataType(), DataType.INTEGER); + assertEquals(((UnaryNode) (arithmeticNode.getRight())).getValue(), 20); + assertEquals(((UnaryNode) (arithmeticNode.getRight())).getDataType(), DataType.INTEGER); + assertEquals(arithmeticNode.getOperator(), Operator.ADD); + } + + @Test + public void testSingleDateToken() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("created_date = 2023-03-05"); + assertTrue(nodeOptional.isSuccess()); + verifyComparisonToken(nodeOptional.get(), "created_date", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), LocalDate.of(2023, 3, 5), DataType.DATE); + } + + @Test + public void testSingleDateTimeToken() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("timestamp = 2023-03-05 14:30:00"); + assertTrue(nodeOptional.isSuccess()); + verifyComparisonToken(nodeOptional.get(), "timestamp", Operator.EQUALS); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), LocalDateTime.of(2023, 3, 5, 14, 30, 0), DataType.DATETIME); + } + + @Test + public void testDateComparison() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("start_date > 2023-01-01"); + assertTrue(nodeOptional.isSuccess()); + verifyComparisonToken(nodeOptional.get(), "start_date", Operator.GREATER_THAN); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), LocalDate.of(2023, 1, 1), DataType.DATE); + } + + @Test + public void testDateTimeComparison() { + final Try nodeOptional = boolExpressionBoolParser.parseExpression("last_login < 2023-12-31 23:59:59"); + assertTrue(nodeOptional.isSuccess()); + verifyComparisonToken(nodeOptional.get(), "last_login", Operator.LESS_THAN); + verifyUnaryToken(((ComparisonNode) nodeOptional.get()).getRight(), LocalDateTime.of(2023, 12, 31, 23, 59, 59), DataType.DATETIME); + } + + private void verifyUnaryToken(final Node node, final Object value, final DataType dataType) { + assertEquals(node.getTokenType().name(), NodeType.UNARY.name()); + assertEquals(((UnaryNode)node).getValue(), value); + assertEquals(((UnaryNode)node).getDataType(), dataType); + } + + private void verifyFieldToken(final Node node, final Object value) { + assertEquals(node.getTokenType().name(), NodeType.FIELD.name()); + assertEquals(((FieldNode)node).getField(), value); } - private void verifyNumericToken(final ComparisonNode comparisonToken, final String field, final Object value, final Operator operator) { - assertEquals(comparisonToken.getTokenType().name(), NodeType.COMPARISON.name()); - assertEquals(comparisonToken.getField(), field); - assertEquals(comparisonToken.getValue(), value); - assertEquals(comparisonToken.getOperator().name(), operator.name()); + private void verifyComparisonToken(final Node node, final String field, final Operator operator) { + assertEquals(node.getTokenType().name(), NodeType.COMPARISON.name()); + assertEquals(((FieldNode)((ComparisonNode)node).getLeft()).getField(), field); + assertEquals(((ComparisonNode)node).getOperator(), operator); } private void verifyNumericRangeToken(final NumericRangeNode numericRangeToken, final String field, final Object fromValue, final Object toValue) {