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 class
IExpressionEvaluator
by calling any of the following methods:
ICookable.cook(String, java.io.Reader)
methods to scan,
parse, compile and load the expression into the JVM.
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 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
Special value for
setExpressionType(Class) that indicates that the expression may have any type. |
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)
Define the type of the expression.
|
void |
setExpressionTypes(Class[] expressionTypes)
Same as
setExpressionType(Class) , but for multiple 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
static final Class ANY_TYPE
setExpressionType(Class)
that indicates that the expression may have any type.void setExpressionType(Class expressionType)
void setExpressionTypes(Class[] expressionTypes)
setExpressionType(Class)
, but for multiple expressions.@Deprecated void setReturnType(Class returnType)
IExpressionEvaluator
; use setExpressionType(Class)
instead.IScriptEvaluator
null
value is implementation-dependent.setReturnType
in interface IScriptEvaluator
@Deprecated void setReturnTypes(Class[] returnTypes)
IExpressionEvaluator
; use setExpressionTypes(Class[])
instead.IScriptEvaluator
null
elements is
implementation-dependent.setReturnTypes
in interface IScriptEvaluator
Object evaluate(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 values.InvocationTargetException
<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.All other configuration (implemented type, static method, return type, method name, parameter names and types, thrown exceptions) are predetermined by thesetClassName
("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
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 =All other configuration (implemented type, static method, return type, method name, parameter names and types, thrown exceptions) are predetermined by theCompilerFactoryFactory
.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));
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 © 2001–2016. All rights reserved.