definitionvalidator.java

一个java工作流引擎

package org.jbpm.model.definition.impl;

import java.util.*;
import org.apache.commons.logging.*;

/**
 * validates a definition.
 */
public class DefinitionValidator {

  private DefinitionImpl definition = null;
  private List errors = null;
  
  public static List validate( DefinitionImpl definition ) {
    DefinitionValidator validator = new DefinitionValidator( definition );
    validator.validate();
    return validator.getErrors();
  }
  
	public DefinitionValidator( DefinitionImpl definition ) {
    this.definition = definition;
    this.errors = new ArrayList();
  }
  
  /**
   * gets the list of error messages as String's.
   * @return a list of Strings that are the error messages.
   */
  public List getErrors() {
    return errors;
  }

  public boolean hasErrors() {
    return ( errors.size() > 0 );  
  }
  
  private void validate() {
    Iterator iter = null; 
    
    if ( definition.getSwimlanes() != null ) {
      iter = definition.getSwimlanes().values().iterator();
      while (iter.hasNext()) validateActor( (SwimlaneImpl) iter.next() );
    }
    
    if ( definition.getTypes() != null ) {
      iter = definition.getTypes().iterator();
      while (iter.hasNext()) validateType( (TypeImpl) iter.next() );
    }
    
    if ( ( definition.getNodes() != null )
         && ( definition.getNodes().size() >0 ) ) {
      iter = definition.getNodes().values().iterator();
      while (iter.hasNext()) {
        try {
          NodeImpl node = (NodeImpl) iter.next();
          
          if ( node == null ) {
            errors.add( "one of the nodes is a null-value" ); 
          } else {
            if ( node instanceof StartStateImpl ) {
              validateStartState( (StartStateImpl) node );
            } else if ( node instanceof EndStateImpl ) {
              validateEndState( (EndStateImpl) node );
            } else if ( node instanceof ProcessStateImpl ) {
              validateProcessState( (ProcessStateImpl) node );
            } else if ( node instanceof StateImpl ) {
              validateState( (StateImpl) node );
            } else if ( node instanceof DecisionImpl ) {
              validateDecision( (DecisionImpl) node );
            } else if ( node instanceof ForkImpl ) {
              validateFork( (ForkImpl) node );
            } else if ( node instanceof JoinImpl ) {
              validateJoin( (JoinImpl) node );
            } else {
              errors.add( "unexpected node type (" + node.getClass().getName() + ")" ); 
            }
          }
        } catch (ClassCastException e) {
          errors.add( "one of the elements in definition.nodes is not a NodeImpl" );
        }
      }
    } else {
      errors.add( "the definition does not have nodes" ); 
    }
    
    if ( definition.getVariables() != null ) {
      iter = definition.getVariables().values().iterator();
      while (iter.hasNext()) validateVariable( (VariableImpl) iter.next() );
    }
  }

	private void validateActor(SwimlaneImpl actor) {
  }

  private void validateType(TypeImpl type) {
  }

  private void validateNode(NodeImpl node) {
    validateElement( node );
    
    if ( ! ( node instanceof EndStateImpl ) ) {
      if ( node.getLeavingTransitions().size() <= 0 ) {
        errors.add( "node '"+ node.getName() + "' does not have a leaving transition" ); 
      }
    }
    
    Iterator iter = node.getLeavingTransitions().iterator();
		while (iter.hasNext()) {
			validateTransition( (TransitionImpl) iter.next() );
		}
  }

	private void validateVariable(VariableImpl variable) {
  }

  private void validateStartState(StartStateImpl startState) {
  }

  private void validateEndState(EndStateImpl endState) {
    if ( ( endState.getLeavingTransitions() != null ) 
         && ( endState.getLeavingTransitions().size() > 0 ) ) {
      errors.add( "the end-state has a leaving transition" ); 
    }
  }

  private void validateProcessState(ProcessStateImpl impl) {
  }

  private void validateState(StateImpl state) {
    if ( ! ( state instanceof StartStateImpl ) ) {
      if ( state.getSwimlane() == null ) {
        errors.add( "state '" + state.getName() + "' is not associated to a swimlane" );
      }
    }
  }

  public void validateDecision( DecisionImpl decision ) {
    // a decision must have at least 2 leaving transitions
    if ( decision.getLeavingTransitions().size() < 2 ) {
      errors.add( "decision '" + decision.getName() + "' has less than 2 leaving transitions" ); 
    }
	}

	public void validateFork(ForkImpl fork) {
	}

	public void validateJoin(JoinImpl join) {
    // a join must have exactly one leaving transition (enforced in the dtd)
    if ( join.getLeavingTransitions().size() != 1 ) {
      errors.add( "join '" + join.getName() + "' does not have exactly one leaving transition" ); 
    }
	}

	public void validateElement(ElementImpl element) {
    Iterator iter = element.getActions().iterator();
		while (iter.hasNext()) validateAction( (ActionImpl) iter.next() );
	}

	public void validateTransition(TransitionImpl transition) {
	}

	public void validateAction(ActionImpl action) {
	}

	public void validateDelegation(DelegationImpl delegation) {
	}

  private static Log log = LogFactory.getLog(DefinitionValidator.class);
}