Class JexlFeatures
These control syntactical constructs that will throw JexlException.Feature exceptions (a subclass of JexlException.Parsing) when disabled.
It is recommended to be explicit in choosing the features you need rather than rely on the default
constructor: the 2 convenience methods createNone() and createAll()
are the recommended starting points to selectively enable or disable chosen features.
- Registers: register syntax (#number), used internally for {g,s}etProperty
- Reserved Names: a set of reserved variable names that cannot be used as local variable (or parameter) names
- Global Side Effect : assigning/modifying values on global variables (=, += , -=, ...)
- Lexical: lexical scope, prevents redefining local variables
- Lexical Shade: local variables shade globals, prevents confusing a global variable with a local one
- Side Effect : assigning/modifying values on any variables or left-value
- Constant Array Reference: ensures array references only use constants;they should be statically solvable.
- New Instance: creating an instance using new(...)
- Loops: loop constructs (while(true), for(...))
- Lambda: function definitions (()->{...}, function(...) ).
- Method calls: calling methods (obj.method(...) or obj['method'](...)); when disabled, leaves function calls - including namespace prefixes - available
- Structured literals: arrays, lists, maps, sets, ranges
- Pragma: pragma construct as in
#pragma x y - Annotation: @annotation statement;
- Thin-arrow: use the thin-arrow, ie
->for lambdas as inx -> x + x - Fat-arrow: use the fat-arrow, ie
=>for lambdas as inx => x + x - Namespace pragma: whether the
#pragma jexl.namespace.ns namespacesyntax is allowed - Namespace identifier: whether the
ns:fun(...)parser treats the ns:fun as one identifier, no spaces allowed - Import pragma: whether the
#pragma jexl.import fully.qualified.class.namesyntax is allowed - Comparator names: whether the comparator operator names can be used (as in
gtfor >,ltfor <, ...) - Pragma anywhere: whether pragma, that are not statements and handled before execution begins, can appear anywhere in the source or before any statements - ie at the beginning of a script.
- Const Capture: whether variables captured by lambdas are read-only (aka const, same as Java) or read-write.
- Reference Capture: whether variables captured by lambdas are pass-by-reference or pass-by-value.
- Since:
- 3.2
-
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionprivate static final classA pragma key test made of exact keys and key prefixes. -
Field Summary
FieldsModifier and TypeFieldDescriptionprivate static final longAll features.static final intAmbiguous or strict statement allowed.static final intAnnotation feature ordinal.static final intExpressions allowed in array reference ordinal.static final intComparator names (legacy) syntax.static final intCaptured variables are const.private static final longThe default features flag mask.private static final String[]The feature names (for toString()).static final intFat-arrow lambda syntax.private longThe feature flags.static final intIgnore template prefix.static final intImport pragma feature ordinal.static final intLambda feature ordinal.static final intLexical feature ordinal.static final intLexical shade feature ordinal.static final intLocals feature ordinal.static final intLoops feature ordinal.static final intLambda feature ordinal.static final intAllow reflective auto-instantiation of a namespace functor from a class/FQCN binding.The namespace names.static final intNew-instance feature ordinal.static final intNamespace syntax as an identifier (no space).static final intNamespace pragma feature ordinal.static final intPragma feature ordinal.static final intThe pragma anywhere feature ordinal.The allowed pragma keys.static final intCaptured variables are reference.private static final intRegisters feature ordinal.static final intReserved future feature ordinal (unused as of 3.3.1).Protected future syntactic elements.The set of reserved names, aka global variables that cannot be masked by local variables or parameters.static final intScript feature ordinal.private static final longThe canonical scripting (since 3.3.1) features flag mask based on the original default.static final intSide effects feature ordinal.static final intGlobal side effects feature ordinal.static final intDeprecated.3.6static final intStructured literal feature ordinal.The false predicate.The true predicate.static final intThin-arrow lambda syntax. -
Constructor Summary
ConstructorsModifierConstructorDescriptionCreates default instance, equivalent to the result of calling the preferred alternativecreateDefault()protectedJexlFeatures(long f, Set<String> r, Predicate<String> n) An all member constructor for derivation.JexlFeatures(JexlFeatures features) Copy constructor. -
Method Summary
Modifier and TypeMethodDescriptionambiguousStatement(boolean flag) Sets whether statements can be ambiguous.annotation(boolean flag) Sets whether annotation constructs are enabled.arrayReferenceExpr(boolean flag) Sets whether array references expressions are enabled.comparatorNames(boolean flag) Sets whether the legacy comparison operator names syntax is enabled.constCapture(boolean flag) Sets whether lambda captured-variables are constant or mutable.static JexlFeaturesCreates an all features enabled set.static JexlFeaturesCreates a default features set suitable for basic but complete scripting needs.static JexlFeaturesCreates an empty feature set.static JexlFeaturesThe modern scripting features set.booleanfatArrow(boolean flag) Sets whether fat-arrow lambda syntax is enabled.private booleangetFeature(int feature) Gets a feature flag value.longgetFlags()Gets the feature flagsGets the immutable set of reserved names.inthashCode()ignoreTemplatePrefix(boolean flag) Sets whether to ignore template prefixes in template expressions.importPragma(boolean flag) Sets whether import pragma constructs are enabled.booleanGets whether to ignore template prefixes in template expressions.booleanIs the lexical scope feature enabled?booleanIs the lexical shade feature enabled?booleanisReservedName(String name) Checks whether a name is reserved.lambda(boolean flag) Sets whether lambda/function constructs are enabled.lexical(boolean flag) Sets whether syntactic lexical mode is enabled.lexicalShade(boolean flag) Sets whether syntactic lexical shade is enabled.localVar(boolean flag) Sets whether local variables are enabled.loops(boolean flag) Sets whether looping constructs are enabled.methodCall(boolean flag) Sets whether method calls expressions are enabled.namespaceIdentifier(boolean flag) Sets whether namespace as identifier syntax is enabled.namespaceInstantiation(boolean flag) Sets whether a namespace bound to a class or fully-qualified class name may be reflectively auto-instantiated into a functor.namespacePragma(boolean flag) Sets whether namespace pragma constructs are enabled.Gets the declared namespaces test.namespaceTest(Predicate<String> names) Sets a test to determine namespace declaration.newInstance(boolean flag) Sets whether creating new instances is enabled.pragma(boolean flag) Sets whether pragma constructs are enabled.pragmaAnywhere(boolean flag) Sets whether pragma constructs can appear anywhere in the code.pragmaPatterns(Collection<String> patterns) Creates a pragma key test from a collection of patterns, meant forpragmaTest(Predicate).Gets the allowed pragma keys test.pragmaTest(Predicate<String> keys) Sets a test to determine which pragma keys are allowed.referenceCapture(boolean flag) Sets whether lambda captured-variables are references or values.register(boolean flag) Sets whether register are enabled.reservedNames(Collection<String> names) Sets a collection of reserved r precluding those to be used as local variables or parameter r.script(boolean flag) Sets whether scripts constructs are enabled.private voidsetFeature(int feature, boolean flag) Sets a feature flag.sideEffect(boolean flag) Sets whether side effect expressions are enabled.sideEffectGlobal(boolean flag) Sets whether side effect expressions on global variables (aka non-local) are enabled.static Stringstringify(int feature) The text corresponding to a feature code.structuredLiteral(boolean flag) Sets whether array/map/set literal expressions are enabled.booleanChecks whether statements can be ambiguous.booleanDoes the engine support annotations?booleanDoes the engine support array references which contain method call expressions?booleanDoes the engine support legacy comparison operator names syntax?booleanDoes the engine support lambda captured-variables as const?booleanDoes the engine support expressions (aka not scripts)booleanDoes the engine support fat-arrow lambda syntax?booleanDoes the engine support import pragma?booleanDoes the engine support lambdas?booleanIs local variables syntax enabled?booleanAre loops enabled?booleanCan array references contain expressions?booleanIs namespace identifier syntax enabled?booleanDoes the engine allow reflective auto-instantiation of a namespace functor from a class or class-name binding?booleanIs namespace pragma enabled?booleanIs creating new instances enabled?booleanIs the namespace pragma enabled?booleanCan pragma constructs appear anywhere in the code?booleanDoes the engine support lambda captured-variables as references?booleanIs register syntax enabled?booleanAre scripts enabled?booleanAre side effects enabled?booleanCan global variables be assigned?booleanAre array/map/set literal expressions supported?booleanIs thin-arrow lambda syntax enabled?thinArrow(boolean flag) Sets whether thin-arrow lambda syntax is enabled.
-
Field Details
-
TEST_STR_FALSE
The false predicate. -
TEST_STR_TRUE
The true predicate.- Since:
- 3.7.1
-
F_NAMES
The feature names (for toString()). -
REGISTER
private static final int REGISTERRegisters feature ordinal.- See Also:
-
RESERVED
public static final int RESERVEDReserved future feature ordinal (unused as of 3.3.1).- See Also:
-
LOCAL_VAR
public static final int LOCAL_VARLocals feature ordinal.- See Also:
-
SIDE_EFFECT
public static final int SIDE_EFFECTSide effects feature ordinal.- See Also:
-
SIDE_EFFECT_GLOBAL
public static final int SIDE_EFFECT_GLOBALGlobal side effects feature ordinal.- See Also:
-
ARRAY_REF_EXPR
public static final int ARRAY_REF_EXPRExpressions allowed in array reference ordinal.- See Also:
-
NEW_INSTANCE
public static final int NEW_INSTANCENew-instance feature ordinal.- See Also:
-
LOOP
public static final int LOOPLoops feature ordinal.- See Also:
-
LAMBDA
public static final int LAMBDALambda feature ordinal.- See Also:
-
METHOD_CALL
public static final int METHOD_CALLLambda feature ordinal.- See Also:
-
STRUCTURED_LITERAL
public static final int STRUCTURED_LITERALStructured literal feature ordinal.- See Also:
-
PRAGMA
public static final int PRAGMAPragma feature ordinal.- See Also:
-
ANNOTATION
public static final int ANNOTATIONAnnotation feature ordinal.- See Also:
-
SCRIPT
public static final int SCRIPTScript feature ordinal.- See Also:
-
LEXICAL
public static final int LEXICALLexical feature ordinal.- See Also:
-
LEXICAL_SHADE
public static final int LEXICAL_SHADELexical shade feature ordinal.- See Also:
-
THIN_ARROW
public static final int THIN_ARROWThin-arrow lambda syntax.- See Also:
-
FAT_ARROW
public static final int FAT_ARROWFat-arrow lambda syntax.- See Also:
-
NS_PRAGMA
public static final int NS_PRAGMANamespace pragma feature ordinal.- See Also:
-
NS_IDENTIFIER
public static final int NS_IDENTIFIERNamespace syntax as an identifier (no space).- See Also:
-
IMPORT_PRAGMA
public static final int IMPORT_PRAGMAImport pragma feature ordinal.- See Also:
-
COMPARATOR_NAMES
public static final int COMPARATOR_NAMESComparator names (legacy) syntax.- See Also:
-
PRAGMA_ANYWHERE
public static final int PRAGMA_ANYWHEREThe pragma anywhere feature ordinal.- See Also:
-
CONST_CAPTURE
public static final int CONST_CAPTURECaptured variables are const.- See Also:
-
REF_CAPTURE
public static final int REF_CAPTURECaptured variables are reference.- See Also:
-
AMBIGUOUS_STATEMENT
public static final int AMBIGUOUS_STATEMENTAmbiguous or strict statement allowed.- See Also:
-
IGNORE_TEMPLATE_PREFIX
public static final int IGNORE_TEMPLATE_PREFIXIgnore template prefix.- See Also:
-
STRICT_STATEMENT
Deprecated.3.6Bad naming, use AMBIGUOUS_STATEMENT.- See Also:
-
NAMESPACE_INSTANTIATE
public static final int NAMESPACE_INSTANTIATEAllow reflective auto-instantiation of a namespace functor from a class/FQCN binding.- See Also:
-
ALL_FEATURES
private static final long ALL_FEATURESAll features. Ensure this is updated if additional features are added.- See Also:
-
DEFAULT_FEATURES
private static final long DEFAULT_FEATURESThe default features flag mask.Meant for compatibility with scripts written before 3.3.1
- See Also:
-
SCRIPT_FEATURES
private static final long SCRIPT_FEATURESThe canonical scripting (since 3.3.1) features flag mask based on the original default.Adds lexical, lexical-shade and const-capture but removes comparator-names and pragma-anywhere
- See Also:
-
RESERVED_WORDS
Protected future syntactic elements.class, jexl, $jexl
- Since:
- 3.3.1
-
flags
private long flagsThe feature flags. -
reservedNames
The set of reserved names, aka global variables that cannot be masked by local variables or parameters. -
nameSpaces
The namespace names. -
pragmas
The allowed pragma keys.
-
-
Constructor Details
-
JexlFeatures
public JexlFeatures()Creates default instance, equivalent to the result of calling the preferred alternativecreateDefault() -
JexlFeatures
Copy constructor.- Parameters:
features- The feature to copy from
-
JexlFeatures
An all member constructor for derivation.Not respecting immutability or thread-safety constraints for this class constructor arguments will likely result in unexpected behavior.
- Parameters:
f- flagr- reserved variable names; must be an immutable Set or thread-safe (concurrent or synchronized set)n- namespace predicate; must be stateless or thread-safe
-
-
Method Details
-
createAll
Creates an all features enabled set.- Returns:
- A new instance of all features set
- Since:
- 3.3.1
-
createDefault
Creates a default features set suitable for basic but complete scripting needs.Maximizes compatibility with older version scripts (before 3.3), new projects should use
createScript()or equivalent features as a base.The following scripting features are enabled:
- local variable,
supportsLocalVar() - side effect,
supportsSideEffect() - global side effect,
supportsSideEffectGlobal() - array reference expression,
supportsStructuredLiteral() - new instance,
supportsNewInstance() - loop,
supportsLoops() - lambda,
supportsLambda() - method call,
supportsMethodCall() - structured literal,
supportsStructuredLiteral() - pragma,
supportsPragma() - annotation,
supportsAnnotation() - script,
supportsScript() - comparator names,
supportsComparatorNames() - namespace pragma,
supportsNamespacePragma() - import pragma,
supportsImportPragma() - pragma anywhere,
supportsPragmaAnywhere()
- Returns:
- A new instance of a default scripting features set
- Since:
- 3.3.1
- local variable,
-
createNone
Creates an empty feature set.This is the strictest base-set since no feature is allowed, suitable as-is only for the simplest expressions.
- Returns:
- A new instance of an empty features set
- Since:
- 3.3.1
-
createScript
The modern scripting features set.This is the recommended set for new projects.
All default features with the following differences:
- disable pragma-anywhere,
supportsPragmaAnywhere() - disable comparator-names,
supportsComparatorNames() - enable lexical,
isLexical() - enable lexical-shade,
isLexicalShade() - enable const-capture,
supportsConstCapture()
It also adds a set of reserved words to enable future unencumbered syntax evolution: try, catch, throw, finally, switch, case, default, class, instanceof
- Returns:
- A new instance of a modern scripting features set
- Since:
- 3.3.1
- disable pragma-anywhere,
-
stringify
The text corresponding to a feature code.- Parameters:
feature- The feature number- Returns:
- The feature name
-
annotation
Sets whether annotation constructs are enabled.When disabled, parsing a script/expression using syntactic annotation constructs (@annotation) will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
arrayReferenceExpr
Sets whether array references expressions are enabled.When disabled, parsing a script/expression using 'obj[ ref ]' where ref is not a string or integer literal will throw a parsing exception;
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
comparatorNames
Sets whether the legacy comparison operator names syntax is enabled.When disabled, comparison operators names (eq;ne;le;lt;ge;gt) will be treated as plain identifiers.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
- Since:
- 3.3
-
constCapture
Sets whether lambda captured-variables are constant or mutable.When disabled, lambda-captured variables are implicitly converted to read-write local variable (let), when enabled, those are implicitly converted to read-only local variables (const).
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
referenceCapture
Sets whether lambda captured-variables are references or values.When variables are pass-by-reference, side effects are visible from inner lexical scopes to outer-scope.
When disabled, lambda-captured variables use pass-by-value semantic, when enabled, those use pass-by-reference semantic.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
namespaceInstantiation
Sets whether a namespace bound to a class or fully-qualified class name may be reflectively auto-instantiated into a functor.When enabled (the default), a namespace declared as a
Classor class-nameStringis instantiated - through a constructor, optionally receiving the context - the first time it is used, allowing instance (non-static) namespace methods. When disabled, no constructor is invoked: only static methods of the bound class are reachable and explicit host-supplied functors are still honored.- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
- Since:
- 3.7.1
-
equals
-
fatArrow
Sets whether fat-arrow lambda syntax is enabled.When disabled, parsing a script/expression using syntactic fat-arrow (=<) will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
- Since:
- 3.3
-
getFeature
private boolean getFeature(int feature) Gets a feature flag value.- Parameters:
feature- feature ordinal- Returns:
- true if on, false if off
-
getFlags
public long getFlags()Gets the feature flags- Returns:
- these features"s flags
-
getReservedNames
Gets the immutable set of reserved names.- Returns:
- The (unmodifiable) set of reserved names.
-
hashCode
public int hashCode() -
ignoreTemplatePrefix
Sets whether to ignore template prefixes in template expressions.Note that this only precludes using a variable whose name is exactly the template prefix (for example, with the default prefix "$$", a variable named "$$" is ignored, but "$", "$a", or "$$$" are still valid variable names).
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
- Since:
- 3.6.3
-
isIgnoreTemplatePrefix
public boolean isIgnoreTemplatePrefix()Gets whether to ignore template prefixes in template expressions.- Returns:
- true if enabled, false otherwise
- Since:
- 3.6.3
-
importPragma
Sets whether import pragma constructs are enabled.When disabled, parsing a script/expression using syntactic import pragma constructs (#pragma jexl.import....) will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
- Since:
- 3.3
-
isLexical
public boolean isLexical()Is the lexical scope feature enabled?- Returns:
- whether lexical scope feature is enabled
-
isLexicalShade
public boolean isLexicalShade()Is the lexical shade feature enabled?- Returns:
- whether lexical shade feature is enabled
-
isReservedName
Checks whether a name is reserved.- Parameters:
name- The name to check- Returns:
- true if reserved, false otherwise
-
lambda
Sets whether lambda/function constructs are enabled.When disabled, parsing a script/expression using syntactic lambda constructs (->,function) will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
lexical
Sets whether syntactic lexical mode is enabled.- Parameters:
flag- true means syntactic lexical function scope is in effect, false implies non-lexical scoping- Returns:
- this features instance
-
lexicalShade
Sets whether syntactic lexical shade is enabled.- Parameters:
flag- true means syntactic lexical shade is in effect and implies lexical scope- Returns:
- this features instance
-
localVar
Sets whether local variables are enabled.When disabled, parsing a script/expression using a local variable or parameter syntax will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
loops
Sets whether looping constructs are enabled.When disabled, parsing a script/expression using syntactic looping constructs (for, while) will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
methodCall
Sets whether method calls expressions are enabled.When disabled, parsing a script/expression using 'obj.method()' will throw a parsing exception;
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
namespacePragma
Sets whether namespace pragma constructs are enabled.When disabled, parsing a script/expression using syntactic namespace pragma constructs (#pragma jexl.namespace....) will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
- Since:
- 3.3
-
namespaceIdentifier
Sets whether namespace as identifier syntax is enabled.When enabled, a namespace call must be of the form
ns:fun(...)with no spaces between the namespace name and the function.- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
- Since:
- 3.5.0
-
namespaceTest
Gets the declared namespaces test.- Returns:
- The declared namespaces test.
-
namespaceTest
Sets a test to determine namespace declaration.- Parameters:
names- The name predicate- Returns:
- this features instance
-
newInstance
Sets whether creating new instances is enabled.When disabled, parsing a script/expression using 'new(...)' will throw a parsing exception; using a class as functor will fail at runtime.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
pragma
Sets whether pragma constructs are enabled.When disabled, parsing a script/expression using syntactic pragma constructs (#pragma) will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
pragmaAnywhere
Sets whether pragma constructs can appear anywhere in the code.- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
- Since:
- 3.3
-
pragmaTest
Gets the allowed pragma keys test.- Returns:
- The allowed pragma keys test, never null.
- Since:
- 3.7.1
-
pragmaTest
Sets a test to determine which pragma keys are allowed.When set, parsing a script/expression declaring a pragma (#pragma key value) whose key does not satisfy the predicate will throw a parsing exception. This applies to all pragmas, including
jexl.options,jexl.import,jexl.namespace.*andjexl.module.*.An engine built with these features applies the test to every script, expression and template it parses. As with every other feature, scripts created with explicit (non-null) features through
JexlEngine.createScript(JexlFeatures, JexlInfo, String, String...)use those features' pragma test, not the engine's.- Parameters:
keys- The pragma key predicate; must be stateless or thread-safe; null allows all pragma keys- Returns:
- this features instance
- Since:
- 3.7.1
-
pragmaPatterns
Creates a pragma key test from a collection of patterns, meant forpragmaTest(Predicate).A pattern ending with
*matches any key starting with what precedes it, any other pattern matches the key exactly. For instance,dlm.*matchesdlm.fooanddlm.foo.bar;*matches any key. Patterns are trimmed, null or empty patterns are ignored.Tests created from the same patterns are equal, so are the features using them.
- Parameters:
patterns- The allowed pragma key patterns; null or empty allows no pragma key- Returns:
- The pragma key test
- Since:
- 3.7.1
-
register
Sets whether register are enabled.This is mostly used internally during execution of JexlEngine.{g,s}etProperty.
When disabled, parsing a script/expression using the register syntax will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
reservedNames
Sets a collection of reserved r precluding those to be used as local variables or parameter r.- Parameters:
names- The r to reserve- Returns:
- this features instance
-
script
Sets whether scripts constructs are enabled.When disabled, parsing a script using syntactic script constructs (statements, ...) will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
setFeature
private void setFeature(int feature, boolean flag) Sets a feature flag.- Parameters:
feature- The feature ordinalflag- turn-on, turn off
-
ambiguousStatement
Sets whether statements can be ambiguous.When enabled, the semicolumn is not required between expressions that otherwise are considered ambiguous. The default will report ambiguity in cases like
if (true) { x 5 }considering this may be missing an operator or that the intent is not clear.- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
supportsAmbiguousStatement
public boolean supportsAmbiguousStatement()Checks whether statements can be ambiguous.When enabled, the semicolumn is not required between expressions that otherwise are considered ambiguous. The default will report ambiguity in cases like
if (true) { x 5 }considering this may be missing an operator or that the intent is not clear.- Returns:
- true if statements can be ambiguous, false otherwise
-
sideEffect
Sets whether side effect expressions are enabled.When disabled, parsing a script/expression using syntactical constructs modifying variables or members will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
sideEffectGlobal
Sets whether side effect expressions on global variables (aka non-local) are enabled.When disabled, parsing a script/expression using syntactical constructs modifying variables including all potentially ant-ish variables will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
structuredLiteral
Sets whether array/map/set literal expressions are enabled.When disabled, parsing a script/expression creating one of these literals will throw a parsing exception;
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
-
supportsAnnotation
public boolean supportsAnnotation()Does the engine support annotations?- Returns:
- true if annotation are enabled, false otherwise
-
supportsArrayReferenceExpr
public boolean supportsArrayReferenceExpr()Does the engine support array references which contain method call expressions?- Returns:
- true if array references can contain method call expressions, false otherwise
-
supportsComparatorNames
public boolean supportsComparatorNames()Does the engine support legacy comparison operator names syntax?- Returns:
- true if legacy comparison operator names syntax is enabled, false otherwise
- Since:
- 3.3
-
supportsConstCapture
public boolean supportsConstCapture()Does the engine support lambda captured-variables as const?- Returns:
- true if lambda captured-variables are const, false otherwise
-
supportsReferenceCapture
public boolean supportsReferenceCapture()Does the engine support lambda captured-variables as references?- Returns:
- true if lambda captured-variables are references, false otherwise
-
supportsNamespaceInstantiation
public boolean supportsNamespaceInstantiation()Does the engine allow reflective auto-instantiation of a namespace functor from a class or class-name binding?- Returns:
- true if namespace auto-instantiation is allowed, false otherwise
- Since:
- 3.7.1
-
supportsExpression
public boolean supportsExpression()Does the engine support expressions (aka not scripts)- Returns:
- true if expressions (aka not scripts) are enabled, false otherwise
-
supportsFatArrow
public boolean supportsFatArrow()Does the engine support fat-arrow lambda syntax?- Returns:
- true if fat-arrow lambda syntax is enabled, false otherwise
- Since:
- 3.3
-
supportsImportPragma
public boolean supportsImportPragma()Does the engine support import pragma?- Returns:
- true if import pragma are enabled, false otherwise
- Since:
- 3.3
-
supportsLambda
public boolean supportsLambda()Does the engine support lambdas?- Returns:
- true if lambda are enabled, false otherwise
-
supportsLocalVar
public boolean supportsLocalVar()Is local variables syntax enabled?- Returns:
- true if local variables syntax is enabled
-
supportsLoops
public boolean supportsLoops()Are loops enabled?- Returns:
- true if loops are enabled, false otherwise
-
supportsMethodCall
public boolean supportsMethodCall()Can array references contain expressions?- Returns:
- true if array references can contain expressions, false otherwise
-
supportsNamespacePragma
public boolean supportsNamespacePragma()Is namespace pragma enabled?- Returns:
- true if namespace pragma are enabled, false otherwise
- Since:
- 3.3
-
supportsNamespaceIdentifier
public boolean supportsNamespaceIdentifier()Is namespace identifier syntax enabled?- Returns:
- true if namespace identifier syntax is enabled, false otherwise
- Since:
- 3.5.0
-
supportsNewInstance
public boolean supportsNewInstance()Is creating new instances enabled?- Returns:
- true if creating new instances is enabled, false otherwise
-
supportsPragma
public boolean supportsPragma()Is the namespace pragma enabled?- Returns:
- true if namespace pragma are enabled, false otherwise
-
supportsPragmaAnywhere
public boolean supportsPragmaAnywhere()Can pragma constructs appear anywhere in the code?- Returns:
- true if pragma constructs can appear anywhere in the code, false otherwise
- Since:
- 3.3
-
supportsRegister
public boolean supportsRegister()Is register syntax enabled?- Returns:
- true if register syntax is enabled
-
supportsScript
public boolean supportsScript()Are scripts enabled?- Returns:
- true if scripts are enabled, false otherwise
-
supportsSideEffect
public boolean supportsSideEffect()Are side effects enabled?- Returns:
- true if side effects are enabled, false otherwise
-
supportsSideEffectGlobal
public boolean supportsSideEffectGlobal()Can global variables be assigned?- Returns:
- true if global variables can be assigned
-
supportsStructuredLiteral
public boolean supportsStructuredLiteral()Are array/map/set literal expressions supported?- Returns:
- true if array/map/set literal expressions are supported, false otherwise
-
supportsThinArrow
public boolean supportsThinArrow()Is thin-arrow lambda syntax enabled?- Returns:
- true if thin-arrow lambda syntax is enabled, false otherwise
- Since:
- 3.3
-
thinArrow
Sets whether thin-arrow lambda syntax is enabled.When disabled, parsing a script/expression using syntactic thin-arrow (-<) will throw a parsing exception.
- Parameters:
flag- true to enable, false to disable- Returns:
- this features instance
- Since:
- 3.3
-