javainvokers.stg

jboss规则引擎

group javaInvokeable;

getMethodBytecode(package, ruleClassName, methodName) ::= <<
    public java.util.List getMethodBytecode() {
        org.drools.util.asm.MethodComparator.Tracer visit = new org.drools.util.asm.MethodComparator.Tracer("<methodName>");


        java.io.InputStream is = <ruleClassName>.class.getClassLoader().getResourceAsStream( "<package>.<ruleClassName>".replace( '.', '/' ) + ".class" );
                
        java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
        byte[] data = new byte[1024];
        int byteCount;
        try {
            while ( (byteCount = is.read( data,
                                 0,
                                 1024 )) > -1 )
            {                    
                bos.write(data, 0, byteCount);
            }
        } catch ( java.io.IOException e ) {
            throw new org.drools.RuntimeDroolsException("Unable getResourceAsStream for Class '<ruleClassName>' ");
        }               
        
        org.drools.asm.ClassReader classReader = new org.drools.asm.ClassReader( bos.toByteArray() );
        classReader.accept( visit, true );
        org.drools.asm.util.TraceMethodVisitor trace = visit.getTrace();
        return trace.getText();     
    }
>>    
    

equals() ::= <<
    public boolean equals(Object object) {
        if (object == null ) {
            return false;
        } else if ( object == this ){
            return true;
        }
        
        if ( ! (object instanceof org.drools.spi.CompiledInvoker) ) {
            return false;
        }
        
        org.drools.spi.CompiledInvoker other = ( org.drools.spi.CompiledInvoker ) object;
        
        return org.drools.util.asm.MethodComparator.compareBytecode( getMethodBytecode(), other.getMethodBytecode() );
    }
>>

hashCode(hashCode) ::= <<
    public int hashCode() {
        return <hashCode>;
    }
>>

returnValueInvoker(package, invokerClassName, ruleClassName, methodName, declarations, declarationTypes, globals, globalTypes, hashCode) ::= <<
package <package>;

public class <invokerClassName> implements org.drools.spi.ReturnValueExpression, org.drools.spi.CompiledInvoker
{
    private static final long serialVersionUID  = 7952983928232702826L;
    
    public Object evaluate(org.drools.spi.Tuple tuple,
                            org.drools.rule.Declaration[] declarations, 
                            org.drools.WorkingMemory workingMemory) throws Exception {                               

        <declarationTypes, declarations:{ type, declr| <type> <declr.identifier> = ( <type> ) declarations[<i0>].getValue( ( (org.drools.common.InternalFactHandle) tuple.get( declarations[<i0>] ) ).getObject() );<\n>}>
        <globalTypes, globals:{ type, identifier | <type> <identifier> = ( <type> ) workingMemory.getGlobal( "<identifier>" );<\n>}>    
        
        return <ruleClassName>.<methodName>( 
            <declarations:{ declr | <declr.identifier>}; separator=",\n"><if(globals)><if(declarations)>,<endif><endif>
	        <globals:{ identifier | <identifier>}; separator=",\n"> );
    }    
    
    <hashCode(hashCode=hashCode)>
    
    <getMethodBytecode(package=package, ruleClassName=ruleClassName, methodName=methodName)>
    
    <equals()>    
}     
>>

predicateInvoker(package, invokerClassName, ruleClassName, methodName, declaration, declarationType, 
                 declarations, declarationTypes, globals, globalTypes, hashCode) ::= <<
package <package>;

public class <invokerClassName> implements org.drools.spi.PredicateExpression, org.drools.spi.CompiledInvoker
{
    private static final long serialVersionUID  = 7952983928232702826L;
    
    public boolean evaluate(org.drools.spi.Tuple tuple,
                            org.drools.FactHandle factHandle,
                            org.drools.rule.Declaration declaration,
                            org.drools.rule.Declaration[] declarations, 
                            org.drools.WorkingMemory workingMemory) throws Exception {                               
		<declarationType> <declaration.identifier> = (<declarationType>) declaration.getValue( workingMemory.getObject( factHandle ) );
        <declarationTypes, declarations:{ type, declr| <type> <declr.identifier> = ( <type> ) declarations[<i0>].getValue( ( (org.drools.common.InternalFactHandle) tuple.get( declarations[<i0>] ) ).getObject() );<\n>}>
        <globalTypes, globals:{ type, identifier | <type> <identifier> = ( <type> ) workingMemory.getGlobal( "<identifier>" );<\n>}>    
        
        return <ruleClassName>.<methodName>( 
            <declaration.identifier><if(declarations)>,<endif>
            <declarations:{ declr | <declr.identifier>}; separator=",\n"><if(globals)>,<endif>
	        <globals:{ identifier | <identifier>}; separator=",\n"> );
    }
    
    <hashCode(hashCode=hashCode)>
    
    <getMethodBytecode(package=package, ruleClassName=ruleClassName, methodName=methodName)>
    
    <equals()>    
}     
>>


evalInvoker(package, invokerClassName, ruleClassName, methodName, declarations, declarationTypes, globals, globalTypes, hashCode) ::= <<
package <package>;

import org.drools.asm.ClassReader;
import org.drools.asm.util.TraceMethodVisitor;
import org.drools.util.asm.MethodComparator.Tracer;

public class <invokerClassName> implements org.drools.spi.EvalExpression, org.drools.spi.CompiledInvoker
{
    private static final long serialVersionUID  = 7952983928232702826L;
    
    public boolean evaluate(org.drools.spi.Tuple tuple,
                            org.drools.rule.Declaration[] declarations, 
                            org.drools.WorkingMemory workingMemory) throws Exception {                               

        <declarationTypes, declarations:{ type, declr| <type> <declr.identifier> = ( <type> ) declarations[<i0>].getValue( ( (org.drools.common.InternalFactHandle) tuple.get( declarations[<i0>] ) ).getObject() );<\n>}>
        <globalTypes, globals:{ type, identifier | <type> <identifier> = ( <type> ) workingMemory.getGlobal( "<identifier>" );<\n>}>    
        
        return <ruleClassName>.<methodName>( 
            <declarations:{ declr | <declr.identifier>}; separator=",\n"><if(globals)><if(declarations)>,<endif><endif>
	        <globals:{ identifier | <identifier>}; separator=",\n"> );
    }

    <hashCode(hashCode=hashCode)>
    
    <getMethodBytecode(package=package, ruleClassName=ruleClassName, methodName=methodName)>
    
    <equals()>  
}     
>>

consequenceInvoker(package, invokerClassName, ruleClassName, methodName, declarations, declarationTypes, indexes, globals, globalTypes, text) ::= <<
package <package>;

public class <invokerClassName> implements org.drools.spi.Consequence
{
    private static final long serialVersionUID  = 7952983928232702826L;

    public void evaluate(org.drools.spi.KnowledgeHelper knowledgeHelper,
                         org.drools.WorkingMemory workingMemory) throws Exception {    
                       
        org.drools.spi.Tuple tuple = knowledgeHelper.getTuple();
        org.drools.rule.Rule rule = knowledgeHelper.getRule();
        org.drools.rule.Declaration[] declarations = rule.getDeclarations();                                                  

        <declarations, indexes:{ declr, index| org.drools.common.InternalFactHandle <declr.identifier>__Handle__ = ( org.drools.common.InternalFactHandle ) tuple.get( declarations[<index>] );<\n>}>

        <declarationTypes, declarations, indexes :{ type, declr, index| <type> <declr.identifier> = ( <type> )  declarations[<index>].getValue( <declr.identifier>__Handle__.getObject() );<\n>}>
        
        <globalTypes, globals:{ type, identifier | <type> <identifier> = ( <type> ) workingMemory.getGlobal( "<identifier>" );<\n>}>    
        
        <ruleClassName>.<methodName>( 
            knowledgeHelper<if(declarations)>,<endif>
            <declarations:{ declr | <declr.identifier>, <declr.identifier>__Handle__}; separator=",\n"><if(globals)>,<endif>
	        <globals:{ identifier | <identifier>}; separator=",\n"> );
    }
}     
>>