basewaltztest.java

jboss规则引擎

package org.drools.examples.waltz;

/*
 * Copyright 2005 JBoss Inc
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

import org.drools.DroolsTestCase;
import org.drools.WorkingMemory;
import org.drools.base.ClassFieldExtractorFactory;
import org.drools.base.ClassObjectType;
import org.drools.base.EvaluatorFactory;
import org.drools.rule.BoundVariableConstraint;
import org.drools.rule.Column;
import org.drools.rule.Declaration;
import org.drools.rule.InvalidRuleException;
import org.drools.rule.LiteralConstraint;
import org.drools.rule.Not;
import org.drools.rule.Or;
import org.drools.rule.Package;
import org.drools.rule.Rule;
import org.drools.spi.Consequence;
import org.drools.spi.ConsequenceException;
import org.drools.spi.Evaluator;
import org.drools.spi.FieldConstraint;
import org.drools.spi.FieldExtractor;
import org.drools.spi.KnowledgeHelper;
import org.drools.spi.MockField;
import org.drools.spi.Tuple;

/**
 * @author Alexander Bagerman
 * 
 */
public abstract class BaseWaltzTest extends DroolsTestCase {
    private ClassObjectType stageType;

    private ClassObjectType lineType;

    private ClassObjectType edgeType;

    private ClassObjectType junctionType;

    private Evaluator       objectEqualEvaluator;

    private Evaluator       objectNotEqualEvaluator;

    private Evaluator       integerEqualEvaluator;

    private Evaluator       integerNotEqualEvaluator;

    private Evaluator       integerGreaterEvaluator;

    private Evaluator       integerLessEvaluator;

    private Evaluator       booleanEqualEvaluator;

    private Evaluator       booleanNotEqualEvaluator;

    protected Package       pkg;

    protected void setUp() throws Exception {
        // types
        this.stageType = new ClassObjectType( Stage.class );
        this.lineType = new ClassObjectType( Line.class );
        this.edgeType = new ClassObjectType( Edge.class );
        this.junctionType = new ClassObjectType( Junction.class );
        // evaluators
        this.integerEqualEvaluator = EvaluatorFactory.getEvaluator( Evaluator.INTEGER_TYPE,
                                                                    Evaluator.EQUAL );
        this.integerNotEqualEvaluator = EvaluatorFactory.getEvaluator( Evaluator.INTEGER_TYPE,
                                                                       Evaluator.NOT_EQUAL );
        this.integerGreaterEvaluator = EvaluatorFactory.getEvaluator( Evaluator.INTEGER_TYPE,
                                                                      Evaluator.GREATER );
        this.integerLessEvaluator = EvaluatorFactory.getEvaluator( Evaluator.INTEGER_TYPE,
                                                                   Evaluator.LESS );

        this.objectEqualEvaluator = EvaluatorFactory.getEvaluator( Evaluator.OBJECT_TYPE,
                                                                   Evaluator.EQUAL );
        this.objectNotEqualEvaluator = EvaluatorFactory.getEvaluator( Evaluator.OBJECT_TYPE,
                                                                      Evaluator.NOT_EQUAL );

        this.booleanEqualEvaluator = EvaluatorFactory.getEvaluator( Evaluator.BOOLEAN_TYPE,
                                                                    Evaluator.EQUAL );
        this.booleanNotEqualEvaluator = EvaluatorFactory.getEvaluator( Evaluator.BOOLEAN_TYPE,
                                                                       Evaluator.NOT_EQUAL );

        // rules
        this.pkg = new Package( "Waltz" );
        this.pkg.addRule( getBeginRule() );
        this.pkg.addRule( getReverseEdgesRule() );
        this.pkg.addRule( getDoneReversingRule() );
        this.pkg.addRule( getMake3JunctionRule() );
        this.pkg.addRule( getMakeLRule() );
        this.pkg.addRule( getDoneDetectingRule() );
        this.pkg.addRule( getInitialBoundaryJunctionLRule() );
        this.pkg.addRule( getInitialBoundaryJunctionArrowRule() );
        this.pkg.addRule( getSecondBoundaryJunctionLRule() );
        this.pkg.addRule( getSecondBoundaryJunctionArrowRule() );
        this.pkg.addRule( getMatchEdgeRule() );
        this.pkg.addRule( getLabelLRule() );
        this.pkg.addRule( getLabelTeeARule() );
        this.pkg.addRule( getLabelTeeBRule() );
        this.pkg.addRule( getLabelFork1Rule() );
        this.pkg.addRule( getLabelFork2Rule() );
        this.pkg.addRule( getLabelFork3Rule() );
        this.pkg.addRule( getLabelFork4Rule() );
        this.pkg.addRule( getLabelArrow1ARule() );
        this.pkg.addRule( getLabelArrow1BRule() );
        this.pkg.addRule( getLabelArrow2ARule() );
        this.pkg.addRule( getLabelArrow2BRule() );
        this.pkg.addRule( getLabelArrow3ARule() );
        this.pkg.addRule( getLabelArrow3BRule() );
        this.pkg.addRule( getLabelArrow4ARule() );
        this.pkg.addRule( getLabelArrow4BRule() );
        this.pkg.addRule( getLabelArrow5ARule() );
        this.pkg.addRule( getLabelArrow5BRule() );
        this.pkg.addRule( getDoneLabelingRule() );
        this.pkg.addRule( getPlotRemainingRule() );
        this.pkg.addRule( getPlotBoudariesRule() );
        this.pkg.addRule( getDonePlotingRule() );
        this.pkg.addRule( getDoneRule() );

    }

    private Rule getBeginRule() throws IntrospectionException,
                               InvalidRuleException {
        final Rule rule = new Rule( "begin" );
        final Column stageColumn = new Column( 0,
                                               this.stageType,
                                               "stage" );
        stageColumn.addConstraint( getLiteralConstraint( stageColumn,
                                                         "value",
                                                         new Integer( Stage.START ),
                                                         this.integerEqualEvaluator ) );
        rule.addPattern( stageColumn );
        final Declaration stageDeclaration = rule.getDeclaration( "stage" );
        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.DUPLICATE );
                    drools.modifyObject( tuple.get( stageDeclaration ),
                                         stage );

                    drools.assertObject( new Line( 122,
                                                   107 ) );
                    drools.assertObject( new Line( 107,
                                                   2207 ) );
                    drools.assertObject( new Line( 2207,
                                                   3204 ) );
                    drools.assertObject( new Line( 3204,
                                                   6404 ) );
                    drools.assertObject( new Line( 2216,
                                                   2207 ) );
                    drools.assertObject( new Line( 3213,
                                                   3204 ) );
                    drools.assertObject( new Line( 2216,
                                                   3213 ) );
                    drools.assertObject( new Line( 107,
                                                   2601 ) );
                    drools.assertObject( new Line( 2601,
                                                   7401 ) );
                    drools.assertObject( new Line( 6404,
                                                   7401 ) );
                    drools.assertObject( new Line( 3213,
                                                   6413 ) );
                    drools.assertObject( new Line( 6413,
                                                   6404 ) );
                    drools.assertObject( new Line( 7416,
                                                   7401 ) );
                    drools.assertObject( new Line( 5216,
                                                   6413 ) );
                    drools.assertObject( new Line( 2216,
                                                   5216 ) );
                    drools.assertObject( new Line( 122,
                                                   5222 ) );
                    drools.assertObject( new Line( 5222,
                                                   7416 ) );
                    drools.assertObject( new Line( 5222,
                                                   5216 ) );
                    System.out.println( "Started waltz..." );
                } catch ( Exception e ) {
                    e.printStackTrace();
                    throw new ConsequenceException( e );
                }
            }
        };
        rule.setConsequence( consequence );
        return rule;
    }

    // ;If the duplicate flag is set, and there is still a line in WM, delete
    // the line
    // ;and add two edges. One edge runs from p1 to p2 and the other runs from
    // p2 to
    // ;p1. We then plot the edge.
    // (p reverse_edges
    // (stage ^value duplicate)
    // (line ^p1 <p1> ^p2 <p2>)
    // -->
    // ; (write draw <p1> <p2> (crlf))
    // (make edge ^p1 <p1> ^p2 <p2> ^joined false)
    // (make edge ^p1 <p2> ^p2 <p1> ^joined false)
    // (remove 2))
    private Rule getReverseEdgesRule() throws IntrospectionException,
                                      InvalidRuleException {
        final Rule rule = new Rule( "reverse_edges" );

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

        final Column lineColumn = new Column( 1,
                                              this.lineType,
                                              "line" );