Package org.camunda.bpm.engine.impl.bpmn.parser

Class BpmnParse

java.lang.Object
org.xml.sax.helpers.DefaultHandler
org.camunda.bpm.engine.impl.util.xml.Parse
org.camunda.bpm.engine.impl.bpmn.parser.BpmnParse
All Implemented Interfaces:
ContentHandler, DTDHandler, EntityResolver, ErrorHandler
public class BpmnParse extends Parse
Specific parsing of one BPMN 2.0 XML file, created by the BpmnParser. Instances of this class should not be reused and are also not threadsafe.
Author:
Tom Baeyens, Bernd Ruecker, Joram Barrez, Christian Stettler, Frederik Heremans, Falko Menge, Esteban Robles, Daniel Meyer, Saeid Mirzaei, Nico Rehwaldt, Ronny Bräunlich, Christopher Zell, Deivarayan Azhagappan, Ingo Richtsmeier

  • Field Details

  • Constructor Details

  • Method Details

    • deployment

      public BpmnParse deployment(DeploymentEntity deployment)

    • execute

      public BpmnParse execute()
      Overrides:
      execute in class Parse

    • parseRootElement

      protected void parseRootElement()
      Parses the 'definitions' root element

    • collectElementIds

      protected void collectElementIds()

    • parseDefinitionsAttributes

      protected void parseDefinitionsAttributes()

    • resolveName

      protected String resolveName(String name)

    • parseImports

      protected void parseImports()
      Parses the rootElement importing structures

    • getImporter

      protected XMLImporter getImporter(String importType, Element theImport)

    • parseMessages

      public void parseMessages()
      Parses the messages of the given definitions file. Messages are not contained within a process element, but they can be referenced from inner process elements.

    • parseSignals

      protected void parseSignals()
      Parses the signals of the given definitions file. Signals are not contained within a process element, but they can be referenced from inner process elements.

    • parseErrors

      public void parseErrors()

    • parseEscalations

      protected void parseEscalations()

    • createEscalation

      protected Escalation createEscalation(String id, Element element)

    • parseProcessDefinitions

      public void parseProcessDefinitions()
      Parses all the process definitions defined within the 'definitions' root element.

    • parseCollaboration

      public void parseCollaboration()
      Parses the collaboration definition defined within the 'definitions' root element and get all participants to lookup their process references during DI parsing.

    • parseProcess

      public ProcessDefinitionEntity parseProcess(Element processElement)
      Parses one process (ie anything inside a <process> element).
      Parameters:
      processElement - The 'process' element.
      Returns:
      The parsed version of the XML: a ProcessDefinitionImpl object.

    • validateAndSetHTTL

      protected void validateAndSetHTTL(Element processElement, ProcessDefinitionEntity processDefinition, boolean skipEnforceTtl)

    • parseLaneSets

      protected void parseLaneSets(Element parentElement, ProcessDefinitionEntity processDefinition)

    • parseLanes

      protected void parseLanes(Element laneSetElement, LaneSet laneSet)

    • parseScope

      public void parseScope(Element scopeElement, ScopeImpl parentScope)
      Parses a scope: a process, subprocess, etc. Note that a process definition is a scope on itself.
      Parameters:
      scopeElement - The XML element defining the scope
      parentScope - The scope that contains the nested scope.

    • filterIntermediateCatchEvents

      protected HashMap<String,Element> filterIntermediateCatchEvents(List<Element> activityElements)

    • filterCompensationHandlers

      protected HashMap<String,Element> filterCompensationHandlers(List<Element> activityElements)

    • parseIntermediateCatchEvents

      protected void parseIntermediateCatchEvents(Element scopeElement, ScopeImpl parentScope, Map<String,Element> intermediateCatchEventElements)

    • parseProcessDefinitionCustomExtensions

      protected void parseProcessDefinitionCustomExtensions(Element scopeElement, ProcessDefinition definition)

    • parseStartAuthorization

      protected void parseStartAuthorization(Element scopeElement, ProcessDefinition definition)

    • parsePotentialStarterResourceAssignment

      protected void parsePotentialStarterResourceAssignment(Element performerElement, ProcessDefinitionEntity processDefinition)

    • parseAssociations

      protected void parseAssociations(Element scopeElement, ScopeImpl parentScope, Map<String,Element> compensationHandlers)

    • parseCompensationHandlerForCompensationBoundaryEvent

      protected ActivityImpl parseCompensationHandlerForCompensationBoundaryEvent(ScopeImpl parentScope, ActivityImpl sourceActivity, String targetRef, Map<String,Element> compensationHandlers)

    • parseAssociationOfCompensationBoundaryEvent

      protected void parseAssociationOfCompensationBoundaryEvent(Element associationElement, ActivityImpl sourceActivity, ActivityImpl targetActivity)

    • parseCompensationHandlers

      protected void parseCompensationHandlers(ScopeImpl parentScope, Map<String,Element> compensationHandlers)

    • parseStartEvents

      public void parseStartEvents(Element parentElement, ScopeImpl scope)
      Parses the start events of a certain level in the process (process, subprocess or another scope).
      Parameters:
      parentElement - The 'parent' element that contains the start events (process, subprocess).
      scope - The ScopeImpl to which the start events must be added.

    • selectInitial

      protected void selectInitial(List<ActivityImpl> startEventActivities, ProcessDefinitionEntity processDefinition, Element parentElement)

    • parseProcessDefinitionStartEvent

      protected void parseProcessDefinitionStartEvent(ActivityImpl startEventActivity, Element startEventElement, Element parentElement, ScopeImpl scope)

    • parseStartFormHandlers

      protected void parseStartFormHandlers(List<Element> startEventElements, ProcessDefinitionEntity processDefinition)

    • parseScopeStartEvent

      protected void parseScopeStartEvent(ActivityImpl startEventActivity, Element startEventElement, Element parentElement, ActivityImpl scopeActivity)

    • parseCompensationEventSubprocess

      protected void parseCompensationEventSubprocess(ActivityImpl startEventActivity, Element startEventElement, ActivityImpl scopeActivity, Element compensateEventDefinition)

    • parseErrorStartEventDefinition

      protected void parseErrorStartEventDefinition(Element errorEventDefinition, ActivityImpl startEventActivity)

    • setErrorCodeVariableOnErrorEventDefinition

      protected void setErrorCodeVariableOnErrorEventDefinition(Element errorEventDefinition, ErrorEventDefinition definition)
      Sets the value for "camunda:errorCodeVariable" on the passed definition if it's present.
      Parameters:
      errorEventDefinition - the XML errorEventDefinition tag
      definition - the errorEventDefintion that can get the errorCodeVariable value

    • setErrorMessageVariableOnErrorEventDefinition

      protected void setErrorMessageVariableOnErrorEventDefinition(Element errorEventDefinition, ErrorEventDefinition definition)
      Sets the value for "camunda:errorMessageVariable" on the passed definition if it's present.
      Parameters:
      errorEventDefinition - the XML errorEventDefinition tag
      definition - the errorEventDefintion that can get the errorMessageVariable value

    • parseMessageEventDefinition

      protected EventSubscriptionDeclaration parseMessageEventDefinition(Element messageEventDefinition, String messageElementId)

    • addEventSubscriptionDeclaration

      protected void addEventSubscriptionDeclaration(EventSubscriptionDeclaration subscription, ScopeImpl scope, Element element)

    • hasMultipleMessageEventDefinitionsWithSameName

      protected boolean hasMultipleMessageEventDefinitionsWithSameName(EventSubscriptionDeclaration subscription, Collection<EventSubscriptionDeclaration> eventDefinitions)

    • hasMultipleSignalEventDefinitionsWithSameName

      protected boolean hasMultipleSignalEventDefinitionsWithSameName(EventSubscriptionDeclaration subscription, Collection<EventSubscriptionDeclaration> eventDefinitions)

    • hasMultipleConditionalEventDefinitionsWithSameCondition

      protected boolean hasMultipleConditionalEventDefinitionsWithSameCondition(EventSubscriptionDeclaration subscription, Collection<EventSubscriptionDeclaration> eventDefinitions)

    • hasMultipleEventDefinitionsWithSameName

      protected boolean hasMultipleEventDefinitionsWithSameName(EventSubscriptionDeclaration subscription, Collection<EventSubscriptionDeclaration> eventDefinitions, String eventType)

    • addEventSubscriptionJobDeclaration

      protected void addEventSubscriptionJobDeclaration(EventSubscriptionJobDeclaration jobDeclaration, ActivityImpl activity, Element element)

    • activityAlreadyContainsJobDeclarationEventType

      protected boolean activityAlreadyContainsJobDeclarationEventType(List<EventSubscriptionJobDeclaration> jobDeclarationsForActivity, EventSubscriptionJobDeclaration jobDeclaration)
      Assumes that an activity has at most one declaration of a certain eventType.

    • parseActivities

      public void parseActivities(List<Element> activityElements, Element parentElement, ScopeImpl scopeElement)
      Parses the activities of a certain level in the process (process, subprocess or another scope).
      Parameters:
      activityElements - The list of activities to be parsed. This list may be filtered before.
      parentElement - The 'parent' element that contains the activities (process, subprocess).
      scopeElement - The ScopeImpl to which the activities must be added.

    • parseActivity

      protected ActivityImpl parseActivity(Element activityElement, Element parentElement, ScopeImpl scopeElement)

    • validateActivities

      public void validateActivities(List<ActivityImpl> activities)

    • validateActivity

      protected void validateActivity(ActivityImpl activity)

    • validateOutgoingFlows

      protected void validateOutgoingFlows(ActivityImpl activity)

    • validateExclusiveGateway

      public void validateExclusiveGateway(ActivityImpl activity)

    • parseIntermediateCatchEvent

      public ActivityImpl parseIntermediateCatchEvent(Element intermediateEventElement, ScopeImpl scopeElement, ActivityImpl eventBasedGateway)

    • parseIntermediateLinkEventCatchBehavior

      protected void parseIntermediateLinkEventCatchBehavior(Element intermediateEventElement, ActivityImpl activity, Element linkEventDefinitionElement)

    • parseIntermediateMessageEventDefinition

      protected void parseIntermediateMessageEventDefinition(Element messageEventDefinition, ActivityImpl nestedActivity)

    • parseIntermediateThrowEvent

      public ActivityImpl parseIntermediateThrowEvent(Element intermediateEventElement, ScopeImpl scopeElement)

    • parseThrowCompensateEventDefinition

      protected CompensateEventDefinition parseThrowCompensateEventDefinition(Element compensateEventDefinitionElement, ScopeImpl scopeElement, String parentElementId)

    • validateCatchCompensateEventDefinition

      protected void validateCatchCompensateEventDefinition(Element compensateEventDefinitionElement, String parentElementId)

    • parseBoundaryCompensateEventDefinition

      protected void parseBoundaryCompensateEventDefinition(Element compensateEventDefinition, ActivityImpl activity)

    • parseBoundaryCancelEventDefinition

      protected ActivityBehavior parseBoundaryCancelEventDefinition(Element cancelEventDefinition, ActivityImpl activity)

    • parseMultiInstanceLoopCharacteristics

      public ScopeImpl parseMultiInstanceLoopCharacteristics(Element activityElement, ScopeImpl scope)
      Parses loopCharacteristics (standardLoop/Multi-instance) of an activity, if any is defined.

    • getIdForMiBody

      public static String getIdForMiBody(String id)

    • createActivityOnScope

      public ActivityImpl createActivityOnScope(Element activityElement, ScopeImpl scopeElement)
      Parses the generic information of an activity element (id, name, documentation, etc.), and creates a new ActivityImpl on the given scope element.

    • setActivityAsyncDelegates

      protected void setActivityAsyncDelegates(ActivityImpl activity)
      Sets the delegates for the activity, which will be called if the attribute asyncAfter or asyncBefore was changed.
      Parameters:
      activity - the activity which gets the delegates

    • addMessageJobDeclaration

      protected void addMessageJobDeclaration(MessageJobDeclaration messageJobDeclaration, ActivityImpl activity, boolean exclusive)
      Adds the new message job declaration to existing declarations. There will be executed an existing check before the adding is executed.
      Parameters:
      messageJobDeclaration - the new message job declaration
      activity - the corresponding activity
      exclusive - the flag which indicates if the async should be exclusive

    • exists

      protected boolean exists(MessageJobDeclaration msgJobdecl, String procDefKey, String activityId)
      Checks whether the message declaration already exists.
      Parameters:
      msgJobdecl - the message job declaration which is searched
      procDefKey - the corresponding process definition key
      activityId - the corresponding activity id
      Returns:
      true if the message job declaration exists, false otherwise

    • removeMessageJobDeclarationWithJobConfiguration

      protected void removeMessageJobDeclarationWithJobConfiguration(ActivityImpl activity, String jobConfiguration)
      Removes a job declaration which belongs to the given activity and has the given job configuration.
      Parameters:
      activity - the activity of the job declaration
      jobConfiguration - the job configuration of the declaration

    • parseDocumentation

      public String parseDocumentation(Element element)

    • parseDocumentation

      public static String parseDocumentation(List<String> docStrings)

    • isCompensationHandler

      protected boolean isCompensationHandler(Element activityElement)

    • parseExclusiveGateway

      public ActivityImpl parseExclusiveGateway(Element exclusiveGwElement, ScopeImpl scope)
      Parses an exclusive gateway declaration.

    • parseInclusiveGateway

      public ActivityImpl parseInclusiveGateway(Element inclusiveGwElement, ScopeImpl scope)
      Parses an inclusive gateway declaration.

    • parseEventBasedGateway

      public ActivityImpl parseEventBasedGateway(Element eventBasedGwElement, Element parentElement, ScopeImpl scope)

    • parseParallelGateway

      public ActivityImpl parseParallelGateway(Element parallelGwElement, ScopeImpl scope)
      Parses a parallel gateway declaration.

    • parseScriptTask

      public ActivityImpl parseScriptTask(Element scriptTaskElement, ScopeImpl scope)
      Parses a scriptTask declaration.

    • parseScriptTaskElement

      protected ScriptTaskActivityBehavior parseScriptTaskElement(Element scriptTaskElement)
      Returns a ScriptTaskActivityBehavior for the script task element corresponding to the script source or resource specified.
      Parameters:
      scriptTaskElement - the script task element
      Returns:
      the corresponding ScriptTaskActivityBehavior

    • parseResultVariable

      protected String parseResultVariable(Element element)

    • parseServiceTask

      public ActivityImpl parseServiceTask(Element serviceTaskElement, ScopeImpl scope)
      Parses a serviceTask declaration.

    • parseServiceTaskLike

      public void parseServiceTaskLike(ActivityImpl activity, String elementName, Element serviceTaskElement, Element camundaPropertiesElement, ScopeImpl scope)
      Parameters:
      elementName -
      serviceTaskElement - the element that contains the camunda service task definition (e.g. camunda:class attributes)
      camundaPropertiesElement - the element that contains the camunda:properties extension elements that apply to this service task. Usually, but not always, this is the same as serviceTaskElement
      scope -

    • validateServiceTaskLike

      protected void validateServiceTaskLike(ActivityImpl activity, String elementName, Element serviceTaskElement)

    • parseBusinessRuleTask

      public ActivityImpl parseBusinessRuleTask(Element businessRuleTaskElement, ScopeImpl scope)
      Parses a businessRuleTask declaration.

    • parseDmnBusinessRuleTask

      protected ActivityImpl parseDmnBusinessRuleTask(Element businessRuleTaskElement, ScopeImpl scope)
      Parse a Business Rule Task which references a decision.

    • parseDecisionResultMapper

      protected DecisionResultMapper parseDecisionResultMapper(Element businessRuleTaskElement)

    • parseAsynchronousContinuationForActivity

      protected void parseAsynchronousContinuationForActivity(Element activityElement, ActivityImpl activity)
      Parse async continuation of an activity and create async jobs for the activity.

      When the activity is marked as multi instance, then async jobs create instead for the multi instance body. When the wrapped activity has async characteristics in 'multiInstanceLoopCharacteristics' element, then async jobs create additionally for the wrapped activity.

    • parseAsynchronousContinuation

      protected void parseAsynchronousContinuation(Element element, ActivityImpl activity)
      Parse async continuation of the given element and create async jobs for the activity.
      Parameters:
      element - with async characteristics
      activity -

    • parsePriority

      protected ParameterValueProvider parsePriority(Element element, String priorityAttribute)

    • parseTopic

      protected ParameterValueProvider parseTopic(Element element, String topicAttribute)

    • addMessageJobDeclarationToActivity

      protected void addMessageJobDeclarationToActivity(MessageJobDeclaration messageJobDeclaration, ActivityImpl activity)

    • addJobDeclarationToProcessDefinition

      protected void addJobDeclarationToProcessDefinition(JobDeclaration<?,?> jobDeclaration, ProcessDefinition processDefinition)

    • parseSendTask

      public ActivityImpl parseSendTask(Element sendTaskElement, ScopeImpl scope)
      Parses a sendTask declaration.

    • parseEmailServiceTask

      protected void parseEmailServiceTask(ActivityImpl activity, Element serviceTaskElement, List<FieldDeclaration> fieldDeclarations)

    • parseShellServiceTask

      protected void parseShellServiceTask(ActivityImpl activity, Element serviceTaskElement, List<FieldDeclaration> fieldDeclarations)

    • parseExternalServiceTask

      protected void parseExternalServiceTask(ActivityImpl activity, Element serviceTaskElement, Element camundaPropertiesElement)

    • validateFieldDeclarationsForEmail

      protected void validateFieldDeclarationsForEmail(Element serviceTaskElement, List<FieldDeclaration> fieldDeclarations)

    • validateFieldDeclarationsForShell

      protected void validateFieldDeclarationsForShell(Element serviceTaskElement, List<FieldDeclaration> fieldDeclarations)

    • parseFieldDeclarations

      public List<FieldDeclaration> parseFieldDeclarations(Element element)

    • parseFieldDeclaration

      protected FieldDeclaration parseFieldDeclaration(Element serviceTaskElement, Element fieldDeclarationElement)

    • parseStringFieldDeclaration

      protected FieldDeclaration parseStringFieldDeclaration(Element fieldDeclarationElement, Element serviceTaskElement, String fieldName)

    • parseExpressionFieldDeclaration

      protected FieldDeclaration parseExpressionFieldDeclaration(Element fieldDeclarationElement, Element serviceTaskElement, String fieldName)

    • getStringValueFromAttributeOrElement

      protected String getStringValueFromAttributeOrElement(String attributeName, String elementName, Element element, String ancestorElementId)

    • parseTask

      public ActivityImpl parseTask(Element taskElement, ScopeImpl scope)
      Parses a task with no specific type (behaves as passthrough).

    • parseManualTask

      public ActivityImpl parseManualTask(Element manualTaskElement, ScopeImpl scope)
      Parses a manual task.

    • parseReceiveTask

      public ActivityImpl parseReceiveTask(Element receiveTaskElement, ScopeImpl scope)
      Parses a receive task.

    • parseUserTask

      public ActivityImpl parseUserTask(Element userTaskElement, ScopeImpl scope)
      Parses a userTask declaration.

    • parseTaskDefinition

      public TaskDefinition parseTaskDefinition(Element taskElement, String taskDefinitionKey, ActivityImpl activity, ProcessDefinitionEntity processDefinition)

    • parseFormDefinition

      protected FormDefinition parseFormDefinition(Element flowNodeElement)

    • parseHumanPerformer

      protected void parseHumanPerformer(Element taskElement, TaskDefinition taskDefinition)

    • parsePotentialOwner

      protected void parsePotentialOwner(Element taskElement, TaskDefinition taskDefinition)

    • parseHumanPerformerResourceAssignment

      protected void parseHumanPerformerResourceAssignment(Element performerElement, TaskDefinition taskDefinition)

    • parsePotentialOwnerResourceAssignment

      protected void parsePotentialOwnerResourceAssignment(Element performerElement, TaskDefinition taskDefinition)

    • getAssignmentId

      protected String getAssignmentId(String expression, String prefix)

    • parseUserTaskCustomExtensions

      protected void parseUserTaskCustomExtensions(Element taskElement, ActivityImpl activity, TaskDefinition taskDefinition)

    • parseCommaSeparatedList

      protected List<String> parseCommaSeparatedList(String s)
      Parses the given String as a list of comma separated entries, where an entry can possibly be an expression that has comma's. If somebody is smart enough to write a regex for this, please let us know.
      Returns:
      the entries of the comma separated list, trimmed.

    • parseTaskListeners

      protected void parseTaskListeners(Element userTaskElement, ActivityImpl activity, TaskDefinition taskDefinition)

    • parseTaskListener

      protected TaskListener parseTaskListener(Element taskListenerElement, String taskElementId)

    • parseTimeoutTaskListener

      protected TaskListener parseTimeoutTaskListener(Element taskListenerElement, ActivityImpl timerActivity, TaskDefinition taskDefinition)

    • parseEndEvents

      public void parseEndEvents(Element parentElement, ScopeImpl scope)
      Parses the end events of a certain level in the process (process, subprocess or another scope).
      Parameters:
      parentElement - The 'parent' element that contains the end events (process, subprocess).
      scope - The ScopeImpl to which the end events must be added.

    • parseBoundaryEvents

      public void parseBoundaryEvents(Element parentElement, ScopeImpl flowScope)
      Parses the boundary events of a certain 'level' (process, subprocess or other scope). Note that the boundary events are not parsed during the parsing of the bpmn activities, since the semantics are different (boundaryEvent needs to be added as nested activity to the reference activity on PVM level).
      Parameters:
      parentElement - The 'parent' element that contains the activities (process, subprocess).
      flowScope - The ScopeImpl to which the activities must be added.

    • parseCamundaErrorEventDefinitions

      public List<CamundaErrorEventDefinition> parseCamundaErrorEventDefinitions(ActivityImpl activity, Element scopeElement)

    • getMultiInstanceScope

      protected ActivityImpl getMultiInstanceScope(ActivityImpl activity)

    • parseBoundaryTimerEventDefinition

      public void parseBoundaryTimerEventDefinition(Element timerEventDefinition, boolean interrupting, ActivityImpl boundaryActivity)
      Parses a boundary timer event. The end-result will be that the given nested activity will get the appropriate ActivityBehavior.
      Parameters:
      timerEventDefinition - The XML element corresponding with the timer event details
      interrupting - Indicates whether this timer is interrupting.
      boundaryActivity - The activity which maps to the structure of the timer event on the boundary of another activity. Note that this is NOT the activity onto which the boundary event is attached, but a nested activity inside this activity, specifically created for this event.

    • parseBoundarySignalEventDefinition

      public void parseBoundarySignalEventDefinition(Element element, boolean interrupting, ActivityImpl signalActivity)

    • parseBoundaryMessageEventDefinition

      public void parseBoundaryMessageEventDefinition(Element element, boolean interrupting, ActivityImpl messageActivity)

    • parseTimerStartEventDefinition

      protected void parseTimerStartEventDefinition(Element timerEventDefinition, ActivityImpl timerActivity, ProcessDefinitionEntity processDefinition)

    • parseTimerStartEventDefinitionForEventSubprocess

      protected void parseTimerStartEventDefinitionForEventSubprocess(Element timerEventDefinition, ActivityImpl timerActivity, boolean interrupting)

    • parseEventDefinitionForSubprocess

      protected void parseEventDefinitionForSubprocess(EventSubscriptionDeclaration subscriptionDeclaration, ActivityImpl activity, Element element)

    • parseIntermediateSignalEventDefinition

      protected void parseIntermediateSignalEventDefinition(Element element, ActivityImpl signalActivity)

    • parseSignalCatchEventDefinition

      protected void parseSignalCatchEventDefinition(Element element, ActivityImpl signalActivity, boolean isStartEvent)

    • parseSignalEventDefinition

      protected EventSubscriptionDeclaration parseSignalEventDefinition(Element signalEventDefinitionElement, boolean isThrowing, String signalElementId)
      Parses the Signal Event Definition XML including payload definition.
      Parameters:
      signalEventDefinitionElement - the Signal Event Definition element
      isThrowing - true if a Throwing signal event is being parsed
      Returns:

    • parseIntermediateTimerEventDefinition

      protected void parseIntermediateTimerEventDefinition(Element timerEventDefinition, ActivityImpl timerActivity)

    • parseTimer

      protected TimerDeclarationImpl parseTimer(Element timerEventDefinition, ActivityImpl timerActivity, String jobHandlerType)

    • parseExpression

      protected Expression parseExpression(Element parent, String name)

    • parseBoundaryErrorEventDefinition

      public void parseBoundaryErrorEventDefinition(Element errorEventDefinition, ActivityImpl boundaryEventActivity)

    • addErrorEventDefinition

      protected void addErrorEventDefinition(ErrorEventDefinition errorEventDefinition, ScopeImpl catchingScope)

    • parseBoundaryEscalationEventDefinition

      protected void parseBoundaryEscalationEventDefinition(Element escalationEventDefinitionElement, boolean cancelActivity, ActivityImpl boundaryEventActivity)

    • findEscalationForEscalationEventDefinition

      protected Escalation findEscalationForEscalationEventDefinition(Element escalationEventDefinition, String escalationElementId)
      Find the referenced escalation of the given escalation event definition. Add errors if the referenced escalation not found.
      Returns:
      referenced escalation or null, if referenced escalation not found

    • createEscalationEventDefinitionForEscalationHandler

      protected EscalationEventDefinition createEscalationEventDefinitionForEscalationHandler(Element escalationEventDefinitionElement, ActivityImpl escalationHandler, boolean cancelActivity, String parentElementId)

    • addEscalationEventDefinition

      protected void addEscalationEventDefinition(ScopeImpl catchingScope, EscalationEventDefinition escalationEventDefinition, Element element, String escalationElementId)

    • addTimerDeclaration

      protected void addTimerDeclaration(ScopeImpl scope, TimerDeclarationImpl timerDeclaration)

    • addTimerListenerDeclaration

      protected void addTimerListenerDeclaration(String listenerId, ScopeImpl scope, TimerDeclarationImpl timerDeclaration)

    • addVariableDeclaration

      protected void addVariableDeclaration(ScopeImpl scope, VariableDeclaration variableDeclaration)

    • parseBoundaryConditionalEventDefinition

      public BoundaryConditionalEventActivityBehavior parseBoundaryConditionalEventDefinition(Element element, boolean interrupting, ActivityImpl conditionalActivity)
      Parses the given element as conditional boundary event.
      Parameters:
      element - the XML element which contains the conditional event information
      interrupting - indicates if the event is interrupting or not
      conditionalActivity - the conditional event activity
      Returns:
      the boundary conditional event behavior which contains the condition

    • parseIntermediateConditionalEventDefinition

      public ConditionalEventDefinition parseIntermediateConditionalEventDefinition(Element element, ActivityImpl conditionalActivity)
      Parses the given element as intermediate conditional event.
      Parameters:
      element - the XML element which contains the conditional event information
      conditionalActivity - the conditional event activity
      Returns:
      returns the conditional activity with the parsed information

    • parseConditionalStartEventForEventSubprocess

      public ConditionalEventDefinition parseConditionalStartEventForEventSubprocess(Element element, ActivityImpl conditionalActivity, boolean interrupting)
      Parses the given element as conditional start event of an event subprocess.
      Parameters:
      element - the XML element which contains the conditional event information
      interrupting - indicates if the event is interrupting or not
      conditionalActivity - the conditional event activity
      Returns:

    • parseConditionalEventDefinition

      protected ConditionalEventDefinition parseConditionalEventDefinition(Element element, ActivityImpl conditionalActivity)
      Parses the given element and returns an ConditionalEventDefinition object.
      Parameters:
      element - the XML element which contains the conditional event information
      conditionalActivity - the conditional event activity
      Returns:
      the conditional event definition which was parsed

    • parseSubProcess

      public ActivityImpl parseSubProcess(Element subProcessElement, ScopeImpl scope)
      Parses a subprocess (formally known as an embedded subprocess): a subprocess defined within another process definition.
      Parameters:
      subProcessElement - The XML element corresponding with the subprocess definition
      scope - The current scope on which the subprocess is defined.

    • parseTransaction

      protected ActivityImpl parseTransaction(Element transactionElement, ScopeImpl scope)

    • parseCallActivity

      public ActivityImpl parseCallActivity(Element callActivityElement, ScopeImpl scope, boolean isMultiInstance)
      Parses a call activity (currently only supporting calling subprocesses).
      Parameters:
      callActivityElement - The XML element defining the call activity
      scope - The current scope on which the call activity is defined.

    • parseBinding

      protected void parseBinding(Element callActivityElement, ActivityImpl activity, BaseCallableElement callableElement, String bindingAttributeName)

    • parseTenantId

      protected void parseTenantId(Element callingActivityElement, ActivityImpl activity, BaseCallableElement callableElement, String attrName)

    • parseVersion

      protected void parseVersion(Element callingActivityElement, ActivityImpl activity, BaseCallableElement callableElement, String bindingAttributeName, String versionAttributeName)

    • parseVersionTag

      protected void parseVersionTag(Element callingActivityElement, ActivityImpl activity, BaseCallableElement callableElement, String bindingAttributeName, String versionTagAttributeName)

    • parseInputParameter

      protected void parseInputParameter(Element elementWithParameters, CallableElement callableElement)

    • parseOutputParameter

      protected void parseOutputParameter(Element callActivityElement, ActivityImpl activity, CallableElement callableElement)

    • attributeValueEquals

      protected boolean attributeValueEquals(Element element, String attribute, String comparisonValue)

    • parseCallableElementProvider

      protected CallableElementParameter parseCallableElementProvider(Element parameterElement, String ancestorElementId)

    • parseProperties

      public void parseProperties(Element element, ActivityImpl activity)
      Parses the properties of an element (if any) that can contain properties (processes, activities, etc.) Returns true if property subelemens are found.
      Parameters:
      element - The element that can contain properties.
      activity - The activity where the property declaration is done.

    • parseProperty

      public void parseProperty(Element propertyElement, ActivityImpl activity)
      Parses one property definition.
      Parameters:
      propertyElement - The 'property' element that defines how a property looks like and is handled.

    • parsePropertyCustomExtensions

      public void parsePropertyCustomExtensions(ActivityImpl activity, Element propertyElement, String propertyName, String propertyType)
      Parses the custom extensions for properties.
      Parameters:
      activity - The activity where the property declaration is done.
      propertyElement - The 'property' element defining the property.
      propertyName - The name of the property.
      propertyType - The type of the property.

    • parseSequenceFlow

      public void parseSequenceFlow(Element processElement, ScopeImpl scope, Map<String,Element> compensationHandlers)
      Parses all sequence flow of a scope.
      Parameters:
      processElement - The 'process' element wherein the sequence flow are defined.
      scope - The scope to which the sequence flow must be added.
      compensationHandlers -

    • parseSequenceFlowConditionExpression

      public void parseSequenceFlowConditionExpression(Element seqFlowElement, TransitionImpl seqFlow)
      Parses a condition expression on a sequence flow.
      Parameters:
      seqFlowElement - The 'sequenceFlow' element that can contain a condition.
      seqFlow - The sequenceFlow object representation to which the condition must be added.

    • parseConditionExpression

      protected Condition parseConditionExpression(Element conditionExprElement, String ancestorElementId)

    • parseExecutionListenersOnScope

      public void parseExecutionListenersOnScope(Element scopeElement, ScopeImpl scope)
      Parses all execution-listeners on a scope.
      Parameters:
      scopeElement - the XML element containing the scope definition.
      scope - the scope to add the executionListeners to.

    • isValidEventNameForScope

      protected boolean isValidEventNameForScope(String eventName, Element listenerElement, String ancestorElementId)
      Check if the given event name is valid. If not, an appropriate error is added.

    • parseExecutionListenersOnTransition

      public void parseExecutionListenersOnTransition(Element activitiElement, TransitionImpl activity)

    • parseExecutionListener

      public ExecutionListener parseExecutionListener(Element executionListenerElement, String ancestorElementId)
      Parses an ExecutionListener implementation for the given executionListener element.
      Parameters:
      executionListenerElement - the XML element containing the executionListener definition.

    • parseDiagramInterchangeElements

      public void parseDiagramInterchangeElements()

    • parseBPMNDiagram

      public void parseBPMNDiagram(Element bpmndiagramElement)

    • parseBPMNPlane

      public void parseBPMNPlane(Element bpmnPlaneElement)

    • parseBPMNShape

      public void parseBPMNShape(Element bpmnShapeElement)

    • parseDIBounds

      protected void parseDIBounds(Element bpmnShapeElement, HasDIBounds target)

    • parseBPMNEdge

      public void parseBPMNEdge(Element bpmnEdgeElement)

    • getProcessDefinitions

      public List<ProcessDefinitionEntity> getProcessDefinitions()

    • getProcessDefinition

      public ProcessDefinitionEntity getProcessDefinition(String processDefinitionKey)

    • name

      public BpmnParse name(String name)
      Overrides:
      name in class Parse

    • sourceInputStream

      public BpmnParse sourceInputStream(InputStream inputStream)
      Overrides:
      sourceInputStream in class Parse

    • sourceResource

      public BpmnParse sourceResource(String resource, ClassLoader classLoader)
      Overrides:
      sourceResource in class Parse

    • sourceResource

      public BpmnParse sourceResource(String resource)
      Overrides:
      sourceResource in class Parse

    • sourceString

      public BpmnParse sourceString(String string)
      Overrides:
      sourceString in class Parse

    • sourceUrl

      public BpmnParse sourceUrl(String url)
      Overrides:
      sourceUrl in class Parse

    • sourceUrl

      public BpmnParse sourceUrl(URL url)
      Overrides:
      sourceUrl in class Parse

    • parseBooleanAttribute

      public Boolean parseBooleanAttribute(String booleanText, boolean defaultValue)

    • parseBooleanAttribute

      public Boolean parseBooleanAttribute(String booleanText)

    • parseDoubleAttribute

      public Double parseDoubleAttribute(Element element, String attributeName, String doubleText, boolean required)

    • isStartable

      protected boolean isStartable(Element element)

    • isExclusive

      protected boolean isExclusive(Element element)

    • isAsyncBefore

      protected boolean isAsyncBefore(Element element)

    • isAsyncAfter

      protected boolean isAsyncAfter(Element element)

    • isServiceTaskLike

      protected boolean isServiceTaskLike(Element element)

    • hasConnector

      protected boolean hasConnector(Element element)

    • getJobDeclarations

      public Map<String,List<JobDeclaration<?,?>>> getJobDeclarations()

    • getJobDeclarationsByKey

      public List<JobDeclaration<?,?>> getJobDeclarationsByKey(String processDefinitionKey)

    • parseActivityInputOutput

      protected void parseActivityInputOutput(Element activityElement, ActivityImpl activity)

    • checkActivityInputOutputSupported

      protected boolean checkActivityInputOutputSupported(Element activityElement, ActivityImpl activity, IoMapping inputOutput)

    • checkActivityOutputParameterSupported

      protected boolean checkActivityOutputParameterSupported(Element activityElement, ActivityImpl activity)

    • ensureNoIoMappingDefined

      protected void ensureNoIoMappingDefined(Element element)

    • createParameterValueProvider

      protected ParameterValueProvider createParameterValueProvider(Object value, ExpressionManager expressionManager)

    • addTimeCycleWarning

      protected void addTimeCycleWarning(Element timeCycleElement, String type, String timerElementId)

    • ensureNoExpressionInMessageStartEvent

      protected void ensureNoExpressionInMessageStartEvent(Element element, EventSubscriptionDeclaration messageStartEventSubscriptionDeclaration, String parentElementId)