basewaltztest.java

jboss规则引擎

                                         edge2 );
                } catch ( Exception e ) {
                    e.printStackTrace();
                    throw new ConsequenceException( e );
                }
            }
        };
        rule.setConsequence( consequence );
        return rule;
    }

    // ;Ditto for an arrow
    // (p initial_boundary_junction_arrow
    // (stage ^value find_initial_boundary)
    // (junction ^type arrow ^base_point <bp> ^p1 <p1> ^p2 <p2> ^p3 <p3>)
    // (edge ^p1 <bp> ^p2 <p1>)
    // (edge ^p1 <bp> ^p2 <p2>)
    // (edge ^p1 <bp> ^p2 <p3>)
    // - (junction ^base_point > <bp>)
    // -->
    // (modify 3 ^label B)
    // (modify 4 ^label +)
    // (modify 5 ^label B)
    // (modify 1 ^value find_second_boundary))
    private Rule getInitialBoundaryJunctionArrowRule() throws IntrospectionException,
                                                      InvalidRuleException {
        final Rule rule = new Rule( "initial_boundary_junction_arrow" );

        final Column stageColumn = new Column( 0,
                                               this.stageType,
                                               "stage" );
        stageColumn.addConstraint( getLiteralConstraint( stageColumn,
                                                         "value",
                                                         new Integer( Stage.FIND_INITIAL_BOUNDARY ),
                                                         this.integerEqualEvaluator ) );
        rule.addPattern( stageColumn );
        final Declaration stageDeclaration = rule.getDeclaration( "stage" );

        final Column junctionColumn = new Column( 1,
                                                  this.junctionType );
        junctionColumn.addConstraint( getLiteralConstraint( junctionColumn,
                                                            "type",
                                                            Junction.ARROW,
                                                            this.objectEqualEvaluator ) );
        setFieldDeclaration( junctionColumn,
                             "basePoint",
                             "junctionBasePoint" );
        setFieldDeclaration( junctionColumn,
                             "p1",
                             "junctionP1" );
        setFieldDeclaration( junctionColumn,
                             "p2",
                             "junctionP2" );
        setFieldDeclaration( junctionColumn,
                             "p3",
                             "junctionP3" );
        rule.addPattern( junctionColumn );
        final Declaration junctionBasePointDeclaration = rule.getDeclaration( "junctionBasePoint" );
        final Declaration junctionP1Declaration = rule.getDeclaration( "junctionP1" );
        final Declaration junctionP2Declaration = rule.getDeclaration( "junctionP2" );
        final Declaration junctionP3Declaration = rule.getDeclaration( "junctionP3" );

        final Column edgeColumn1 = new Column( 2,
                                               this.edgeType,
                                               "edge1" );
        rule.addPattern( edgeColumn1 );
        final Declaration edge1Declaration = rule.getDeclaration( "edge1" );
        edgeColumn1.addConstraint( getBoundVariableConstraint( edgeColumn1,
                                                               "p1",
                                                               junctionBasePointDeclaration,
                                                               this.integerEqualEvaluator ) );
        edgeColumn1.addConstraint( getBoundVariableConstraint( edgeColumn1,
                                                               "p2",
                                                               junctionP1Declaration,
                                                               this.integerEqualEvaluator ) );

        final Column edgeColumn2 = new Column( 3,
                                               this.edgeType,
                                               "edge2" );
        rule.addPattern( edgeColumn2 );
        final Declaration edge2Declaration = rule.getDeclaration( "edge2" );
        edgeColumn2.addConstraint( getBoundVariableConstraint( edgeColumn2,
                                                               "p1",
                                                               junctionBasePointDeclaration,
                                                               this.integerEqualEvaluator ) );
        edgeColumn2.addConstraint( getBoundVariableConstraint( edgeColumn2,
                                                               "p2",
                                                               junctionP2Declaration,
                                                               this.integerEqualEvaluator ) );

        final Column edgeColumn3 = new Column( 4,
                                               this.edgeType,
                                               "edge3" );
        rule.addPattern( edgeColumn3 );
        final Declaration edge3Declaration = rule.getDeclaration( "edge3" );
        edgeColumn3.addConstraint( getBoundVariableConstraint( edgeColumn3,
                                                               "p1",
                                                               junctionBasePointDeclaration,
                                                               this.integerEqualEvaluator ) );
        edgeColumn3.addConstraint( getBoundVariableConstraint( edgeColumn3,
                                                               "p2",
                                                               junctionP3Declaration,
                                                               this.integerEqualEvaluator ) );

        final Column notJunctionColumn = new Column( 5,
                                                     this.junctionType );
        notJunctionColumn.addConstraint( getBoundVariableConstraint( notJunctionColumn,
                                                                     "basePoint",
                                                                     junctionBasePointDeclaration,
                                                                     this.integerGreaterEvaluator ) );
        final Not notJunction = new Not();
        notJunction.addChild( notJunctionColumn );
        rule.addPattern( notJunction );

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

                    Stage stage = (Stage) drools.get( stageDeclaration );
                    stage.setValue( Stage.FIND_SECOND_BOUNDARY );
                    Edge edge1 = (Edge) drools.get( edge1Declaration );
                    edge1.setLabel( Edge.B );
                    Edge edge2 = (Edge) drools.get( edge2Declaration );
                    edge2.setLabel( Edge.PLUS );
                    Edge edge3 = (Edge) drools.get( edge3Declaration );
                    edge3.setLabel( Edge.B );

                    drools.modifyObject( tuple.get( stageDeclaration ),
                                         stage );
                    drools.modifyObject( tuple.get( edge1Declaration ),
                                         edge1 );
                    drools.modifyObject( tuple.get( edge2Declaration ),
                                         edge2 );
                    drools.modifyObject( tuple.get( edge3Declaration ),
                                         edge3 );
                } catch ( Exception e ) {
                    e.printStackTrace();
                    throw new ConsequenceException( e );
                }
            }
        };
        rule.setConsequence( consequence );
        return rule;
    }

    //   
    // ;If we have already found the first boundary point, then find the second
    // ;boundary point, and label it.
    //   
    // (defrule second_boundary_junction_L
    // ?f1 <- (stage (value find_second_boundary))
    // (junction (type L) (base_point ?base_point) (p1 ?p1) (p2 ?p2))
    // ?f3 <- (edge (p1 ?base_point) (p2 ?p1))
    // ?f4 <- (edge (p1 ?base_point) (p2 ?p2))
    // (not (junction (base_point ?bp&:(< ?bp ?base_point))))
    // =>
    // (modify ?f3 (label B))
    // (modify ?f4 (label B))
    // (modify ?f1 (value labeling)))
    private Rule getSecondBoundaryJunctionLRule() throws IntrospectionException,
                                                 InvalidRuleException {
        final Rule rule = new Rule( "second_boundary_junction_L" );

        final Column stageColumn = new Column( 0,
                                               this.stageType,
                                               "stage" );
        stageColumn.addConstraint( getLiteralConstraint( stageColumn,
                                                         "value",
                                                         new Integer( Stage.FIND_SECOND_BOUNDARY ),
                                                         this.integerEqualEvaluator ) );
        rule.addPattern( stageColumn );
        final Declaration stageDeclaration = rule.getDeclaration( "stage" );

        final Column junctionColumn = new Column( 1,
                                                  this.junctionType );
        junctionColumn.addConstraint( getLiteralConstraint( junctionColumn,
                                                            "type",
                                                            Junction.L,
                                                            this.objectEqualEvaluator ) );
        setFieldDeclaration( junctionColumn,
                             "basePoint",
                             "junctionBasePoint" );
        setFieldDeclaration( junctionColumn,
                             "p1",
                             "junctionP1" );
        setFieldDeclaration( junctionColumn,
                             "p2",
                             "junctionP2" );
        rule.addPattern( junctionColumn );
        final Declaration junctionBasePointDeclaration = rule.getDeclaration( "junctionBasePoint" );
        final Declaration junctionP1Declaration = rule.getDeclaration( "junctionP1" );
        final Declaration junctionP2Declaration = rule.getDeclaration( "junctionP2" );

        final Column edgeColumn1 = new Column( 2,
                                               this.edgeType,
                                               "edge1" );
        rule.addPattern( edgeColumn1 );
        final Declaration edge1Declaration = rule.getDeclaration( "edge1" );
        edgeColumn1.addConstraint( getBoundVariableConstraint( edgeColumn1,
                                                               "p1",
                                                               junctionBasePointDeclaration,
                                                               this.integerEqualEvaluator ) );
        edgeColumn1.addConstraint( getBoundVariableConstraint( edgeColumn1,
                                                               "p2",
                                                               junctionP1Declaration,
                                                               this.integerEqualEvaluator ) );

        final Column edgeColumn2 = new Column( 3,
                                               this.edgeType,
                                               "edge2" );
        rule.addPattern( edgeColumn2 );
        final Declaration edge2Declaration = rule.getDeclaration( "edge2" );
        edgeColumn2.addConstraint( getBoundVariableConstraint( edgeColumn2,
                                                               "p1",
                                                               junctionBasePointDeclaration,
                                                               this.integerEqualEvaluator ) );
        edgeColumn2.addConstraint( getBoundVariableConstraint( edgeColumn2,
                                                               "p2",
                                                               junctionP2Declaration,
                                                               this.integerEqualEvaluator ) );

        final Column notJunctionColumn = new Column( 4,
                                                     this.junctionType );
        notJunctionColumn.addConstraint( getBoundVariableConstraint( notJunctionColumn,
                                                                     "basePoint",
                                                                     junctionBasePointDeclaration,
                                                                     this.integerLessEvaluator ) );
        final Not notJunction = new Not();
        notJunction.addChild( notJunctionColumn );
        rule.addPattern( notJunction );

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

                    Edge edge1 = (Edge) drools.get( edge1Declaration );
                    edge1.setLabel( Edge.B );
                    Edge edge2 = (Edge) drools.get( edge2Declaration );
                    edge2.setLabel( Edge.B );
                    Stage stage = (Stage) drools.get( stageDeclaration );
                    stage.setValue( Stage.LABELING );