droolsscriptevaluator.java

rule engine drools-2.0-beta-18

package org.drools.semantics.java;

import net.janino.EvaluatorBase;
import net.janino.Java;
import net.janino.Mod;
import net.janino.Parser;
import net.janino.Scanner;
import net.janino.util.PrimitiveWrapper;
import net.janino.DebuggingInformation;

import org.drools.rule.Declaration;
import org.drools.semantics.base.ClassObjectType;
import org.drools.spi.ObjectType;

import java.io.IOException;
import java.io.StringReader;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

public class DroolsScriptEvaluator extends EvaluatorBase
{

    private final Method method;

    public Method getMethod()
    {
        return this.method;
    }

    public DroolsScriptEvaluator(String code,
                                 Class interfaceToImplement,
                                 String[] parameterNames,
                                 Declaration[] declarations,
                                 Set imports,
                                 Map applicationData ) throws Scanner.ScanException,
                                                     Parser.ParseException,
                                                     Java.CompileException,
                                                     IOException
    {
        super( null );
        Scanner scanner = new Scanner( null, new StringReader( code ) );

        Method[] methods = interfaceToImplement.getDeclaredMethods( );
        if ( methods.length != 1 ) throw new RuntimeException(
                                                               "Interface \""
                                                                                                                                                                                                                                                            + interfaceToImplement
                                                                                                                                                                                                                                                            + "\" must declare exactly one method" );
        Method methodToImplement = methods[0];
        String methodName = methodToImplement.getName( );
        Class[] parameterTypes = methodToImplement.getParameterTypes( );

        if ( parameterNames.length != parameterTypes.length ) throw new RuntimeException(
                                                                                          "Lengths of \"parameterNames\" and \"parameterTypes\" do not match" );

        // Create a temporary compilation unit.
        Java.CompilationUnit compilationUnit = new Java.CompilationUnit(
                                                                         scanner
                                                                                .peek( )
                                                                                .getLocation( )
                                                                                .getFileName( ) );

        // Parse import declarations.
        this.parseImportDeclarations( compilationUnit, scanner );

        // Create class, method and block.
        Java.Block block = this
                               .addClassMethodBlockDeclaration(
                                                                scanner
                                                                       .peek( )
                                                                       .getLocation( ), // location
                                                                compilationUnit, // compilationUnit
                                                                "DroolsConsequence", // className
                                                                null, // optionalExtendedType
                                                                new Class[]{interfaceToImplement}, // implementedTypes
                                                                false, // staticMethod
                                                                methodToImplement
                                                                                 .getReturnType( ), // returnType
                                                                methodName, // methodName
                                                                parameterNames, // parameterNames
                                                                parameterTypes, // parameterTypes
                                                                methodToImplement
                                                                                 .getExceptionTypes( ) // thrownExceptions
                               );

        // Parse block statements.
        Parser parser = new Parser( scanner );

        //block.addStatement(
        addDeclarations( scanner, block, declarations, imports );
        addAppData( scanner, block, imports, applicationData );

        Scanner.Location loc = scanner.peek( ).getLocation( );
        Iterator it = imports.iterator( );
        String type;
        List list;
        StringTokenizer st;
        String token;
        boolean importOnDemand;
        while ( it.hasNext( ) )
        {
            importOnDemand = false;
            list = new ArrayList( );
            type = (String) it.next( );
            st = new StringTokenizer( type, "." );
            while ( st.hasMoreTokens( ) )
            {
                token = st.nextToken( );
                if (!token.equals("*"))
                {
                    list.add( token );
                }
                else
                {
                    importOnDemand = true;
                }
            }
            if (importOnDemand)
            {
                compilationUnit
                .addTypeImportOnDemand(( String[] ) list
                                                       .toArray( new String[list
                                                                                .size( )] ) );
            }
            else
            {
            compilationUnit
                           .addSingleTypeImport(
                                                 loc,
                                                 ( String[] ) list
                                                                  .toArray( new String[list
                                                                                           .size( )] ) );
            }
        }

        while ( !scanner.peek( ).isEOF( ) )
        {
            block.addStatement( parser.parseBlockStatement( block ) );
        }

        //UnparseVisitor.unparse(compilationUnit, new BufferedWriter( new OutputStreamWriter(System.err)));

        // Compile and load it.
        Class c;
        try
        {
            c = this.compileAndLoad( compilationUnit, DebuggingInformation.ALL, "DroolsConsequence" );
        }
        catch ( ClassNotFoundException e )
        {
            throw new RuntimeException( );
        }

        // Find script method by name.
        try
        {
            this.method = c.getMethod( methodName, parameterTypes );
        }
        catch ( NoSuchMethodException ex )
        {
            throw new RuntimeException( ex.toString( ) );
        }

        if ( this.method == null ) throw new RuntimeException( "Method \""
                                                               + methodName
                                                               + "\" not found" );
    }

    private void addAppData(Scanner scanner,
                            Java.Block block,
                            Set imports,