Examples of org.drools.rule.Rule

org.drools.rule.Rule
A Rule contains a set of Conditions and a Consequence.
The Conditions describe the circumstances that representrepresent a match for this rule. The Consequence gets fired when the Conditions match. @see Condition @see Consequence @author bob mcwhirter @author Simon Harris @author mark pro

        RuleSet ruleSet = new RuleSet( "Miss Manners" );


        // ===========================================
        // <rule name="find first seat" salience="40">
        // ===========================================
        final Rule findFirstSeatRule = new Rule( "find first seat" );
        findFirstSeatRule.setSalience( 40 );


        // Build the declaration and specify it as a parameter of the Rule
        // <parameter identifier="context">
        // <class>org.drools.examples.manners.model.Context</class>
        // </parameter>
        final Declaration contextDeclA = findFirstSeatRule.addParameterDeclaration( "context",
                                                                                    contextType );


        // <parameter identifier="guest">
        // <class>org.drools.examples.manners.model.Guest</class>
        // </parameter>
        final Declaration guestDeclA = findFirstSeatRule.addParameterDeclaration( "guest",
                                                                                  guestType );


        // Build and Add the Condition to the Rule
        // <java:condition>context.isState("start")</java:condition>
        final Condition conditionA1 = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                Context context = (Context) tuple.get( contextDeclA );
                return context.isState( "start" );
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{contextDeclA};
            }


            public String toString()
            {
                return "context.isState(\"start\")";
            }
        };
        findFirstSeatRule.addCondition( conditionA1 );


        // Build and Add the Consequence to the Rule
        // <java:consequence>
        // System.out.println("FIRE: find first seat: " + guest);
        // import org.drools.examples.manners.model.Seating;
        // drools.assertObject(new Seating(1, guest, null));
        // context.setState("find_seating");
        // drools.modifyObject(context);
        // </java:consequence>
        final Consequence consequenceA = new Consequence( )
        {
            public void invoke(Tuple tuple) throws ConsequenceException
            {
                Context context = (Context) tuple.get( contextDeclA );
                Guest guest = (Guest) tuple.get( guestDeclA );


                System.out.println( "FIRE: find first seat: " + guest );


                try
                {
                    workingMemory.assertObject( new Seating( 1,
                                                             guest,
                                                             null ) );
                }
                catch ( FactException e )
                {
                    throw new ConsequenceException( e );
                }


                context.setState( "find_seating" );


                try
                {
                    workingMemory.modifyObject( tuple.getFactHandleForObject( context ),
                                                context );
                }
                catch ( FactException e )
                {
                    throw new ConsequenceException( e );
                }
            }
        };
        findFirstSeatRule.setConsequence( consequenceA );
        ruleSet.addRule( findFirstSeatRule );


        // ========================================
        // <rule name="find seating" salience="30">
        // ========================================
        final Rule findSeatingRule = new Rule( "find seating" );
        findSeatingRule.setSalience( 30 );


        // Build the declaration and specify it as a parameter of the Rule
        // <parameter identifier="context">
        // <class>org.drools.examples.manners.model.Context</class>
        // </parameter>
        final Declaration contextDeclB = findSeatingRule.addParameterDeclaration( "context",
                                                                                  contextType );


        // <parameter identifier="guest">
        // <class>org.drools.examples.manners.model.Guest</class>
        // </parameter>
        final Declaration guestDeclB = findSeatingRule.addParameterDeclaration( "guest",
                                                                                guestType );


        // <parameter identifier="seating">
        // <class>org.drools.examples.manners.model.Seating</class>
        // </parameter>
        final Declaration seatingDeclB = findSeatingRule.addParameterDeclaration( "seating",
                                                                                  seatingType );


        // Build and Add the Condition to the Rule
        // <java:condition>context.isState("find_seating")</java:condition>
        final Condition conditionB1 = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                Context context = (Context) tuple.get( contextDeclB );
                return context.isState( "find_seating" );
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{contextDeclB};
            }


            public String toString()
            {
                return "context.isState(\"find_seating\")";
            }
        };
        findSeatingRule.addCondition( conditionB1 );


        // <java:condition>seating.getGuest2() == null</java:condition>
        final Condition conditionB2 = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                Seating seating = (Seating) tuple.get( seatingDeclB );
                return seating.getGuest2( ) == null;
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{seatingDeclB};
            }


            public String toString()
            {
                return "seating.getGuest2() == null";
            }
        };
        findSeatingRule.addCondition( conditionB2 );


        // <java:condition>!seating.getTabooList().contains(guest)</java:condition>
        final Condition conditionB3 = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                Seating seating = (Seating) tuple.get( seatingDeclB );
                Guest guest = (Guest) tuple.get( guestDeclB );
                return !seating.getTabooList( ).contains( guest );
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{seatingDeclB, guestDeclB};
            }


            public String toString()
            {
                return "!seating.getTabooList().contains(guest)";
            }
        };
        findSeatingRule.addCondition( conditionB3 );


        // <java:condition>seating.getGuest1().hasOppositeSex(guest)</java:condition>
        final Condition conditionB4 = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                Seating seating = (Seating) tuple.get( seatingDeclB );
                Guest guest = (Guest) tuple.get( guestDeclB );
                return seating.getGuest1( ).hasOppositeSex( guest );
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{seatingDeclB, guestDeclB};
            }


            public String toString()
            {
                return "seating.getGuest1().hasOppositeSex(guest)";
            }
        };
        findSeatingRule.addCondition( conditionB4 );


        // <java:condition>seating.getGuest1().hasSameHobby(guest)</java:condition>
        final Condition conditionB5 = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                Seating seating = (Seating) tuple.get( seatingDeclB );
                Guest guest = (Guest) tuple.get( guestDeclB );
                return seating.getGuest1( ).hasSameHobby( guest );
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{seatingDeclB, guestDeclB};
            }


            public String toString()
            {
                return "seating.getGuest1().hasSameHobby(guest)";
            }
        };
        findSeatingRule.addCondition( conditionB5 );


        // Build and Add the Consequence to the Rule
        // <java:consequence>
        // System.out.println("FIRE: find seating: " + seating + " " + guest);
        //
        // Seating nextSeat = new Seating(seating.getSeat2(), guest, seating);
        // drools.assertObject(nextSeat);
        //
        // seating.setGuest2(guest);
        // seating.getTabooList().add(guest);
        // drools.modifyObject(seating);
        // </java:consequence>
        final Consequence consequenceB = new Consequence( )
        {
            public void invoke(Tuple tuple) throws ConsequenceException
            {
                Guest guest = (Guest) tuple.get( guestDeclB );
                Seating seating = (Seating) tuple.get( seatingDeclB );


                System.out.println( "FIRE: find seating: " + seating + " " + guest );


                Seating nextSeat = new Seating( seating.getSeat2( ),
                                                guest,
                                                seating );
                try
                {
                    workingMemory.assertObject( nextSeat );
                }
                catch ( FactException e )
                {
                    throw new ConsequenceException( e );
                }


                seating.setGuest2( guest );
                seating.getTabooList( ).add( guest );


                try
                {
                    workingMemory.modifyObject( tuple.getFactHandleForObject( seating ),
                                                seating );
                }
                catch ( FactException e )
                {
                    throw new ConsequenceException( e );
                }
            }
        };
        findSeatingRule.setConsequence( consequenceB );
        ruleSet.addRule( findSeatingRule );


        // ===========================================
        // <rule name="try another path" salience="20">
        // ===========================================
        final Rule tryAnotherPathRule = new Rule( "try another path" );
        tryAnotherPathRule.setSalience( 20 );


        // Build the declaration and specify it as a parameter of the Rule
        // <parameter identifier="context">
        // <class>org.drools.examples.manners.model.Context</class>
        // </parameter>
        final Declaration contextDeclC = tryAnotherPathRule.addParameterDeclaration( "context",
                                                                                     contextType );


        // <parameter identifier="lastSeat">
        // <class>org.drools.examples.manners.model.LastSeat</class>
        // </parameter>
        final Declaration lastSeatDeclC = tryAnotherPathRule.addParameterDeclaration( "lastSeat",
                                                                                      lastSeatType );


        // <parameter identifier="seating">
        // <class>org.drools.examples.manners.model.Seating</class>
        // </parameter>
        final Declaration seatingDeclC = tryAnotherPathRule.addParameterDeclaration( "seating",
                                                                                     seatingType );


        // <java:condition>context.isState("find_seating")</java:condition>
        final Condition conditionC1 = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                Context context = (Context) tuple.get( contextDeclC );
                return context.isState( "find_seating" );
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{contextDeclC};
            }


            public String toString()
            {
                return "context.isState(\"find_seating\")";
            }
        };
        tryAnotherPathRule.addCondition( conditionC1 );


        // <java:condition>lastSeat.getSeat() >
        // seating.getSeat1()</java:condition>
        final Condition conditionC2 = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                LastSeat lastSeat = (LastSeat) tuple.get( lastSeatDeclC );
                Seating seating = (Seating) tuple.get( seatingDeclC );
                return lastSeat.getSeat( ) > seating.getSeat1( );
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{lastSeatDeclC, seatingDeclC};
            }


            public String toString()
            {
                return "lastSeat.getSeat() > seating.getSeat1()";
            }
        };
        tryAnotherPathRule.addCondition( conditionC2 );


        // <java:condition>seating.getGuest2() == null</java:condition>
        final Condition conditionC3 = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                Seating seating = (Seating) tuple.get( seatingDeclC );
                return seating.getGuest2( ) == null;
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{seatingDeclC};
            }


            public String toString()
            {
                return "seating.getGuest2() == null";
            }
        };
        tryAnotherPathRule.addCondition( conditionC3 );


        // <java:consequence>
        // System.out.println("FIRE: try another path: " + seating);
        //
        // Seating prevSeat = seating.getPrevSeat();
        // prevSeat.setGuest2(null);
        // drools.modifyObject(prevSeat);
        //
        // drools.retractObject(seating);
        // </java:consequence>
        final Consequence consequenceC = new Consequence( )
        {
            public void invoke(Tuple tuple) throws ConsequenceException
            {
                Seating seating = (Seating) tuple.get( seatingDeclC );


                System.out.println( "FIRE: try another path: " + seating );


                Seating prevSeat = seating.getPrevSeat( );
                prevSeat.setGuest2( null );


                try
                {
                    workingMemory.modifyObject( tuple.getFactHandleForObject( prevSeat ),
                                                prevSeat );
                }
                catch ( FactException e )
                {
                    throw new ConsequenceException( e );
                }


                try
                {
                    workingMemory.retractObject( tuple.getFactHandleForObject( seating ) );
                }
                catch ( FactException e )
                {
                    throw new ConsequenceException( e );
                }
            }
        };
        tryAnotherPathRule.setConsequence( consequenceC );
        ruleSet.addRule( tryAnotherPathRule );


        // =======================================
        // <rule name="we are done" salience="10">
        // =======================================
        final Rule weAreDoneRule = new Rule( "we are done" );
        weAreDoneRule.setSalience( 10 );


        // Build the declaration and specify it as a parameter of the Rule
        // <parameter identifier="context">
        // <class>org.drools.examples.manners.model.Context</class>
        // </parameter>
        final Declaration contextDeclD = weAreDoneRule.addParameterDeclaration( "context",
                                                                                contextType );


        // <parameter identifier="lastSeat">
        // <class>org.drools.examples.manners.model.LastSeat</class>
        // </parameter>
        final Declaration lastSeatDeclD = weAreDoneRule.addParameterDeclaration( "lastSeat",
                                                                                 lastSeatType );


        // <parameter identifier="seating">
        // <class>org.drools.examples.manners.model.Seating</class>
        // </parameter>
        final Declaration seatingDeclD = weAreDoneRule.addParameterDeclaration( "seating",
                                                                                seatingType );


        // <java:condition>context.isState("find_seating")</java:condition>
        final Condition conditionD1 = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                Context context = (Context) tuple.get( contextDeclD );
                return context.isState( "find_seating" );
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{contextDeclD};
            }


            public String toString()
            {
                return "context.isState(\"find_seating\")";
            }
        };
        weAreDoneRule.addCondition( conditionD1 );


        // <java:condition>lastSeat.getSeat() ==
        // seating.getSeat1()</java:condition>
        final Condition conditionD2 = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                LastSeat lastSeat = (LastSeat) tuple.get( lastSeatDeclD );
                Seating seating = (Seating) tuple.get( seatingDeclD );
                return lastSeat.getSeat( ) == seating.getSeat1( );
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{lastSeatDeclD, seatingDeclD};
            }


            public String toString()
            {
                return "lastSeat.getSeat() == seating.getSeat1()";
            }
        };
        weAreDoneRule.addCondition( conditionD2 );


        // <java:consequence>
        // System.out.println("FIRE: we are done");
        //
        // import org.drools.examples.manners.model.Seat;
        // List list = new ArrayList();
        // while(seating != null) {
        // Seat seat = new Seat(seating.getSeat1(),
        // seating.getGuest1().getName());
        // seating = seating.getPrevSeat();
        // list.add(seat);
        // }
        //
        // for (int i = list.size(); i > 0; i--) {
        // Seat seat = (Seat)list.get(i-1);
        // System.out.println(seat);
        // drools.assertObject(seat);
        // }
        //
        // context.setState("all_done");
        // drools.modifyObject(context);
        // </java:consequence>
        final Consequence consequenceD = new Consequence( )
        {
            public void invoke(Tuple tuple) throws ConsequenceException
            {
                System.out.println( "FIRE: we are done" );


                Seating seating = (Seating) tuple.get( seatingDeclD );
                Context context = (Context) tuple.get( contextDeclD );


                List list = new ArrayList( );
                while ( seating != null )
                {
                    Seat seat = new Seat( seating.getSeat1( ),
                                          seating.getGuest1( ).getName( ) );
                    seating = seating.getPrevSeat( );
                    list.add( seat );
                }


                for ( int i = list.size( ); i > 0; i-- )
                {
                    Seat seat = (Seat) list.get( i - 1 );
                    System.out.println( seat );
                    try
                    {
                        workingMemory.assertObject( seat );
                    }
                    catch ( FactException e )
                    {
                        throw new ConsequenceException( e );
                    }
                }


                context.setState( "all_done" );
                try
                {
                    workingMemory.modifyObject( tuple.getFactHandleForObject( context ),
                                                context );
                }
                catch ( FactException e )
                {
                    throw new ConsequenceException( e );
                }
            }
        };
        weAreDoneRule.setConsequence( consequenceD );
        ruleSet.addRule( weAreDoneRule );


        // ==================
        // Build the RuleSet.
        // ==================

View Full Code Here

        this.ruleSetReader.startConfiguration( localName,
                                               attrs );


        Configuration config = this.ruleSetReader.endConfiguration( );


        Rule rule;
        try
        {
            rule = factory.newRule( this.ruleSetReader.getRuleSet( ),
                                    this.ruleSetReader.getFactoryContext( ),
                                    config );

View Full Code Here

        assertRuleC(ruleSet);
        assertRuleD(ruleSet);
    }


    private void assertRuleA(RuleSet ruleSet) {
        Rule rule_A = ruleSet.getRule(TestRules.PojoRule_A.class.getName());
        assertNotNull(rule_A);
    }

View Full Code Here

        Rule rule_A = ruleSet.getRule(TestRules.PojoRule_A.class.getName());
        assertNotNull(rule_A);
    }


    private void assertRuleB(RuleSet ruleSet) {
        Rule rule_B = ruleSet.getRule(TestRules.PojoRule_B.class.getName());
        assertNotNull(rule_B);
        assertEquals("my B docs", rule_B.getDocumentation());
        assertEquals(10, rule_B.getSalience());
    }

View Full Code Here

        assertEquals("my B docs", rule_B.getDocumentation());
        assertEquals(10, rule_B.getSalience());
    }


    private void assertRuleC(RuleSet ruleSet) {
        Rule rule_C = ruleSet.getRule("myC");
        assertNotNull(rule_C);
        assertEquals("my C docs", rule_C.getDocumentation());
        assertTrue(rule_C.isNoLoop());
    }

View Full Code Here

        assertEquals("my C docs", rule_C.getDocumentation());
        assertTrue(rule_C.isNoLoop());
    }


    private void assertRuleD(RuleSet ruleSet) {
        Rule rule_D = ruleSet.getRule(TestRules.PojoRule_D.class.getName());
        assertNotNull(rule_D);
    }

View Full Code Here


public class HelloWorldNative
{
    public static void main(String[] args) throws DroolsException
    {
        Rule helloRule = new Rule( "Hello World" );
        Rule goodbyeRule = new Rule( "Goodbye Cruel World" );
        Rule debugRule = new Rule( "Debug" );


        /*
         * Reuse the Java semantics ObjectType so Drools can identify String and
         * Object
         */
        ClassObjectType StringType = new ClassObjectType( String.class );
        ClassObjectType ObjectType = new ClassObjectType( Object.class );


        /*
         * Build the declaration and specify it as a parameter of the hello Rule
         */
        final Declaration helloDeclaration = helloRule.addParameterDeclaration( "hello",
                                                                                StringType );


        /*
         * Build the declaration and specify it as a parameter of the goodbye
         * Rule
         */
        final Declaration goodbyeDeclaration = goodbyeRule.addParameterDeclaration( "goodbye",
                                                                                    StringType );


        /*
         * Build the declaration and specify it as a parameter of the debug Rule
         */
        final Declaration debugDeclaration = debugRule.addParameterDeclaration( "object",
                                                                                ObjectType );


        /*
         * Build and Add the Condition to the hello Rule
         */
        Condition conditionHello = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                String hello = (String) tuple.get( helloDeclaration );
                if ( hello == null ) return false;
                if ( hello.equals( "Hello" ) ) return true;
                return false;
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{helloDeclaration};
            }
        };
        helloRule.addCondition( conditionHello );


        /*
         * Build and Add the Condition to the goodbye Rule
         */
        Condition conditionGoodbye = new Condition( )
        {
            public boolean isAllowed(Tuple tuple)
            {
                String goodbye = (String) tuple.get( goodbyeDeclaration );
                if ( goodbye == null ) return false;
                if ( goodbye.equals( "Goodbye" ) ) return true;
                return false;
            }


            public Declaration[] getRequiredTupleMembers()
            {
                return new Declaration[]{goodbyeDeclaration};
            }
        };
        goodbyeRule.addCondition( conditionGoodbye );


        // No condition to build and add to the debug Rule


        /*
         * Build and Add the Consequence to the hello Rule
         */
        Consequence helloConsequence = new Consequence( )
        {
            public void invoke(Tuple tuple)
            {
                String hello = (String) tuple.get( helloDeclaration );
                System.out.println( hello + " World" );
            }
        };
        helloRule.setConsequence( helloConsequence );


        /*
         * Build and Add the Consequence to the goodbye Rule
         */
        Consequence goodbyeConsequence = new Consequence( )
        {
            public void invoke(Tuple tuple)
            {
                String goodbye = (String) tuple.get( goodbyeDeclaration );
                System.out.println( goodbye + " Cruel World" );
            }
        };
        goodbyeRule.setConsequence( goodbyeConsequence );


        /*
         * Build and Add the Consequence to the debug Rule
         */
        Consequence debugConsequence = new Consequence( )
        {
            public void invoke(Tuple tuple)
            {
                Object object = tuple.get( debugDeclaration );
                System.out.println( "Asserted object: " + object );
            }
        };
        debugRule.setConsequence( debugConsequence );


        RuleSet ruleSet = new RuleSet( "Hello World Example" );
        ruleSet.addRule( helloRule );
        ruleSet.addRule( goodbyeRule );
        ruleSet.addRule( debugRule );

View Full Code Here

import org.drools.spring.pojorule.KnowledgeHelperArgument;


public class KnowledgeHelperArgumentMetadataTest extends TestCase {


    public void testCreate() throws Exception {
        Rule rule = new Rule("for-test");
        KnowledgeHelperArgumentMetadata metadata = new KnowledgeHelperArgumentMetadata();


        Argument argument = metadata.createArgument(rule);


        assertTrue(argument instanceof KnowledgeHelperArgument);

View Full Code Here

        DefaultConfiguration configuration = new DefaultConfiguration( "test1" );


        final RuleSet ruleSet = new RuleSet( "test RuleSet",
                                             ruleBaseContext );


        final Rule rule = new Rule( "Test Rule 1",
                                    ruleSet );


        Importer importer = new DefaultImporter( );
        rule.setImporter( importer );


        ObjectTypeFactory factory = new ClassFieldObjectTypeFactory( );


        try
        {

View Full Code Here

                                    "bob" );


        final RuleSet ruleSet = new RuleSet( "test RuleSet",
                                             ruleBaseContext );


        final Rule rule = new Rule( "Test Rule 1",
                                    ruleSet );


        Importer importer = new DefaultImporter( );
        rule.setImporter( importer );


        ObjectTypeFactory factory = new ClassFieldObjectTypeFactory( );


        ClassFieldObjectType type = (ClassFieldObjectType) factory.newObjectType( rule,
                                                                                  ruleBaseContext,

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.drools.rule.Rule

org.drools.agent.impl.KnowledgeAgentImpl

org.drools.agent.KnowledgeAgentTest

org.drools.clips.ClipsShellTest

org.drools.common.AbstractRuleBase

org.drools.common.DefaultAgenda

org.drools.common.NamedEntryPoint

org.drools.common.SequentialAgendaTest

org.drools.compiler.PackageBuilder

org.drools.compiler.PackageBuilderTest

org.drools.compiler.PackageRegistry

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.