xpdlutils.java

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

         Transitions trs = (Transitions) ((XMLCollectionElement) trasToRemove.toArray()[0]).getParent();
         trs.removeAll(new ArrayList(trasToRemove));
         Iterator itt = trasToRemove.iterator();
         while (itt.hasNext()) {
            Transition t = (Transition) itt.next();
            Activity from = acs.getActivity(t.getFrom());
            Activity to = acs.getActivity(t.getTo());
            if (from != null && !acts.contains(from)) {
               correctSplitAndJoin(from);
            }
            if (to != null && !acts.contains(to)) {
               correctSplitAndJoin(to);
            }
         }
      }
   }

   protected Set getTransitionsForActivity(Activity act) {
      Set trasToRemove = XMLUtil.getIncomingTransitions(act);
      trasToRemove.addAll(XMLUtil.getOutgoingTransitions(act));
      return trasToRemove;
   }

   public List getTransitions(Transitions tras, String actId, boolean isToAct) {
      List l = new ArrayList();
      Iterator it = tras.toElements().iterator();
      while (it.hasNext()) {
         Transition t = (Transition) it.next();
         if (isToAct) {
            if (t.getTo().equals(actId)) {
               l.add(t);
            }
         } else {
            if (t.getFrom().equals(actId)) {
               l.add(t);
            }
         }
      }
      return l;
   }

   public void updateTypeDeclarationReferences(List refDeclaredTypes, String newTdId) {
      Iterator it = refDeclaredTypes.iterator();
      while (it.hasNext()) {
         DeclaredType dt = (DeclaredType) it.next();
         dt.setId(newTdId);
      }
   }

   public void updateApplicationReferences(List refTools, String newAppId) {
      Iterator it = refTools.iterator();
      while (it.hasNext()) {
         Tool t = (Tool) it.next();
         t.setId(newAppId);
      }
   }

   public void updateParticipantReferences(List refPerfsAndResps, String newParId) {
      Iterator it = refPerfsAndResps.iterator();
      while (it.hasNext()) {
         XMLElement pOrR = (XMLElement) it.next();
         pOrR.setValue(newParId);
      }
   }

   public void updateWorkflowProcessReferences(List refSbflws, String newWpId) {
      Iterator it = refSbflws.iterator();
      while (it.hasNext()) {
         SubFlow s = (SubFlow) it.next();
         s.setId(newWpId);
      }
   }

   public void updateActivitySetReferences(List refBlocks, String newAsId) {
      Iterator it = refBlocks.iterator();
      while (it.hasNext()) {
         BlockActivity ba = (BlockActivity) it.next();
         ba.setBlockId(newAsId);
      }
   }

   public void updateVariableReferences(List refAPsOrPerfsOrCondsOrDlConds,
                                        String oldDfOrFpId,
                                        String newDfOrFpId) {
      Iterator it = refAPsOrPerfsOrCondsOrDlConds.iterator();
      int varLengthDiff = newDfOrFpId.length() - oldDfOrFpId.length();
      while (it.hasNext()) {
         XMLElement apOrPerfOrCondOrDlCond = (XMLElement) it.next();
         String expr = apOrPerfOrCondOrDlCond.toValue();
         List positions = XMLUtil.getUsingPositions(expr,
                                                    oldDfOrFpId,
                                                    XMLUtil.getWorkflowProcess(apOrPerfOrCondOrDlCond)
                                                       .getAllVariables());
         for (int i = 0; i < positions.size(); i++) {
            int pos = ((Integer) positions.get(i)).intValue();
            int realPos = pos + varLengthDiff * i;
            String pref = expr.substring(0, realPos);
            String suff = expr.substring(realPos + oldDfOrFpId.length());
            expr = pref + newDfOrFpId + suff;
            // System.out.println("Pref="+pref+", suff="+suff+", expr="+expr);
         }
         apOrPerfOrCondOrDlCond.setValue(expr);
      }
   }

   public List getActivities(Package pkg, List types) {
      List l = new ArrayList();
      Iterator it = pkg.getWorkflowProcesses().toElements().iterator();
      while (it.hasNext()) {
         WorkflowProcess wp = (WorkflowProcess) it.next();
         l.addAll(getActivities(wp, types));
      }
      return l;
   }

   public List getActivities(WorkflowProcess wp, List types) {
      List l = new ArrayList();
      l.addAll(getActivities(wp.getActivities(), types));
      Iterator it = wp.getActivitySets().toElements().iterator();
      while (it.hasNext()) {
         ActivitySet as = (ActivitySet) it.next();
         l.addAll(getActivities(as.getActivities(), types));
      }
      return l;
   }

   public List getActivities(Activities acts, List types) {
      List l = new ArrayList();

      Iterator it = acts.toElements().iterator();
      while (it.hasNext()) {
         Activity act = (Activity) it.next();
         int type = act.getActivityType();
         if (types.contains(new Integer(type))) {
            l.add(act);
         }
      }

      return l;
   }

   public SequencedHashMap getPossibleResponsibles(Responsibles resp, Responsible rsp) {
      SequencedHashMap choices = null;
      if (XMLUtil.getWorkflowProcess(resp) != null) {
         choices = XMLUtil.getPossibleParticipants(XMLUtil.getWorkflowProcess(resp),
                                                   JaWEManager.getInstance()
                                                      .getXPDLHandler());
      } else {
         choices = XMLUtil.getPossibleParticipants(XMLUtil.getPackage(resp),
                                                   JaWEManager.getInstance()
                                                      .getXPDLHandler());
      }
      // filter choices: exclude already existing performers
      Iterator it = resp.toElements().iterator();
      while (it.hasNext()) {
         Responsible r = (Responsible) it.next();
         if (r != rsp) {
            choices.remove(r.toValue());
         }
      }
      return choices;
   }

   public boolean doesCrossreferenceExist(Package pkg) {
      XPDLHandler xpdlhandler = JaWEManager.getInstance().getXPDLHandler();
      boolean crossRefs = false;

      Iterator epids = pkg.getExternalPackageIds().iterator();
      while (epids.hasNext()) {
         try {
            Package extP = xpdlhandler.getPackageById((String) epids.next());
            if (XMLUtil.getAllExternalPackageIds(xpdlhandler, extP, new HashSet())
               .contains(pkg.getId())) {
               crossRefs = true;
               break;
            }
         } catch (Exception ex) {
         }
      }
      return crossRefs;
   }

   public Set getAllExtendedAttributeNames(XMLComplexElement cel, XPDLHandler xpdlh) {
      Set extAttribNames = new HashSet();

      Iterator it = xpdlh.getAllPackages().iterator();
      while (it.hasNext()) {
         extAttribNames.addAll(getAllExtendedAttributeNames((Package) it.next(), cel));
      }
      return extAttribNames;
   }

   public Set getAllExtendedAttributeNames(Package pkg, XMLComplexElement cel) {
      Set extAttribNames = new HashSet();
      if (cel instanceof Activity) {
         Iterator it = pkg.getWorkflowProcesses().toElements().iterator();
         while (it.hasNext()) {
            WorkflowProcess wp = (WorkflowProcess) it.next();
            extAttribNames.addAll(getAllExtendedAttributeNamesForElements(wp.getActivities()
               .toElements()));

            Iterator asets = wp.getActivitySets().toElements().iterator();
            while (asets.hasNext()) {
               ActivitySet as = (ActivitySet) asets.next();
               extAttribNames.addAll(getAllExtendedAttributeNamesForElements(as.getActivities()
                  .toElements()));
            }
         }
      } else if (cel instanceof Application) {
         extAttribNames.addAll(getAllExtendedAttributeNamesForElements(pkg.getApplications()
            .toElements()));
         Iterator it = pkg.getWorkflowProcesses().toElements().iterator();
         while (it.hasNext()) {
            WorkflowProcess wp = (WorkflowProcess) it.next();
            extAttribNames.addAll(getAllExtendedAttributeNamesForElements(wp.getApplications()
               .toElements()));
         }
      } else if (cel instanceof DataField) {
         extAttribNames.addAll(getAllExtendedAttributeNamesForElements(pkg.getDataFields()
            .toElements()));
         Iterator it = pkg.getWorkflowProcesses().toElements().iterator();
         while (it.hasNext()) {
            WorkflowProcess wp = (WorkflowProcess) it.next();
            extAttribNames.addAll(getAllExtendedAttributeNamesForElements(wp.getDataFields()
               .toElements()));
         }
      } else if (cel instanceof ExternalPackage) {
         extAttribNames.addAll(getAllExtendedAttributeNamesForElements(pkg.getExternalPackages()
            .toElements()));
      } else if (cel instanceof Package) {
         extAttribNames.addAll(getAllExtendedAttributeNames(pkg.getExtendedAttributes()
            .toElements()));
      } else if (cel instanceof Participant) {
         extAttribNames.addAll(getAllExtendedAttributeNamesForElements(pkg.getParticipants()
            .toElements()));
         Iterator it = pkg.getWorkflowProcesses().toElements().iterator();
         while (it.hasNext()) {
            WorkflowProcess wp = (WorkflowProcess) it.next();
            extAttribNames.addAll(getAllExtendedAttributeNamesForElements(wp.getParticipants()
               .toElements()));
         }
      } else if (cel instanceof Tool) {
         Iterator it = pkg.getWorkflowProcesses().toElements().iterator();
         while (it.hasNext()) {
            WorkflowProcess wp = (WorkflowProcess) it.next();
            Iterator acti = wp.getActivities().toElements().iterator();
            while (acti.hasNext()) {
               Activity act = (Activity) acti.next();
               if (act.getActivityType() == XPDLConstants.ACTIVITY_TYPE_TOOL) {
                  Tools ts = act.getActivityTypes()
                     .getImplementation()
                     .getImplementationTypes()
                     .getTools();
                  extAttribNames.addAll(getAllExtendedAttributeNamesForElements(ts.toElements()));
               }
            }
            Iterator asets = wp.getActivitySets().toElements().iterator();
            while (asets.hasNext()) {
               ActivitySet as = (ActivitySet) asets.next();
               acti = as.getActivities().toElements().iterator();
               while (acti.hasNext()) {
                  Activity act = (Activity) acti.next();
                  if (act.getActivityType() == XPDLConstants.ACTIVITY_TYPE_TOOL) {
                     Tools ts = act.getActivityTypes()
                        .getImplementation()
                        .getImplementationTypes()
                        .getTools();
                     extAttribNames.addAll(getAllExtendedAttributeNamesForElements(ts.toElements()));
                  }
               }
            }
         }
      } else if (cel instanceof Transition) {
         Iterator it = pkg.getWorkflowProcesses().toElements().iterator();
         while (it.hasNext()) {
            WorkflowProcess wp = (WorkflowProcess) it.next();
            extAttribNames.addAll(getAllExtendedAttributeNamesForElements(wp.getTransitions()
               .toElements()));
            Iterator asets = wp.getActivitySets().toElements().iterator();
            while (asets.hasNext()) {
               ActivitySet as = (ActivitySet) asets.next();
               extAttribNames.addAll(getAllExtendedAttributeNamesForElements(as.getTransitions()
                  .toElements()));
            }
         }
      } else if (cel instanceof TypeDeclaration) {
         extAttribNames.addAll(getAllExtendedAttributeNamesForElements(pkg.getTypeDeclarations()
            .toElements()));
      } else if (cel instanceof WorkflowProcess) {
         extAttribNames.addAll(getAllExtendedAttributeNamesForElements(pkg.getWorkflowProcesses()
            .toElements()));
      }
      return extAttribNames;
   }

   public Set getAllExtendedAttributeNamesForElements(Collection elements) {
      Set s = new HashSet();
      Iterator it = elements.iterator();
      while (it.hasNext()) {
         XMLComplexElement cel = (XMLComplexElement) it.next();
         s.addAll(((ExtendedAttributes) cel.get("ExtendedAttributes")).toElements());
      }
      return getAllExtendedAttributeNames(s);
   }

   public Set getAllExtendedAttributeNames(Collection extAttribs) {
      Set eaNames = new HashSet();
      Iterator it = extAttribs.iterator();
      while (it.hasNext()) {
         ExtendedAttribute ea = (ExtendedAttribute) it.next();
         String eaName = ea.getName();
         XMLElement pp = ea.getParent().getParent();
         if (pp instanceof XMLComplexElement && eaName.equals(JaWEEAHandler.EA_JAWE_TYPE)) {
            continue;
         }
         if (pp instanceof Package
             && (eaName.equals(JaWEEAHandler.EA_EDITING_TOOL)
                 || eaName.equals(JaWEEAHandler.EA_EDITING_TOOL_VERSION)
                 || eaName.equals(JaWEEAHandler.EA_JAWE_CONFIGURATION) || eaName.equals(JaWEEAHandler.EA_JAWE_EXTERNAL_PACKAGE_ID))) {
            continue;
         }
         if (pp instanceof WorkflowProcess
             && (eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_WORKFLOW_PARTICIPANT_ORIENTATION)
                 || eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_BLOCK_PARTICIPANT_ORIENTATION)
                 || eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_WORKFLOW_PARTICIPANT_ORDER)
                 || eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_BLOCK_PARTICIPANT_ORDER)
                 || eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_START_OF_WORKFLOW)
                 || eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_END_OF_WORKFLOW)
                 || eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_START_OF_BLOCK) || eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_END_OF_BLOCK))) {
            continue;
         }
         if (pp instanceof Activity
             && (eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_OFFSET) || eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_PARTICIPANT_ID))) {
            continue;
         }
         if (pp instanceof Transition
             && (eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_BREAK_POINTS) || eaName.equals(GraphEAConstants.EA_JAWE_GRAPH_TRANSITION_STYLE))) {
              continue;
           }
         eaNames.add(eaName);
      }
      return eaNames;
   }

}