public interface IExpressionEvaluator extends IScriptEvaluator
The syntax of the expression to compile is that of a Java expression, as defined in JLS7, section 15. Notice that a Java expression does not have a concluding semicolon.
Example:
a + 7 * b
(Notice that this expression refers to two parameters "a" and "b", as explained below.)
The expression may optionally be preceeded with a sequence of import directives like
import java.text.*; new DecimalFormat("####,###.##").format(10200020.345345)
(Notice that the import directive is concluded with a semicolon, while the expression is not.) This feature is not available if you compile many expressions at a time (see below).
To set up an IExpressionEvaluator
object, proceed as follows:
IExpressionEvaluator
-derived classIExpressionEvaluator
by calling any of the following methods:setExpressionType(Class)
IScriptEvaluator.setParameters(String[], Class[])
IScriptEvaluator.setThrownExceptions(Class[])
ICookable.setParentClassLoader(ClassLoader)
IClassBodyEvaluator.setDefaultImports(String[])
ICookable.cook(String, java.io.Reader)
methods to scan, parse, compile and load the expression
into the JVM.
After the IExpressionEvaluator
object is set up, the expression can be evaluated as often with different
parameter values (see evaluate(Object[])
). This evaluation is very fast, compared to the compilation.
Less common methods exist that allow for the specification of the name of the generated class, the class it
extends, the interfaces it implements, the name of the method that executes the expression, the exceptions that
this method (i.e. the expression) is allowed to throw, and the ClassLoader
that is used to define the
generated class and to load classes referenced by the expression.
If you want to compile many expressions at the same time, you have the option to cook an array of
expressions in one IExpressionEvaluator
by using the following methods:
IScriptEvaluator.setMethodNames(String[])
IScriptEvaluator.setParameters(String[][], Class[][])
setExpressionTypes(Class[])
IScriptEvaluator.setStaticMethod(boolean[])
IScriptEvaluator.setThrownExceptions(Class[][])
IScriptEvaluator.cook(String[], Reader[])
IScriptEvaluator.evaluate(int, Object[])
Notice that these methods have array parameters in contrast to their one-expression brethren.
Notice that for functionally identical IExpressionEvaluator
s, Object.equals(java.lang.Object)
will return true
. E.g. "a+b" and "c + d" are functionally
identical if "a" and "c" have the same type, and so do "b" and "d".
'JLS7' refers to the Java Language Specification, Java SE 7 Edition.
Modifier and Type | Field and Description |
---|---|
static Class<?> |
ANY_TYPE
Deprecated.
Since autoboxing was introduced in JANINO, this feature is no longer necessary because you can use
expression type
Object .class |
DEFAULT_CLASS_NAME
BOOT_CLASS_LOADER, SYSTEM_PROPERTY_SOURCE_DEBUGGING_DIR, SYSTEM_PROPERTY_SOURCE_DEBUGGING_ENABLE
Modifier and Type | Method and Description |
---|---|
<T> Object |
createFastEvaluator(Reader reader,
Class<T> interfaceToImplement,
String[] parameterNames)
If the parameter and return types of the expression are known at compile time, then a "fast" script evaluator
can be instantiated through this method.
|
<T> Object |
createFastEvaluator(String expression,
Class<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 through
createFastEvaluator(String, Class, String[]) . |
Object |
evaluate(Object[] arguments)
Evaluates the expression with concrete parameter values.
|
void |
setExpressionType(Class<?> expressionType)
Defines the type of the expression.
|
void |
setExpressionTypes(Class<?>[] expressionTypes)
Configures the types of the expressions.
|
void |
setReturnType(Class<?> returnType)
Deprecated.
Must not be used on an
IExpressionEvaluator ; use setExpressionType(Class) instead |
void |
setReturnTypes(Class<?>[] returnTypes)
Deprecated.
Must not be used on an
IExpressionEvaluator ; use setExpressionTypes(Class[])
instead |
cook, cook, cook, cook, evaluate, getMethod, getMethod, setMethodName, setMethodNames, setOverrideMethod, setOverrideMethod, setParameters, setParameters, setStaticMethod, setStaticMethod, setThrownExceptions, setThrownExceptions
createInstance, getClazz, setClassName, setDefaultImports, setExtendedClass, setExtendedType, setImplementedInterfaces, setImplementedTypes
cook, cook, cook, cook, cook, cook, cook, cook, cookFile, cookFile, cookFile, cookFile, setCompileErrorHandler, setDebuggingInformation, setParentClassLoader, setWarningHandler
@Deprecated static final Class<?> ANY_TYPE
Object
.class
setExpressionType(Class)
that indicates that the expression may have any type.void setExpressionType(Class<?> expressionType)
Defaults to Object
.class
, which, thanks to autoboxing, allows for any expression type
(including primitive types).
If expressionType
is void.class
, then the expression must be an invocation of a void
method.
void setExpressionTypes(Class<?>[] expressionTypes)
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 a void
method.
@Deprecated void setReturnType(Class<?> returnType)
IScriptEvaluator
null
is equivalent with void.class
.setReturnType
in interface IScriptEvaluator
@Deprecated void setReturnTypes(Class<?>[] returnTypes)
IScriptEvaluator
null
.
Unless this method is invoked, the return type of all script is void.class
.
setReturnTypes
in interface IScriptEvaluator
@Nullable Object evaluate(@Nullable Object[] arguments) throws InvocationTargetException
Each argument value must have the same type as specified through the "parameterTypes" parameter of IScriptEvaluator.setParameters(String[], Class[])
.
Arguments of primitive type must passed with their wrapper class objects.
The object returned has the class as specified through setExpressionType(Class)
.
This method is thread-safe.
evaluate
in interface IScriptEvaluator
arguments
- The actual parameter valuesInvocationTargetException
<T> Object createFastEvaluator(String expression, Class<T> interfaceToImplement, String[] parameterNames) throws CompileException
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); } ... 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 expression
All 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 declared
public
, or with protected
or default access in the package of the compiled class (see IClassBodyEvaluator.setClassName(String)
.
createFastEvaluator
in interface IScriptEvaluator
expression
- Contains the sequence of script tokensCompileException
IScriptEvaluator.createFastEvaluator(Reader, Class, String[])
<T> Object createFastEvaluator(Reader reader, Class<T> interfaceToImplement, String[] parameterNames) throws CompileException, IOException
IScriptEvaluator
Script evaluation is faster than through IScriptEvaluator.evaluate(Object[])
, because it is not done through
reflection but through direct method invocation.
Example:
public interface Foo { int bar(int a, int b); } ... IScriptEvaluator se =CompilerFactoryFactory
.getDefaultCompilerFactory
().newScriptEvaluator
(); // Optionally configure the SE her: se.setClassName
("Bar"); se.setDefaultImports
(new String[] { "java.util.*" }); se.setExtendedClass
(SomeOtherClass.class); se.setParentClassLoader
(someClassLoader); Foo f = (Foo) se.createFastScriptEvaluator
( "return a - b;", Foo.class, new String[] { "a", "b" } ); System.out.println("1 - 2 = " + f.bar(1, 2));
All 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 either be declared public
, or with package scope in the
same package as the generated class (see IClassBodyEvaluator.setClassName(String)
).
createFastEvaluator
in interface IScriptEvaluator
reader
- Produces the stream of script tokensinterfaceToImplement
- Must declare exactly one methodparameterNames
- The names of the parameters of that methodCompileException
IOException
createFastEvaluator(String, Class, String[])
Copyright © 2016. All rights reserved.