Package org.apache.commons.jexl3

# Class JexlFeatures

java.lang.Object
org.apache.commons.jexl3.JexlFeatures

public final class JexlFeatures extends Object
A set of language feature options.

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 in `x -> x + x`
- Fat-arrow: use the fat-arrow, ie `=>` for lambdas as in `x => x + x`
- Namespace pragma: whether the `#pragma jexl.namespace.ns namespace` syntax 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.name` syntax is allowed
- Comparator names: whether the comparator operator names can be used (as in `gt` for >, `lt` for <, ...)
- 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

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final int`
  `AMBIGUOUS_STATEMENT`
  Ambiguous or strict statement allowed.
  `static final int`
  `ANNOTATION`
  Annotation feature ordinal.
  `static final int`
  `ARRAY_REF_EXPR`
  Expressions allowed in array reference ordinal.
  `static final int`
  `COMPARATOR_NAMES`
  Comparator names (legacy) syntax.
  `static final int`
  `CONST_CAPTURE`
  Captured variables are const.
  `static final int`
  `FAT_ARROW`
  Fat-arrow lambda syntax.
  `static final int`
  `IGNORE_TEMPLATE_PREFIX`
  Ignore template prefix.
  `static final int`
  `IMPORT_PRAGMA`
  Import pragma feature ordinal.
  `static final int`
  `LAMBDA`
  Lambda feature ordinal.
  `static final int`
  `LEXICAL`
  Lexical feature ordinal.
  `static final int`
  `LEXICAL_SHADE`
  Lexical shade feature ordinal.
  `static final int`
  `LOCAL_VAR`
  Locals feature ordinal.
  `static final int`
  `LOOP`
  Loops feature ordinal.
  `static final int`
  `METHOD_CALL`
  Lambda feature ordinal.
  `static final int`
  `NEW_INSTANCE`
  New-instance feature ordinal.
  `static final int`
  `NS_IDENTIFIER`
  Namespace syntax as an identifier (no space).
  `static final int`
  `NS_PRAGMA`
  Namespace pragma feature ordinal.
  `static final int`
  `PRAGMA`
  Pragma feature ordinal.
  `static final int`
  `PRAGMA_ANYWHERE`
  The pragma anywhere feature ordinal.
  `static final int`
  `REF_CAPTURE`
  Captured variables are reference.
  `static final int`
  `RESERVED`
  Reserved future feature ordinal (unused as of 3.3.1).
  `static final int`
  `SCRIPT`
  Script feature ordinal.
  `static final int`
  `SIDE_EFFECT`
  Side effects feature ordinal.
  `static final int`
  `SIDE_EFFECT_GLOBAL`
  Global side effects feature ordinal.
  `static final int`
  `STRICT_STATEMENT`
  Deprecated.
  3.6
  `static final int`
  `STRUCTURED_LITERAL`
  Structured literal feature ordinal.
  `static final Predicate<String>`
  `TEST_STR_FALSE`
  The false predicate.
  `static final int`
  `THIN_ARROW`
  Thin-arrow lambda syntax.

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  ``
  `JexlFeatures()`
  Creates default instance, equivalent to the result of calling the preferred alternative `createDefault()`
  `protected`
  `JexlFeatures(long f, Set<String> r, Predicate<String> n)`
  An all member constructor for derivation.
  ``
  `JexlFeatures(JexlFeatures features)`
  Copy constructor.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `JexlFeatures`
  `ambiguousStatement(boolean flag)`
  Sets whether statements can be ambiguous.
  `JexlFeatures`
  `annotation(boolean flag)`
  Sets whether annotation constructs are enabled.
  `JexlFeatures`
  `arrayReferenceExpr(boolean flag)`
  Sets whether array references expressions are enabled.
  `JexlFeatures`
  `comparatorNames(boolean flag)`
  Sets whether the legacy comparison operator names syntax is enabled.
  `JexlFeatures`
  `constCapture(boolean flag)`
  Sets whether lambda captured-variables are constant or mutable.
  `static JexlFeatures`
  `createAll()`
  Creates an all features enabled set.
  `static JexlFeatures`
  `createDefault()`
  Creates a default features set suitable for basic but complete scripting needs.
  `static JexlFeatures`
  `createNone()`
  Creates an empty feature set.
  `static JexlFeatures`
  `createScript()`
  The modern scripting features set.
  `boolean`
  `equals(Object obj)`
  `JexlFeatures`
  `fatArrow(boolean flag)`
  Sets whether fat-arrow lambda syntax is enabled.
  `long`
  `getFlags()`
  Gets the feature flags
  `Set<String>`
  `getReservedNames()`
  Gets the immutable set of reserved names.
  `int`
  `hashCode()`
  `JexlFeatures`
  `ignoreTemplatePrefix(boolean flag)`
  Sets whether to ignore template prefixes in template expressions.
  `JexlFeatures`
  `importPragma(boolean flag)`
  Sets whether import pragma constructs are enabled.
  `boolean`
  `isIgnoreTemplatePrefix()`
  Gets whether to ignore template prefixes in template expressions.
  `boolean`
  `isLexical()`
  Is the lexical scope feature enabled?
  `boolean`
  `isLexicalShade()`
  Is the lexical shade feature enabled?
  `boolean`
  `isReservedName(String name)`
  Checks whether a name is reserved.
  `JexlFeatures`
  `lambda(boolean flag)`
  Sets whether lambda/function constructs are enabled.
  `JexlFeatures`
  `lexical(boolean flag)`
  Sets whether syntactic lexical mode is enabled.
  `JexlFeatures`
  `lexicalShade(boolean flag)`
  Sets whether syntactic lexical shade is enabled.
  `JexlFeatures`
  `localVar(boolean flag)`
  Sets whether local variables are enabled.
  `JexlFeatures`
  `loops(boolean flag)`
  Sets whether looping constructs are enabled.
  `JexlFeatures`
  `methodCall(boolean flag)`
  Sets whether method calls expressions are enabled.
  `JexlFeatures`
  `namespaceIdentifier(boolean flag)`
  Sets whether namespace as identifier syntax is enabled.
  `JexlFeatures`
  `namespacePragma(boolean flag)`
  Sets whether namespace pragma constructs are enabled.
  `Predicate<String>`
  `namespaceTest()`
  Gets the declared namespaces test.
  `JexlFeatures`
  `namespaceTest(Predicate<String> names)`
  Sets a test to determine namespace declaration.
  `JexlFeatures`
  `newInstance(boolean flag)`
  Sets whether creating new instances is enabled.
  `JexlFeatures`
  `pragma(boolean flag)`
  Sets whether pragma constructs are enabled.
  `JexlFeatures`
  `pragmaAnywhere(boolean flag)`
  Sets whether pragma constructs can appear anywhere in the code.
  `JexlFeatures`
  `referenceCapture(boolean flag)`
  Sets whether lambda captured-variables are references or values.
  `JexlFeatures`
  `register(boolean flag)`
  Sets whether register are enabled.
  `JexlFeatures`
  `reservedNames(Collection<String> names)`
  Sets a collection of reserved r precluding those to be used as local variables or parameter r.
  `JexlFeatures`
  `script(boolean flag)`
  Sets whether scripts constructs are enabled.
  `JexlFeatures`
  `sideEffect(boolean flag)`
  Sets whether side effect expressions are enabled.
  `JexlFeatures`
  `sideEffectGlobal(boolean flag)`
  Sets whether side effect expressions on global variables (aka non-local) are enabled.
  `static String`
  `stringify(int feature)`
  The text corresponding to a feature code.
  `JexlFeatures`
  `structuredLiteral(boolean flag)`
  Sets whether array/map/set literal expressions are enabled.
  `boolean`
  `supportsAmbiguousStatement()`
  Checks whether statements can be ambiguous.
  `boolean`
  `supportsAnnotation()`
  Does the engine support annotations?
  `boolean`
  `supportsArrayReferenceExpr()`
  Does the engine support array references which contain method call expressions?
  `boolean`
  `supportsComparatorNames()`
  Does the engine support legacy comparison operator names syntax?
  `boolean`
  `supportsConstCapture()`
  Does the engine support lambda captured-variables as const?
  `boolean`
  `supportsExpression()`
  Does the engine support expressions (aka not scripts)
  `boolean`
  `supportsFatArrow()`
  Does the engine support fat-arrow lambda syntax?
  `boolean`
  `supportsImportPragma()`
  Does the engine support import pragma?
  `boolean`
  `supportsLambda()`
  Does the engine support lambdas?
  `boolean`
  `supportsLocalVar()`
  Is local variables syntax enabled?
  `boolean`
  `supportsLoops()`
  Are loops enabled?
  `boolean`
  `supportsMethodCall()`
  Can array references contain expressions?
  `boolean`
  `supportsNamespaceIdentifier()`
  Is namespace identifier syntax enabled?
  `boolean`
  `supportsNamespacePragma()`
  Is namespace pragma enabled?
  `boolean`
  `supportsNewInstance()`
  Is creating new instances enabled?
  `boolean`
  `supportsPragma()`
  Is the namespace pragma enabled?
  `boolean`
  `supportsPragmaAnywhere()`
  Can pragma constructs appear anywhere in the code?
  `boolean`
  `supportsReferenceCapture()`
  Does the engine support lambda captured-variables as references?
  `boolean`
  `supportsRegister()`
  Is register syntax enabled?
  `boolean`
  `supportsScript()`
  Are scripts enabled?
  `boolean`
  `supportsSideEffect()`
  Are side effects enabled?
  `boolean`
  `supportsSideEffectGlobal()`
  Can global variables be assigned?
  `boolean`
  `supportsStructuredLiteral()`
  Are array/map/set literal expressions supported?
  `boolean`
  `supportsThinArrow()`
  Is thin-arrow lambda syntax enabled?
  `JexlFeatures`
  `thinArrow(boolean flag)`
  Sets whether thin-arrow lambda syntax is enabled.

  ### Methods inherited from class java.lang.Object

  `clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### TEST_STR_FALSE

    public static final Predicate<String> TEST_STR_FALSE
    The false predicate.

  - ### RESERVED

    public static final int RESERVED
    Reserved future feature ordinal (unused as of 3.3.1).
    See Also:
      - Constant Field Values

  - ### LOCAL_VAR

    public static final int LOCAL_VAR
    Locals feature ordinal.
    See Also:
      - Constant Field Values

  - ### SIDE_EFFECT

    public static final int SIDE_EFFECT
    Side effects feature ordinal.
    See Also:
      - Constant Field Values

  - ### SIDE_EFFECT_GLOBAL

    public static final int SIDE_EFFECT_GLOBAL
    Global side effects feature ordinal.
    See Also:
      - Constant Field Values

  - ### ARRAY_REF_EXPR

    public static final int ARRAY_REF_EXPR
    Expressions allowed in array reference ordinal.
    See Also:
      - Constant Field Values

  - ### NEW_INSTANCE

    public static final int NEW_INSTANCE
    New-instance feature ordinal.
    See Also:
      - Constant Field Values

  - ### LOOP

    public static final int LOOP
    Loops feature ordinal.
    See Also:
      - Constant Field Values

  - ### LAMBDA

    public static final int LAMBDA
    Lambda feature ordinal.
    See Also:
      - Constant Field Values

  - ### METHOD_CALL

    public static final int METHOD_CALL
    Lambda feature ordinal.
    See Also:
      - Constant Field Values

  - ### STRUCTURED_LITERAL

    public static final int STRUCTURED_LITERAL
    Structured literal feature ordinal.
    See Also:
      - Constant Field Values

  - ### PRAGMA

    public static final int PRAGMA
    Pragma feature ordinal.
    See Also:
      - Constant Field Values

  - ### ANNOTATION

    public static final int ANNOTATION
    Annotation feature ordinal.
    See Also:
      - Constant Field Values

  - ### SCRIPT

    public static final int SCRIPT
    Script feature ordinal.
    See Also:
      - Constant Field Values

  - ### LEXICAL

    public static final int LEXICAL
    Lexical feature ordinal.
    See Also:
      - Constant Field Values

  - ### LEXICAL_SHADE

    public static final int LEXICAL_SHADE
    Lexical shade feature ordinal.
    See Also:
      - Constant Field Values

  - ### THIN_ARROW

    public static final int THIN_ARROW
    Thin-arrow lambda syntax.
    See Also:
      - Constant Field Values

  - ### FAT_ARROW

    public static final int FAT_ARROW
    Fat-arrow lambda syntax.
    See Also:
      - Constant Field Values

  - ### NS_PRAGMA

    public static final int NS_PRAGMA
    Namespace pragma feature ordinal.
    See Also:
      - Constant Field Values

  - ### NS_IDENTIFIER

    public static final int NS_IDENTIFIER
    Namespace syntax as an identifier (no space).
    See Also:
      - Constant Field Values

  - ### IMPORT_PRAGMA

    public static final int IMPORT_PRAGMA
    Import pragma feature ordinal.
    See Also:
      - Constant Field Values

  - ### COMPARATOR_NAMES

    public static final int COMPARATOR_NAMES
    Comparator names (legacy) syntax.
    See Also:
      - Constant Field Values

  - ### PRAGMA_ANYWHERE

    public static final int PRAGMA_ANYWHERE
    The pragma anywhere feature ordinal.
    See Also:
      - Constant Field Values

  - ### CONST_CAPTURE

    public static final int CONST_CAPTURE
    Captured variables are const.
    See Also:
      - Constant Field Values

  - ### REF_CAPTURE

    public static final int REF_CAPTURE
    Captured variables are reference.
    See Also:
      - Constant Field Values

  - ### AMBIGUOUS_STATEMENT

    public static final int AMBIGUOUS_STATEMENT
    Ambiguous or strict statement allowed.
    See Also:
      - Constant Field Values

  - ### IGNORE_TEMPLATE_PREFIX

    public static final int IGNORE_TEMPLATE_PREFIX
    Ignore template prefix.
    See Also:
      - Constant Field Values

  - ### STRICT_STATEMENT

    @Deprecated public static final int STRICT_STATEMENT
    Deprecated.
    3.6
    Bad naming, use AMBIGUOUS_STATEMENT.
    See Also:
      - Constant Field Values

- ## Constructor Details

  - ### JexlFeatures

    public JexlFeatures()
    Creates default instance, equivalent to the result of calling the preferred alternative `createDefault()`

  - ### JexlFeatures

    public JexlFeatures(JexlFeatures features)
    Copy constructor.
    Parameters:
      `features` - the feature to copy from

  - ### JexlFeatures

    protected JexlFeatures(long f, Set<String> r, Predicate<String> n)
    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` - flag
      `r` - 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

    public static JexlFeatures createAll()
    Creates an all features enabled set.
    Returns:
      a new instance of all features set
    Since:
      3.3.1

  - ### createDefault

    public static JexlFeatures 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

  - ### createNone

    public static JexlFeatures 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

    public static JexlFeatures 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

  - ### stringify

    public static String stringify(int feature)
    The text corresponding to a feature code.
    Parameters:
      `feature` - the feature number
    Returns:
      the feature name

  - ### annotation

    public JexlFeatures annotation(boolean flag)
    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

    public JexlFeatures arrayReferenceExpr(boolean flag)
    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

    public JexlFeatures comparatorNames(boolean flag)
    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

    public JexlFeatures constCapture(boolean flag)
    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

    public JexlFeatures referenceCapture(boolean flag)
    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

  - ### equals

    public boolean equals(Object obj)
    Overrides:
      `equals` in class `Object`

  - ### fatArrow

    public JexlFeatures fatArrow(boolean flag)
    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

  - ### getFlags

    public long getFlags()
    Gets the feature flags
    Returns:
      these features"s flags

  - ### getReservedNames

    public Set<String> getReservedNames()
    Gets the immutable set of reserved names.
    Returns:
      the (unmodifiable) set of reserved names.

  - ### hashCode

    public int hashCode()
    Overrides:
      `hashCode` in class `Object`

  - ### ignoreTemplatePrefix

    public JexlFeatures ignoreTemplatePrefix(boolean flag)
    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

    public JexlFeatures importPragma(boolean flag)
    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

    public boolean isReservedName(String name)
    Checks whether a name is reserved.
    Parameters:
      `name` - the name to check
    Returns:
      true if reserved, false otherwise

  - ### lambda

    public JexlFeatures lambda(boolean flag)
    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

    public JexlFeatures lexical(boolean flag)
    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

    public JexlFeatures lexicalShade(boolean flag)
    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

    public JexlFeatures localVar(boolean flag)
    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

    public JexlFeatures loops(boolean flag)
    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

    public JexlFeatures methodCall(boolean flag)
    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

    public JexlFeatures namespacePragma(boolean flag)
    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

    public JexlFeatures namespaceIdentifier(boolean flag)
    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

    public Predicate<String> namespaceTest()
    Gets the declared namespaces test.
    Returns:
      the declared namespaces test.

  - ### namespaceTest

    public JexlFeatures namespaceTest(Predicate<String> names)
    Sets a test to determine namespace declaration.
    Parameters:
      `names` - the name predicate
    Returns:
      this features instance

  - ### newInstance

    public JexlFeatures newInstance(boolean flag)
    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

    public JexlFeatures pragma(boolean flag)
    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

    public JexlFeatures pragmaAnywhere(boolean flag)
    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

  - ### register

    public JexlFeatures register(boolean flag)
    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

    public JexlFeatures reservedNames(Collection<String> names)
    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

    public JexlFeatures script(boolean flag)
    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

  - ### ambiguousStatement

    public JexlFeatures ambiguousStatement(boolean flag)
    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

    public JexlFeatures sideEffect(boolean flag)
    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

    public JexlFeatures sideEffectGlobal(boolean flag)
    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

    public JexlFeatures structuredLiteral(boolean flag)
    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

  - ### 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

    public JexlFeatures thinArrow(boolean flag)
    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