Examples of org.huihoo.workflow.xpdl.ExtendedAttribute

org.huihoo.workflow.xpdl.ExtendedAttribute
@author zosatapoTo change the template for this generated type comment go to Window - Preferences - Java - Code Generation - Code and Comments

    }
    else if (outTransitions.size() > 1)
    {


      String activity_dispatch_transition_id = null;
      ExtendedAttribute attribute = fromActivity.findExtendedAttribute(XPDLGlobals.ACTIVITY_DISPATCH_TRANSITION_ID);
      if (attribute != null && attribute.getValue() != null && attribute.getValue().length() > 0)
      {
        activity_dispatch_transition_id = attribute.getValue();
      }


      if (activity_dispatch_transition_id != null)
      {
        log.debug("[" + fromActivity + "] select  or-join-transition by attribute '"+XPDLGlobals.ACTIVITY_DISPATCH_TRANSITION_ID+"'");

View Full Code Here


    //  ---------------------------------------------------------------
    //   1. validate package main process
    //  ---------------------------------------------------------------        
    {
      ExtendedAttribute attribute =
        (ExtendedAttribute) workflowPackage.findExtendedAttribute(XPDLGlobals.ID_PROCESS_MAIN);
      if (attribute != null)
      {
        String processId = attribute.getValue();
        if (processId == null || processId.length() == 0)
        {
          errorList.add(
            new WorkflowException(
              "package attribute '"
                + XPDLGlobals.ID_PROCESS_MAIN
                + "' must be set.{packageID="
                + workflowPackage.getUUID()
                + "}"));
        }
      }
      else
      {
        errorList.add(
          new WorkflowException(
            "package attribute '"
              + XPDLGlobals.ID_PROCESS_MAIN
              + "' must be set.{packageID="
              + workflowPackage.getUUID()
              + "}"));
      }
    }


    //  ---------------------------------------------------------------
    //   2. validate workflowapplication qualified class name
    //  ---------------------------------------------------------------  
    List appList = workflowPackage.getWorkflowApplications();
    int app_size = appList.size();
    for (int i = 0; i < app_size; ++i)
    {
      WorkflowApplication app = (WorkflowApplication) appList.get(i);
      ExtendedAttribute attribute = app.findExtendedAttribute(XPDLGlobals.APPLICATION_QUALIFIED_CLASS_NAME);
      if (attribute != null)
      {
        String className = (String) attribute.getValue();
        if (className == null || className.length() == 0)
        {
          errorList.add(
            new WorkflowException(
              "application attribute '"
                + XPDLGlobals.APPLICATION_QUALIFIED_CLASS_NAME
                + "' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",applicationID="
                + app.getUUID()
                + "}"));
        }
      }
      else
      {
        errorList.add(
          new WorkflowException(
            "application attribute '"
              + XPDLGlobals.APPLICATION_QUALIFIED_CLASS_NAME
              + "' must be set.{packageID="
              + workflowPackage.getUUID()
              + ",applicationID="
              + app.getUUID()
              + "}"));
      }
    }


    //  ---------------------------------------------------------------
    //   3. validate workflowprocess beginActivity and endActivity
    //  ---------------------------------------------------------------  
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      ExtendedAttribute attribute = workflowProcess.findExtendedAttribute(XPDLGlobals.ID_ACTIVITY_BEGIN);
      String activityId = null;


      if (attribute != null)
      {
        activityId = (String) attribute.getValue();
        if (activityId == null || activityId.length() == 0)
        {
          errorList.add(
            new WorkflowException(
              "process attribute '"
                + XPDLGlobals.ID_ACTIVITY_BEGIN
                + "' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + "}"));
        }
      }
      else
      {
        errorList.add(
          new WorkflowException(
            "process attribute '"
              + XPDLGlobals.ID_ACTIVITY_BEGIN
              + "' must be set.{packageID="
              + workflowPackage.getUUID()
              + ",processID="
              + workflowProcess.getUUID()
              + "}"));
      }


      attribute = (ExtendedAttribute) workflowProcess.findExtendedAttribute(XPDLGlobals.ID_ACTIVITY_END);
      if (attribute != null)
      {
        activityId = (String) attribute.getValue();
        if (activityId == null || activityId.length() == 0)
        {
          errorList.add(
            new WorkflowException(
              "process attribute '"
                + XPDLGlobals.ID_ACTIVITY_END
                + "' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + "}"));
        }
      }
      else
      {
        errorList.add(
          new WorkflowException(
            "process attribute '"
              + XPDLGlobals.ID_ACTIVITY_END
              + "' must be set.{packageID="
              + workflowPackage.getUUID()
              + ",processID="
              + workflowProcess.getUUID()
              + "}"));
      }
    }


    //  ---------------------------------------------------------------
    //   4. validate workflowActivity activity type
    //  ---------------------------------------------------------------  
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();


      for (int j = 0; j < activitySize; ++j)
      {
        WorkflowActivity activity = (WorkflowActivity) activies.get(j);
        ExtendedAttribute attribute = activity.findExtendedAttribute(XPDLGlobals.ACTIVITY_TYPE);
        if (attribute != null)
        {
          String activity_type = (String) attribute.getValue();
          if (activity_type == null || activity_type.length() == 0)
          {
            errorList.add(
              new WorkflowException(
                "activity attribute '"
                  + XPDLGlobals.ACTIVITY_TYPE
                  + "' must be set.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }
        else
        {
          errorList.add(
            new WorkflowException(
              "activity attribute '"
                + XPDLGlobals.ACTIVITY_TYPE
                + "' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + ",activityID="
                + activity.getUUID()
                + "}"));
        }
      }
    }


    //  ---------------------------------------------------------------
    //   5. validate workflowActivity performer type
    //  ---------------------------------------------------------------  
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();
      for (int j = 0; j < activitySize; ++j)
      {
        WorkflowActivity activity = (WorkflowActivity) activies.get(j);
        ExtendedAttribute attribute = activity.findExtendedAttribute(XPDLGlobals.ACTIVITY_TYPE);
        if (attribute != null)
        {
          if (!ActivityType.parse((String) attribute.getValue()).equals(ActivityType.ACTIVITY_BUSINESS))
          {
            continue;
          }
        }
        attribute = (ExtendedAttribute) activity.findExtendedAttribute(XPDLGlobals.PERFORMER_TYPE);
        if (attribute != null)
        {
          String performer_type = (String) attribute.getValue();
          if (performer_type == null || performer_type.length() == 0)
          {
            errorList.add(
              new WorkflowException(
                "activity attribute '"
                  + XPDLGlobals.PERFORMER_TYPE
                  + "' must be set.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }
        else
        {
          errorList.add(
            new WorkflowException(
              "activity attribute '"
                + XPDLGlobals.PERFORMER_TYPE
                + "' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + ",activityID="
                + activity.getUUID()
                + "}"));
        }
      }
    }


    //  ---------------------------------------------------------------
    //   6. validate workflowActivity Implementation referrence
    //  ---------------------------------------------------------------      
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();


      WorkflowActivity activity = null;
      Implementation impl = null;
      ToolImplementation toolImpl = null;
      ToolSet toolSet = null;
      SubFlowImplementation subFlowImpl = null;


      for (int j = 0; j < activitySize; ++j)
      {
        activity = (WorkflowActivity) activies.get(j);
        impl = activity.getImplementation();


        if (impl == null)
        {
          continue;
        }


        if ((impl instanceof ToolImplementation) && ActivityType.ACTIVITY_BUSINESS.equals(activity.getActivityType()))
        {
          toolImpl = (ToolImplementation) impl;
          String appId = toolImpl.getApplicationID();
          if ((appId == null) || (workflowPackage.findWorkflowApplication(appId) == null))
          {
            errorList.add(
              new WorkflowException(
                "Tool attribute 'Id' must be set.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }


        if ((impl instanceof ToolSet) && ActivityType.ACTIVITY_BUSINESS.equals(activity.getActivityType()))
        {
          toolSet = (ToolSet) impl;
          List toolImpls = toolSet.getToolKits();
          int toolImpls_size = toolImpls.size();


          for (int k = 0; k < toolImpls_size; ++k)
          {
            toolImpl = (ToolImplementation) toolImpls.get(k);
            String appId = toolImpl.getApplicationID();
            if ((appId == null) || (workflowPackage.findWorkflowApplication(appId) == null))
            {
              errorList.add(
                new WorkflowException(
                  "Tool attribute 'Id' must be set.{packageID="
                    + workflowPackage.getUUID()
                    + ",processID="
                    + workflowProcess.getUUID()
                    + ",activityID="
                    + activity.getUUID()
                    + "}"));
            }
          }
        }


        if ((impl instanceof SubFlowImplementation)
          && ActivityType.ACTIVITY_SUBFLOW.equals(activity.getActivityType()))
        {
          subFlowImpl = (SubFlowImplementation) impl;
          String processId = subFlowImpl.getProcessID();
          if ((processId == null) || (workflowPackage.findWorkflowProcess(processId) == null))
          {
            errorList.add(
              new WorkflowException(
                "SubFlow attribute 'Id' must be set.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }
      }
    }


    //  ---------------------------------------------------------------
    //   7. validate WorkflowTransition formActivity & toActivity
    //  ---------------------------------------------------------------      
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List trans = workflowProcess.getWorkflowTransitions();
      int trans_size = trans.size();


      WorkflowTransition tran = null;


      for (int j = 0; j < trans_size; ++j)
      {
        tran = (WorkflowTransition) trans.get(j);
        if (tran.getFromWorkflowActivity() == null)
        {
          errorList.add(
            new WorkflowException(
              "Transition attribute 'From' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + ",transitionID="
                + tran.getUUID()
                + "}"));
        }


        if (tran.getToWorkflowActivity() == null)
        {
          errorList.add(
            new WorkflowException(
              "Transition attribute 'To' must be set.{packageID="
                + workflowPackage.getUUID()
                + ",processID="
                + workflowProcess.getUUID()
                + ",transitionID="
                + tran.getUUID()
                + "}"));
        }
      }
    }


    //  ---------------------------------------------------------------
    //   8. validate workflowActivity activity type match performer Type
    //  ---------------------------------------------------------------  
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();


      for (int j = 0; j < activitySize; ++j)
      {
        WorkflowActivity activity = (WorkflowActivity) activies.get(j);
        ExtendedAttribute attribute = activity.findExtendedAttribute(XPDLGlobals.ACTIVITY_TYPE);
        if (attribute != null)
        {
          if (ActivityType.parse((String) attribute.getValue()).equals(ActivityType.ACTIVITY_BUSINESS))
          {
            continue;
          }


          attribute = (ExtendedAttribute) activity.findExtendedAttribute(XPDLGlobals.PERFORMER_TYPE);
          if (attribute != null
            && !(PerformerType.parse(attribute.getValue()).equals(PerformerType.PERFORMER_AUTOMATION)))
          {
            errorList.add(
              new WorkflowException(
                "activity attribute '"
                  + XPDLGlobals.PERFORMER_TYPE

View Full Code Here

      {
        transition = (WorkflowTransition) transitions.get(j);
        WorkflowCondition condition = transition.getCondition();
        if (condition != null && condition.getContent() != null)
        {
          ExtendedAttribute attribute = transition.findExtendedAttribute(XPDLGlobals.CONDITION_TYPE);
          if (attribute != null)
          {
            ConditionType ctype = ConditionType.parse(attribute.getValue());
            if (ConditionType.CONDITION_SCRIPT.equals(ctype))
            {
              transition.setCondition(new ScriptCondition(condition.getContent()));
            }


            transition.removeExtendedAttribute(XPDLGlobals.CONDITION_TYPE);
          }
        }
      }
    }


    //  ---------------------------------------------------------------
    //   3. format activity type
    //  ---------------------------------------------------------------    
    for (int i = 0; i < processList.size(); ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();


      WorkflowActivity activity = null;
      Implementation impl = null;
      ExtendedAttribute attribute = null;
      for (int j = 0; j < activitySize; ++j)
      {
        activity = (WorkflowActivity) activies.get(j);
        attribute = (ExtendedAttribute) activity.findExtendedAttribute(XPDLGlobals.ACTIVITY_TYPE);
        if (attribute != null)
        {
          activity.setActivityType(ActivityType.parse(attribute.getValue()));
          activity.removeExtendedAttribute(XPDLGlobals.ACTIVITY_TYPE);
        }
      }
    }


    //  ---------------------------------------------------------------
    //   4. format activity implementation
    //  ---------------------------------------------------------------
    for (int i = 0; i < processList.size(); ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();


      WorkflowActivity activity = null;
      Implementation impl = null;
      ExtendedAttribute attribute = null;
      for (int j = 0; j < activitySize; ++j)
      {
        activity = (WorkflowActivity) activies.get(j);
        impl = activity.getImplementation();
        if (impl != null)
        {
          if (impl instanceof NoImplementation)
          {
            attribute = activity.findExtendedAttribute(XPDLGlobals.PAGE_URL);
            if (attribute != null)
            {
              activity.setImplementation(new PageImplementation(attribute.getValue()));
            }
          }
        }
      }
    }


    //  ---------------------------------------------------------------
    //   5. format performer type
    //  --------------------------------------------------------------- 
    for (int i = 0; i < processList.size(); ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();


      WorkflowActivity activity = null;
      Implementation impl = null;
      ExtendedAttribute attribute = null;
      for (int j = 0; j < activitySize; ++j)
      {
        activity = (WorkflowActivity) activies.get(j);
        attribute = (ExtendedAttribute) activity.findExtendedAttribute(XPDLGlobals.PERFORMER_TYPE);
        if (attribute != null)
        {
          activity.setPerformerType(PerformerType.parse(attribute.getValue()));
          activity.removeExtendedAttribute(XPDLGlobals.PERFORMER_TYPE);
        }
      }
    }


    //  ---------------------------------------------------------------
    //   6. format application QualifiedClassName
    //  ---------------------------------------------------------------  
    List wfApps = workflowPackage.getWorkflowApplications();
    int wfAppSize = wfApps.size();
    WorkflowApplication wfApp = null;
    for (int i = 0; i < wfAppSize; ++i)
    {
      wfApp = (WorkflowApplication) wfApps.get(i);
      ExtendedAttribute attribute = wfApp.findExtendedAttribute(XPDLGlobals.APPLICATION_QUALIFIED_CLASS_NAME);
      if (attribute != null)
      {
        wfApp.setQualifiedClassName(attribute.getValue());
        wfApp.removeExtendedAttribute(XPDLGlobals.APPLICATION_QUALIFIED_CLASS_NAME);
      }
    }


    //  ---------------------------------------------------------------
    //   7. validate workflowActivity Implementation & ActivityType
    //  ---------------------------------------------------------------    
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();


      WorkflowActivity activity = null;
      Implementation impl = null;
      ToolImplementation toolImpl = null;
      ToolSet toolSet = null;
      SubFlowImplementation subFlowImpl = null;


      for (int j = 0; j < activitySize; ++j)
      {
        activity = (WorkflowActivity) activies.get(j);
        impl = activity.getImplementation();
        if (ActivityType.ACTIVITY_BUSINESS.equals(activity.getActivityType()))
        {
          if (impl != null && (impl instanceof SubFlowImplementation))
          {
            errorList.add(
              new WorkflowException(
                "ActivityType 'ACTIVITY_BUSINESS' Implementation can not be 'SubFlow'.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }


        if (ActivityType.ACTIVITY_SUBFLOW.equals(activity.getActivityType()))
        {
          if (impl != null && !(impl instanceof SubFlowImplementation))
          {
            errorList.add(
              new WorkflowException(
                "ActivityType 'ACTIVITY_SUBFLOW' Implementation must be 'SubFlow'.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }


        if (ActivityType.ACTIVITY_ROUTE.equals(activity.getActivityType()))
        {
          if (impl != null && !(impl instanceof NoImplementation))
          {
            errorList.add(
              new WorkflowException(
                "ActivityType 'ACTIVITY_ROUTE' Implementation must be 'No'.{packageID="
                  + workflowPackage.getUUID()
                  + ",processID="
                  + workflowProcess.getUUID()
                  + ",activityID="
                  + activity.getUUID()
                  + "}"));
          }
        }


      }
    }


    //  ---------------------------------------------------------------
    //   8. format workflowProcess  listener class name
    //  ---------------------------------------------------------------  
    for (int i = 0; i < process_size; ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      ExtendedAttribute attribute = workflowProcess.findExtendedAttribute(XPDLGlobals.LISTENER_QUALIFIED_CLASS_NAME);
      if (attribute != null)
      {
        workflowProcess.setListenerClassName(attribute.getValue());
        workflowProcess.removeExtendedAttribute(XPDLGlobals.LISTENER_QUALIFIED_CLASS_NAME);
      }
    }


    //  ---------------------------------------------------------------
    //   9. format workflowActivity  listener class name
    //  ---------------------------------------------------------------  
    for (int i = 0; i < processList.size(); ++i)
    {
      WorkflowProcess workflowProcess = (WorkflowProcess) processList.get(i);
      List activies = workflowProcess.getWorkflowActivities();
      int activitySize = activies.size();


      WorkflowActivity activity = null;
      Implementation impl = null;
      ExtendedAttribute attribute = null;
      for (int j = 0; j < activitySize; ++j)
      {
        activity = (WorkflowActivity) activies.get(j);
        attribute = (ExtendedAttribute) activity.findExtendedAttribute(XPDLGlobals.LISTENER_QUALIFIED_CLASS_NAME);
        if (attribute != null)
        {
          activity.setListenerClassName(attribute.getValue());
          activity.removeExtendedAttribute(XPDLGlobals.LISTENER_QUALIFIED_CLASS_NAME);
        }
      }
    }

View Full Code Here

    WorkflowTransition workflowTransition)
    throws WorkflowException
  {
    List users = new ArrayList();
    WorkflowActivity workflowActivity = workflowTransition.getToWorkflowActivity();
    ExtendedAttribute attribute =
      (ExtendedAttribute) workflowActivity.getExtendedAttributes().get(
        XPDLGlobals.SELECTOR_QUALIFIED_CLASS_NAME);


    String implClassName = attribute.getValue();
    Class implClass = null;
    PerformerSelector selector = null;
    try
    {
      implClass = Class.forName(implClassName);

View Full Code Here

    }
    
    Iterator iterator=extendedAttributes.values().iterator();
    while(iterator.hasNext())
    {
      ExtendedAttribute extendAttr =(ExtendedAttribute)iterator.next();    
      if( ID.equals(extendAttr.getUUID()) )
      {
        return (ExtendedAttribute)extendedAttributes.remove(extendAttr.getName());
      }
    }
    
    return null;
  }

View Full Code Here

    
    Iterator iterator=extendedAttributes.values().iterator();
    
    while(iterator.hasNext())
    {
      ExtendedAttribute extendAttr =(ExtendedAttribute)iterator.next();    
      if( ID.equals(extendAttr.getUUID()) )
      {      
        return extendAttr;
      }
    }

View Full Code Here

    this.parameters.add(formalParameter);
  }


  public String getQualifiedClassName()
  {
    ExtendedAttribute attribute =
      (ExtendedAttribute) getExtendedAttributes().get(
        XPDLGlobals.APPLICATION_QUALIFIED_CLASS_NAME);
    if (attribute != null)
    {
      return attribute.getValue();
    }
    return qualifiedClassName;
  }

View Full Code Here

    return transition;
  }
    
  public WorkflowActivity            getBeginActivity()
  {
    ExtendedAttribute attribute =
      (ExtendedAttribute) getExtendedAttributes().get(XPDLGlobals.ID_ACTIVITY_BEGIN);
    if(attribute==null)
    {
      return null;
    }
    
    String beginActivityId= attribute.getValue();
    return findWorkflowActivity(beginActivityId);
  }

View Full Code Here

    return findWorkflowActivity(beginActivityId);
  }


  public void            setBeginActivity(WorkflowActivity beginActivity)
  {
    ExtendedAttribute attribute =
      (ExtendedAttribute) getExtendedAttributes().get(XPDLGlobals.ID_ACTIVITY_BEGIN);
 
    if(attribute==null)
    {
      this.addExtendedAttribute(new ExtendedAttribute(XPDLGlobals.ID_ACTIVITY_BEGIN,beginActivity.getUUID()));
    } 
      
    attribute.setValue(beginActivity.getUUID());
  }

View Full Code Here

    attribute.setValue(beginActivity.getUUID());
  }
    
  public WorkflowActivity            getEndActivity()
  {
    ExtendedAttribute attribute =
      (ExtendedAttribute) getExtendedAttributes().get(XPDLGlobals.ID_ACTIVITY_END);
    
    if(attribute==null)
    {
      return null;
    }
    
    String endActivityId= attribute.getValue();   
    return findWorkflowActivity(endActivityId);
  }

View Full Code Here

0 1

TOP

Related Classes of org.huihoo.workflow.xpdl.ExtendedAttribute

org.huihoo.workflow.ComplexComponentObject

org.huihoo.workflow.impl.store.util.JoinActivityFinder

org.huihoo.workflow.impl.store.util.ParticipantSelector

org.huihoo.workflow.impl.xpdl.serializer.XPDLSerializerIO

org.huihoo.workflow.impl.xpdl.WorkflowApplicationImpl

org.huihoo.workflow.impl.xpdl.WorkflowPackageImpl

org.huihoo.workflow.impl.xpdl.WorkflowProcessImpl

org.huihoo.workflow.xpdl.parser.XPDLParserTools

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.