Examples of org.drools.core.rule.Rule

org.drools.core.rule.Rule
A Rule contains a set of Tests and a Consequence.
The Tests describe the circumstances that representrepresent a match for this rule. The Consequence gets fired when the Conditions match.

                leftTupleSource = new MockTupleSource( buildContext.getNextId() );
            } else {
                leftTupleSource = (LeftTupleSource) context.get( leftInput );
            }


            Rule rule = new Rule( name );


            final RuleTerminalNode rtn = new RuleTerminalNode( buildContext.getNextId(),
                                                               leftTupleSource,
                                                               rule,
                                                               null,
                                                               0,
                                                               buildContext );
            Consequence consequence = new Consequence() {
                public void evaluate(KnowledgeHelper knowledgeHelper,
                                     WorkingMemory workingMemory) throws Exception {


                }
                
                public String getName() {
                    return "default";
                }
            };


            rule.setConsequence( consequence );


            rtn.attach(buildContext);
            context.put( name,
                         rtn );

View Full Code Here

                                        prefixPattern,
                                        (Query) context.getRule() );
            }


            if ( rce == null ) {
                Rule rule = context.getPkg().getRule( patternDescr.getObjectType() );
                if ( rule instanceof Query ) {
                    // it's a query so delegate to the QueryElementBuilder
                    QueryElementBuilder qeBuilder = new QueryElementBuilder();
                    rce = qeBuilder.build( context,
                                           descr,

View Full Code Here

        for ( List<RuleDescr> rds : parents.values() ) {
            for ( RuleDescr ruleDescr : rds ) {
                if ( parents.get( ruleDescr.getParentName() ) != null
                     && (sorted.containsKey( ruleDescr.getName() ) || parents.containsKey( ruleDescr.getName() )) ) {
                    circularDep = true;
                    results.add( new RuleBuildError( new Rule( ruleDescr.getName() ), ruleDescr, null,
                                                     "Circular dependency in rules hierarchy" ) );
                    break;
                }
                manageUnresolvedExtension( ruleDescr, sorted.values() );
            }

View Full Code Here

        }
        String msg = "Unresolved parent name " + ruleDescr.getParentName();
        if ( candidateRules.size() > 0 ) {
            msg += " >> did you mean any of :" + candidateRules;
        }
        results.add( new RuleBuildError( new Rule( ruleDescr.getName() ), ruleDescr, msg,
                                         "Unable to resolve parent rule, please check that both rules are in the same package" ) );
    }

View Full Code Here

                                                   rule.getLine(),
                                                   rule.getColumn(),
                                                   packageDescr.getNamespace() ) );
            }
            if ( pkg != null ) {
                Rule duplicatedRule = pkg.getRule( name );
                if ( duplicatedRule != null ) {
                    Resource resource = rule.getResource();
                    Resource duplicatedResource = duplicatedRule.getResource();
                    if ( resource == null || duplicatedResource == null || duplicatedResource.getSourcePath() == null ||
                         duplicatedResource.getSourcePath().equals( resource.getSourcePath() ) ) {
                        this.results.add( new DuplicateRule( rule,
                                                             packageDescr,
                                                             this.configuration ) );

View Full Code Here

     * @throws IntrospectionException
     * @throws InvalidRuleException
     */
    private Rule getAssignFirstSeatRule() throws IntrospectionException,
                                         InvalidRuleException {
        final Rule rule = new Rule( "assignFirstSeat" );


        // -----------
        // context : Context( state == Context.START_UP )
        // -----------
        final Pattern contextPattern = new Pattern( 0,
                                                    this.contextType,
                                                    "context" );


        contextPattern.addConstraint( getLiteralConstraint( contextPattern,
                                                            "state",
                                                            Context.START_UP ) );


        rule.addPattern( contextPattern );


        final Declaration contextDeclaration = rule.getDeclaration( "context" );


        // -----------
        // guest: Guest()
        // -----------
        final Pattern guestPattern = new Pattern( 1,
                                                  this.guestType,
                                                  "guest" );


        rule.addPattern( guestPattern );


        final Declaration guestDeclaration = rule.getDeclaration( "guest" );


        // ------------
        // count : Count()
        // ------------
        final Pattern countPattern = new Pattern( 2,
                                                  this.countType,
                                                  "count" );


        rule.addPattern( countPattern );


        final Declaration countDeclaration = rule.getDeclaration( "count" );


        final Consequence consequence = new Consequence() {


            public void evaluate(KnowledgeHelper drools,
                                 WorkingMemory workingMemory) throws ConsequenceException {
                try {
                    Rule rule = drools.getRule();
                    Tuple tuple = drools.getTuple();


                    Guest guest = (Guest) drools.get( guestDeclaration );
                    Context context = (Context) drools.get( contextDeclaration );
                    Count count = (Count) drools.get( countDeclaration );


                    String guestName = guest.getName();


                    Seating seating = new Seating( count.getValue(),
                                                   0,
                                                   true,
                                                   1,
                                                   guestName,
                                                   1,
                                                   guestName );


                    drools.insert( seating );


                    Path path = new Path( count.getValue(),
                                          1,
                                          guestName );


                    drools.insert( path );


                    count.setValue( count.getValue() );
                    drools.update( tuple.get( countDeclaration ),
                                   count );


                    context.setState( Context.ASSIGN_SEATS );
                    //                    drools.update( tuple.get( contextDeclaration ),
                    //                            context );


                    drools.update( tuple.get( contextDeclaration ) );


                    //                    System.err.println( "assign first seat :  " + seating + " : " + path );


                } catch ( Exception e ) {
                    e.printStackTrace();
                    throw new ConsequenceException( e );
                }
            }


            public void readExternal(ObjectInput in) throws IOException,
                                                    ClassNotFoundException {


            }


            public void writeExternal(ObjectOutput out) throws IOException {


            }
            
            public String getName() {
                return "default";
            }
        };


        rule.setConsequence( consequence );


        return rule;
    }

View Full Code Here

     * @throws IntrospectionException
     * @throws InvalidRuleException
     */
    private Rule getFindSeating() throws IntrospectionException,
                                 InvalidRuleException {
        final Rule rule = new Rule( "findSeating" );


        // ---------------
        // context : Context( state == Context.ASSIGN_SEATS )
        // ---------------
        final Pattern contextPattern = new Pattern( 0,
                                                    this.contextType,
                                                    "context" );


        contextPattern.addConstraint( getLiteralConstraint( contextPattern,
                                                            "state",
                                                            Context.ASSIGN_SEATS ) );


        rule.addPattern( contextPattern );


        final Declaration contextDeclaration = rule.getDeclaration( "context" );


        // -------------------------------
        // Seating( seatingId:id, seatingPid:pid, pathDone == true
        // seatingRightSeat:rightSeat seatingRightGuestName:rightGuestName )
        // -------------------------------
        final Pattern seatingPattern = new Pattern( 1,
                                                    this.seatingType );


        setFieldDeclaration( seatingPattern,
                             "id",
                             "seatingId" );


        setFieldDeclaration( seatingPattern,
                             "pid",
                             "seatingPid" );


        seatingPattern.addConstraint( getLiteralConstraint( seatingPattern,
                                                            "pathDone",
                                                            true ) );


        setFieldDeclaration( seatingPattern,
                             "rightSeat",
                             "seatingRightSeat" );


        setFieldDeclaration( seatingPattern,
                             "rightGuestName",
                             "seatingRightGuestName" );


        rule.addPattern( seatingPattern );


        final Declaration seatingIdDeclaration = rule.getDeclaration( "seatingId" );
        final Declaration seatingPidDeclaration = rule.getDeclaration( "seatingPid" );
        final Declaration seatingRightGuestNameDeclaration = rule.getDeclaration( "seatingRightGuestName" );
        final Declaration seatingRightSeatDeclaration = rule.getDeclaration( "seatingRightSeat" );
        // --------------
        // Guest( name == seatingRightGuestName, rightGuestSex:sex,
        // rightGuestHobby:hobby )
        // ---------------
        final Pattern rightGuestPattern = new Pattern( 2,
                                                       this.guestType );


        rightGuestPattern.addConstraint( getBoundVariableConstraint( rightGuestPattern,
                                                                     "name",
                                                                     seatingRightGuestNameDeclaration,
                                                                     "==" ) );


        setFieldDeclaration( rightGuestPattern,
                             "sex",
                             "rightGuestSex" );


        setFieldDeclaration( rightGuestPattern,
                             "hobby",
                             "rightGuestHobby" );


        rule.addPattern( rightGuestPattern );


        final Declaration rightGuestSexDeclaration = rule.getDeclaration( "rightGuestSex" );
        final Declaration rightGuestHobbyDeclaration = rule.getDeclaration( "rightGuestHobby" );


        // ----------------
        // Guest( leftGuestName:name , sex != rightGuestSex, hobby ==
        // rightGuestHobby )
        // ----------------
        final Pattern leftGuestPattern = new Pattern( 3,
                                                      this.guestType );


        setFieldDeclaration( leftGuestPattern,
                             "name",
                             "leftGuestName" );


        leftGuestPattern.addConstraint( getBoundVariableConstraint( rightGuestPattern,
                                                                    "hobby",
                                                                    rightGuestHobbyDeclaration,
                                                                    "==" ) );


        leftGuestPattern.addConstraint( getBoundVariableConstraint( leftGuestPattern,
                                                                    "sex",
                                                                    rightGuestSexDeclaration,
                                                                    "!=" ) );


        rule.addPattern( leftGuestPattern );
        final Declaration leftGuestNameDeclaration = rule.getDeclaration( "leftGuestName" );


        // ---------------
        // count : Count()
        // ---------------
        final Pattern count = new Pattern( 4,
                                           this.countType,
                                           "count" );


        rule.addPattern( count );


        final Declaration countDeclaration = rule.getDeclaration( "count" );


        // --------------
        // not ( Path( id == seatingId, guestName == leftGuestName) )
        // --------------
        final Pattern notPathPattern = new Pattern( 5,
                                                    this.pathType );


        notPathPattern.addConstraint( getBoundVariableConstraint( notPathPattern,
                                                                  "id",
                                                                  seatingIdDeclaration,
                                                                  "==" ) );


        notPathPattern.addConstraint( getBoundVariableConstraint( notPathPattern,
                                                                  "guestName",
                                                                  leftGuestNameDeclaration,
                                                                  "==" ) );
        final GroupElement notPath = GroupElementFactory.newNotInstance();
        notPath.addChild( notPathPattern );
        rule.addPattern( notPath );
        // ------------
        // not ( Chosen( id == seatingId, guestName == leftGuestName, hobby ==
        // rightGuestHobby ) )
        // ------------
        final Pattern notChosenPattern = new Pattern( 6,
                                                      this.chosenType );


        notChosenPattern.addConstraint( getBoundVariableConstraint( notChosenPattern,
                                                                    "id",
                                                                    seatingIdDeclaration,
                                                                    "==" ) );


        notChosenPattern.addConstraint( getBoundVariableConstraint( notChosenPattern,
                                                                    "guestName",
                                                                    leftGuestNameDeclaration,
                                                                    "==" ) );


        notChosenPattern.addConstraint( getBoundVariableConstraint( notChosenPattern,
                                                                    "hobby",
                                                                    rightGuestHobbyDeclaration,
                                                                    "==" ) );


        final GroupElement notChosen = GroupElementFactory.newNotInstance();
        notChosen.addChild( notChosenPattern );


        rule.addPattern( notChosen );


        // ------------
        // int newSeat = rightSeat + 1;
        // drools.assert( new Seating( coung.getValue(), rightSeat,
        // rightSeatName, leftGuestName, newSeat, countValue, id, false );
        // drools.assert( new Path( countValue, leftGuestName, newSeat );
        // drools.assert( new Chosen( id, leftGuestName, rightGuestHobby ) );
        //
        // System.err.println( "seat " + rightSeat + " " + rightSeatName + " " +
        // leftGuestName );
        //
        // count.setCount( countValue + 1 );
        // context.setPath( Context.MAKE_PATH );
        // ------------
        final Consequence consequence = new Consequence() {


            public void evaluate(KnowledgeHelper drools,
                                 WorkingMemory workingMemory) throws ConsequenceException {
                try {
                    //                    MemoryVisitor visitor = new MemoryVisitor( ( InternalWorkingMemory ) workingMemory );
                    //                    visitor.visit( workingMemory.getRuleBase() );


                    Rule rule = drools.getRule();
                    Tuple tuple = drools.getTuple();


                    Context context = (Context) drools.get( contextDeclaration );
                    Count count = (Count) drools.get( countDeclaration );
                    int seatId = seatingIdDeclaration.getExtractor().getIntValue( (InternalWorkingMemory) workingMemory,
                                                                                  tuple.get( seatingIdDeclaration ).getObject() );
                    int seatingRightSeat = seatingRightSeatDeclaration.getExtractor().getIntValue( (InternalWorkingMemory) workingMemory,
                                                                                                   tuple.get( seatingRightSeatDeclaration ).getObject() );


                    String leftGuestName = (String) drools.get( leftGuestNameDeclaration );
                    String rightGuestName = (String) drools.get( seatingRightGuestNameDeclaration );
                    Hobby rightGuestHobby = (Hobby) drools.get( rightGuestHobbyDeclaration );


                    Seating seating = new Seating( count.getValue(),
                                                   seatId,
                                                   false,
                                                   seatingRightSeat,
                                                   rightGuestName,
                                                   seatingRightSeat + 1,
                                                   leftGuestName );
                    drools.insert( seating );


                    Path path = new Path( count.getValue(),
                                          seatingRightSeat + 1,
                                          leftGuestName );


                    drools.insert( path );


                    Chosen chosen = new Chosen( seatId,
                                                leftGuestName,
                                                rightGuestHobby );


                    drools.insert( chosen );
                    count.setValue( count.getValue() + 1 );


                    //                    if ( count.getValue() == 5 ) {
                    //                        drools.retractObject( tuple.getFactHandleForDeclaration( countDeclaration ) );
                    //                    } else {
                    //                        drools.update( tuple.getFactHandleForDeclaration( countDeclaration ),
                    //                                             count );
                    //                    }


                    drools.update( tuple.get( countDeclaration ),
                                   count );


                    context.setState( Context.MAKE_PATH );
                    drools.update( tuple.get( contextDeclaration ),
                                   context );


                    System.err.println( "find seating : " + seating + " : " + path + " : " + chosen );


                } catch ( Exception e ) {
                    e.printStackTrace();
                    throw new ConsequenceException( e );
                }
            }


            public void readExternal(ObjectInput in) throws IOException,
                                                    ClassNotFoundException {


            }


            public void writeExternal(ObjectOutput out) throws IOException {


            }
            
            public String getName() {
                return "default";
            }
        };


        rule.setConsequence( consequence );


        return rule;
    }

View Full Code Here

     * @throws IntrospectionException
     * @throws InvalidRuleException
     */
    private Rule getMakePath() throws IntrospectionException,
                              InvalidRuleException {
        final Rule rule = new Rule( "makePath" );


        // -----------
        // context : Context( state == Context.MAKE_PATH )
        // -----------
        final Pattern contextPattern = new Pattern( 0,
                                                    this.contextType );


        contextPattern.addConstraint( getLiteralConstraint( contextPattern,
                                                            "state",
                                                            Context.MAKE_PATH ) );


        rule.addPattern( contextPattern );


        // ---------------
        // Seating( seatingId:id, seatingPid:pid, pathDone == false )
        // ---------------
        final Pattern seatingPattern = new Pattern( 1,
                                                    this.seatingType );


        setFieldDeclaration( seatingPattern,
                             "id",
                             "seatingId" );


        setFieldDeclaration( seatingPattern,
                             "pid",
                             "seatingPid" );


        seatingPattern.addConstraint( getLiteralConstraint( seatingPattern,
                                                            "pathDone",
                                                            false ) );


        rule.addPattern( seatingPattern );


        final Declaration seatingIdDeclaration = rule.getDeclaration( "seatingId" );
        final Declaration seatingPidDeclaration = rule.getDeclaration( "seatingPid" );


        // -----------
        // Path( id == seatingPid, pathGuestName:guestName, pathSeat:seat )
        // -----------
        final Pattern pathPattern = new Pattern( 2,
                                                 this.pathType );


        pathPattern.addConstraint( getBoundVariableConstraint( pathPattern,
                                                               "id",
                                                               seatingPidDeclaration,
                                                               "==" ) );


        setFieldDeclaration( pathPattern,
                             "guestName",
                             "pathGuestName" );


        setFieldDeclaration( pathPattern,
                             "seat",
                             "pathSeat" );


        rule.addPattern( pathPattern );


        final Declaration pathGuestNameDeclaration = rule.getDeclaration( "pathGuestName" );
        final Declaration pathSeatDeclaration = rule.getDeclaration( "pathSeat" );
        // -------------
        // (not Path( id == seatingId, guestName == pathGuestName )
        // -------------
        final Pattern notPathPattern = new Pattern( 3,
                                                    this.pathType );


        notPathPattern.addConstraint( getBoundVariableConstraint( notPathPattern,
                                                                  "id",
                                                                  seatingIdDeclaration,
                                                                  "==" ) );
        notPathPattern.addConstraint( getBoundVariableConstraint( notPathPattern,
                                                                  "guestName",
                                                                  pathGuestNameDeclaration,
                                                                  "==" ) );


        final GroupElement not = GroupElementFactory.newNotInstance();


        not.addChild( notPathPattern );


        rule.addPattern( not );


        // ------------
        // drools.assert( new Path( id, pathName, pathSeat ) );
        // ------------
        final Consequence consequence = new Consequence() {


            public void evaluate(KnowledgeHelper drools,
                                 WorkingMemory workingMemory) throws ConsequenceException {
                try {
                    Rule rule = drools.getRule();
                    Tuple tuple = drools.getTuple();


                    int id = seatingIdDeclaration.getExtractor().getIntValue( (InternalWorkingMemory) workingMemory,
                                                                              tuple.get( seatingIdDeclaration ).getObject() );
                    int seat = pathSeatDeclaration.getExtractor().getIntValue( (InternalWorkingMemory) workingMemory,
                                                                               tuple.get( pathSeatDeclaration ).getObject() );
                    String guestName = (String) drools.get( pathGuestNameDeclaration );


                    Path path = new Path( id,
                                          seat,
                                          guestName );


                    drools.insert( path );


                    //System.err.println( "make path : " + path );
                } catch ( Exception e ) {
                    e.printStackTrace();
                    throw new ConsequenceException( e );
                }
            }


            public void readExternal(ObjectInput in) throws IOException,
                                                    ClassNotFoundException {


            }


            public void writeExternal(ObjectOutput out) throws IOException {


            }
            
            public String getName() {
                return "default";
            }
        };


        rule.setConsequence( consequence );


        return rule;
    }

View Full Code Here

     * @throws IntrospectionException
     * @throws InvalidRuleException
     */
    private Rule getPathDone() throws IntrospectionException,
                              InvalidRuleException {
        final Rule rule = new Rule( "pathDone" );


        // -----------
        // context : Context( state == Context.MAKE_PATH )
        // -----------
        final Pattern contextPattern = new Pattern( 0,
                                                    this.contextType,
                                                    "context" );


        contextPattern.addConstraint( getLiteralConstraint( contextPattern,
                                                            "state",
                                                            Context.MAKE_PATH ) );


        rule.addPattern( contextPattern );
        final Declaration contextDeclaration = rule.getDeclaration( "context" );


        // ---------------
        // seating : Seating( pathDone == false )
        // ---------------
        final Pattern seatingPattern = new Pattern( 1,
                                                    this.seatingType,
                                                    "seating" );


        seatingPattern.addConstraint( getLiteralConstraint( seatingPattern,
                                                            "pathDone",
                                                            false ) );


        rule.addPattern( seatingPattern );


        final Declaration seatingDeclaration = rule.getDeclaration( "seating" );


        // ------------
        // context.setName( Context.CHECK_DONE );
        // seating.setPathDone( true );
        // ------------
        final Consequence consequence = new Consequence() {


            public void evaluate(KnowledgeHelper drools,
                                 WorkingMemory workingMemory) throws ConsequenceException {
                try {
                    Rule rule = drools.getRule();
                    Tuple tuple = drools.getTuple();


                    Context context = (Context) drools.get( contextDeclaration );
                    Seating seating = (Seating) drools.get( seatingDeclaration );


                    seating.setPathDone( true );


                    //                    if ( seating.getId() == 6 ) {
                    //                        System.err.println( "pause" );
                    //                    }
                    drools.update( tuple.get( seatingDeclaration ) );


                    context.setState( Context.CHECK_DONE );
                    drools.update( tuple.get( contextDeclaration ),
                                   context );
                    //System.err.println( "path done" + seating );
                } catch ( Exception e ) {
                    e.printStackTrace();
                    throw new ConsequenceException( e );
                }
            }


            public void readExternal(ObjectInput in) throws IOException,
                                                    ClassNotFoundException {


            }


            public void writeExternal(ObjectOutput out) throws IOException {


            }
            
            public String getName() {
                return "default";
            }
        };


        rule.setConsequence( consequence );


        return rule;
    }

View Full Code Here

     * @throws IntrospectionException
     * @throws InvalidRuleException
     */
    private Rule getAreWeDone() throws IntrospectionException,
                               InvalidRuleException {
        final Rule rule = new Rule( "areWeDone" );


        // -----------
        // context : Context( state == Context.CHECK_DONE )
        // -----------
        final Pattern contextPattern = new Pattern( 0,
                                                    this.contextType,
                                                    "context" );


        contextPattern.addConstraint( getLiteralConstraint( contextPattern,
                                                            "state",
                                                            Context.CHECK_DONE ) );


        rule.addPattern( contextPattern );
        final Declaration contextDeclaration = rule.getDeclaration( "context" );


        // ---------------
        // LastSeat( lastSeat: seat )
        // ---------------
        final Pattern lastSeatPattern = new Pattern( 1,
                                                     this.lastSeatType );


        setFieldDeclaration( lastSeatPattern,
                             "seat",
                             "lastSeat" );


        rule.addPattern( lastSeatPattern );
        final Declaration lastSeatDeclaration = rule.getDeclaration( "lastSeat" );
        // -------------
        // Seating( rightSeat == lastSeat )
        // -------------
        final Pattern seatingPattern = new Pattern( 2,
                                                    this.seatingType,
                                                    null );


        seatingPattern.addConstraint( getBoundVariableConstraint( seatingPattern,
                                                                  "rightSeat",
                                                                  lastSeatDeclaration,
                                                                  "==" ) );


        rule.addPattern( seatingPattern );


        // ------------
        // context.setName( Context.PRINT_RESULTS );
        // ------------
        final Consequence consequence = new Consequence() {


            public void evaluate(KnowledgeHelper drools,
                                 WorkingMemory workingMemory) throws ConsequenceException {
                try {
                    Rule rule = drools.getRule();
                    Tuple tuple = drools.getTuple();


                    Context context = (Context) drools.get( contextDeclaration );
                    context.setState( Context.PRINT_RESULTS );


                    drools.update( tuple.get( contextDeclaration ),
                                   context );


                    //                    System.err.println( "We Are Done!!!" );
                } catch ( Exception e ) {
                    throw new ConsequenceException( e );
                }
            }


            public void readExternal(ObjectInput in) throws IOException,
                                                    ClassNotFoundException {


            }


            public void writeExternal(ObjectOutput out) throws IOException {


            }
            
            public String getName() {
                return "default";
            }
        };


        rule.setConsequence( consequence );


        return rule;
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.drools.core.rule.Rule

org.drools.compiler.compiler.PackageBuilder

org.drools.compiler.compiler.PackageBuilderTest

org.drools.compiler.compiler.PackageRegistry

org.drools.compiler.integrationtests.CepEspTest

org.drools.compiler.integrationtests.FirstOrderLogicTest

org.drools.compiler.integrationtests.marshalling.MarshallingTest

org.drools.compiler.integrationtests.RuleMetadataTest

org.drools.compiler.lang.api.DescrBuilderTest

org.drools.compiler.phreak.PhreakJoinNodeTest

org.drools.compiler.phreak.PhreakNotNodeTest

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.