public class ScriptEvaluator extends ClassBodyEvaluator implements IScriptEvaluator
IScriptEvaluator that utilizes the JANINO Java compiler.
This implementation implements the concept of "Local methods", i.e. statements may be freely intermixed with
method declarations. These methods are typically called by the "main code" of the script evaluator. One limitation
exists: When cooking multiple scripts in one ScriptEvaluator, then local method signatures
(names and parameter types) must not collide between scripts.
A plethora of "convenience constructors" exist that execute the setup steps instantly. Their use is discouraged,
in favor of using the default constructor, plus calling a number of setters, and then one of the cook()
methods.
| Modifier and Type | Field and Description |
|---|---|
protected boolean[] |
optionalOverrideMethod
Whether methods override a method declared by a supertype;
null means "none". |
protected Class<?>[] |
optionalReturnTypes
The methods' return types;
null means "none". |
protected boolean[] |
optionalStaticMethod
Whether methods are static;
null means "all". |
DEFAULT_CLASS_NAMEBOOT_CLASS_LOADER, SYSTEM_PROPERTY_SOURCE_DEBUGGING_DIR, SYSTEM_PROPERTY_SOURCE_DEBUGGING_ENABLE| Constructor and Description |
|---|
ScriptEvaluator()
Constructs a script evaluator with all the default settings (return type
void |
ScriptEvaluator(Scanner scanner,
Class<?> optionalExtendedType,
Class<?>[] implementedTypes,
Class<?> returnType,
String[] parameterNames,
Class<?>[] parameterTypes,
Class<?>[] thrownExceptions,
ClassLoader optionalParentClassLoader)
Equivalent to
ScriptEvaluator se = new ScriptEvaluator();
se.setExtendedType(optionalExtendedType);
se.setImplementedTypes(implementedTypes);
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.setParentClassLoader(optionalParentClassLoader);
se.cook(scanner);
|
ScriptEvaluator(Scanner scanner,
Class<?> returnType,
String[] parameterNames,
Class<?>[] parameterTypes,
Class<?>[] thrownExceptions,
ClassLoader optionalParentClassLoader)
Equivalent to
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.setParentClassLoader(optionalParentClassLoader);
se.cook(scanner);
|
ScriptEvaluator(Scanner scanner,
String className,
Class<?> optionalExtendedType,
Class<?>[] implementedTypes,
boolean staticMethod,
Class<?> returnType,
String methodName,
String[] parameterNames,
Class<?>[] parameterTypes,
Class<?>[] thrownExceptions,
ClassLoader optionalParentClassLoader)
Equivalent to
ScriptEvaluator se = new ScriptEvaluator();
se.setClassName(className);
se.setExtendedType(optionalExtendedType);
se.setImplementedTypes(implementedTypes);
se.setStaticMethod(staticMethod);
se.setReturnType(returnType);
se.setMethodName(methodName);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.setParentClassLoader(optionalParentClassLoader);
se.cook(scanner);
|
ScriptEvaluator(String script)
Equivalent to
ScriptEvaluator se = new ScriptEvaluator();
se.cook(script);
|
ScriptEvaluator(String script,
Class<?> returnType)
Equivalent to
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.cook(script);
|
ScriptEvaluator(String script,
Class<?> returnType,
String[] parameterNames,
Class<?>[] parameterTypes)
Equivalent to
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.cook(script);
|
ScriptEvaluator(String script,
Class<?> returnType,
String[] parameterNames,
Class<?>[] parameterTypes,
Class<?>[] thrownExceptions)
Equivalent to
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.cook(script);
|
ScriptEvaluator(String optionalFileName,
InputStream is,
Class<?> returnType,
String[] parameterNames,
Class<?>[] parameterTypes,
Class<?>[] thrownExceptions,
ClassLoader optionalParentClassLoader)
Equivalent to
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.setParentClassLoader(optionalParentClassLoader);
se.cook(optionalFileName, is);
|
ScriptEvaluator(String optionalFileName,
Reader reader,
Class<?> returnType,
String[] parameterNames,
Class<?>[] parameterTypes,
Class<?>[] thrownExceptions,
ClassLoader optionalParentClassLoader)
Equivalent to
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.setParentClassLoader(optionalParentClassLoader);
se.cook(reader);
|
| Modifier and Type | Method and Description |
|---|---|
void |
cook(Parser[] parsers) |
void |
cook(Reader[] readers)
Same as
ICookable.cook(Reader), but for multiple scripts. |
void |
cook(Scanner scanner)
Scans, parses and ompiles a given compilation unit from the given scanner.
|
void |
cook(Scanner[] scanners)
Like
cook(Scanner), but cooks a set of scripts into one class. |
void |
cook(String[] strings)
Same as
ICookable.cook(String), but for multiple scripts. |
void |
cook(String[] optionalFileNames,
Reader[] readers)
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.
|
void |
cook(String[] optionalFileNames,
String[] strings)
Same as
ICookable.cook(String, String), but for multiple scripts. |
<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.
|
Object |
createFastEvaluator(Scanner scanner,
Class<?> interfaceToImplement,
String[] parameterNames)
Notice: This method is not declared in
IScriptEvaluator, and is hence only available in this
implementation of org.codehaus.commons.compiler. |
<T> Object |
createFastEvaluator(String script,
Class<T> interfaceToImplement,
String[] parameterNames) |
static Object |
createFastScriptEvaluator(Scanner scanner,
Class<?> interfaceToImplement,
String[] parameterNames,
ClassLoader optionalParentClassLoader)
Deprecated.
|
static Object |
createFastScriptEvaluator(Scanner scanner,
String[] optionalDefaultImports,
String className,
Class<?> optionalExtendedClass,
Class<?> interfaceToImplement,
String[] parameterNames,
ClassLoader optionalParentClassLoader)
Deprecated.
Use
createFastEvaluator(Scanner,Class,String[]) instead: |
static Object |
createFastScriptEvaluator(Scanner scanner,
String className,
Class<?> optionalExtendedType,
Class<?> interfaceToImplement,
String[] parameterNames,
ClassLoader optionalParentClassLoader)
Deprecated.
|
static Object |
createFastScriptEvaluator(String script,
Class<?> interfaceToImplement,
String[] parameterNames)
Deprecated.
|
Object |
createInstance(Reader reader)
Don't use.
|
Object |
evaluate(int idx,
Object[] arguments)
Same as
IScriptEvaluator.evaluate(Object[]), but for multiple scripts. |
Object |
evaluate(Object[] arguments)
Calls the script with concrete parameter values.
|
protected Class<?> |
getDefaultReturnType() |
Method |
getMethod()
Returns the loaded
Method. |
Method |
getMethod(int idx)
Same as
IScriptEvaluator.getMethod(), but for multiple scripts. |
protected Class<?> |
getReturnType(int i) |
static String[] |
guessParameterNames(Scanner scanner)
Guesses the names of the parameters used in the given expression.
|
protected Java.MethodDeclarator |
makeMethodDeclaration(Location location,
Java.Annotation[] annotations,
boolean staticMethod,
Class<?> returnType,
String methodName,
Class<?>[] parameterTypes,
String[] parameterNames,
Class<?>[] thrownExceptions,
List<Java.BlockStatement> statements)
To the given
Java.AbstractClassDeclaration, adds
A public method declaration with the given return type, name, parameter names and values and thrown
exceptions
A block
|
protected List<Java.BlockStatement> |
makeStatements(int idx,
Parser parser) |
protected void |
parseScript(Parser parser,
List<Java.BlockStatement> mainStatements,
List<Java.MethodDeclarator> localMethods)
Fills the given
block by parsing statements until EOF and adding them to the block. |
void |
setMethodName(String methodName)
Defines the name of the generated method.
|
void |
setMethodNames(String[] methodNames)
Same as
IScriptEvaluator.setMethodName(String), but for multiple scripts. |
void |
setOverrideMethod(boolean overrideMethod)
Defines whether the generated method overrides a methods declared in a supertype.
|
void |
setOverrideMethod(boolean[] overrideMethod)
Same as
IScriptEvaluator.setOverrideMethod(boolean), but for multiple scripts. |
void |
setParameters(String[][] parameterNames,
Class<?>[][] parameterTypes)
Same as
IScriptEvaluator.setParameters(String[], Class[]), but for multiple scripts. |
void |
setParameters(String[] parameterNames,
Class<?>[] parameterTypes)
Defines the names and types of the parameters of the generated method.
|
void |
setReturnType(Class<?> returnType)
Defines the return types of the generated methods.
|
void |
setReturnTypes(Class<?>[] returnTypes)
Defines the return types of the generated methods.
|
void |
setStaticMethod(boolean staticMethod)
Defines whether the generated method should be STATIC or not.
|
void |
setStaticMethod(boolean[] staticMethod)
Same as
IScriptEvaluator.setStaticMethod(boolean), but for multiple scripts. |
void |
setThrownExceptions(Class<?>[] thrownExceptions)
Defines sthe exceptions that the generated method may throw.
|
void |
setThrownExceptions(Class<?>[][] thrownExceptions)
Same as
IScriptEvaluator.setThrownExceptions(Class[]), but for multiple scripts. |
addPackageMemberClassDeclaration, compileToClass, createFastClassBodyEvaluator, createFastClassBodyEvaluator, getClazz, makeCompilationUnit, setClassName, setDefaultImports, setExtendedClass, setExtendedType, setImplementedInterfaces, setImplementedTypesassertNotCooked, classesToTypes, classToType, compileToClassLoader, cook, cook, equals, getClassLoader, hashCode, main, optionalClassToType, setCompileErrorHandler, setDebuggingInformation, setParentClassLoader, setWarningHandlercook, cook, cook, cook, cook, cook, cook, cookFile, cookFile, cookFile, cookFile, readStringclone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitgetClazz, setClassName, setDefaultImports, setExtendedClass, setExtendedType, setImplementedInterfaces, setImplementedTypescook, cook, cook, cook, cook, cook, cook, cook, cookFile, cookFile, cookFile, cookFile, setCompileErrorHandler, setDebuggingInformation, setParentClassLoader, setWarningHandler@Nullable protected boolean[] optionalOverrideMethod
null means "none".@Nullable protected boolean[] optionalStaticMethod
null means "all".public ScriptEvaluator(String script) throws CompileException
ScriptEvaluator se = new ScriptEvaluator();
se.cook(script);
CompileExceptionScriptEvaluator(),
Cookable.cook(String)public ScriptEvaluator(String script, Class<?> returnType) throws CompileException
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.cook(script);
CompileExceptionScriptEvaluator(),
setReturnType(Class),
Cookable.cook(String)public ScriptEvaluator(String script, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes) throws CompileException
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.cook(script);
public ScriptEvaluator(String script, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions) throws CompileException
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.cook(script);
public ScriptEvaluator(@Nullable String optionalFileName, InputStream is, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader optionalParentClassLoader) throws CompileException, IOException
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.setParentClassLoader(optionalParentClassLoader);
se.cook(optionalFileName, is);
public ScriptEvaluator(@Nullable String optionalFileName, Reader reader, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader optionalParentClassLoader) throws CompileException, IOException
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.setParentClassLoader(optionalParentClassLoader);
se.cook(reader);
public ScriptEvaluator(Scanner scanner, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader optionalParentClassLoader) throws CompileException, IOException
ScriptEvaluator se = new ScriptEvaluator();
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.setParentClassLoader(optionalParentClassLoader);
se.cook(scanner);
public ScriptEvaluator(Scanner scanner, @Nullable Class<?> optionalExtendedType, Class<?>[] implementedTypes, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader optionalParentClassLoader) throws CompileException, IOException
ScriptEvaluator se = new ScriptEvaluator();
se.setExtendedType(optionalExtendedType);
se.setImplementedTypes(implementedTypes);
se.setReturnType(returnType);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.setParentClassLoader(optionalParentClassLoader);
se.cook(scanner);
CompileExceptionIOExceptionScriptEvaluator(),
ClassBodyEvaluator.setExtendedClass(Class),
ClassBodyEvaluator.setImplementedInterfaces(Class[]),
setReturnType(Class),
setParameters(String[], Class[]),
setThrownExceptions(Class[]),
SimpleCompiler.setParentClassLoader(ClassLoader),
Cookable.cook(Reader)public ScriptEvaluator(Scanner scanner, String className, @Nullable Class<?> optionalExtendedType, Class<?>[] implementedTypes, boolean staticMethod, Class<?> returnType, String methodName, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader optionalParentClassLoader) throws CompileException, IOException
ScriptEvaluator se = new ScriptEvaluator();
se.setClassName(className);
se.setExtendedType(optionalExtendedType);
se.setImplementedTypes(implementedTypes);
se.setStaticMethod(staticMethod);
se.setReturnType(returnType);
se.setMethodName(methodName);
se.setParameters(parameterNames, parameterTypes);
se.setThrownExceptions(thrownExceptions);
se.setParentClassLoader(optionalParentClassLoader);
se.cook(scanner);
CompileExceptionIOExceptionScriptEvaluator(),
ClassBodyEvaluator.setClassName(String),
ClassBodyEvaluator.setExtendedClass(Class),
ClassBodyEvaluator.setImplementedInterfaces(Class[]),
setStaticMethod(boolean),
setReturnType(Class),
setMethodName(String),
setParameters(String[], Class[]),
setThrownExceptions(Class[]),
SimpleCompiler.setParentClassLoader(ClassLoader),
Cookable.cook(Reader)public ScriptEvaluator()
voidpublic void setOverrideMethod(boolean overrideMethod)
IScriptEvaluatorsetOverrideMethod in interface IScriptEvaluatorpublic void setStaticMethod(boolean staticMethod)
IScriptEvaluatortrue.setStaticMethod in interface IScriptEvaluatorpublic void setReturnType(Class<?> returnType)
setReturnType in interface IScriptEvaluatorreturnType - The method's return type; null means the "default return type", which is the type
returned by getDefaultReturnType() (void.class for ScriptEvaluator
and Object.class for ExpressionEvaluator)getDefaultReturnType(),
ExpressionEvaluator.getDefaultReturnType()public void setMethodName(String methodName)
IScriptEvaluatorsetMethodName in interface IScriptEvaluatorpublic void setParameters(String[] parameterNames, Class<?>[] parameterTypes)
IScriptEvaluatornames and types must have the same number of elements.
The parameters can be of primitive type, e.g. double.class.
The default is to have zero parameters.
setParameters in interface IScriptEvaluatorpublic void setThrownExceptions(Class<?>[] thrownExceptions)
IScriptEvaluatorsetThrownExceptions in interface IScriptEvaluatorpublic final void cook(Scanner scanner) throws CompileException, IOException
SimpleCompilerSimpleCompiler.getClassLoader() returns a ClassLoader that allows for access to the compiled classes.cook in class ClassBodyEvaluatorCompileExceptionIOException@Nullable public Object evaluate(@Nullable Object[] arguments) throws InvocationTargetException
IScriptEvaluator
Each argument 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 IScriptEvaluator.setReturnType(Class).
This method is thread-safe.
evaluate in interface IScriptEvaluatorarguments - The actual parameter valuesInvocationTargetExceptionpublic Method getMethod()
IScriptEvaluatorMethod.
This method must only be called after exactly one of the ICookable.cook(String, Reader) methods was called.
getMethod in interface IScriptEvaluatorpublic void setOverrideMethod(boolean[] overrideMethod)
IScriptEvaluatorIScriptEvaluator.setOverrideMethod(boolean), but for multiple scripts.setOverrideMethod in interface IScriptEvaluatorpublic void setStaticMethod(boolean[] staticMethod)
IScriptEvaluatorIScriptEvaluator.setStaticMethod(boolean), but for multiple scripts.setStaticMethod in interface IScriptEvaluatorpublic void setReturnTypes(Class<?>[] returnTypes)
setReturnTypes in interface IScriptEvaluatorreturnTypes - The methods' return types; null elements mean the "default return type", which is the
type returned by getDefaultReturnType() (void.class for ScriptEvaluator and Object.class for ExpressionEvaluator)getDefaultReturnType(),
ExpressionEvaluator.getDefaultReturnType()public void setMethodNames(String[] methodNames)
IScriptEvaluatorIScriptEvaluator.setMethodName(String), but for multiple scripts.
Define the names of the generated methods. By default the methods have distinct and implementation-specific names.
If two scripts have the same name, then they must have different parameter types (see IScriptEvaluator.setParameters(String[][], Class[][])).
setMethodNames in interface IScriptEvaluatorpublic void setParameters(String[][] parameterNames, Class<?>[][] parameterTypes)
IScriptEvaluatorIScriptEvaluator.setParameters(String[], Class[]), but for multiple scripts.setParameters in interface IScriptEvaluatorpublic void setThrownExceptions(Class<?>[][] thrownExceptions)
IScriptEvaluatorIScriptEvaluator.setThrownExceptions(Class[]), but for multiple scripts.setThrownExceptions in interface IScriptEvaluatorpublic final void cook(Scanner[] scanners) throws CompileException, IOException
cook(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 the optionalFileName argument of Scanner.Scanner(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.
IllegalStateException - Any of the preceeding set...() had an array size different from that
of scannersCompileExceptionIOExceptionpublic final void cook(Parser[] parsers) throws CompileException, IOException
CompileExceptionIOExceptioncook(Scanner[])public final void cook(Reader[] readers) throws CompileException, IOException
IScriptEvaluatorICookable.cook(Reader), but for multiple scripts.cook in interface IScriptEvaluatorCompileExceptionIOExceptionpublic final void cook(@Nullable String[] optionalFileNames, Reader[] readers) throws CompileException, IOException
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.
cook in interface IScriptEvaluatorCompileExceptionIOExceptionpublic final void cook(String[] strings) throws CompileException
IScriptEvaluatorICookable.cook(String), but for multiple scripts.cook in interface IScriptEvaluatorCompileExceptionpublic final void cook(@Nullable String[] optionalFileNames, String[] strings) throws CompileException
IScriptEvaluatorICookable.cook(String, String), but for multiple scripts.cook in interface IScriptEvaluatorCompileExceptionprotected Class<?> getDefaultReturnType()
void.classsetReturnTypes(Class[])protected final Class<?> getReturnType(int i)
@Nullable protected List<Java.BlockStatement> makeStatements(int idx, Parser parser) throws CompileException, IOException
CompileExceptionIOExceptionprotected void parseScript(Parser parser, List<Java.BlockStatement> mainStatements, List<Java.MethodDeclarator> localMethods) throws CompileException, IOException
block by parsing statements until EOF and adding them to the block.CompileExceptionIOExceptionprotected Java.MethodDeclarator makeMethodDeclaration(Location location, Java.Annotation[] annotations, boolean staticMethod, Class<?> returnType, String methodName, Class<?>[] parameterTypes, String[] parameterNames, Class<?>[] thrownExceptions, List<Java.BlockStatement> statements)
Java.AbstractClassDeclaration, adds
returnType - Return type of the declared method@Deprecated public static Object createFastScriptEvaluator(String script, Class<?> interfaceToImplement, String[] parameterNames) throws CompileException
createFastScriptEvaluator(Scanner, String[], String, Class, Class, String[],
ClassLoader) insteadCompileException@Deprecated public static Object createFastScriptEvaluator(Scanner scanner, Class<?> interfaceToImplement, String[] parameterNames, @Nullable ClassLoader optionalParentClassLoader) throws CompileException, IOException
createFastScriptEvaluator(Scanner, String[], String, Class, Class, String[],
ClassLoader) insteadCompileExceptionIOException@Deprecated public static Object createFastScriptEvaluator(Scanner scanner, String className, @Nullable Class<?> optionalExtendedType, Class<?> interfaceToImplement, String[] parameterNames, @Nullable ClassLoader optionalParentClassLoader) throws CompileException, IOException
createFastScriptEvaluator(Scanner, String[], String, Class, Class, String[],
ClassLoader) insteadCompileExceptionIOException@Deprecated public static Object createFastScriptEvaluator(Scanner scanner, @Nullable String[] optionalDefaultImports, String className, @Nullable Class<?> optionalExtendedClass, Class<?> interfaceToImplement, String[] parameterNames, @Nullable ClassLoader optionalParentClassLoader) throws CompileException, IOException
createFastEvaluator(Scanner,Class,String[]) instead:
ScriptEvaluator se = new ScriptEvaluator();
se.setDefaultImports.(optionalDefaultImports);
se.setClassName.(className);
se.setExtendedClass.(optionalExtendedClass);
se.setParentClassLoader(optionalParentClassLoader);
return se.createFastEvaluator(scanner,
interfaceToImplement, parameterNames);
CompileExceptionIOExceptionpublic final Object createInstance(Reader reader)
createInstance in interface IClassBodyEvaluatorcreateInstance in class ClassBodyEvaluatorreader - Source of class body tokensoptionalExtendedType and implements the given
implementedTypespublic <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 IScriptEvaluatorreader - Produces the stream of script tokensinterfaceToImplement - Must declare exactly one methodparameterNames - The names of the parameters of that methodCompileExceptionIOExceptionpublic <T> Object createFastEvaluator(String script, Class<T> interfaceToImplement, String[] parameterNames) throws CompileException
createFastEvaluator in interface IScriptEvaluatorscript - Contains the sequence of script tokensCompileExceptionIScriptEvaluator.createFastEvaluator(Reader, Class, String[])public Object createFastEvaluator(Scanner scanner, Class<?> interfaceToImplement, String[] parameterNames) throws CompileException, IOException
IScriptEvaluator, and is hence only available in this
implementation of org.codehaus.commons.compiler. To be independent from this particular
implementation, try to switch to createFastEvaluator(Reader, Class, String[]).scanner - Source of tokens to readCompileExceptionIOExceptioncreateFastEvaluator(Reader, Class, String[])public static String[] guessParameterNames(Scanner scanner) throws CompileException, IOException
CompileExceptionIOExceptionScanner.Scanner(String, Reader)@Nullable public Object evaluate(int idx, @Nullable Object[] arguments) throws InvocationTargetException
IScriptEvaluatorIScriptEvaluator.evaluate(Object[]), but for multiple scripts.evaluate in interface IScriptEvaluatorInvocationTargetExceptionpublic Method getMethod(int idx)
IScriptEvaluatorIScriptEvaluator.getMethod(), but for multiple scripts.getMethod in interface IScriptEvaluator