ExpressionEvaluator (janino 3.1.6 API)

java.lang.Object
- org.codehaus.commons.compiler.Cookable
- - org.codehaus.commons.compiler.MultiCookable
  - - org.codehaus.janino.ExpressionEvaluator

All Implemented Interfaces:

ICookable, IExpressionEvaluator, IMultiCookable
```
public class ExpressionEvaluator
extends MultiCookable
implements IExpressionEvaluator
```
This 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

	Server JVM	Client JVM
Normal EE	23.7 ns	64.0 ns
Fast EE	31.2 ns	42.2 ns

Field Summary
- Fields inherited from interface org.codehaus.commons.compiler.IExpressionEvaluator
  ANY_TYPE, DEFAULT_CLASS_NAME, DEFAULT_EXPRESSION_TYPE

Constructor Summary

Constructors
Constructor and Description
`ExpressionEvaluator()`
`ExpressionEvaluator(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.
`ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes)` Equivalent to ExpressionEvaluator ee = new ExpressionEvaluator(); ee.setExpressionType(expressionType); ee.setParameters(parameterNames, parameterTypes); ee.cook(expression);
`ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, Class<?> extendedClass, Class<?>[] implementedTypes, ClassLoader parentClassLoader)` Equivalent to ExpressionEvaluator 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);
`ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader)` Equivalent to ExpressionEvaluator ee = new ExpressionEvaluator(); ee.setExpressionType(expressionType); ee.setParameters(parameterNames, parameterTypes); ee.setThrownExceptions(thrownExceptions); ee.setParentClassLoader(parentClassLoader); ee.cook(expression);

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected Java.Type[]`	`classesToTypes(Location location, Class<?>... classes)` Converts an array of `Class`es into an array of`Java.Type`s.
`protected Java.Type`	`classToType(Location location, Class<?> clazz)` Wraps a reflection `Class` in a `Java.Type` object.
`void`	`cook(Parser... parsers)`
`void`	`cook(Scanner... scanners)` Like `cook(Scanner)`, but cooks a set of scripts into one class.
`void`	`cook(Scanner scanner)`
`void`	`cook(String[] fileNames, Reader[] readers)`
`void`	`cook(String fileName, Reader reader)`
`<T> T`	`createFastEvaluator(Reader reader, Class<? extends T> interfaceToImplement, String... parameterNames)`
`<T> T`	`createFastEvaluator(Scanner scanner, Class<T> 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> T`	`createFastEvaluator(String script, Class<? extends T> interfaceToImplement, String... parameterNames)`
`static Object`	`createFastExpressionEvaluator(Scanner scanner, String[] defaultImports, String className, Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)` Deprecated. Use `createFastEvaluator(Reader, Class, String[])` instead
`static Object`	`createFastExpressionEvaluator(Scanner scanner, String className, Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)` Deprecated. Use `createFastEvaluator(Reader, Class, String[])` instead
`static Object`	`createFastExpressionEvaluator(String expression, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)` Deprecated. Use `createFastEvaluator(String, Class, String[])` instead:
`Object`	`evaluate(int idx, Object... arguments)`
`Object`	`evaluate(Object... arguments)`
`Map<String,byte[]>`	`getBytecodes()`
`Class<?>`	`getClazz()`
`Class<?>`	`getDefaultExpressionType()`
`String[]`	`getDefaultImports()`
`Method`	`getMethod()`
`Method`	`getMethod(int idx)`
`Method[]`	`getResult()`
`static String[]`	`guessParameterNames(Scanner scanner)` Guess the names of the parameters used in the given expression.
`protected Java.Type`	`optionalClassToType(Location location, Class<?> clazz)` Wraps a reflection `Class` in a `Java.Type` object.
`EnumSet<JaninoOption>`	`options()`
`ExpressionEvaluator`	`options(EnumSet<JaninoOption> options)` Sets the options for all future compilations.
`void`	`setClassName(String className)`
`void`	`setCompileErrorHandler(ErrorHandler compileErrorHandler)`
`void`	`setDebuggingInformation(boolean debugSource, boolean debugLines, boolean debugVars)`
`void`	`setDefaultExpressionType(Class<?> defaultExpressionType)`
`void`	`setDefaultImports(String... defaultImports)`
`void`	`setExpressionType(Class<?> expressionType)`
`void`	`setExpressionTypes(Class<?>[] expressionTypes)`
`void`	`setExtendedClass(Class<?> extendedType)`
`void`	`setImplementedInterfaces(Class<?>[] implementedTypes)`
`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)`
`void`	`setReturnType(Class<?> returnType)`
`void`	`setSourceVersion(int version)`
`void`	`setStaticMethod(boolean staticMethod)`
`void`	`setStaticMethod(boolean[] staticMethod)`
`void`	`setTargetVersion(int version)`
`void`	`setThrownExceptions(Class<?>[] thrownExceptions)`
`void`	`setThrownExceptions(Class<?>[][] thrownExceptions)`
`void`	`setWarningHandler(WarningHandler warningHandler)`

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

Methods inherited from interface org.codehaus.commons.compiler.ICookable
cook, cook, cook, cook, cook, cook, cook, cookFile, cookFile, cookFile, cookFile

Methods inherited from interface org.codehaus.commons.compiler.IMultiCookable
cook, cook, cook, cook, cook, cook, cook, cookFiles, cookFiles, cookFiles, cookFiles

Constructor Detail

ExpressionEvaluator

public ExpressionEvaluator(String expression,
                           Class<?> expressionType,
                           String[] parameterNames,
                           Class<?>[] parameterTypes)
                    throws CompileException

Equivalent to

     ExpressionEvaluator ee = new ExpressionEvaluator();
     ee.setExpressionType(expressionType);
     ee.setParameters(parameterNames, parameterTypes);
     ee.cook(expression);

Throws:: CompileException
See Also:: ExpressionEvaluator(), setExpressionType(Class), ScriptEvaluator.setParameters(String[], Class[]), Cookable.cook(String)

ExpressionEvaluator

public ExpressionEvaluator(String expression,
                           Class<?> expressionType,
                           String[] parameterNames,
                           Class<?>[] parameterTypes,
                           Class<?>[] thrownExceptions,
                           @Nullable
                           ClassLoader parentClassLoader)
                    throws CompileException

Equivalent to

     ExpressionEvaluator ee = new ExpressionEvaluator();
     ee.setExpressionType(expressionType);
     ee.setParameters(parameterNames, parameterTypes);
     ee.setThrownExceptions(thrownExceptions);
     ee.setParentClassLoader(parentClassLoader);
     ee.cook(expression);

Throws:: CompileException
See Also:: ExpressionEvaluator(), setExpressionType(Class), ScriptEvaluator.setParameters(String[], Class[]), ScriptEvaluator.setThrownExceptions(Class[]), SimpleCompiler.setParentClassLoader(ClassLoader), Cookable.cook(String)

ExpressionEvaluator

public ExpressionEvaluator(String expression,
                           Class<?> expressionType,
                           String[] parameterNames,
                           Class<?>[] parameterTypes,
                           Class<?>[] thrownExceptions,
                           Class<?> extendedClass,
                           Class<?>[] implementedTypes,
                           @Nullable
                           ClassLoader parentClassLoader)
                    throws CompileException

Equivalent to

     ExpressionEvaluator 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 Detail

setParentClassLoader

public void setParentClassLoader(@Nullable
                                 ClassLoader parentClassLoader)

Specified by:: setParentClassLoader in interface IExpressionEvaluator

setDebuggingInformation

public void setDebuggingInformation(boolean debugSource,
                                    boolean debugLines,
                                    boolean debugVars)

Specified by:: setDebuggingInformation in interface IExpressionEvaluator

setSourceVersion
```
public void setSourceVersion(int version)
```
Specified by:

setSourceVersion in interface ICookable

setTargetVersion
```
public void setTargetVersion(int version)
```
Specified by:

setTargetVersion in interface ICookable

setCompileErrorHandler

public void setCompileErrorHandler(@Nullable
                                   ErrorHandler compileErrorHandler)

Specified by:: setCompileErrorHandler in interface IExpressionEvaluator

setWarningHandler

public void setWarningHandler(@Nullable
                              WarningHandler warningHandler)

Specified by:: setWarningHandler in interface IExpressionEvaluator

setDefaultImports
```
public void setDefaultImports(String... defaultImports)
```
Specified by:

setDefaultImports in interface IExpressionEvaluator

getDefaultImports
```
public String[] getDefaultImports()
```
Specified by:

getDefaultImports in interface IExpressionEvaluator

options
```
public EnumSet<JaninoOption> options()
```
Returns:

A reference to the currently effective compilation options; changes to it take effect immediately

options

public ExpressionEvaluator options(EnumSet<JaninoOption> options)

Sets the options for all future compilations.

setDefaultExpressionType
```
public void setDefaultExpressionType(Class<?> defaultExpressionType)
```
Specified by:

setDefaultExpressionType in interface IExpressionEvaluator

getDefaultExpressionType
```
public Class<?> getDefaultExpressionType()
```
Specified by:

getDefaultExpressionType in interface IExpressionEvaluator

setImplementedInterfaces
```
public void setImplementedInterfaces(Class<?>[] implementedTypes)
```
Specified by:

setImplementedInterfaces in interface IExpressionEvaluator

setReturnType
```
public void setReturnType(Class<?> returnType)
```
Specified by:

setReturnType in interface IExpressionEvaluator

setExpressionType
```
public void setExpressionType(Class<?> expressionType)
```
Specified by:

setExpressionType in interface IExpressionEvaluator

setExpressionTypes
```
public void setExpressionTypes(Class<?>[] expressionTypes)
```
Specified by:

setExpressionTypes in interface IExpressionEvaluator

setOverrideMethod
```
public void setOverrideMethod(boolean overrideMethod)
```
Specified by:

setOverrideMethod in interface IExpressionEvaluator

setOverrideMethod
```
public void setOverrideMethod(boolean[] overrideMethod)
```
Specified by:

setOverrideMethod in interface IExpressionEvaluator

setParameters

public void setParameters(String[] parameterNames,
                          Class<?>[] parameterTypes)

Specified by:: setParameters in interface IExpressionEvaluator

setParameters

public void setParameters(String[][] parameterNames,
                          Class<?>[][] parameterTypes)

Specified by:: setParameters in interface IExpressionEvaluator

setClassName
```
public void setClassName(String className)
```
Specified by:

setClassName in interface IExpressionEvaluator

setExtendedClass

public void setExtendedClass(@Nullable
                             Class<?> extendedType)

Specified by:: setExtendedClass in interface IExpressionEvaluator

setStaticMethod
```
public void setStaticMethod(boolean staticMethod)
```
Specified by:

setStaticMethod in interface IExpressionEvaluator

setStaticMethod
```
public void setStaticMethod(boolean[] staticMethod)
```
Specified by:

setStaticMethod in interface IExpressionEvaluator

setMethodName
```
public void setMethodName(String methodName)
```
Specified by:

setMethodName in interface IExpressionEvaluator

setMethodNames
```
public void setMethodNames(String[] methodNames)
```
Specified by:

setMethodNames in interface IExpressionEvaluator

setThrownExceptions
```
public void setThrownExceptions(Class<?>[] thrownExceptions)
```
Specified by:

setThrownExceptions in interface IExpressionEvaluator

setThrownExceptions
```
public void setThrownExceptions(Class<?>[][] thrownExceptions)
```
Specified by:

setThrownExceptions in interface IExpressionEvaluator

getMethod
```
public Method getMethod()
```
Specified by:

getMethod in interface IExpressionEvaluator

getMethod
```
public Method getMethod(int idx)
```
Specified by:

getMethod in interface IExpressionEvaluator

getResult
```
public Method[] getResult()
```
Specified by:

getResult in interface IExpressionEvaluator

Returns:

The generated method

Throws:

IllegalStateException - The ScriptEvaluator has not yet be cooked

cook

public void cook(@Nullable
                 String fileName,
                 Reader reader)
          throws CompileException,
                 IOException

Specified by:: cook in interface ICookable
Specified by:: cook in class Cookable
Throws:: CompileException; IOException

cook

public void cook(String[] fileNames,
                 Reader[] readers)
          throws CompileException,
                 IOException

Specified by:: cook in interface IMultiCookable
Specified by:: cook in class MultiCookable
Throws:: CompileException; IOException

cook

public final void cook(Scanner scanner)
                throws CompileException,
                       IOException

Throws:: CompileException; IOException

cook
```
public final void cook(Scanner... scanners)
                throws CompileException,
                       IOException
```
Like 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 fileName argument of 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.

Throws:

IllegalStateException - Any of the preceding set...() had an array size different from that of scanners

CompileException

IOException

cook

public final void cook(Parser... parsers)
                throws CompileException,
                       IOException

Throws:: CompileException; IOException
See Also:: cook(Scanner[])

classesToTypes

protected Java.Type[] classesToTypes(Location location,
                                     @Nullable
                                     Class<?>... classes)

Converts an array of Classes into an array ofJava.Types.

optionalClassToType

@Nullable
protected Java.Type optionalClassToType(Location location,
                                                   @Nullable
                                                   Class<?> clazz)

Wraps a reflection Class in a Java.Type object.

classToType

protected Java.Type classToType(Location location,
                                Class<?> clazz)

Wraps a reflection Class in a Java.Type object.

evaluate

@Nullable
public Object evaluate(@Nullable
                                  Object... arguments)
                           throws InvocationTargetException

Specified by:: evaluate in interface IExpressionEvaluator
Throws:: InvocationTargetException

evaluate

@Nullable
public Object evaluate(int idx,
                                  @Nullable
                                  Object... arguments)
                           throws InvocationTargetException

Specified by:: evaluate in interface IExpressionEvaluator
Throws:: InvocationTargetException

getClazz
```
public Class<?> getClazz()
```
Specified by:

getClazz in interface IExpressionEvaluator

getBytecodes
```
public Map<String,byte[]> getBytecodes()
```
Specified by:

getBytecodes in interface ICookable

createFastExpressionEvaluator

@Deprecated
public static Object createFastExpressionEvaluator(String expression,
                                                                Class<?> interfaceToImplement,
                                                                String[] parameterNames,
                                                                @Nullable
                                                                ClassLoader parentClassLoader)
                                                         throws CompileException

Deprecated. Use createFastEvaluator(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. Use createFastEvaluator(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. Use createFastEvaluator(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 interface IExpressionEvaluator
Throws:: CompileException; IOException

createFastEvaluator

public <T> T createFastEvaluator(String script,
                                 Class<? extends T> interfaceToImplement,
                                 String... parameterNames)
                          throws CompileException

Specified by:: createFastEvaluator in interface IExpressionEvaluator
Throws:: CompileException

createFastEvaluator
```
public <T> T createFastEvaluator(Scanner scanner,
                                 Class<T> interfaceToImplement,
                                 String... parameterNames)
                          throws CompileException,
                                 IOException
```
Notice: This method is not declared in 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[]).

Parameters:

scanner - Source of tokens to read

Throws:

CompileException

IOException

See Also:

createFastEvaluator(Reader, Class, String[])

guessParameterNames
```
public static String[] guessParameterNames(Scanner scanner)
                                    throws CompileException,
                                           IOException
```
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:

Scanner(String, Reader)

Class ExpressionEvaluator

Field Summary

Fields inherited from interface org.codehaus.commons.compiler.IExpressionEvaluator

Constructor Summary

Method Summary

Methods inherited from class org.codehaus.commons.compiler.MultiCookable

Methods inherited from class org.codehaus.commons.compiler.Cookable

Methods inherited from class java.lang.Object

Methods inherited from interface org.codehaus.commons.compiler.ICookable

Methods inherited from interface org.codehaus.commons.compiler.IMultiCookable

Constructor Detail

ExpressionEvaluator

ExpressionEvaluator

ExpressionEvaluator

ExpressionEvaluator

ExpressionEvaluator

Method Detail

setParentClassLoader

setDebuggingInformation

setSourceVersion

setTargetVersion

setCompileErrorHandler

setWarningHandler

setDefaultImports

getDefaultImports

options

options

setDefaultExpressionType

getDefaultExpressionType

setImplementedInterfaces

setReturnType

setExpressionType

setExpressionTypes

setOverrideMethod

setOverrideMethod

setParameters

setParameters

setClassName

setExtendedClass

setStaticMethod

setStaticMethod

setMethodName

setMethodNames

setThrownExceptions

setThrownExceptions

getMethod

getMethod

getResult

cook

cook

cook

cook

cook

classesToTypes

optionalClassToType

classToType

evaluate

evaluate

getClazz

getBytecodes

createFastExpressionEvaluator

createFastExpressionEvaluator

createFastExpressionEvaluator

createFastEvaluator

createFastEvaluator

createFastEvaluator

guessParameterNames