All Classes and Interfaces
Class
Description
Abstract class that is used to execute an arbitrary
method that is introspected.
Abstract class that is used to execute an arbitrary 'get' method.
Abstract class that is used to execute an arbitrary method.
Abstract class that is used to execute an arbitrary 'set' method.
Helper class to create typed arrays.
An Iterator wrapper for an Object[].
A class that wraps an array within an AbstractList.
An ascending iterator on an integer range.
An iterator on a long range.
Annotation.
An array literal.
Declares a block.
Declares a for each loop.
Identifiers, variables, ie symbols.
Identifiers, variables and registers.
x.`expr`.
x?.identifier .
x?.`expr` .
Lambda (function).
Enhanced script to allow parameters declaration.
Namespace : identifier.
Identifiers, variables, ie symbols.
Declares a local variable.
Specialized executor to get a boolean property from an object.
A cache of introspection information for a specific class instance.
Utility for Java9+ backport in Java8 of class and module related methods.
A Script closure.
A JexlMethod that wraps a constructor.
Helps pinpoint the cause of problems in expressions that fail during evaluation.
A descending iterator on an integer range.
An iterator on a long range.
Specialized executor to get a property from an object.
Specialized executor to set a property of an object.
A JexlEngine implementation.
Gets the default instance of Uberspect.
Utility class to collect variables.
An Engine that behaves like JEXL 3.2, bugs included.
An Iterator wrapper for an Enumeration.
Controls that a script only uses enabled features.
A JexlPropertyGet for public fields.
A JexlPropertySet for public fields.
Helper resolving a simple class name into a fully-qualified class name (hence FqcnResolver) using
package names as roots of import.
A call frame, created from a scope, stores the arguments and local variables in a "stack frame" (sic).
Abstract an indexed property container.
A generic indexed property container, exposes get(key) and set(key, value)
and solves method call dynamically based on arguments.
A range of integers.
Ascending integer range.
Descending integer range.
An interpreter of JEXL syntax.
The helper base of an interpreter of JEXL syntax.
Cached arithmetic function call.
Cached context function call.
A ctor that needs a context as 1st argument.
Cached function call.
This basic function of this class is to return a Method object for a
particular class given the name of a method and the parameters to the method
in the form of an Object[].
A Constructor get cache-miss.
The common info provided by Javacc errors.
Perform arithmetic, implements JexlOperator methods.
Helper interface used when creating an array literal.
Helper interface used when creating a map literal.
Marker class for null operand exceptions.
Helper interface used when creating a set literal.
The interface that uberspects JexlArithmetic classes.
Configures and builds a JexlEngine.
Manages variables which can be referenced in a JEXL expression.
A marker interface of the JexlContext that processes annotations.
A marker interface of the JexlContext sharing a cancelling flag.
A marker interface that solves a simple class name into a fully-qualified one.
A marker interface of the JexlContext that processes module definitions.
A marker interface of the JexlContext, NamespaceFunctor allows creating an instance
to delegate namespace methods calls to.
A marker interface of the JexlContext that declares how to resolve a namespace from its name;
it is used by the interpreter during evaluation.
A marker interface of the JexlContext that exposes runtime evaluation options.
A marker interface of the JexlContext that processes pragmas.
A marker interface of the JexlContext that indicates the interpreter to put this context
in the JexlEngine thread local context instance during evaluation.
Creates and evaluates JexlExpression and JexlScript objects.
The empty context class, public for instrospection.
The empty/static/non-mutable JexlNamespace class, public for instrospection.
The failure marker class.
Deprecated.
3.2
Wraps any error that might occur during interpretation of a script or expression.
Thrown when parsing fails due to an ambiguous statement.
Thrown when an annotation handler throws an exception.
Thrown when parsing fails due to an invalid assignment.
Thrown to break a loop.
Thrown to cancel a script execution.
Thrown to continue a loop.
Thrown when parsing fails due to a disallowed feature.
Thrown when a method or ctor is unknown, ambiguous or inaccessible.
Thrown when an operator fails.
Thrown when parsing fails.
Thrown when a property is unknown.
Thrown to return a value.
Thrown when reaching stack-overflow.
Thrown when tokenization fails.
Thrown when method/ctor invocation fails.
Thrown when a variable is unknown.
The various type of variable issues.
Represents a single JEXL expression.
A set of language feature options.
Helper class to carry information such as a url/file name, line and column for
debugging information reporting.
Describes errors more precisely.
Base class for AST nodes behaving as lexical units.
Interface used for regular method invocation.
Base class for parser nodes - holds an 'image' of the token for later use.
A marker interface for constants.
Marker interface for cachable function calls.
An info bound to its node.
The JEXL operators.
Flags and properties that can alter the evaluation behavior.
The base class for parsing, manages the parameter/local variable frame.
A lexical unit is the container defining local symbols and their
visibility boundaries.
This interface describes permissions used by JEXL introspection that constrain which
packages/classes/constructors/fields/methods are made visible to JEXL scripts.
A permission delegation that augments the RESTRICTED permission with an explicit
set of classes.
A base for permission delegation allowing functional refinement.
Interface for getting values that appear to be properties.
Interface used for setting values that appear to be properties.
A sandbox describes permissions on a class by explicitly allowing or forbidding
access to methods and properties through "allowlists" and "blocklists".
A allow set of names.
Deprecated.
since 3.2, use
JexlSandbox.BlockSetA block set of names.
A base set of names.
Contains the allow or block lists for properties and methods for a given class.
Deprecated.
since 3.2, use
JexlSandbox.AllowSetA JEXL Script.
Implements the JEXL ScriptEngine for JSF-223.
Holds singleton JexlScriptEngineFactory (IODH).
Implements the JEXL ScriptEngineFactory for JSF-223.
'Federated' introspection/reflection interface to allow JEXL introspection
behavior to be customized.
The various builtin property resolvers.
Abstracts getting property setter and getter.
Determines property resolution strategy.
A simple "JeXL Template" engine.
The sole type of (runtime) exception the JxltEngine can throw.
A unified expression that can mix immediate, deferred and nested sub-expressions as well as string constants;
The "immediate" syntax is of the form
"...${jexl-expr}..."
The "deferred" syntax is of the form "...#{jexl-expr}..."
The "nested" syntax is of the form "...#{...${jexl-expr0}...}..."
The "composite" syntax is of the form "...${jexl-expr0}...A template is a JEXL script that evaluates by writing its content through a Writer.
The set of valued symbols defined in a lexical frame.
The set of symbols declared in a lexical scope.
Specialized executor to get a property from a List or array.
Specialized executor to set a property in a List or array.
A range of longs.
Ascending long range.
Descending long range.
Test application for JexlScriptEngine (JSR-223 implementation).
Helper class to create map literals.
Wraps a map in a context.
Specialized executor to get a property from a Map.
Specialized executor to set a property in a Map.
Specialized executor to invoke a method on an object.
A method key usable by the introspector cache.
Simple distinguishable exception, used when
we run across ambiguous overloading.
Indicates JEXL Introspection should not see this element.
Parses number literals.
Wraps an Object as a JEXL context and NamespaceResolver.
Checks if node is an operator node.
Helper class to deal with operator overloading and specifics.
This exception is thrown when parse errors are encountered.
Token literal values and constants.
This class only exists to prevent JJTree from generating it, since it
expects
ParserVisitor to be an interface, not an abstract class.Token Manager.
Fully abstract to avoid public interface exposition.
Checks whether an element (ctor, field or method) is visible by JEXL introspection.
Equivalent of @NoJexl on a ctor, a method or a field in a class.
Equivalent of @NoJexl on a class in a package.
A crude parser to configure permissions akin to NoJexl annotations.
Specialized executor to get a property from an object.
Specialized executor to set a property in an object.
An uberspect that controls usage of properties, methods and constructors through a sandbox.
A script scope, stores the declaration of parameters and local variables as symbols.
A JexlScript implementation.
Concrete visitor base, used for feature and operator controllers.
Helper class to create set literals.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
A class originally generated by JJTree with the following JavaCCOptions:
MULTI=true,NODE_USES_PARSER=true,VISITOR=true,TRACK_TOKENS=false,NODE_PREFIX=AST,NODE_EXTENDS=,NODE_FACTORY=
Works around issue https://javacc.dev.java.net/issues/show_bug.cgi?id=227
As soon as this issue if fixed and the maven plugin uses the correct version of Javacc, this
class can go away.
A soft referenced cache.
A soft cache entry.
Maintains the set of allowed features associated with a script/expression source.
NOTE : This generated class can be safely deleted if installing in a GWT installation (use StringProvider instead)
Common constant strings utilities.
A visitor for templates.
A JxltEngine implementation.
Abstract the source fragments, verbatim or immediate typed text blocks.
The enum capturing the difference between verbatim and code source fragments.
A helper class to build expressions.
Types of expressions.
The different parsing states.
The type of interpreter to use during evaluation of templates.
Helper ctor.
A Template instance.
Describes the input token stream.
Token Manager Error.
Implementation of Uberspect to provide the default introspective
functionality of JEXL.