basemannerstest.java

jboss规则引擎

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

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

        seatingColumn.addConstraint( getLiteralConstraint( seatingColumn,
                                                           "pathDone",
                                                           new Boolean( false ),
                                                           this.booleanEqualEvaluator ) );

        rule.addPattern( seatingColumn );

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

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

        pathColumn.addConstraint( getBoundVariableConstraint( pathColumn,
                                                              "id",
                                                              seatingPidDeclaration,
                                                              this.integerEqualEvaluator ) );

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

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

        rule.addPattern( pathColumn );

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

        notPathColumn.addConstraint( getBoundVariableConstraint( notPathColumn,
                                                                 "id",
                                                                 seatingIdDeclaration,
                                                                 this.integerEqualEvaluator ) );
        notPathColumn.addConstraint( getBoundVariableConstraint( notPathColumn,
                                                                 "guestName",
                                                                 pathGuestNameDeclaration,
                                                                 this.objectEqualEvaluator ) );

        final Not not = new Not();

        not.addChild( notPathColumn );

        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 = ((Integer) drools.get( seatingIdDeclaration )).intValue();
                    int seat = ((Integer) drools.get( pathSeatDeclaration )).intValue();
                    String guestName = (String) drools.get( pathGuestNameDeclaration );

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

                    drools.assertObject( path );

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

        };

        rule.setConsequence( consequence );

        return rule;
    }

    /**
     * 
     * <pre>
     * rule pathDone() { 
     *     Context context; Seating seating; 
     *     when { 
     *         context : Context( state == Context.MAKE_PATH ) 
     *         seating : Seating( pathDone == false ) 
     *     } then { 
     *         seating.setPathDone( true ); 
     *         context.setName( Context.CHECK_DONE ); 
     *     } 
     * }
     * </pre>
     * 
     * @return
     * @throws IntrospectionException
     * @throws InvalidRuleException
     */
    private Rule getPathDone() throws IntrospectionException,
                              InvalidRuleException {
        final Rule rule = new Rule( "pathDone" );

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

        contextColumn.addConstraint( getLiteralConstraint( contextColumn,
                                                           "state",
                                                           new Integer( Context.MAKE_PATH ),
                                                           this.integerEqualEvaluator ) );

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

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

        seatingColumn.addConstraint( getLiteralConstraint( seatingColumn,
                                                           "pathDone",
                                                           new Boolean( false ),
                                                           this.booleanEqualEvaluator ) );

        rule.addPattern( seatingColumn );

        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.out.println( "pause" );
                    }
                    drools.modifyObject( tuple.get( seatingDeclaration ),
                                         seating );

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

        };

        rule.setConsequence( consequence );

        return rule;
    }

    /**
     * <pre>
     * rule areWeDone() { 
     *     Context context; LastSeat lastSear; 
     *     when { 
     *         context : Context( state == Context.CHECK_DONE ) 
     *         LastSeat( lastSeat: seat )
     *         Seating( rightSeat == lastSeat ) 
     *     } then { 
     *         context.setState(Context.PRINT_RESULTS ); 
     *     } 
     * }
     * </pre>
     * 
     * @return
     * @throws IntrospectionException
     * @throws InvalidRuleException
     */
    private Rule getAreWeDone() throws IntrospectionException,
                               InvalidRuleException {
        final Rule rule = new Rule( "areWeDone" );

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

        contextColumn.addConstraint( getLiteralConstraint( contextColumn,
                                                           "state",
                                                           new Integer( Context.CHECK_DONE ),
                                                           this.integerEqualEvaluator ) );

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

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

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

        rule.addPattern( lastSeatColumn );
        final Declaration lastSeatDeclaration = rule.getDeclaration( "lastSeat" );
        // -------------
        // Seating( rightSeat == lastSeat )
        // -------------
        final Column seatingColumn = new Column( 2,
                                                 this.seatingType,
                                                 null );

        seatingColumn.addConstraint( getBoundVariableConstraint( seatingColumn,
                                                                 "rightSeat",
                                                                 lastSeatDeclaration,
                                                                 this.integerEqualEvaluator ) );

        rule.addPattern( seatingColumn );

        // ------------
        // 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.modifyObject( tuple.get( contextDeclaration ),
                                         context );

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

        };

        rule.setConsequence( consequence );

        return rule;
    }