basewaltztest.java

jboss规则引擎

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

    //   
    // (defrule second_boundary_junction_arrow
    // ?f1 <- (stage (value find_second_boundary))
    // (junction (type arrow) (base_point ?bp) (p1 ?p1) (p2 ?p2) (p3 ?p3))
    // ?f3 <- (edge (p1 ?bp) (p2 ?p1))
    // ?f4 <- (edge (p1 ?bp) (p2 ?p2))
    // ?f5 <- (edge (p1 ?bp) (p2 ?p3))
    // (not (junction (base_point ?b&:(< ?b ?bp))))
    // =>
    // (modify ?f3 (label B))
    // (modify ?f4 (label +))
    // (modify ?f5 (label B))
    // (modify ?f1 (value labeling)))
    private Rule getSecondBoundaryJunctionArrowRule() throws IntrospectionException,
                                                     InvalidRuleException {
        final Rule rule = new Rule( "second_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.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.PLUS );
                    Edge edge3 = (Edge) drools.get( edge3Declaration );
                    edge3.setLabel( Edge.B );
                    Stage stage = (Stage) drools.get( stageDeclaration );
                    stage.setValue( Stage.LABELING );

                    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 an edge whose label we already know definitely, then
    // ;label the corresponding edge in the other direction
    // (defrule match_edge
    // (stage (value labeling))
    // ?f2 <- (edge (p1 ?p1) (p2 ?p2) (label ?label& + | - | B ))
    // ?f3 <- (edge (p1 ?p2) (p2 ?p1) (label nil))
    // =>
    // (modify ?f2 (plotted t))
    // (modify ?f3 (label ?label) (plotted t))
    // ; (write plot ?label ?p1 ?p2 (crlf))
    // )
    private Rule getMatchEdgeRule() throws IntrospectionException,
                                   InvalidRuleException {
        final Rule rule = new Rule( "match_edge" );

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

        final Column edgeColumn1plus = new Column( 1,
                                                   this.edgeType,
                                                   "edge1" );
        edgeColumn1plus.addConstraint( getLiteralConstraint( edgeColumn1plus,
                                                             "label",
                                                             Edge.PLUS,
                                                             this.objectEqualEvaluator ) );
        setFieldDeclaration( edgeColumn1plus,
                             "p1",
                             "edge1p1" );
        setFieldDeclaration( edgeColumn1plus,
                             "p2",
                             "edge1p2" );

        final Column edgeColumn1minus = new Column( 1,
                                                    this.edgeType,
                                                    "edge1" );
        edgeColumn1minus.addConstraint( getLiteralConstraint( edgeColumn1minus,
                                                              "label",
                                                              Edge.MINUS,
                                                              this.objectEqualEvaluator ) );
        setFieldDeclaration( edgeColumn1minus,
                             "p1",
                             "edge1p1" );
        setFieldDeclaration( edgeColumn1minus,
                             "p2",
                             "edge1p2" );

        final Column edgeColumn1b = new Column( 1,
                                                this.edgeType,
                                                "edge1" );
        edgeColumn1b.addConstraint( getLiteralConstraint( edgeColumn1b,
                                                          "label",
                                                          Edge.B,
                                                          this.objectEqualEvaluator ) );
        setFieldDeclaration( edgeColumn1b,
                             "p1",
                             "edge1p1" );
        setFieldDeclaration( edgeColumn1b,
                             "p2",
                             "edge1p2" );

        final Or or = new Or();
        or.addChild( edgeColumn1plus );
        or.addChild( edgeColumn1minus );
        or.addChild( edgeColumn1b );
        rule.addPattern( or );
        final Declaration edge1Declaration = rule.getDeclaration( "edge1" );
        final Declaration edge1P1Declaration = rule.getDeclaration( "edge1p1" );
        final Declaration edge1P2Declaration = rule.getDeclaration( "edge1p2" );

        final Column edgeColumn2 = new Column( 2,
                                               this.edgeType,
                                               "edge2" );
        edgeColumn2.addConstraint( getLiteralConstraint( edgeColumn2,
                                                         "label",
                                                         Edge.NIL,
                                                         this.objectEqualEvaluator ) );
        rule.addPattern( edgeColumn2 );
        final Declaration edge2Declaration = rule.getDeclaration( "edge2" );
        edgeColumn2.addConstraint( getBoundVariableConstraint( edgeColumn2,
                                                               "p1",
                                                               edge1P2Declaration,
                                                               this.integerEqualEvaluator ) );
        edgeColumn2.addConstraint( getBoundVariableConstraint( edgeColumn2,