Assign

Represents assignment. An alternative to calling setValue() for an expression is to use an assign.

Example: 'someNumberProperty=42'

AstUtils

Utilities methods for use in the Ast classes.

BeanReference

Represents a bean reference to a type, for example @foo or @'foo.bar'. For a FactoryBean the syntax &foo can be used to access the factory itself.

BooleanLiteral

Represents the literal values TRUE and FALSE.

CompoundExpression

Represents a DOT separated expression sequence, such as 'property1.property2.methodOne()'

ConstructorReference

Represents the invocation of a constructor. Either a constructor on a regular type or construction of an array. When an array is constructed, an initializer can be specified.

Examples: new String('hello world') new int[]{1,2,3,4} new int[3] new int[3]{1,2,3}

Elvis

Represents the elvis operator ?:. For an expression "a?:b" if a is not null, the value of the expression is "a", if a is null then the value of the expression is "b".

FloatLiteral

Expression language AST node that represents a float literal.

FormatHelper

Utility methods (formatters, etc) used during parsing and evaluation.

FunctionReference

A function reference is of the form "#someFunction(a,b,c)". Functions may be defined in the context prior to the expression being evaluated or within the expression itself using a lambda function definition. For example: Lambda function definition in an expression: "(#max = {|x,y|$x>$y?$x:$y};max(2,3))" Calling context defined function: "#isEven(37)". Functions may also be static java methods, registered in the context prior to invocation of the expression.

Functions are very simplistic, the arguments are not part of the definition (right now), so the names must be unique.

Identifier

Indexer

An Indexer can index into some proceeding structure to access a particular piece of it. Supported structures are: strings / collections (lists/sets) / arrays.

InlineList

Represent a list in an expression, e.g. '{1,2,3}'

InlineMap

Represent a map in an expression, e.g. '{name:'foo',age:12}'

IntLiteral

Expression language AST node that represents an integer literal.

Literal

Common superclass for nodes representing literals (boolean, string, number, etc).

LongLiteral

Expression language AST node that represents a long integer literal.

MethodReference

Expression language AST node that represents a method reference.

NullLiteral

Expression language AST node that represents null.

OpAnd

Represents the boolean AND operation.

OpDec

Decrement operator. Can be used in a prefix or postfix form. This will throw appropriate exceptions if the operand in question does not support decrement.

OpDivide

Implements division operator.

OpEQ

Implements the equality operator.

OpGE

Implements greater-than-or-equal operator.

OpGT

Implements the greater-than operator.

OpInc

Increment operator. Can be used in a prefix or postfix form. This will throw appropriate exceptions if the operand in question does not support increment.

OpLE

Implements the less-than-or-equal operator.

OpLT

Implements the less-than operator.

OpMinus

The minus operator supports:

• subtraction of numbers
• subtraction of an int from a string of one character (effectively decreasing that character), so 'd'-3='a'

It can be used as a unary operator for numbers. The standard promotions are performed when the operand types vary (double-int=double). For other options it defers to the registered overloader.

OpModulus

Implements the modulus operator.

OpMultiply

Implements the multiply operator.

Conversions and promotions are handled as defined in Section 5.6.2 of the Java Language Specification, with the addiction of BigDecimal/BigInteger management:

If any of the operands is of a reference type, unboxing conversion (Section 5.1.8) is performed. Then: If either operand is of type BigDecimal, the other is converted to BigDecimal. If either operand is of type double, the other is converted to double. Otherwise, if either operand is of type float, the other is converted to float. If either operand is of type BigInteger, the other is converted to BigInteger. Otherwise, if either operand is of type long, the other is converted to long. Otherwise, both operands are converted to type int.

OpNE

Implements the not-equal operator.

OpOr

Represents the boolean OR operation.

OpPlus

The plus operator will:

• add numbers
• concatenate strings

It can be used as a unary operator for numbers. The standard promotions are performed when the operand types vary (double+int=double). For other options it defers to the registered overloader.

OperatorBetween

Represents the between operator. The left operand to between must be a single value and the right operand must be a list - this operator returns true if the left operand is between (using the registered comparator) the two elements in the list. The definition of between being inclusive follows the SQL BETWEEN definition.

OperatorInstanceof

The operator 'instanceof' checks if an object is of the class specified in the right hand operand, in the same way that instanceof does in Java.

OperatorMatches

Implements the matches operator. Matches takes two operands: The first is a String and the second is a Java regex. It will return true when #getValue is called if the first operand matches the regex.

OperatorNot

Represents a NOT operation.

OperatorPower

The power operator.

Projection

Represents projection, where a given operation is performed on all elements in some input sequence, returning a new sequence of the same size. For example: "{1,2,3,4,5,6,7,8,9,10}.!{#isEven(#this)}" returns "[n, y, n, y, n, y, n, y, n, y]"

PropertyOrFieldReference

Represents a simple property or field reference.

QualifiedIdentifier

Represents a dot separated sequence of strings that indicate a package qualified type reference.

Example: "java.lang.String" as in the expression "new java.lang.String('hello')"

RealLiteral

Expression language AST node that represents a real literal.

Selection

Represents selection over a map or collection. For example: {1,2,3,4,5,6,7,8,9,10}.?{#isEven(#this) == 'y'} returns [2, 4, 6, 8, 10]

Basically a subset of the input data is returned based on the evaluation of the expression supplied as selection criteria.

StringLiteral

Expression language AST node that represents a string literal.

Ternary

Represents a ternary expression, for example: "someCheck()?true:false".

TypeCode

Captures primitive types and their corresponding class objects, plus one special entry that represents all reference (non-primitive) types.

TypeReference

Represents a reference to a type, for example "T(String)" or "T(com.somewhere.Foo)"

VariableReference

Represents a variable reference, eg. #someVar. Note this is different to a *local* variable like $someVar