rulebuilder.java

jboss规则引擎

                    ce.addChild( not );
                } else if ( object instanceof ExistsDescr ) {
                    final Exists exists = new Exists();
                    this.columnCounter.setParent( exists );
                    build( rule,
                           (ConditionalElementDescr) object,
                           exists,
                           true,   // when EXIST is used, offset MUST be decremented
                           true ); // when EXIST is used, offset MUST be decremented for first column
                    ce.addChild( exists );
                } else if ( object instanceof EvalDescr ) {
                    final EvalCondition eval = build( (EvalDescr) object );
                    if ( eval != null ) {
                        ce.addChild( eval );
                    }
                }
            } else if ( object instanceof ColumnDescr ) {
                if ( decrementOffset && decrementFirst ) {
                    this.columnOffset--;
                } else {
                    decrementFirst = true;
                }
                final Column column = build( (ColumnDescr) object );
                if ( column != null ) {
                    ce.addChild( column );
                }
            }
        }
    }

    private Column build(final ColumnDescr columnDescr) {
        if ( columnDescr.getObjectType() == null || columnDescr.getObjectType().equals( "" ) ) {
            this.errors.add( new RuleError( this.rule,
                                            columnDescr,
                                            null,
                                            "ObjectType not correctly defined" ) );
            return null;
        }

        Class clazz = null;

        try {
            //clazz = Class.forName( columnDescr.getObjectType() );
            clazz = this.typeResolver.resolveType( columnDescr.getObjectType() );
        } catch ( final ClassNotFoundException e ) {
            this.errors.add( new RuleError( this.rule,
                                            columnDescr,
                                            null,
                                            "Unable to resolve ObjectType '" + columnDescr.getObjectType() + "'" ) );
            return null;
        }

        Column column;
        if ( columnDescr.getIdentifier() != null && !columnDescr.getIdentifier().equals( "" ) ) {
            column = new Column( this.columnCounter.getNext(),
                                 this.columnOffset,
                                 new ClassObjectType( clazz ),
                                 columnDescr.getIdentifier() );;
            this.declarations.put( column.getDeclaration().getIdentifier(),
                                   column.getDeclaration() );

            if ( this.notDeclarations != null ) {
                this.notDeclarations.put( column.getDeclaration().getIdentifier(),
                                          column.getDeclaration() );
            }
        } else {
            column = new Column( this.columnCounter.getNext(),
                                 this.columnOffset,
                                 new ClassObjectType( clazz ),
                                 null );
        }

        for ( final Iterator it = columnDescr.getDescrs().iterator(); it.hasNext(); ) {
            final Object object = it.next();
            if ( object instanceof FieldBindingDescr ) {
                build( column,
                       (FieldBindingDescr) object );
            } else if ( object instanceof LiteralDescr ) {
                build( column,
                       (LiteralDescr) object );
            } else if ( object instanceof BoundVariableDescr ) {
                build( column,
                       (BoundVariableDescr) object );
            } else if ( object instanceof ReturnValueDescr ) {
                build( column,
                       (ReturnValueDescr) object );
            } else if ( object instanceof PredicateDescr ) {
                build( column,
                       (PredicateDescr) object );
            }
        }
        return column;
    }

    private void build(final Column column,
                       final FieldBindingDescr fieldBindingDescr) {
        Declaration declaration = (Declaration) this.declarations.get( fieldBindingDescr.getIdentifier() );
        if ( declaration != null ) {
            // This declaration already  exists, so throw an Exception
            this.errors.add( new RuleError( this.rule,
                                            fieldBindingDescr,
                                            null,
                                            "Duplicate declaration for variable '" + fieldBindingDescr.getIdentifier() + "' in the rule '" + this.rule.getName() + "'" ) );
            return;
        }

        final Class clazz = ((ClassObjectType) column.getObjectType()).getClassType();

        final FieldExtractor extractor = getFieldExtractor( fieldBindingDescr,
                                                            clazz,
                                                            fieldBindingDescr.getFieldName() );
        if ( extractor == null ) {
            return;
        }

        declaration = column.addDeclaration( fieldBindingDescr.getIdentifier(),
                                             extractor );

        this.declarations.put( declaration.getIdentifier(),
                               declaration );

        if ( this.notDeclarations != null ) {
            this.notDeclarations.put( declaration.getIdentifier(),
                                      declaration );
        }
    }

    private void build(final Column column,
                       final BoundVariableDescr boundVariableDescr) {
        if ( boundVariableDescr.getIdentifier() == null || boundVariableDescr.getIdentifier().equals( "" ) ) {
            this.errors.add( new RuleError( this.rule,
                                            boundVariableDescr,
                                            null,
                                            "Identifier not defined for binding field '" + boundVariableDescr.getFieldName() + "'" ) );
            return;
        }

        final Class clazz = ((ClassObjectType) column.getObjectType()).getClassType();

        final FieldExtractor extractor = getFieldExtractor( boundVariableDescr,
                                                            clazz,
                                                            boundVariableDescr.getFieldName() );
        if ( extractor == null ) {
            return;
        }

        final Declaration declaration = (Declaration) this.declarations.get( boundVariableDescr.getIdentifier() );

        if ( declaration == null ) {
            this.errors.add( new RuleError( this.rule,
                                            boundVariableDescr,
                                            null,
                                            "Unable to return Declaration for identifier '" + boundVariableDescr.getIdentifier() + "'" ) );
            return;
        }

        final Evaluator evaluator = getEvaluator( boundVariableDescr,
                                                  extractor.getObjectType().getValueType(),
                                                  boundVariableDescr.getEvaluator() );
        if ( evaluator == null ) {
            return;
        }

        column.addConstraint( new BoundVariableConstraint( extractor,
                                                           declaration,
                                                           evaluator ) );
    }

    private void build(final Column column,
                       final LiteralDescr literalDescr) {

        final Class clazz = ((ClassObjectType) column.getObjectType()).getClassType();

        final FieldExtractor extractor = getFieldExtractor( literalDescr,
                                                            clazz,
                                                            literalDescr.getFieldName() );
        if ( extractor == null ) {
            return;
        }

        FieldValue field = null;
        if ( literalDescr.isStaticFieldValue() ) {
            final int lastDot = literalDescr.getText().lastIndexOf( '.' );
            final String className = literalDescr.getText().substring( 0,
                                                                       lastDot );
            final String fieldName = literalDescr.getText().substring( lastDot + 1 );
            try {
                final Class staticClass = this.typeResolver.resolveType( className );
                field = new FieldImpl( staticClass.getField( fieldName ).get( null ) );
            } catch ( final ClassNotFoundException e ) {
                this.errors.add( new RuleError( this.rule,
                                                literalDescr,
                                                e,
                                                e.getMessage() ) );
            } catch ( final Exception e ) {
                this.errors.add( new RuleError( this.rule,
                                                literalDescr,
                                                e,
                                                "Unable to create a Field value of type  '" + extractor.getObjectType().getValueType() + "' and value '" + literalDescr.getText() + "'" ) );
            }

        } else {
            try {
                field = FieldFactory.getFieldValue( literalDescr.getText(),
                                                    extractor.getObjectType().getValueType() );
            } catch ( final Exception e ) {
                this.errors.add( new RuleError( this.rule,
                                                literalDescr,
                                                e,
                                                "Unable to create a Field value of type  '" + extractor.getObjectType().getValueType() + "' and value '" + literalDescr.getText() + "'" ) );
            }
        }

        final Evaluator evaluator = getEvaluator( literalDescr,
                                                  extractor.getObjectType().getValueType(),
                                                  literalDescr.getEvaluator() );
        if ( evaluator == null ) {
            return;
        }

        column.addConstraint( new LiteralConstraint( field,
                                                     extractor,
                                                     evaluator ) );
    }

    private void build(final Column column,
                       final ReturnValueDescr returnValueDescr) {
        final String classMethodName = "returnValue" + this.counter++;
        returnValueDescr.setClassMethodName( classMethodName );

        final List[] usedIdentifiers = getUsedIdentifiers( returnValueDescr,
                                                           returnValueDescr.getText() );

        final Declaration[] declarations = new Declaration[usedIdentifiers[0].size()];
        for ( int i = 0, size = usedIdentifiers[0].size(); i < size; i++ ) {
            declarations[i] = (Declaration) this.declarations.get( (String) usedIdentifiers[0].get( i ) );
        }

        final Class clazz = ((ClassObjectType) column.getObjectType()).getClassType();
        final FieldExtractor extractor = getFieldExtractor( returnValueDescr,
                                                            clazz,
                                                            returnValueDescr.getFieldName() );
        if ( extractor == null ) {
            return;
        }

        final Evaluator evaluator = getEvaluator( returnValueDescr,
                                                  extractor.getObjectType().getValueType(),
                                                  returnValueDescr.getEvaluator() );
        if ( evaluator == null ) {
            return;
        }

        final ReturnValueConstraint returnValueConstraint = new ReturnValueConstraint( extractor,
                                                                                       declarations,
                                                                                       evaluator );
        column.addConstraint( returnValueConstraint );

        StringTemplate st = RuleBuilder.ruleGroup.getInstanceOf( "returnValueMethod" );

        setStringTemplateAttributes( st,
                                     declarations,
                                     (String[]) usedIdentifiers[1].toArray( new String[usedIdentifiers[1].size()] ),
                                     returnValueDescr.getText() );

        st.setAttribute( "methodName",
                         classMethodName );

        final String returnValueText = RuleBuilder.functionFixer.fix( returnValueDescr.getText() );
        st.setAttribute( "text",
                         returnValueText );

        this.methods.add( st.toString() );

        st = RuleBuilder.invokerGroup.getInstanceOf( "returnValueInvoker" );

        st.setAttribute( "package",
                         this.pkg.getName() );
        st.setAttribute( "ruleClassName",
                         ucFirst( this.ruleDescr.getClassName() ) );
        st.setAttribute( "invokerClassName",
                         this.ruleDescr.getClassName() + ucFirst( classMethodName ) + "Invoker" );
        st.setAttribute( "methodName",
                         classMethodName );

        setStringTemplateAttributes( st,
                                     declarations,
                                     (String[]) usedIdentifiers[1].toArray( new String[usedIdentifiers[1].size()] ),
                                     returnValueDescr.getText() );

        st.setAttribute( "hashCode",
                         returnValueText.hashCode() );

        final String invokerClassName = this.pkg.getName() + "." + this.ruleDescr.getClassName() + ucFirst( classMethodName ) + "Invoker";
        this.invokers.put( invokerClassName,
                           st.toString() );
        this.invokerLookups.put( invokerClassName,
                                 returnValueConstraint );
        this.descrLookups.put( invokerClassName,
                               returnValueDescr );
    }

    private void build(final Column column,
                       final PredicateDescr predicateDescr) {
        // generate method
        // generate Invoker
        final String classMethodName = "predicate" + this.counter++;
        predicateDescr.setClassMethodName( classMethodName );

        final Class clazz = ((ClassObjectType) column.getObjectType()).getClassType();

        final FieldExtractor extractor = getFieldExtractor( predicateDescr,
                                                            clazz,
                                                            predicateDescr.getFieldName() );
        if ( extractor == null ) {
            return;
        }

        final Declaration declaration = column.addDeclaration( predicateDescr.getDeclaration(),
                                                               extractor );

        this.declarations.put( declaration.getIdentifier(),
                               declaration );

        if ( this.notDeclarations != null ) {
            this.notDeclarations.put( declaration.getIdentifier(),
                                      declaration );
        }

        final List[] usedIdentifiers = getUsedIdentifiers( predicateDescr,
                                                           predicateDescr.getText() );
        // Don't include the focus declaration, that hasn't been merged into the tuple yet.
        usedIdentifiers[0].remove( predicateDescr.getDeclaration() );