VerifierDataMaps.java example

Explorer
droolsjbpm-master
/**
 * Copyright 2010 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.
 */

package org.drools.verifier.data;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import org.drools.verifier.components.Field;
import org.drools.verifier.components.Import;
import org.drools.verifier.components.ObjectType;
import org.drools.verifier.components.Pattern;
import org.drools.verifier.components.Restriction;
import org.drools.verifier.components.RulePackage;
import org.drools.verifier.components.Variable;
import org.drools.verifier.components.VerifierComponentType;
import org.drools.verifier.components.EntryPoint;
import org.drools.verifier.components.VerifierRule;

import com.google.common.collect.Multimap;
import com.google.common.collect.TreeMultimap;

/**
 * 
 * @author Toni Rikkola
 */
class VerifierDataMaps
    implements
    VerifierData {

    private Map<VerifierComponentType, Map<String, VerifierComponent>> all                            = new TreeMap<VerifierComponentType, Map<String, VerifierComponent>>();

    private Map<String, RulePackage>                                   packagesByName                 = new TreeMap<String, RulePackage>();
    private Map<String, ObjectType>                                    objectTypesByFullName          = new TreeMap<String, ObjectType>();
    private Map<String, Field>                                         fieldsByObjectTypeAndFieldName = new TreeMap<String, Field>();
    private Multimap<String, Field>                                    fieldsByObjectTypeId           = TreeMultimap.create();
    private Multimap<String, Pattern>                                  patternsByObjectTypeId         = TreeMultimap.create();
    private Multimap<String, Pattern>                                  patternsByRuleName             = TreeMultimap.create();
    private Multimap<String, Restriction>                              restrictionsByFieldId          = TreeMultimap.create();
    private Map<String, Variable>                                      variablesByRuleAndVariableName = new TreeMap<String, Variable>();
    private Map<String, EntryPoint>                       entryPointsByEntryId           = new TreeMap<String, EntryPoint>();
    private Map<String, VerifierRule>                                  rulesByName                    = new TreeMap<String, VerifierRule>();
    private Map<String, Import>                                        importsByName                  = new TreeMap<String, Import>();
    private Multimap<String, VerifierRule>                             rulesByCategory                = TreeMultimap.create();

    public Collection<ObjectType> getObjectTypesByRuleName(String ruleName) {
        Set<ObjectType> set = new HashSet<ObjectType>();

        for ( Pattern pattern : patternsByRuleName.get( ruleName ) ) {
            ObjectType objectType = (ObjectType) getVerifierObject( VerifierComponentType.OBJECT_TYPE,
                                                                    pattern.getObjectTypePath() );
            set.add( objectType );
        }

        return set;
    }

    public ObjectType getObjectTypeByFullName(String name) {
        return objectTypesByFullName.get( name );
    }

    public Field getFieldByObjectTypeAndFieldName(String objectTypeName,
                                                  String fieldName) {
        return fieldsByObjectTypeAndFieldName.get( objectTypeName + "." + fieldName );
    }

    public Variable getVariableByRuleAndVariableName(String ruleName,
                                                     String variableName) {
        return variablesByRuleAndVariableName.get( ruleName + "." + variableName );
    }

    public Collection<VerifierComponent> getAll() {
        List<VerifierComponent> objects = new ArrayList<VerifierComponent>();

        for ( VerifierComponentType type : all.keySet() ) {
            objects.addAll( all.get( type ).values() );
        }

        return objects;
    }

    public Collection<Field> getFieldsByObjectTypeId(String id) {
        return fieldsByObjectTypeId.get( id );
    }

    public Collection<VerifierRule> getRulesByObjectTypePath(String id) {
        Set<VerifierRule> rules = new HashSet<VerifierRule>();

        for ( Pattern pattern : patternsByObjectTypeId.get( id ) ) {

            rules.add( (VerifierRule) getVerifierObject( VerifierComponentType.RULE,
                                                         pattern.getRulePath() ) );
        }

        return rules;
    }

    public Collection<VerifierRule> getRulesByFieldPath(String id) {

        Set<VerifierRule> rules = new HashSet<VerifierRule>();

        for ( Restriction restriction : restrictionsByFieldId.get( id ) ) {

            rules.add( (VerifierRule) getVerifierObject( VerifierComponentType.RULE,
                                                         restriction.getRulePath() ) );
        }

        return rules;
    }

    public RulePackage getPackageByName(String name) {
        return packagesByName.get( name );
    }

    public Collection<Restriction> getRestrictionsByFieldPath(String id) {
        return restrictionsByFieldId.get( id );
    }

    public void add(VerifierComponent object) {
        if ( VerifierComponentType.FIELD.equals( object.getVerifierComponentType() ) ) {
            Field field = (Field) object;
            ObjectType objectType = (ObjectType) getVerifierObject( VerifierComponentType.OBJECT_TYPE,
                                                                    field.getObjectTypePath() );
            fieldsByObjectTypeAndFieldName.put( objectType.getFullName() + "." + field.getName(),
                                                field );

            fieldsByObjectTypeId.put( field.getObjectTypePath(),
                                      field );
        } else if ( VerifierComponentType.RULE.equals( object.getVerifierComponentType() ) ) {
            VerifierRule rule = (VerifierRule) object;
            rulesByName.put( rule.getName(),
                             rule );
            if ( rule.getMetadata().containsKey( "category" ) ) {
                rulesByCategory.put( rule.getMetaAttribute("category"),
                                     rule );
            }
        } else if ( VerifierComponentType.VARIABLE.equals( object.getVerifierComponentType() ) ) {
            Variable variable = (Variable) object;
            variablesByRuleAndVariableName.put( variable.getRuleName() + "." + variable.getName(),
                                                variable );
        } else if ( VerifierComponentType.PATTERN.equals( object.getVerifierComponentType() ) ) {
            Pattern pattern = (Pattern) object;

            patternsByObjectTypeId.put( pattern.getObjectTypePath(),
                                        pattern );
            patternsByRuleName.put( pattern.getRuleName(),
                                    pattern );
        } else if ( VerifierComponentType.RESTRICTION.equals( object.getVerifierComponentType() ) ) {
            Restriction restriction = (Restriction) object;

            restrictionsByFieldId.put( restriction.getFieldPath(),
                                       restriction );
        } else if ( VerifierComponentType.RULE_PACKAGE.equals( object.getVerifierComponentType() ) ) {
            RulePackage rulePackage = (RulePackage) object;

            packagesByName.put( rulePackage.getName(),
                                rulePackage );
        } else if ( VerifierComponentType.IMPORT.equals( object.getVerifierComponentType() ) ) {
            Import objectImport = (Import) object;
            importsByName.put( objectImport.getName(),
                               objectImport );
        } else if ( VerifierComponentType.OBJECT_TYPE.equals( object.getVerifierComponentType() ) ) {
            ObjectType objectType = (ObjectType) object;
            objectTypesByFullName.put( objectType.getFullName(),
                                       objectType );
        } else if ( VerifierComponentType.ENTRY_POINT_DESCR.equals( object.getVerifierComponentType() ) ) {
            EntryPoint entryPoint = (EntryPoint) object;
            entryPointsByEntryId.put( entryPoint.getEntryPointName(),
                                      entryPoint );
        }

        Map<String, VerifierComponent> map = all.get( object.getVerifierComponentType() );

        if ( map == null ) {
            map = new TreeMap<String, VerifierComponent>();
            all.put( object.getVerifierComponentType(),
                     map );
        }

        String path = object.getPath();

        map.put( path,
                 object );

    }

    public Collection<VerifierRule> getRulesByCategoryName(String categoryName) {
        return rulesByCategory.get( categoryName );
    }

    //    public <T extends VerifierComponent> Collection<T> getAll(VerifierComponentType type) {
    public Collection< ? extends VerifierComponent> getAll(VerifierComponentType type) {
        Map<String, VerifierComponent> result = all.get( type );

        if ( result == null ) {
            return Collections.emptyList();
        } else {
            return result.values();
        }
    }

    //    public <T extends VerifierComponent> T getVerifierObject(VerifierComponentType type,
    //                                                             String path) {
    public VerifierComponent getVerifierObject(VerifierComponentType type,
                                               String path) {
        return all.get( type ).get( path );
    }

    public EntryPoint getEntryPointByEntryId(String entryId) {
        return entryPointsByEntryId.get( entryId );
    }

    public VerifierRule getRuleByName(String name) {
        return rulesByName.get( name );
    }

    public Import getImportByName(String name) {
        return importsByName.get( name );
    }

    public ObjectType getObjectTypeByObjectTypeNameAndPackageName(String factTypeName,
                                                                  String packageName) {

        for ( VerifierComponent verifierComponent : getAll( VerifierComponentType.IMPORT ) ) {
            Import objectImport = (Import) verifierComponent;

            if ( objectImport.getPackageName().equals( packageName ) && objectImport.getShortName().equals( factTypeName ) ) {
                return this.objectTypesByFullName.get( objectImport.getName() );
            }
        }

        return null;
    }
}