definitionparser.java

一个java工作流引擎

    addName(NameType.NODE, fork.getName());
    fork.setDescription(getElementText(forkXml, "description", null));
    DelegationImpl forkDelegation = parseDelegation(forkXml);
    if (forkDelegation != null) {
      fork.setForkDelegation(forkDelegation);
    } else {
      // set the corresponding join for validation purposes
      unresolvedReferences.add(new UnresolvedFork(fork, getAttribute(forkXml, "corresponding-join", null)));
    }
    parseTransitions(fork, forkXml);
    parseActions(fork, forkXml);
    return fork;
  }

  private NodeImpl parseDecision(Element decisionXml) {
    DecisionImpl decision = new DecisionImpl(getAttribute(decisionXml, "name"));
    addName(NameType.NODE, decision.getName());
    decision.setDescription(getElementText(decisionXml, "description", null));
    decision.setDecisionDelegation(parseDelegation(decisionXml));
    parseTransitions(decision, decisionXml);
    parseActions(decision, decisionXml);
    return decision;
  }

  private NodeImpl parseProcessState(Element processStateXml) {
    ProcessStateImpl processState = new ProcessStateImpl(getAttribute(processStateXml, "name"));
    addName(NameType.NODE, processState.getName());
    processState.setDescription(getElementText(processStateXml, "description", null));
    processState.setProcessInvocationDelegation(parseDelegation(processStateXml));
    parseTransitions(processState, processStateXml);
    parseActions(processState, processStateXml);
    return processState;
  }

  private NodeImpl parseState(Element stateXml) {
    StateImpl state = new StateImpl(getAttribute(stateXml, "name"));
    addName(NameType.NODE, state.getName());
    state.setDescription(getElementText(stateXml, "description", null));
    resolveSwimlane(state, stateXml);
    parseTransitions(state, stateXml);
    parseActions(state, stateXml);
    return state;
  }

  private void resolveSwimlane(StateImpl state, Element stateXml) {
    String swimlaneName = getAttribute(stateXml, "swimlane", null);
    state.setSwimlane(definition.getSwimlane(swimlaneName));
  }

  private void parseTransitions(NodeImpl node, Element nodeXml) {
    Iterator iter = nodeXml.elements("transition").iterator();
    while (iter.hasNext()) {
      Element transitionXml = (Element) iter.next();
      TransitionImpl transition = node.addLeavingTransition(new TransitionImpl(getAttribute(transitionXml, "name", null)));
      transition.setFrom( node );
      unresolvedReferences.add(new UnresolvedTransition(transition, getAttribute(transitionXml, "to")));
      parseActions(transition, transitionXml);
    }
  }

  /**
   * checks if names are defined more then once.
   */
  private void addName(NameType nameType, String name) {
    Collection typeNames = (Collection) names.get(nameType);
    if (typeNames == null) {
      typeNames = new ArrayList();
      names.put(nameType, typeNames);
    }
    if (typeNames.contains(name)) {
      errors.add(nameType + " '" + name + "' is defined more then once");
    }
    typeNames.add(name);
  }

  private void parseActions(ElementImpl elementImpl, Element xmlElement) {
    EventType defaultEventType = elementImpl.getDefaultEventType();
    Iterator iter = xmlElement.elementIterator("action");
    while (iter.hasNext()) {
      elementImpl.add(parseAction((Element) iter.next(), defaultEventType));
    }
  }

  private ActionImpl parseAction(Element actionXml, EventType defaultEventType) {
    ActionImpl action = new ActionImpl();
    action.setActionDelegation(parseDelegation(actionXml));
    EventType eventType = defaultEventType;
    String eventTypeId = getAttribute(actionXml, "event-type", null);
    if (eventTypeId != null) {
      eventType = (EventType) Enum.findById(EventType.class, eventTypeId);
      if (eventType == null) {
        errors.add("action has unknown event-type '" + eventTypeId + "'");
      }
    }
    action.setEventType(eventType);
    return action;
  }

  private DelegationImpl parseDelegation(Element xmlElement) {
    DelegationImpl delegation = null;
    Element delegationXml = xmlElement.element("delegation");
    if (delegationXml != null) {
      delegation = new DelegationImpl(definition, getAttribute(delegationXml, "class"));
      String configuration = getElementText(xmlElement, "delegation", null);
      if (configuration != null) {
        delegation.setConfiguration(configuration.trim());
      }
    }
    return delegation;
  }

  private String getElementText(Element xmlElement, String name) {
    String text = getElementText(xmlElement, name, null);
    if (text == null)
      errors.add("element " + name + " is required in element " + xmlElement.asXML());
    return text;
  }

  private String getElementText(Element xmlElement, String name, String defaultValue) {
    String text = defaultValue;
    Element subElement = xmlElement.element(name);
    if (subElement != null) {
      if (subElement.isTextOnly()) {
        text = subElement.getStringValue();
      }
    }
    return text;
  }

  private String getAttribute(Element xmlElement, String name) {
    String value = getAttribute(xmlElement, name, null);
    if (value == null)
      errors.add("attribute " + name + " is required in element " + xmlElement.asXML());
    return value;
  }

  private String getAttribute(Element xmlElement, String name, String defaultValue) {
    String value = defaultValue;
    Attribute attribute = xmlElement.attribute(name);
    if (attribute != null) {
      value = attribute.getText();
    }
    return value;
  }

  private void resolveReferences() {
    Iterator iter = unresolvedReferences.iterator();
    while (iter.hasNext()) {
      UnresolvedReference unresolvedReference = (UnresolvedReference) iter.next();
      unresolvedReference.resolve();
    }
  }

  private static class NameType {
    public static final NameType NODE = new NameType("node");
    public static final NameType JAVATYPE = new NameType("type");
    public static final NameType SWIMLANE = new NameType("swimlane");
    public static final NameType VARIABLE = new NameType("variable");
    private String id = null;
    public NameType(String id) {
      this.id = id;
    }
    public String toString() {
      return id;
    }
  }

  private abstract class UnresolvedReference {
    protected Object object = null;
    protected String reference = null;
    public UnresolvedReference(Object object, String reference) {
      this.object = object;
      this.reference = reference;
    }
    public abstract void resolve();
  }

  private class UnresolvedTransition extends UnresolvedReference {
    public UnresolvedTransition(TransitionImpl transition, String toName) {
      super(transition, toName);
    }
    public void resolve() {
      NodeImpl to = (NodeImpl) definition.getNodes().get(reference);
      if (to == null) {
        errors.add("node '" + ((TransitionImpl) object).getFrom().getName() + "' references unexisting node '" + reference + "'");
      } else {
        ((TransitionImpl) object).setTo(to);
      }
    }
  }

  private class UnresolvedFork extends UnresolvedReference {
    public UnresolvedFork(ForkImpl fork, String joinName) {
      super(fork, joinName);
    }
    public void resolve() {
      try {
        JoinImpl join = (JoinImpl) definition.getNodes().get(reference);
        ((ForkImpl) object).setCorrespondingJoin(join);
      } catch (ClassCastException e) {
        errors.add(
          "fork '" + ((ForkImpl) object).getName() + "' references a '" + definition.getNodes().get(reference).getClass().getName() + "' instead of a join");
      }
    }
  }

  private class UnresolvedJoin extends UnresolvedReference {
    public UnresolvedJoin(JoinImpl join, String forkName) {
      super(join, forkName);
    }
    public void resolve() {
      try {
        ForkImpl fork = (ForkImpl) definition.getNodes().get(reference);
        ((JoinImpl) object).setCorrespondingFork(fork);
      } catch (ClassCastException e) {
        errors.add(
          "join '" + ((ForkImpl) object).getName() + "' references a '" + definition.getNodes().get(reference).getClass().getName() + "' instead of a fork");
      }
    }
  }

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