de.unkrig.commons.text.expression

Class Parser<T,EX extends Throwable>

java.lang.Object

de.unkrig.commons.text.parser.AbstractParser<Scanner.TokenType>

de.unkrig.commons.text.expression.Parser<T,EX>

Type Parameters:

T - The type returned by parse()

EX - The exception thrown by the abstract handlers (e.g. conditional(Object, Object, Object))

public abstract class Parser<T,EX extends Throwable>
extends AbstractParser<Scanner.TokenType>

Parses an expression like

 s == "abc" && (c == 'b' || !b == true)
 

Supported operators (in ascending priority) are:

a ? b : c

b if a, converted to boolean, is true, otherwise c.

a || b

a if a, converted to boolean, is true, otherwise b. (Equivalent to "a ? a : b", except that a is evaluated only once.)

a && b

b if a, converted to boolean, is true, otherwise false. (Equivalent to "a ? b : false".)

== != < <= > >=

Arithmetic comparison (if both operands are numeric) or lexicographic comparison (otherwise).

a =* "*.c"

a =* "(*).c=$1.h"

Wildcard matching/replacing (see Glob). The left-hand-side operand is the subject, the right-hand-side operand is the glob. Iff the right-hand-side operand contains an equal sign ("="), as in the second example, then it specifies a glob and the replacement.
Evaluates

• to null iff the subject does not match the glob, otherwise,
• to the replacement, iff one is specified, otherwise,
• the subject

The "=*" operator is only available if the Parser.Extension.OPERATOR_GLOB parsing extension is enabled (which is the default).

a =~ "A.*"

a =~ "(.*)abc(.*)=$1$2"

Regex matching/replacing (see Pattern). The left-hand-side operand is the subject, the right-hand-side operand is the pattern. Iff the right-hand-side operand contains an equal sign ("="), as in the second example, then it specifies a pattern and the replacement.
Evaluates

• to null iff the subject does not match the pattern, otherwise,
• to the replacement, iff one is specified, otherwise,
• the subject

The "=~" operator is only available if the Parser.Extension.OPERATOR_REGEX parsing extension is enabled (which is the default).

+ -

Addition (if both operands are numeric) or string concatenation; subtraction.

* / %

Multiplication; division; remainder (modulo).

a instanceof reference-type

Whether a is non-null and a subtype of reference-type

(...) ! -

Grouping; logical negation; arithmetic negation.

Primaries are:

"abc"

String literal

123

Integer literal

123L 123l

Long literal

1F 1.2E+3f

Float literal

1D 1d 1. 1.1 1e-3

Double literal

true false null

Special constant values

abc

Variable reference, see Expression.evaluate(de.unkrig.commons.lang.protocol.Mapping)

new pkg.Clazz(arg1, arg2)

new RootPackageClazz(arg1, arg2)

new ImportedClazz(arg1, arg2)

Class instance creation

new pkg.Clazz (Only with Parser.Extension.NEW_CLASS_WITHOUT_PARENTHESES)

pkg.Clazz() (Only with Parser.Extension.NEW_CLASS_WITHOUT_KEYWORD)

pkg.Clazz (Only with Parser.Extension.NEW_CLASS_WITHOUT_KEYWORD and Parser.Extension.NEW_CLASS_WITHOUT_PARENTHESES)

Abbreviated forms of "new pkg.Clazz()"

new pkg.Clazz[x]

new pkg.Clazz[x][y][][]

new int[x]

new int[x][y][][]

Array creation (notice that there is no abbreviated notation, without the new keyword, as for class instance creation)

pkg.Clazz[x]

pkg.Clazz[x][y][][]

int[x]

int[x][y][][]

Abbreviated array creation

x[y]

Array element access

x.name

Attribute reference; gets the value of the field "x.name", or invokes "x.name()" or "x.getName()" (it is not possible to set an attribute this way)

x.meth(a, b, c)

Method invocation

Null operands are handled leniently, e.g. "7 == null" is false, "null == null" is true.

To implement your parser, derive from this class and implement the abstract methods.

See Also:

enableExtension(Extension), disableExtension(Extension)

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Parser.BinaryOperator Representation of all binary operators.
static class	Parser.Extension Various extensions to the Java expression syntax.
static class	Parser.UnaryOperator Representation of all unary operators.

Field Summary

Fields inherited from class de.unkrig.commons.text.parser.AbstractParser

scanner

Constructor Summary

Constructors

Constructor and Description
Parser(ProducerWhichThrows<? extends AbstractScanner.Token<Scanner.TokenType>,? extends ScanException> tokenProducer)
Parser(Reader in)
Parser(String expression)

Method Summary

Modifier and Type	Method and Description
protected abstract T	arrayAccess(T lhs, T rhs)
protected abstract T	binaryOperation(T lhs, Parser.BinaryOperator operator, T rhs)
protected abstract T	cast(Class<?> targetType, T operand)
protected abstract T	conditional(T lhs, T mhs, T rhs)
void	disableExtension(Parser.Extension extension) Disables the given parsing extension.
void	enableExtension(Parser.Extension extension) Enables the given parsing extension.
protected abstract T	fieldReference(T target, String fieldName)
ClassLoader	getClassLoader()
String[]	getImports()
protected abstract T	instanceoF(T lhs, Class<?> rhs)
protected abstract T	literal(Object value)
protected abstract T	methodInvocation(T target, String methodName, List<T> arguments)
protected abstract T	newArray(Class<?> clasS, List<T> dimensions)
protected abstract T	newClass(Class<?> clasS, List<T> arguments)
protected abstract T	parenthesized(T value)
T	parse()
T	parsePart()
Parser<T,EX>	setClassLoader(ClassLoader classLoader)
void	setExtensions(Collection<Parser.Extension> extensions) Sets the given parsing extensions.
void	setExtensions(EnumSet<Parser.Extension> extensions) Sets the given parsing extensions.
Parser<T,EX>	setImports(String[] imports) By default, there is only one import: "java.lang".
protected abstract T	staticFieldReference(Class<?> type, String fieldName)
protected abstract T	staticMethodInvocation(Class<?> target, String methodName, List<T> arguments)
protected abstract T	unaryOperation(Parser.UnaryOperator operator, T operand)
protected abstract T	variableReference(String variableName)

Methods inherited from class de.unkrig.commons.text.parser.AbstractParser

eoi, peek, peek, peek, peek, peekRead, peekRead, peekRead, peekRead, peekReadEnum, read, read, read, read, unread

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Parser

public Parser(ProducerWhichThrows<? extends AbstractScanner.Token<Scanner.TokenType>,? extends ScanException> tokenProducer)

Parser

public Parser(Reader in)

Parser

public Parser(String expression)

Method Detail

getImports

public String[] getImports()

Returns:

The currently configured imports

setImports

public Parser<T,EX> setImports(String[] imports)

By default, there is only one import: "java.lang".

getClassLoader

public ClassLoader getClassLoader()

Returns:

The currently configured ClassLoader

setClassLoader

public Parser<T,EX> setClassLoader(ClassLoader classLoader)

Parameters:

classLoader - Used to load classes named in the expression; by default the class loader which loaded the Parser class.

setExtensions

public void setExtensions(Collection<Parser.Extension> extensions)

Sets the given parsing extensions. By default, all extensions are enabled.

See Also:

Parser.Extension

setExtensions

public void setExtensions(EnumSet<Parser.Extension> extensions)

Sets the given parsing extensions. By default, all extensions are enabled.

See Also:

Parser.Extension

enableExtension

public void enableExtension(Parser.Extension extension)

Enables the given parsing extension. By default, all extensions are enabled.

See Also:

Parser.Extension

disableExtension

public void disableExtension(Parser.Extension extension)

Disables the given parsing extension. By default, all extensions are enabled.

See Also:

Parser.Extension

parse

public T parse()
        throws ParseException,
               EX extends Throwable

Returns:

The parsed expression

Throws:

ParseException

EX extends Throwable

parsePart

public T parsePart()
            throws ParseException,
                   EX extends Throwable

Returns:

The parsed expression

Throws:

ParseException

EX extends Throwable

conditional

protected abstract T conditional(T lhs,
                                 T mhs,
                                 T rhs)
                          throws EX extends Throwable

Throws:

EX extends Throwable

unaryOperation

protected abstract T unaryOperation(Parser.UnaryOperator operator,
                                    T operand)
                             throws EX extends Throwable

Throws:

EX extends Throwable

binaryOperation

protected abstract T binaryOperation(T lhs,
                                     Parser.BinaryOperator operator,
                                     T rhs)
                              throws EX extends Throwable

Throws:

EX extends Throwable

fieldReference

protected abstract T fieldReference(T target,
                                    String fieldName)
                             throws EX extends Throwable

Throws:

EX extends Throwable

staticFieldReference

protected abstract T staticFieldReference(Class<?> type,
                                          String fieldName)
                                   throws EX extends Throwable

Throws:

EX extends Throwable

methodInvocation

protected abstract T methodInvocation(T target,
                                      String methodName,
                                      List<T> arguments)
                               throws EX extends Throwable

Throws:

EX extends Throwable

staticMethodInvocation

protected abstract T staticMethodInvocation(Class<?> target,
                                            String methodName,
                                            List<T> arguments)
                                     throws EX extends Throwable

Throws:

EX extends Throwable

variableReference

protected abstract T variableReference(String variableName)
                                throws EX extends Throwable,
                                       ParseException

Throws:

EX extends Throwable

ParseException

literal

protected abstract T literal(@Nullable
                             Object value)
                      throws EX extends Throwable

Throws:

EX extends Throwable

parenthesized

protected abstract T parenthesized(T value)
                            throws EX extends Throwable

Throws:

EX extends Throwable

instanceoF

protected abstract T instanceoF(T lhs,
                                Class<?> rhs)
                         throws EX extends Throwable

Throws:

EX extends Throwable

newClass

protected abstract T newClass(Class<?> clasS,
                              List<T> arguments)
                       throws EX extends Throwable

Throws:

EX extends Throwable

newArray

protected abstract T newArray(Class<?> clasS,
                              List<T> dimensions)
                       throws EX extends Throwable

Throws:

EX extends Throwable

cast

protected abstract T cast(Class<?> targetType,
                          T operand)
                   throws EX extends Throwable,
                          ParseException

Throws:

EX extends Throwable

ParseException

arrayAccess

protected abstract T arrayAccess(T lhs,
                                 T rhs)
                          throws EX extends Throwable

Throws:

EX extends Throwable