Class ExpressionEvaluator
- All Implemented Interfaces:
ICookable
,IExpressionEvaluator
,IMultiCookable
IExpressionEvaluator
is implemented by creating and compiling a temporary compilation unit defining one
class with one static method with one RETURN statement.
A number of "convenience constructors" exist that execute the set-up steps described for IExpressionEvaluator
instantly.
If the expression type and the parameters' types are known at compile time, then a "fast" expression evaluator
can be instantiated through createFastEvaluator(String, Class, String...)
.
Expression evaluation is faster than through evaluate(Object[])
, because it is not done through
reflection but through direct method invocation.
Example:
public interface Foo { int bar(int a, int b); } ... Foo f = (Foo) ExpressionEvaluator.createFastExpressionEvaluator( "a + b", // expression to evaluate Foo.class, // interface that describes the expression's signature new String[] { "a", "b" }, // the parameters' names (ClassLoader) null // Use current thread's context class loader ); System.out.println("1 + 2 = " + f.bar(1, 2)); // Evaluate the expression
Notice: The interfaceToImplement
must either be declared public
, or with package scope in the root
package (i.e. "no" package).
On my system (Intel P4, 2 GHz, MS Windows XP, JDK 1.4.1), expression "x + 1" evaluates as follows:
Server JVM | Client JVM | |
---|---|---|
Normal EE | 23.7 ns | 64.0 ns |
Fast EE | 31.2 ns | 42.2 ns |
-
Field Summary
FieldsModifier and TypeFieldDescriptionprivate final ScriptEvaluator
private int
private WarningHandler
Fields inherited from interface org.codehaus.commons.compiler.IExpressionEvaluator
ANY_TYPE, DEFAULT_CLASS_NAME, DEFAULT_EXPRESSION_TYPE
-
Constructor Summary
ConstructorsConstructorDescriptionExpressionEvaluator
(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes) Equivalent toExpressionEvaluator
(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, Class<?> extendedClass, Class<?>[] implementedTypes, ClassLoader parentClassLoader) Equivalent toExpressionEvaluator
(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader) Equivalent toExpressionEvaluator
(Scanner scanner, String className, Class<?> extendedType, Class<?>[] implementedTypes, boolean staticMethod, Class<?> expressionType, String methodName, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader) Creates an expression evaluator with the full configurability. -
Method Summary
Modifier and TypeMethodDescriptionprotected Java.Type[]
classesToTypes
(Location location, Class<?>... classes) protected Java.Type
classToType
(Location location, Class<?> clazz) void
Same asCookable.cook(String, Reader)
, but cooks a set of documents into one class.void
Reads, scans, parses and compiles Java tokens from the givenReader
.final void
final void
final void
Likecook(Scanner)
, but cooks a set of scripts into one class.<T> T
createFastEvaluator
(Reader reader, Class<? extends T> interfaceToImplement, String... parameterNames) <T> T
createFastEvaluator
(String script, Class<? extends T> interfaceToImplement, String... parameterNames) If the parameter and return types of the expression are known at compile time, then a "fast" expression evaluator can be instantiated throughIExpressionEvaluator.createFastEvaluator(String, Class, String[])
.<T> T
createFastEvaluator
(Scanner scanner, Class<T> interfaceToImplement, String... parameterNames) Notice: This method is not declared inIScriptEvaluator
, and is hence only available in this implementation oforg.codehaus.commons.compiler
.static Object
createFastExpressionEvaluator
(String expression, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader) Deprecated.static Object
createFastExpressionEvaluator
(Scanner scanner, String[] defaultImports, String className, Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader) Deprecated.UsecreateFastEvaluator(Reader, Class, String[])
insteadstatic Object
createFastExpressionEvaluator
(Scanner scanner, String className, Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader) Deprecated.UsecreateFastEvaluator(Reader, Class, String[])
insteadNull
arguments is equivalent withnew Object[0]
.Evaluates the expression with concrete parameter values.Class<?>
getClazz()
Class<?>
String[]
getMethod
(int idx) Method[]
static String[]
guessParameterNames
(Scanner scanner) Guess the names of the parameters used in the given expression.protected Java.Type
optionalClassToType
(Location location, Class<?> clazz) options()
options
(EnumSet<JaninoOption> options) Sets the options for all future compilations.void
setClassName
(String className) void
setCompileErrorHandler
(ErrorHandler compileErrorHandler) Installs anErrorHandler
which is invoked during compilation on each error.void
setDebuggingInformation
(boolean debugSource, boolean debugLines, boolean debugVars) Determines what kind of debugging information is included in the generates classes.void
setDefaultExpressionType
(Class<?> defaultExpressionType) Reconfigures the "default expression type"; if no expression type is configured for an expression, then, when cooking thisIExpressionEvaluator
, the "default expression type" is used for the expressionvoid
setDefaultImports
(String... defaultImports) void
setExpressionType
(Class<?> expressionType) Defines the type of the expression.void
setExpressionTypes
(Class<?>[] expressionTypes) Configures the types of the expressions.void
setExtendedClass
(Class<?> extendedType) void
setImplementedInterfaces
(Class<?>[] implementedTypes) Configures the interfaces that the generated class implements.void
setMethodName
(String methodName) void
setMethodNames
(String[] methodNames) void
setOverrideMethod
(boolean overrideMethod) void
setOverrideMethod
(boolean[] overrideMethod) void
setParameters
(String[][] parameterNames, Class<?>[][] parameterTypes) void
setParameters
(String[] parameterNames, Class<?>[] parameterTypes) void
setParentClassLoader
(ClassLoader parentClassLoader) The "parent class loader" is used to load referenced classes.void
setReturnType
(Class<?> returnType) void
setSourceVersion
(int version) Specifies the version of source code accepted, in analogy with JAVAC's-source
command line option.void
setStaticMethod
(boolean staticMethod) void
setStaticMethod
(boolean[] staticMethod) void
setTargetVersion
(int version) Generates class files that target a specified release of the virtual machine, in analogy with JAVAC's-target
command line option.void
setThrownExceptions
(Class<?>[] thrownExceptions) void
setThrownExceptions
(Class<?>[][] thrownExceptions) void
setWarningHandler
(WarningHandler warningHandler) By default, warnings are discarded, but an application my install a customWarningHandler
.Methods inherited from class org.codehaus.commons.compiler.MultiCookable
cook, cook, cook, cook, cook, cook, cook, cookFiles, cookFiles, cookFiles, cookFiles
Methods inherited from class org.codehaus.commons.compiler.Cookable
cook, cook, cook, cook, cook, cook, cook, cookFile, cookFile, cookFile, cookFile
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
-
Field Details
-
sourceVersion
private int sourceVersion -
warningHandler
-
se
-
-
Constructor Details
-
ExpressionEvaluator
public ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes) throws CompileException Equivalent toExpressionEvaluator ee = new ExpressionEvaluator(); ee.setExpressionType(expressionType); ee.setParameters(parameterNames, parameterTypes); ee.cook(expression);
-
ExpressionEvaluator
public ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader parentClassLoader) throws CompileException Equivalent toExpressionEvaluator ee = new ExpressionEvaluator(); ee.setExpressionType(expressionType); ee.setParameters(parameterNames, parameterTypes); ee.setThrownExceptions(thrownExceptions); ee.setParentClassLoader(parentClassLoader); ee.cook(expression);
-
ExpressionEvaluator
public ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, Class<?> extendedClass, Class<?>[] implementedTypes, @Nullable ClassLoader parentClassLoader) throws CompileException Equivalent toExpressionEvaluator ee = new ExpressionEvaluator(); ee.setExpressionType(expressionType); ee.setParameters(parameterNames, parameterTypes); ee.setThrownExceptions(thrownExceptions); ee.setExtendedClass(extendedClass); ee.setImplementedTypes(implementedTypes); ee.setParentClassLoader(parentClassLoader); ee.cook(expression);
- Throws:
CompileException
- See Also:
-
ExpressionEvaluator()
setExpressionType(Class)
ScriptEvaluator.setParameters(String[], Class[])
ScriptEvaluator.setThrownExceptions(Class[])
ClassBodyEvaluator.setExtendedClass(Class)
ClassBodyEvaluator.setImplementedInterfaces(Class[])
SimpleCompiler.setParentClassLoader(ClassLoader)
Cookable.cook(String)
-
ExpressionEvaluator
public ExpressionEvaluator(Scanner scanner, String className, @Nullable Class<?> extendedType, Class<?>[] implementedTypes, boolean staticMethod, Class<?> expressionType, String methodName, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader parentClassLoader) throws CompileException, IOException Creates an expression evaluator with the full configurability.Equivalent to:
ExpressionEvaluator ee = new ExpressionEvaluator(); ee.setClassName(className); ee.setExtendedType(extendedType); ee.setImplementedTypes(implementedTypes); ee.setStaticMethod(staticMethod); ee.setExpressionType(expressionType); ee.setMethodName(methodName); ee.setParameters(parameterNames, parameterTypes); ee.setThrownExceptions(thrownExceptions); ee.setParentClassLoader(parentClassLoader); ee.cook(scanner);
- Throws:
CompileException
IOException
- See Also:
-
IExpressionEvaluator
IClassBodyEvaluator.setClassName(String)
IClassBodyEvaluator.setExtendedClass(Class)
IClassBodyEvaluator.setImplementedInterfaces(Class[])
IScriptEvaluator.setStaticMethod(boolean)
IExpressionEvaluator.setExpressionType(Class)
IScriptEvaluator.setMethodName(String)
IScriptEvaluator.setParameters(String[], Class[])
IScriptEvaluator.setThrownExceptions(Class[])
ISimpleCompiler.setParentClassLoader(ClassLoader)
ICookable.cook(Reader)
-
ExpressionEvaluator
public ExpressionEvaluator()
-
-
Method Details
-
setParentClassLoader
Description copied from interface:IExpressionEvaluator
The "parent class loader" is used to load referenced classes. Useful values are:System.getSystemClassLoader()
The running JVM's class path Thread.currentThread().getContextClassLoader()
ornull
The class loader effective for the invoking thread ClassLoaders.BOOTCLASSPATH_CLASS_LOADER
The running JVM's boot class path The parent class loader defaults to the current thread's context class loader.
- Specified by:
setParentClassLoader
in interfaceIExpressionEvaluator
-
setDebuggingInformation
public void setDebuggingInformation(boolean debugSource, boolean debugLines, boolean debugVars) Description copied from interface:IExpressionEvaluator
Determines what kind of debugging information is included in the generates classes. The default is typically "-g:none
".- Specified by:
setDebuggingInformation
in interfaceIExpressionEvaluator
-
setSourceVersion
public void setSourceVersion(int version) Description copied from interface:ICookable
Specifies the version of source code accepted, in analogy with JAVAC's-source
command line option. May be ignored by an implementation (e.g. thejanino
implementation always accepts the language features as described on the home page). Allowed values, and the default value, depend on the implementation.-1
means to use a default version.- Specified by:
setSourceVersion
in interfaceICookable
-
setTargetVersion
public void setTargetVersion(int version) Description copied from interface:ICookable
Generates class files that target a specified release of the virtual machine, in analogy with JAVAC's-target
command line option. Allowed values depend on the implementation. The default value also depends on the implementation. The only invariant is that the generated class files are suitable for the currently executing JVM.-1
means to use a default version.- Specified by:
setTargetVersion
in interfaceICookable
-
setCompileErrorHandler
Description copied from interface:IExpressionEvaluator
Installs anErrorHandler
which is invoked during compilation on each error. (By default, the compilation throws aCompileException
on the first error and terminates.)If the given
ErrorHandler
throws aCompileException
, then the compilation terminates and the exception is propagated.If the given
ErrorHandler
does not throw aCompileException
but completes normally, then the compilation may or may not continue, depending on the error. Iff the compilation completes normally but errors were reported, then it will throw aCompileException
indicating the number of errors.In other words: The
ErrorHandler
may throw aCompileException
or not, but the compilation will definitely throw aCompileException
if one or more compile errors have occurred.- Specified by:
setCompileErrorHandler
in interfaceIExpressionEvaluator
- Parameters:
compileErrorHandler
-null
to restore the default behavior (throwing aCompileException
)
-
setWarningHandler
Description copied from interface:IExpressionEvaluator
By default, warnings are discarded, but an application my install a customWarningHandler
.- Specified by:
setWarningHandler
in interfaceIExpressionEvaluator
- Parameters:
warningHandler
-null
to indicate that no warnings be issued
-
setDefaultImports
- Specified by:
setDefaultImports
in interfaceIExpressionEvaluator
- See Also:
-
getDefaultImports
- Specified by:
getDefaultImports
in interfaceIExpressionEvaluator
- See Also:
-
options
- Returns:
- A reference to the currently effective compilation options; changes to it take effect immediately
-
options
Sets the options for all future compilations. -
setDefaultExpressionType
Description copied from interface:IExpressionEvaluator
Reconfigures the "default expression type"; if no expression type is configured for an expression, then, when cooking thisIExpressionEvaluator
, the "default expression type" is used for the expression- Specified by:
setDefaultExpressionType
in interfaceIExpressionEvaluator
-
getDefaultExpressionType
- Specified by:
getDefaultExpressionType
in interfaceIExpressionEvaluator
- Returns:
- The currently configured "default expression type"
- See Also:
-
setImplementedInterfaces
Description copied from interface:IExpressionEvaluator
Configures the interfaces that the generated class implements.- Specified by:
setImplementedInterfaces
in interfaceIExpressionEvaluator
-
setReturnType
- Specified by:
setReturnType
in interfaceIExpressionEvaluator
-
setExpressionType
Description copied from interface:IExpressionEvaluator
Defines the type of the expression.Defaults to
Object
.class
, which, thanks to autoboxing, allows for any expression type (including primitive types).If
expressionType
isvoid.class
, then the expression must be an invocation of avoid
method.- Specified by:
setExpressionType
in interfaceIExpressionEvaluator
-
setExpressionTypes
Description copied from interface:IExpressionEvaluator
Configures the types of the expressions.Unless this method is called, all expressions have type
Object
.class
.If any expression has type
void.class
, then it must be an invocation of avoid
method.- Specified by:
setExpressionTypes
in interfaceIExpressionEvaluator
-
setOverrideMethod
public void setOverrideMethod(boolean overrideMethod) - Specified by:
setOverrideMethod
in interfaceIExpressionEvaluator
- See Also:
-
setOverrideMethod
public void setOverrideMethod(boolean[] overrideMethod) - Specified by:
setOverrideMethod
in interfaceIExpressionEvaluator
- See Also:
-
setParameters
- Specified by:
setParameters
in interfaceIExpressionEvaluator
- See Also:
-
setParameters
- Specified by:
setParameters
in interfaceIExpressionEvaluator
- See Also:
-
setClassName
- Specified by:
setClassName
in interfaceIExpressionEvaluator
- See Also:
-
setExtendedClass
- Specified by:
setExtendedClass
in interfaceIExpressionEvaluator
- See Also:
-
setStaticMethod
public void setStaticMethod(boolean staticMethod) - Specified by:
setStaticMethod
in interfaceIExpressionEvaluator
- See Also:
-
setStaticMethod
public void setStaticMethod(boolean[] staticMethod) - Specified by:
setStaticMethod
in interfaceIExpressionEvaluator
- See Also:
-
setMethodName
- Specified by:
setMethodName
in interfaceIExpressionEvaluator
- See Also:
-
setMethodNames
- Specified by:
setMethodNames
in interfaceIExpressionEvaluator
- See Also:
-
setThrownExceptions
- Specified by:
setThrownExceptions
in interfaceIExpressionEvaluator
- See Also:
-
setThrownExceptions
- Specified by:
setThrownExceptions
in interfaceIExpressionEvaluator
- See Also:
-
getMethod
- Specified by:
getMethod
in interfaceIExpressionEvaluator
- See Also:
-
getMethod
- Specified by:
getMethod
in interfaceIExpressionEvaluator
- See Also:
-
getResult
- Specified by:
getResult
in interfaceIExpressionEvaluator
- Returns:
- The generated method
- Throws:
IllegalStateException
- TheScriptEvaluator
has not yet be cooked- See Also:
-
cook
Description copied from interface:ICookable
Reads, scans, parses and compiles Java tokens from the givenReader
.- Specified by:
cook
in interfaceICookable
- Specified by:
cook
in classCookable
- Parameters:
fileName
- Used when reporting errors and warnings- Throws:
CompileException
IOException
-
cook
Description copied from interface:IMultiCookable
Same asCookable.cook(String, Reader)
, but cooks a set of documents into one class. Notice that if any of the documents causes trouble, the entire compilation will fail. If you need to report which of the documents causes the exception, you may want to use thefileNames
parameter to distinguish between the individual token sources.- Specified by:
cook
in interfaceIMultiCookable
- Specified by:
cook
in classMultiCookable
- Throws:
CompileException
IOException
-
cook
- Throws:
CompileException
IOException
-
cook
Likecook(Scanner)
, but cooks a set of scripts into one class. Notice that if any of the scripts causes trouble, the entire compilation will fail. If you need to report which of the scripts causes the exception, you may want to use thefileName
argument ofScanner(String, Reader)
to distinguish between the individual token sources.On a 2 GHz Intel Pentium Core Duo under Windows XP with an IBM 1.4.2 JDK, compiling 10000 expressions "a + b" (integer) takes about 4 seconds and 56 MB of main memory. The generated class file is 639203 bytes large.
The number and the complexity of the scripts is restricted by the Limitations of the Java Virtual Machine, where the most limiting factor is the 64K entries limit of the constant pool. Since every method with a distinct name requires one entry there, you can define at best 32K (very simple) scripts.
If and only if the number of scanners is one, then that single script may contain leading IMPORT directives.
- Throws:
IllegalStateException
- Any of the precedingset...()
had an array size different from that ofscanners
CompileException
IOException
-
cook
- Throws:
CompileException
IOException
- See Also:
-
classesToTypes
-
optionalClassToType
-
classToType
-
evaluate
Description copied from interface:IExpressionEvaluator
Evaluates the expression with concrete parameter values.Each argument value must have the same type as specified through the "parameterTypes" parameter of
IExpressionEvaluator.setParameters(String[], Class[])
.Arguments of primitive type must passed with their wrapper class objects.
The object returned has the class as specified through
IExpressionEvaluator.setExpressionType(Class)
.This method is thread-safe.
Null
arguments is equivalent withnew Object[0]
.- Specified by:
evaluate
in interfaceIExpressionEvaluator
- Parameters:
arguments
- The actual parameter values- Throws:
InvocationTargetException
-
evaluate
@Nullable public Object evaluate(int idx, @Nullable Object... arguments) throws InvocationTargetException Description copied from interface:IExpressionEvaluator
Null
arguments is equivalent withnew Object[0]
.- Specified by:
evaluate
in interfaceIExpressionEvaluator
- Throws:
InvocationTargetException
-
getClazz
- Specified by:
getClazz
in interfaceIExpressionEvaluator
- See Also:
-
getBytecodes
- Specified by:
getBytecodes
in interfaceICookable
- Returns:
- The generated Java bytecode; maps class name to bytes
-
createFastExpressionEvaluator
@Deprecated public static Object createFastExpressionEvaluator(String expression, Class<?> interfaceToImplement, String[] parameterNames, @Nullable ClassLoader parentClassLoader) throws CompileException Deprecated.UsecreateFastEvaluator(String, Class, String[])
instead:- Throws:
CompileException
-
createFastExpressionEvaluator
@Deprecated public static Object createFastExpressionEvaluator(Scanner scanner, String className, @Nullable Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, @Nullable ClassLoader parentClassLoader) throws CompileException, IOException Deprecated.UsecreateFastEvaluator(Reader, Class, String[])
instead- Throws:
CompileException
IOException
-
createFastExpressionEvaluator
@Deprecated public static Object createFastExpressionEvaluator(Scanner scanner, String[] defaultImports, String className, @Nullable Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, @Nullable ClassLoader parentClassLoader) throws CompileException, IOException Deprecated.UsecreateFastEvaluator(Reader, Class, String[])
instead- Throws:
CompileException
IOException
-
createFastEvaluator
public <T> T createFastEvaluator(Reader reader, Class<? extends T> interfaceToImplement, String... parameterNames) throws CompileException, IOException - Specified by:
createFastEvaluator
in interfaceIExpressionEvaluator
- Throws:
CompileException
IOException
- See Also:
-
createFastEvaluator
public <T> T createFastEvaluator(String script, Class<? extends T> interfaceToImplement, String... parameterNames) throws CompileException Description copied from interface:IExpressionEvaluator
If the parameter and return types of the expression are known at compile time, then a "fast" expression evaluator can be instantiated throughIExpressionEvaluator.createFastEvaluator(String, Class, String[])
. Expression evaluation is faster than throughIExpressionEvaluator.evaluate(Object[])
, because it is not done through reflection but through direct method invocation.Example:
public interface Foo { int bar(int a, int b); } ... ExpressionEvaluator ee = CompilerFactoryFactory.getDefaultCompilerFactory().newExpressionEvaluator(); // Optionally configure the EE here... ee.
setClassName
("Bar"); ee.setDefaultImports
(new String[] { "java.util.*" }); ee.setExtendedClass
(SomeOtherClass.class); ee.setParentClassLoader
(someClassLoader); // Optionally configure the EE here... Foo f = (Foo) ee.createFastEvaluator( "a + b", // expression to evaluate Foo.class, // interface that describes the expression's signature new String[] { "a", "b" } // the parameters' names ); System.out.println("1 + 2 = " + f.bar(1, 2)); // Evaluate the expressionAll other configuration (implemented type, static method, return type, method name, parameter names and types, thrown exceptions) are predetermined by the interfaceToImplement.
Notice: The
interfaceToImplement
must be accessible by the compiled class, i.e. either be declaredpublic
, or withprotected
or default access in the package of the compiled class (seeIExpressionEvaluator.setClassName(String)
.- Specified by:
createFastEvaluator
in interfaceIExpressionEvaluator
- Throws:
CompileException
-
createFastEvaluator
public <T> T createFastEvaluator(Scanner scanner, Class<T> interfaceToImplement, String... parameterNames) throws CompileException, IOException Notice: This method is not declared inIScriptEvaluator
, and is hence only available in this implementation oforg.codehaus.commons.compiler
. To be independent from this particular implementation, try to switch tocreateFastEvaluator(Reader, Class, String[])
.- Parameters:
scanner
- Source of tokens to read- Throws:
CompileException
IOException
- See Also:
-
guessParameterNames
Guess the names of the parameters used in the given expression. The strategy is to look at all "ambiguous names" in the expression (e.g. in "a.b.c.d()", the ambiguous name is "a.b.c"), and then at the first components of the ambiguous name.- If any component starts with an upper-case letter, then ambiguous name is assumed to be a type name.
- Otherwise, it is assumed to be a parameter name.
- Throws:
CompileException
IOException
- See Also:
-
createFastEvaluator(String, Class, String[])
instead: