xpdlutils.java

jawe的最新版本,基于Java的图形化工作流编辑器。图形化工作流编辑器 。使用JAVA语言开发

package org.enhydra.jawe;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.enhydra.jawe.base.xpdlhandler.XPDLHandler;
import org.enhydra.jawe.components.graph.GraphEAConstants;
import org.enhydra.shark.utilities.SequencedHashMap;
import org.enhydra.shark.xpdl.XMLCollection;
import org.enhydra.shark.xpdl.XMLCollectionElement;
import org.enhydra.shark.xpdl.XMLComplexElement;
import org.enhydra.shark.xpdl.XMLElement;
import org.enhydra.shark.xpdl.XMLUtil;
import org.enhydra.shark.xpdl.XPDLConstants;
import org.enhydra.shark.xpdl.elements.Activities;
import org.enhydra.shark.xpdl.elements.Activity;
import org.enhydra.shark.xpdl.elements.ActivitySet;
import org.enhydra.shark.xpdl.elements.ActualParameter;
import org.enhydra.shark.xpdl.elements.Application;
import org.enhydra.shark.xpdl.elements.Applications;
import org.enhydra.shark.xpdl.elements.ArrayType;
import org.enhydra.shark.xpdl.elements.BlockActivity;
import org.enhydra.shark.xpdl.elements.DataField;
import org.enhydra.shark.xpdl.elements.DataFields;
import org.enhydra.shark.xpdl.elements.DataTypes;
import org.enhydra.shark.xpdl.elements.Deadline;
import org.enhydra.shark.xpdl.elements.DeclaredType;
import org.enhydra.shark.xpdl.elements.ExtendedAttribute;
import org.enhydra.shark.xpdl.elements.ExtendedAttributes;
import org.enhydra.shark.xpdl.elements.ExternalPackage;
import org.enhydra.shark.xpdl.elements.FormalParameter;
import org.enhydra.shark.xpdl.elements.Join;
import org.enhydra.shark.xpdl.elements.ListType;
import org.enhydra.shark.xpdl.elements.Member;
import org.enhydra.shark.xpdl.elements.Package;
import org.enhydra.shark.xpdl.elements.Participant;
import org.enhydra.shark.xpdl.elements.RecordType;
import org.enhydra.shark.xpdl.elements.RedefinableHeader;
import org.enhydra.shark.xpdl.elements.Responsible;
import org.enhydra.shark.xpdl.elements.Responsibles;
import org.enhydra.shark.xpdl.elements.Split;
import org.enhydra.shark.xpdl.elements.SubFlow;
import org.enhydra.shark.xpdl.elements.Tool;
import org.enhydra.shark.xpdl.elements.Tools;
import org.enhydra.shark.xpdl.elements.Transition;
import org.enhydra.shark.xpdl.elements.TransitionRef;
import org.enhydra.shark.xpdl.elements.TransitionRefs;
import org.enhydra.shark.xpdl.elements.TransitionRestriction;
import org.enhydra.shark.xpdl.elements.TransitionRestrictions;
import org.enhydra.shark.xpdl.elements.Transitions;
import org.enhydra.shark.xpdl.elements.TypeDeclaration;
import org.enhydra.shark.xpdl.elements.UnionType;
import org.enhydra.shark.xpdl.elements.WorkflowProcess;

/**
 * Various utilities.
 * 
 * @author Sasa Bojanic
 */
public class XPDLUtils {

   public boolean hasCircularTransitions(Set transitions) {
      Iterator it = transitions.iterator();
      while (it.hasNext()) {
         Transition t = (Transition) it.next();
         if (t.getFrom().equals(t.getTo()))
            return true;
      }
      return false;
   }

   // Useful only if JaWE is set to work without start/end bubbles
   public boolean isStartingActivity(Activity act) {
      Set trans = XMLUtil.getIncomingTransitions(act);
      if (trans.size() == 0 || (trans.size() == 1 && hasCircularTransitions(trans))) {
         return true;
      }
      return false;
   }

   // Useful only if JaWE is set to work without start/end bubbles
   public boolean isEndingActivity(Activity act) {
      Set trans = XMLUtil.getNonExceptionalOutgoingTransitions(act);
      if (trans.size() == 0 || (trans.size() == 1 && hasCircularTransitions(trans))) {
         return true;
      }
      return false;
   }

   public List getReferences(XMLComplexElement pkgOrWp, XMLComplexElement referenced) {
      if (pkgOrWp instanceof Package) {
         return getReferences((Package) pkgOrWp, referenced);
      } else if (pkgOrWp instanceof WorkflowProcess) {
         return getReferences((WorkflowProcess) pkgOrWp, referenced);
      }
      return new ArrayList();
   }

   public List getReferences(Package pkg, XMLComplexElement referenced) {
      if (referenced instanceof Package) {
         return getReferences((Package) referenced);
      } else if (referenced instanceof TypeDeclaration) {
         return getReferences(pkg, (TypeDeclaration) referenced);
      } else if (referenced instanceof Participant) {
         return getReferences(pkg, (Participant) referenced);
      } else if (referenced instanceof Application) {
         return getReferences(pkg, (Application) referenced);
      } else if (referenced instanceof DataField) {
         return getReferences(pkg, (DataField) referenced);
      } else if (referenced instanceof WorkflowProcess) {
         return getReferences(pkg, (WorkflowProcess) referenced);
      }
      return new ArrayList();
   }

   public List getReferences(WorkflowProcess wp, XMLComplexElement referenced) {
      if (referenced instanceof Participant) {
         return getReferences(wp, (Participant) referenced);
      } else if (referenced instanceof Application) {
         return getReferences(wp, (Application) referenced);
      } else if (referenced instanceof DataField) {
         return getReferences(wp, (DataField) referenced);
      } else if (referenced instanceof WorkflowProcess) {
         return getReferences(wp, (WorkflowProcess) referenced);
      } else if (referenced instanceof FormalParameter) {
         return getReferences(wp, (FormalParameter) referenced);
      } else if (referenced instanceof ActivitySet) {
         return getReferences(wp, (ActivitySet) referenced);
      }

      return new ArrayList();
   }

   public List getReferences(Package pkg) {
      List references = new ArrayList();
      String pkgId = pkg.getId();
      Iterator it = JaWEManager.getInstance()
         .getXPDLHandler()
         .getAllPackages()
         .iterator();
      while (it.hasNext()) {
         Package p = (Package) it.next();
         if (p.getExternalPackageIds().contains(pkgId)) {
            references.add(p);
         }
      }

      return references;

   }

   public List getAllExternalPackageReferences(Package pkg, Package referenced) {
      List references = new ArrayList();

      if (referenced != null) {
         Iterator it = referenced.getApplications().toElements().iterator();
         while (it.hasNext()) {
            Application app = (Application) it.next();
            references.addAll(getReferences(pkg, app));
         }
         it = referenced.getParticipants().toElements().iterator();
         while (it.hasNext()) {
            Participant par = (Participant) it.next();
            references.addAll(getReferences(pkg, par));
         }
         it = referenced.getWorkflowProcesses().toElements().iterator();
         while (it.hasNext()) {
            WorkflowProcess wp = (WorkflowProcess) it.next();
            references.addAll(getReferences(pkg, wp));
         }
      }

      return references;
   }

   public List getReferences(Package pkg, TypeDeclaration referenced) {
      return getTypeDeclarationReferences(pkg, referenced.getId());
   }

   public List getReferences(WorkflowProcess wp, TypeDeclaration referenced) {
      return tGetTypeDeclarationReferences(wp, referenced.getId());
   }

   public List getReferences(TypeDeclaration td, TypeDeclaration referenced) {
      if (td.getId().equals(referenced.getId()))
         return new ArrayList();
      return getReferencingDeclaredTypes(td.getDataTypes(), referenced.getId());
   }

   public List getTypeDeclarationReferences(Package pkg, String referencedId) {
      List references = new ArrayList();
      if (referencedId.equals("")) {
         return references;
      }
      Iterator it = pkg.getTypeDeclarations().toElements().iterator();
      while (it.hasNext()) {
         TypeDeclaration td = (TypeDeclaration) it.next();
         if (td.getId().equals(referencedId))
            continue;
         references.addAll(getReferencingDeclaredTypes(td.getDataTypes(), referencedId));
      }

      references.addAll(tGetTypeDeclarationReferences(pkg, referencedId));

      it = pkg.getWorkflowProcesses().toElements().iterator();
      while (it.hasNext()) {
         WorkflowProcess wp = (WorkflowProcess) it.next();
         references.addAll(tGetTypeDeclarationReferences(wp, referencedId));
      }

      return references;
   }

   protected List tGetTypeDeclarationReferences(XMLComplexElement pkgOrWp,
                                                String referencedId) {
      List references = new ArrayList();
      if (referencedId.equals("")) {
         return references;
      }

      Iterator it = ((Applications) pkgOrWp.get("Applications")).toElements().iterator();
      while (it.hasNext()) {
         Application app = (Application) it.next();
         Iterator fps = app.getApplicationTypes()
            .getFormalParameters()
            .toElements()
            .iterator();
         while (fps.hasNext()) {
            Object obj = fps.next();
            // System.err.println(obj.getClass().getName());
            FormalParameter fp = (FormalParameter) obj;
            references.addAll(getReferencingDeclaredTypes(fp.getDataType().getDataTypes(),
                                                          referencedId));
         }
      }
      it = ((DataFields) pkgOrWp.get("DataFields")).toElements().iterator();
      while (it.hasNext()) {
         DataField df = (DataField) it.next();
         references.addAll(getReferencingDeclaredTypes(df.getDataType().getDataTypes(),
                                                       referencedId));
      }
      if (pkgOrWp instanceof WorkflowProcess) {
         it = ((WorkflowProcess) pkgOrWp).getFormalParameters().toElements().iterator();
         while (it.hasNext()) {
            FormalParameter fp = (FormalParameter) it.next();
            references.addAll(getReferencingDeclaredTypes(fp.getDataType().getDataTypes(),
                                                          referencedId));
         }
      }

      return references;
   }

   public List getReferencingDeclaredTypes(DataTypes dts, String typeDeclarationId) {
      List toRet = new ArrayList();
      if (typeDeclarationId.equals("")) {
         return toRet;
      }

      XMLElement choosen = dts.getChoosen();
      if (choosen instanceof DeclaredType) {
         if (((DeclaredType) choosen).getId().equals(typeDeclarationId)) {
            toRet.add(choosen);
         }
      } else if (choosen instanceof ArrayType) {
         return getReferencingDeclaredTypes(((ArrayType) choosen).getDataTypes(),
                                            typeDeclarationId);
      } else if (choosen instanceof ListType) {
         return getReferencingDeclaredTypes(((ListType) choosen).getDataTypes(),
                                            typeDeclarationId);
      } else if (choosen instanceof RecordType || choosen instanceof UnionType) {
         Iterator it = ((XMLCollection) choosen).toElements().iterator();
         while (it.hasNext()) {
            Member m = (Member) it.next();
            toRet.addAll(getReferencingDeclaredTypes(m.getDataTypes(), typeDeclarationId));
         }
      }

      return toRet;
   }

   public List getParticipantReferences(XMLComplexElement pkgOrWp, String referencedId) {
      if (referencedId.equals("")) {
         return new ArrayList();
      }
      if (pkgOrWp instanceof Package) {
         return getParticipantReferences((Package) pkgOrWp, referencedId);
      }

      return getParticipantReferences((WorkflowProcess) pkgOrWp, referencedId);
   }

   public List getReferences(Package pkg, Participant referenced) {
      if (XMLUtil.getPackage(referenced) != pkg
          && pkg.getParticipant(referenced.getId()) != null) {
         return new ArrayList();
      }

      return getParticipantReferences(pkg, referenced.getId());
   }

   public List getParticipantReferences(Package pkg, String referencedId) {
      List references = new ArrayList();
      if (referencedId.equals("")) {
         return references;
      }

      references.addAll(tGetParticipantReferences(pkg, referencedId));

      Iterator it = pkg.getWorkflowProcesses().toElements().iterator();
      while (it.hasNext()) {
         WorkflowProcess wp = (WorkflowProcess) it.next();
         if (wp.getParticipant(referencedId) == null) {
            references.addAll(getParticipantReferences(wp, referencedId));
         }
      }

      return references;
   }

   public List getReferences(WorkflowProcess wp, Participant referenced) {
      if (XMLUtil.getWorkflowProcess(referenced) == null
          && wp.getParticipant(referenced.getId()) != null) {
         return new ArrayList();
      }
      Package pkg = XMLUtil.getPackage(wp);
      if (XMLUtil.getPackage(referenced) != pkg
          && pkg.getParticipant(referenced.getId()) != null) {
         return new ArrayList();
      }

      return getParticipantReferences(wp, referenced.getId());
   }

   public List getParticipantReferences(WorkflowProcess wp, String referencedId) {
      List references = new ArrayList();
      if (referencedId.equals("")) {
         return references;
      }
      references.addAll(tGetParticipantReferences(wp, referencedId));