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 ScriptEvaluatorprivate intprivate WarningHandlerFields inherited from interface 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.TypeclassToType(Location location, Class<?> clazz) voidSame asCookable.cook(String, Reader), but cooks a set of documents into one class.voidReads, scans, parses and compiles Java tokens from the givenReader.final voidfinal voidfinal voidLikecook(Scanner), but cooks a set of scripts into one class.private void<T> TcreateFastEvaluator(Reader reader, Class<? extends T> interfaceToImplement, String... parameterNames) <T> TcreateFastEvaluator(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> TcreateFastEvaluator(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 ObjectcreateFastExpressionEvaluator(String expression, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader) Deprecated.static ObjectcreateFastExpressionEvaluator(Scanner scanner, String[] defaultImports, String className, Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader) Deprecated.UsecreateFastEvaluator(Reader, Class, String[])insteadstatic ObjectcreateFastExpressionEvaluator(Scanner scanner, String className, Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader) Deprecated.UsecreateFastEvaluator(Reader, Class, String[])insteadevaluate()Shorthand forevaluate(new Object[0]).Same asIExpressionEvaluator.evaluate(Object[]), but for multiple expressions.Evaluates the expression with concrete parameter values.Class<?> getClazz()Class<?> String[]getMethod(int idx) Same asIExpressionEvaluator.getMethod(), but for multiple expressions.Method[]static String[]guessParameterNames(Scanner scanner) Guess the names of the parameters used in the given expression.private static String[]guessParameterNames2(Scanner scanner) protected Java.TypeoptionalClassToType(Location location, Class<?> clazz) options()options(EnumSet<JaninoOption> options) Sets the options for all future compilations.voidsetClassName(String className) Sets the name of the generated class.voidsetCompileErrorHandler(ErrorHandler compileErrorHandler) Installs anErrorHandlerwhich is invoked during compilation on each error.voidsetDebuggingInformation(boolean debugSource, boolean debugLines, boolean debugVars) Determines what kind of debugging information is included in the generates classes.voidsetDefaultExpressionType(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 expressionvoidsetDefaultImports(String... defaultImports) "Default imports" add to the system import "java.lang", i.e.voidsetExpressionType(Class<?> expressionType) Defines the type of the expression.voidsetExpressionTypes(Class<?>[] expressionTypes) Configures the types of the expressions.voidsetExtendedClass(Class<?> extendedType) Sets a particular superclass that the generated class will extend.voidsetImplementedInterfaces(Class<?>[] implementedTypes) Configures the interfaces that the generated class implements.voidsetMethodName(String methodName) Defines the name of the generated method.voidsetMethodNames(String[] methodNames) Same asIExpressionEvaluator.setMethodName(String), but for multiple expressions.voidsetOverrideMethod(boolean overrideMethod) Defines whether the generated method overrides a methods declared in a supertype.voidsetOverrideMethod(boolean[] overrideMethod) Same asIExpressionEvaluator.setOverrideMethod(boolean), but for multiple expressions.voidsetParameters(String[][] parameterNames, Class<?>[][] parameterTypes) Same asIExpressionEvaluator.setParameters(String[], Class[]), but for multiple expressions.voidsetParameters(String[] parameterNames, Class<?>[] parameterTypes) Defines the names and types of the parameters of the generated method.voidsetParentClassLoader(ClassLoader parentClassLoader) The "parent class loader" is used to load referenced classes.voidsetReturnType(Class<?> returnType) voidsetSourceVersion(int version) Specifies the version of source code accepted, in analogy with JAVAC's-sourcecommand line option.voidsetStaticMethod(boolean staticMethod) Defines whether the generated method should be STATIC or not.voidsetStaticMethod(boolean[] staticMethod) Same asIExpressionEvaluator.setStaticMethod(boolean), but for multiple expressions.voidsetTargetVersion(int version) Generates class files that target a specified release of the virtual machine, in analogy with JAVAC's-targetcommand line option.voidsetThrownExceptions(Class<?>[] thrownExceptions) Defines the exceptions that the generated method may throw.voidsetThrownExceptions(Class<?>[][] thrownExceptions) Same asIExpressionEvaluator.setThrownExceptions(Class[]), but for multiple expressions.voidsetWarningHandler(WarningHandler warningHandler) By default, warnings are discarded, but an application my install a customWarningHandler.Methods inherited from class MultiCookable
cook, cook, cook, cook, cook, cook, cook, cookFiles, cookFiles, cookFiles, cookFilesMethods inherited from class Cookable
cook, cook, cook, cook, cook, cook, cook, cookFile, cookFile, cookFile, cookFileMethods inherited from class 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);- Throws:
CompileException- See Also:
-
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);- Throws:
CompileException- See Also:
-
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
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:
CompileExceptionIOException- See Also:
-
ExpressionEvaluator
public ExpressionEvaluator()
-
-
Method Details
-
setParentClassLoader
Description copied from interface:IExpressionEvaluatorThe "parent class loader" is used to load referenced classes. Useful values are:System.getSystemClassLoader()The running JVM's class path Thread.currentThread().getContextClassLoader()ornullThe class loader effective for the invoking thread ClassLoaders.BOOTCLASSPATH_CLASS_LOADERThe running JVM's boot class path The parent class loader defaults to the current thread's context class loader.
- Specified by:
setParentClassLoaderin interfaceIExpressionEvaluator
-
setDebuggingInformation
public void setDebuggingInformation(boolean debugSource, boolean debugLines, boolean debugVars) Description copied from interface:IExpressionEvaluatorDetermines what kind of debugging information is included in the generates classes. The default is typically "-g:none".- Specified by:
setDebuggingInformationin interfaceIExpressionEvaluator
-
setSourceVersion
public void setSourceVersion(int version) Description copied from interface:ICookableSpecifies the version of source code accepted, in analogy with JAVAC's-sourcecommand line option. May be ignored by an implementation (e.g. thejaninoimplementation always accepts the language features as described on the home page). Allowed values, and the default value, depend on the implementation.-1means to use a default version.- Specified by:
setSourceVersionin interfaceICookable
-
setTargetVersion
public void setTargetVersion(int version) Description copied from interface:ICookableGenerates class files that target a specified release of the virtual machine, in analogy with JAVAC's-targetcommand 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.-1means to use a default version.- Specified by:
setTargetVersionin interfaceICookable
-
setCompileErrorHandler
Description copied from interface:IExpressionEvaluatorInstalls anErrorHandlerwhich is invoked during compilation on each error. (By default, the compilation throws aCompileExceptionon the first error and terminates.)If the given
ErrorHandlerthrows aCompileException, then the compilation terminates and the exception is propagated.If the given
ErrorHandlerdoes not throw aCompileExceptionbut 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 aCompileExceptionindicating the number of errors.In other words: The
ErrorHandlermay throw aCompileExceptionor not, but the compilation will definitely throw aCompileExceptionif one or more compile errors have occurred.- Specified by:
setCompileErrorHandlerin interfaceIExpressionEvaluator- Parameters:
compileErrorHandler-nullto restore the default behavior (throwing aCompileException)
-
setWarningHandler
Description copied from interface:IExpressionEvaluatorBy default, warnings are discarded, but an application my install a customWarningHandler.- Specified by:
setWarningHandlerin interfaceIExpressionEvaluator- Parameters:
warningHandler-nullto indicate that no warnings be issued
-
setDefaultImports
Description copied from interface:IExpressionEvaluator"Default imports" add to the system import "java.lang", i.e. the evaluator may refer to classes imported by default imports without having to explicitly declare IMPORT statements.Notice that JDK 5 "static imports" are also supported, as shown here:
sc.setDefaultImports( "java.util.Map", // Single type import "java.io.*", // Type-import-on-demand "static java.util.Collections.EMPTY_MAP", // Single static import "static java.util.Collections.*", // Static-import-on-demand );- Specified by:
setDefaultImportsin interfaceIExpressionEvaluator
-
getDefaultImports
- Specified by:
getDefaultImportsin interfaceIExpressionEvaluator- Returns:
- The default imports that were previously configured with
IExpressionEvaluator.setDefaultImports(String...)
-
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:IExpressionEvaluatorReconfigures 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:
setDefaultExpressionTypein interfaceIExpressionEvaluator
-
getDefaultExpressionType
- Specified by:
getDefaultExpressionTypein interfaceIExpressionEvaluator- Returns:
- The currently configured "default expression type"
- See Also:
-
setImplementedInterfaces
Description copied from interface:IExpressionEvaluatorConfigures the interfaces that the generated class implements.- Specified by:
setImplementedInterfacesin interfaceIExpressionEvaluator
-
setReturnType
- Specified by:
setReturnTypein interfaceIExpressionEvaluator
-
setExpressionType
Description copied from interface:IExpressionEvaluatorDefines the type of the expression.Defaults to
Object.class, which, thanks to autoboxing, allows for any expression type (including primitive types).If
expressionTypeisvoid.class, then the expression must be an invocation of avoidmethod.- Specified by:
setExpressionTypein interfaceIExpressionEvaluator
-
setExpressionTypes
Description copied from interface:IExpressionEvaluatorConfigures 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 avoidmethod.- Specified by:
setExpressionTypesin interfaceIExpressionEvaluator
-
setOverrideMethod
public void setOverrideMethod(boolean overrideMethod) Description copied from interface:IExpressionEvaluatorDefines whether the generated method overrides a methods declared in a supertype.- Specified by:
setOverrideMethodin interfaceIExpressionEvaluator
-
setOverrideMethod
public void setOverrideMethod(boolean[] overrideMethod) Description copied from interface:IExpressionEvaluatorSame asIExpressionEvaluator.setOverrideMethod(boolean), but for multiple expressions.- Specified by:
setOverrideMethodin interfaceIExpressionEvaluator
-
setParameters
Description copied from interface:IExpressionEvaluatorDefines the names and types of the parameters of the generated method.names
.lengthand types.lengthmust be equal. This invariant may be checked immediately, or later when the expression is cooked.The parameters can be of primitive type, e.g.
double.class.The default is to have zero parameters.
- Specified by:
setParametersin interfaceIExpressionEvaluator
-
setParameters
Description copied from interface:IExpressionEvaluatorSame asIExpressionEvaluator.setParameters(String[], Class[]), but for multiple expressions.- Specified by:
setParametersin interfaceIExpressionEvaluator
-
setClassName
Description copied from interface:IExpressionEvaluatorSets the name of the generated class. Defaults toIExpressionEvaluator.DEFAULT_CLASS_NAME. In most cases, there is no need to set this name, because the generated class is loaded into its ownClassLoaderwhere its name cannot collide with classes generated by other evaluators.One reason to use this function is to have a class name in a non-default package, which can be relevant when types and members with DEFAULT accessibility are accessed.
- Specified by:
setClassNamein interfaceIExpressionEvaluator
-
setExtendedClass
Description copied from interface:IExpressionEvaluatorSets a particular superclass that the generated class will extend. If extendedClass isnull, the generated class will extendObject.The usual reason to set a base class for an evaluator is that the generated class can directly access the superclass's (non-private) members.
- Specified by:
setExtendedClassin interfaceIExpressionEvaluator
-
setStaticMethod
public void setStaticMethod(boolean staticMethod) Description copied from interface:IExpressionEvaluatorDefines whether the generated method should be STATIC or not. Defaults totrue.- Specified by:
setStaticMethodin interfaceIExpressionEvaluator
-
setStaticMethod
public void setStaticMethod(boolean[] staticMethod) Description copied from interface:IExpressionEvaluatorSame asIExpressionEvaluator.setStaticMethod(boolean), but for multiple expressions.- Specified by:
setStaticMethodin interfaceIExpressionEvaluator
-
setMethodName
Description copied from interface:IExpressionEvaluatorDefines the name of the generated method. Initially, the method name is "eval*".- Specified by:
setMethodNamein interfaceIExpressionEvaluator- Parameters:
methodName-nullmeans reset to default name- See Also:
-
setMethodNames
Description copied from interface:IExpressionEvaluatorSame asIExpressionEvaluator.setMethodName(String), but for multiple expressions.Define the names of the generated methods. By default the methods have distinct and implementation-specific names.
If two expressions have the same name, then they must have different parameter types (see
IExpressionEvaluator.setParameters(String[][], Class[][])).- Specified by:
setMethodNamesin interfaceIExpressionEvaluator
-
setThrownExceptions
Description copied from interface:IExpressionEvaluatorDefines the exceptions that the generated method may throw.- Specified by:
setThrownExceptionsin interfaceIExpressionEvaluator
-
setThrownExceptions
Description copied from interface:IExpressionEvaluatorSame asIExpressionEvaluator.setThrownExceptions(Class[]), but for multiple expressions.- Specified by:
setThrownExceptionsin interfaceIExpressionEvaluator
-
getMethod
- Specified by:
getMethodin interfaceIExpressionEvaluator- Returns:
- The generated and loaded
Method
-
getMethod
Description copied from interface:IExpressionEvaluatorSame asIExpressionEvaluator.getMethod(), but for multiple expressions.- Specified by:
getMethodin interfaceIExpressionEvaluator
-
getResult
- Specified by:
getResultin interfaceIExpressionEvaluator- Returns:
- The generated method
- Throws:
IllegalStateException- TheScriptEvaluatorhas not yet be cooked
-
cook
Description copied from interface:ICookableReads, scans, parses and compiles Java tokens from the givenReader.- Specified by:
cookin interfaceICookable- Specified by:
cookin classCookable- Parameters:
fileName- Used when reporting errors and warnings- Throws:
CompileExceptionIOException
-
cook
Description copied from interface:IMultiCookableSame 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 thefileNamesparameter to distinguish between the individual token sources.- Specified by:
cookin interfaceIMultiCookable- Specified by:
cookin classMultiCookable- Throws:
CompileExceptionIOException
-
cook
- Throws:
CompileExceptionIOException
-
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 thefileNameargument 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 ofscannersCompileExceptionIOException
-
cook
- Throws:
CompileExceptionIOException- See Also:
-
cook2
- Throws:
CompileExceptionIOException
-
classesToTypes
-
optionalClassToType
-
classToType
-
evaluate
Description copied from interface:IExpressionEvaluatorShorthand forevaluate(new Object[0]).- Specified by:
evaluatein interfaceIExpressionEvaluator- Throws:
InvocationTargetException
-
evaluate
Description copied from interface:IExpressionEvaluatorEvaluates 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.
Nullarguments is equivalent withnew Object[0].Notice: In version 3.1.8, the arguments parameter was changed from
Object[]toObject..., which turned out to be a really bad decision because it caused a very ugly invocation ambiguity withIExpressionEvaluator.evaluate(int, Object[]). Thus, with version 3.1.10, the parameter was changed back toObject[].- Specified by:
evaluatein 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:IExpressionEvaluatorSame asIExpressionEvaluator.evaluate(Object[]), but for multiple expressions.Notice: In version 3.1.8, the arguments parameter was changed from
Object[]toObject..., which turned out to be a really bad decision because it caused a very ugly invocation ambiguity withIExpressionEvaluator.evaluate(int, Object[]). Thus, with version 3.1.10, the parameter was changed back toObject[].- Specified by:
evaluatein interfaceIExpressionEvaluator- Throws:
InvocationTargetException
-
getClazz
- Specified by:
getClazzin interfaceIExpressionEvaluator- Returns:
- The generated
Class
-
getBytecodes
- Specified by:
getBytecodesin 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:
CompileExceptionIOException
-
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:
CompileExceptionIOException
-
createFastEvaluator
public <T> T createFastEvaluator(Reader reader, Class<? extends T> interfaceToImplement, String... parameterNames) throws CompileException, IOException - Specified by:
createFastEvaluatorin interfaceIExpressionEvaluator- Throws:
CompileExceptionIOException- See Also:
-
createFastEvaluator
public <T> T createFastEvaluator(String script, Class<? extends T> interfaceToImplement, String... parameterNames) throws CompileException Description copied from interface:IExpressionEvaluatorIf 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
interfaceToImplementmust be accessible by the compiled class, i.e. either be declaredpublic, or withprotectedor default access in the package of the compiled class (seeIExpressionEvaluator.setClassName(String).- Specified by:
createFastEvaluatorin 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:
CompileExceptionIOException- 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:
CompileExceptionIOException- See Also:
-
guessParameterNames2
- Throws:
CompileExceptionIOException
-
createFastEvaluator(String, Class, String[])instead: