BpmnParse (Camunda BPM Javadocs 7.13.0-SNAPSHOT)

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

Property Summary
- Properties inherited from class org.camunda.bpm.engine.impl.util.xml.Parse
  resolveAccessExternalSchemaProperty

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`ALL`
`protected static String`	`ASSIGNEE_EXTENSION`
`protected static String`	`ATTRIBUTEVALUE_T_FORMAL_EXPRESSION`
`static Namespace`	`BPMN_DC_NS`
`static Namespace`	`BPMN_DI_NS`
`static Namespace`	`CAMUNDA_BPMN_EXTENSIONS_NS`
`static String`	`CANCEL_EVENT_DEFINITION`
`protected static String`	`CANDIDATE_GROUPS_EXTENSION`
`protected static String`	`CANDIDATE_STARTER_GROUPS_EXTENSION`
`protected static String`	`CANDIDATE_STARTER_USERS_EXTENSION`
`protected static String`	`CANDIDATE_USERS_EXTENSION`
`static String`	`COMPENSATE_EVENT_DEFINITION`
`static String`	`CONDITION`
`static String`	`CONDITION_EXPRESSION`
`static String`	`CONDITIONAL_EVENT_DEFINITION`
`protected DeploymentEntity`	`deployment` The deployment to which the parsed process definitions will be added.
`protected static String`	`DUE_DATE_EXTENSION`
`protected List<String>`	`elementIds` A list of all element IDs.
`static String`	`ERROR_EVENT_DEFINITION`
`protected Map<String,Error>`	`errors` Mapping of found errors in BPMN 2.0 file
`static String`	`ESCALATION_EVENT_DEFINITION`
`protected Map<String,Escalation>`	`escalations` Mapping of found escalation elements
`protected ExpressionManager`	`expressionManager`
`protected static String`	`FOLLOW_UP_DATE_EXTENSION`
`protected static String`	`FORMAL_EXPRESSION`
`protected static String`	`GROUP_PREFIX`
`protected static String`	`HUMAN_PERFORMER`
`protected Map<String,XMLImporter>`	`importers`
`static String`	`INTERRUPTING`
`protected Map<String,List<JobDeclaration<?,?>>>`	`jobDeclarations` Mapping from a process definition key to his containing list of job declarations
`static String`	`LINK_EVENT_DEFINITION`
`protected static BpmnParseLogger`	`LOG`
`static String`	`MESSAGE_EVENT_DEFINITION`
`protected Map<String,MessageDefinition>`	`messages` Mapping containing values stored during the first phase of parsing since other elements can reference these messages.
`static String`	`MULTI_INSTANCE_BODY_ID_SUFFIX`
`static Namespace`	`OMG_DI_NS`
`protected List<BpmnParseListener>`	`parseListeners`
`protected Map<String,String>`	`participantProcesses` A map for storing the process references of participants
`protected static String`	`POTENTIAL_OWNER`
`protected static String`	`POTENTIAL_STARTER`
`protected Map<String,String>`	`prefixs`
`protected static String`	`PRIORITY_EXTENSION`
`protected List<ProcessDefinitionEntity>`	`processDefinitions` The end result of the parsing: a list of process definition.
`static String`	`PROPERTYNAME_CLASS`
`static String`	`PROPERTYNAME_COMPENSATION_HANDLER_ID`
`static String`	`PROPERTYNAME_CONDITION`
`static String`	`PROPERTYNAME_CONDITION_TEXT`
`static String`	`PROPERTYNAME_CONSUMES_COMPENSATION`
`static String`	`PROPERTYNAME_DELEGATE_EXPRESSION`
`static String`	`PROPERTYNAME_DOCUMENTATION`
`static String`	`PROPERTYNAME_ERROR_EVENT_DEFINITIONS` Deprecated. use `BpmnProperties.ERROR_EVENT_DEFINITIONS`
`static String`	`PROPERTYNAME_EVENT_SUBSCRIPTION_JOB_DECLARATION`
`static String`	`PROPERTYNAME_EXPRESSION`
`static String`	`PROPERTYNAME_EXTERNAL_TASK_TOPIC`
`static String`	`PROPERTYNAME_HAS_CONDITIONAL_EVENTS`
`static String`	`PROPERTYNAME_INITIATOR_VARIABLE_NAME`
`static String`	`PROPERTYNAME_IS_FOR_COMPENSATION`
`static String`	`PROPERTYNAME_IS_MULTI_INSTANCE`
`static String`	`PROPERTYNAME_ISEXPANDED`
`static String`	`PROPERTYNAME_JOB_PRIORITY`
`static String`	`PROPERTYNAME_LANGUAGE`
`static String`	`PROPERTYNAME_MESSAGE_JOB_DECLARATION`
`static String`	`PROPERTYNAME_RESOURCE`
`static String`	`PROPERTYNAME_START_TIMER`
`static String`	`PROPERTYNAME_TASK_PRIORITY`
`static String`	`PROPERTYNAME_THROWS_COMPENSATION`
`static String`	`PROPERTYNAME_TIMER_DECLARATION`
`static String`	`PROPERTYNAME_TYPE` Deprecated. use `BpmnProperties.TYPE`
`static String`	`PROPERTYNAME_VARIABLE_DECLARATIONS`
`static String`	`PROPERTYNAME_VARIABLE_MAPPING_CLASS`
`static String`	`PROPERTYNAME_VARIABLE_MAPPING_DELEGATE_EXPRESSION`
`protected static String`	`RESOURCE_ASSIGNMENT_EXPR`
`protected Map<String,TransitionImpl>`	`sequenceFlows` A map for storing sequence flow based on their id during parsing.
`static String`	`SIGNAL_EVENT_DEFINITION`
`protected Map<String,SignalDefinition>`	`signals`
`protected String`	`targetNamespace`
`static String`	`TIMER_EVENT_DEFINITION`
`static String`	`TRUE`
`static String`	`TYPE`
`protected static String`	`USER_PREFIX`
`static List<String>`	`VARIABLE_EVENTS`
`static Namespace`	`XSI_NS`

Fields inherited from class org.camunda.bpm.engine.impl.util.xml.Parse
enableXxeProcessing, name, parser, rootElement, schemaResource, streamSource, warnings

Constructor Summary

Constructors
Constructor and Description

BpmnParse(BpmnParser parser)
Constructor to be called by the BpmnParser.

Constructors
Constructor and Description
`BpmnParse(BpmnParser parser)` Constructor to be called by the `BpmnParser`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected boolean`	`activityAlreadyContainsJobDeclarationEventType(List<EventSubscriptionJobDeclaration> jobDeclarationsForActivity, EventSubscriptionJobDeclaration jobDeclaration)` Assumes that an activity has at most one declaration of a certain eventType.
`protected void`	`addErrorEventDefinition(ErrorEventDefinition errorEventDefinition, ScopeImpl catchingScope)`
`protected void`	`addEscalationEventDefinition(ScopeImpl catchingScope, EscalationEventDefinition escalationEventDefinition, Element element, String escalationElementId)`
`protected void`	`addEventSubscriptionDeclaration(EventSubscriptionDeclaration subscription, ScopeImpl scope, Element element)`
`protected void`	`addEventSubscriptionJobDeclaration(EventSubscriptionJobDeclaration jobDeclaration, ActivityImpl activity, Element element)`
`protected void`	`addJobDeclarationToProcessDefinition(JobDeclaration<?,?> jobDeclaration, ProcessDefinition processDefinition)`
`protected void`	`addMessageJobDeclaration(MessageJobDeclaration messageJobDeclaration, ActivityImpl activity, boolean exclusive)` Adds the new message job declaration to existing declarations.
`protected void`	`addMessageJobDeclarationToActivity(MessageJobDeclaration messageJobDeclaration, ActivityImpl activity)`
`protected void`	`addTimeCycleWarning(Element timeCycleElement, String type, String timerElementId)`
`protected void`	`addTimerDeclaration(ScopeImpl scope, TimerDeclarationImpl timerDeclaration)`
`protected void`	`addTimerListenerDeclaration(String listenerId, ScopeImpl scope, TimerDeclarationImpl timerDeclaration)`
`protected void`	`addVariableDeclaration(ScopeImpl scope, VariableDeclaration variableDeclaration)`
`protected boolean`	`attributeValueEquals(Element element, String attribute, String comparisonValue)`
`protected boolean`	`checkActivityInputOutputSupported(Element activityElement, ActivityImpl activity, IoMapping inputOutput)`
`protected boolean`	`checkActivityOutputParameterSupported(Element activityElement, ActivityImpl activity)`
`protected void`	`collectElementIds()`
`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.
`protected Escalation`	`createEscalation(String id, Element element)`
`protected EscalationEventDefinition`	`createEscalationEventDefinitionForEscalationHandler(Element escalationEventDefinitionElement, ActivityImpl escalationHandler, boolean cancelActivity, String parentElementId)`
`protected ParameterValueProvider`	`createParameterValueProvider(Object value, ExpressionManager expressionManager)`
`BpmnParse`	`deployment(DeploymentEntity deployment)`
`protected void`	`ensureNoExpressionInMessageStartEvent(Element element, EventSubscriptionDeclaration messageStartEventSubscriptionDeclaration, String parentElementId)`
`protected void`	`ensureNoIoMappingDefined(Element element)`
`BpmnParse`	`execute()`
`protected boolean`	`exists(MessageJobDeclaration msgJobdecl, String procDefKey, String activityId)` Checks whether the message declaration already exists.
`protected HashMap<String,Element>`	`filterCompensationHandlers(List<Element> activityElements)`
`protected HashMap<String,Element>`	`filterIntermediateCatchEvents(List<Element> activityElements)`
`protected Escalation`	`findEscalationForEscalationEventDefinition(Element escalationEventDefinition, String escalationElementId)` Find the referenced escalation of the given escalation event definition.
`protected String`	`getAssignmentId(String expression, String prefix)`
`static String`	`getIdForMiBody(String id)`
`protected XMLImporter`	`getImporter(String importType, Element theImport)`
`Map<String,List<JobDeclaration<?,?>>>`	`getJobDeclarations()`
`List<JobDeclaration<?,?>>`	`getJobDeclarationsByKey(String processDefinitionKey)`
`protected ActivityImpl`	`getMultiInstanceScope(ActivityImpl activity)`
`ProcessDefinitionEntity`	`getProcessDefinition(String processDefinitionKey)`
`List<ProcessDefinitionEntity>`	`getProcessDefinitions()`
`protected String`	`getStringValueFromAttributeOrElement(String attributeName, String elementName, Element element, String ancestorElementId)`
`protected boolean`	`hasConnector(Element element)`
`protected boolean`	`hasMultipleConditionalEventDefinitionsWithSameCondition(EventSubscriptionDeclaration subscription, Collection<EventSubscriptionDeclaration> eventDefinitions)`
`protected boolean`	`hasMultipleEventDefinitionsWithSameName(EventSubscriptionDeclaration subscription, Collection<EventSubscriptionDeclaration> eventDefinitions, String eventType)`
`protected boolean`	`hasMultipleMessageEventDefinitionsWithSameName(EventSubscriptionDeclaration subscription, Collection<EventSubscriptionDeclaration> eventDefinitions)`
`protected boolean`	`hasMultipleSignalEventDefinitionsWithSameName(EventSubscriptionDeclaration subscription, Collection<EventSubscriptionDeclaration> eventDefinitions)`
`protected boolean`	`isAsyncAfter(Element element)`
`protected boolean`	`isAsyncBefore(Element element)`
`protected boolean`	`isCompensationHandler(Element activityElement)`
`protected boolean`	`isExclusive(Element element)`
`protected boolean`	`isServiceTaskLike(Element element)`
`protected boolean`	`isStartable(Element element)`
`protected boolean`	`isValidEventNameForScope(String eventName, Element listenerElement, String ancestorElementId)` Check if the given event name is valid.
`BpmnParse`	`name(String name)`
`void`	`parseActivities(List<Element> activityElements, Element parentElement, ScopeImpl scopeElement)` Parses the activities of a certain level in the process (process, subprocess or another scope).
`protected ActivityImpl`	`parseActivity(Element activityElement, Element parentElement, ScopeImpl scopeElement)`
`protected void`	`parseActivityInputOutput(Element activityElement, ActivityImpl activity)`
`protected void`	`parseAssociationOfCompensationBoundaryEvent(Element associationElement, ActivityImpl sourceActivity, ActivityImpl targetActivity)`
`protected void`	`parseAssociations(Element scopeElement, ScopeImpl parentScope, Map<String,Element> compensationHandlers)`
`protected void`	`parseAsynchronousContinuation(Element element, ActivityImpl activity)` Parse async continuation of the given element and create async jobs for the activity.
`protected void`	`parseAsynchronousContinuationForActivity(Element activityElement, ActivityImpl activity)` Parse async continuation of an activity and create async jobs for the activity.
`protected void`	`parseBinding(Element callActivityElement, ActivityImpl activity, BaseCallableElement callableElement, String bindingAttributeName)`
`Boolean`	`parseBooleanAttribute(String booleanText)`
`Boolean`	`parseBooleanAttribute(String booleanText, boolean defaultValue)`
`protected ActivityBehavior`	`parseBoundaryCancelEventDefinition(Element cancelEventDefinition, ActivityImpl activity)`
`protected void`	`parseBoundaryCompensateEventDefinition(Element compensateEventDefinition, ActivityImpl activity)`
`BoundaryConditionalEventActivityBehavior`	`parseBoundaryConditionalEventDefinition(Element element, boolean interrupting, ActivityImpl conditionalActivity)` Parses the given element as conditional boundary event.
`void`	`parseBoundaryErrorEventDefinition(Element errorEventDefinition, ActivityImpl boundaryEventActivity)`
`protected void`	`parseBoundaryEscalationEventDefinition(Element escalationEventDefinitionElement, boolean cancelActivity, ActivityImpl boundaryEventActivity)`
`void`	`parseBoundaryEvents(Element parentElement, ScopeImpl flowScope)` Parses the boundary events of a certain 'level' (process, subprocess or other scope).
`void`	`parseBoundaryMessageEventDefinition(Element element, boolean interrupting, ActivityImpl messageActivity)`
`void`	`parseBoundarySignalEventDefinition(Element element, boolean interrupting, ActivityImpl signalActivity)`
`void`	`parseBoundaryTimerEventDefinition(Element timerEventDefinition, boolean interrupting, ActivityImpl boundaryActivity)` Parses a boundary timer event.
`void`	`parseBPMNDiagram(Element bpmndiagramElement)`
`void`	`parseBPMNEdge(Element bpmnEdgeElement)`
`void`	`parseBPMNPlane(Element bpmnPlaneElement)`
`void`	`parseBPMNShape(Element bpmnShapeElement)`
`ActivityImpl`	`parseBusinessRuleTask(Element businessRuleTaskElement, ScopeImpl scope)` Parses a businessRuleTask declaration.
`protected CallableElementParameter`	`parseCallableElementProvider(Element parameterElement, String ancestorElementId)`
`ActivityImpl`	`parseCallActivity(Element callActivityElement, ScopeImpl scope, boolean isMultiInstance)` Parses a call activity (currently only supporting calling subprocesses).
`void`	`parseCollaboration()` Parses the collaboration definition defined within the 'definitions' root element and get all participants to lookup their process references during DI parsing.
`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.
`protected void`	`parseCompensationEventSubprocess(ActivityImpl startEventActivity, Element startEventElement, ActivityImpl scopeActivity, Element compensateEventDefinition)`
`protected ActivityImpl`	`parseCompensationHandlerForCompensationBoundaryEvent(ScopeImpl parentScope, ActivityImpl sourceActivity, String targetRef, Map<String,Element> compensationHandlers)`
`protected void`	`parseCompensationHandlers(ScopeImpl parentScope, Map<String,Element> compensationHandlers)`
`protected ConditionalEventDefinition`	`parseConditionalEventDefinition(Element element, ActivityImpl conditionalActivity)` Parses the given element and returns an ConditionalEventDefinition object.
`ConditionalEventDefinition`	`parseConditionalStartEventForEventSubprocess(Element element, ActivityImpl conditionalActivity, boolean interrupting)` Parses the given element as conditional start event of an event subprocess.
`protected Condition`	`parseConditionExpression(Element conditionExprElement, String ancestorElementId)`
`protected DecisionResultMapper`	`parseDecisionResultMapper(Element businessRuleTaskElement)`
`protected void`	`parseDefinitionsAttributes()`
`void`	`parseDiagramInterchangeElements()`
`protected void`	`parseDIBounds(Element bpmnShapeElement, HasDIBounds target)`
`protected ActivityImpl`	`parseDmnBusinessRuleTask(Element businessRuleTaskElement, ScopeImpl scope)` Parse a Business Rule Task which references a decision.
`String`	`parseDocumentation(Element element)`
`static String`	`parseDocumentation(List<String> docStrings)`
`Double`	`parseDoubleAttribute(Element element, String attributeName, String doubleText, boolean required)`
`protected void`	`parseEmailServiceTask(ActivityImpl activity, Element serviceTaskElement, List<FieldDeclaration> fieldDeclarations)`
`void`	`parseEndEvents(Element parentElement, ScopeImpl scope)` Parses the end events of a certain level in the process (process, subprocess or another scope).
`void`	`parseErrors()`
`protected void`	`parseErrorStartEventDefinition(Element errorEventDefinition, ActivityImpl startEventActivity)`
`protected void`	`parseEscalations()`
`ActivityImpl`	`parseEventBasedGateway(Element eventBasedGwElement, Element parentElement, ScopeImpl scope)`
`protected void`	`parseEventDefinitionForSubprocess(EventSubscriptionDeclaration subscriptionDeclaration, ActivityImpl activity, Element element)`
`ActivityImpl`	`parseExclusiveGateway(Element exclusiveGwElement, ScopeImpl scope)` Parses an exclusive gateway declaration.
`ExecutionListener`	`parseExecutionListener(Element executionListenerElement, String ancestorElementId)` Parses an `ExecutionListener` implementation for the given executionListener element.
`void`	`parseExecutionListenersOnScope(Element scopeElement, ScopeImpl scope)` Parses all execution-listeners on a scope.
`void`	`parseExecutionListenersOnTransition(Element activitiElement, TransitionImpl activity)`
`protected Expression`	`parseExpression(Element parent, String name)`
`protected FieldDeclaration`	`parseExpressionFieldDeclaration(Element fieldDeclarationElement, Element serviceTaskElement, String fieldName)`
`protected void`	`parseExternalServiceTask(ActivityImpl activity, Element serviceTaskElement)`
`protected FieldDeclaration`	`parseFieldDeclaration(Element serviceTaskElement, Element fieldDeclarationElement)`
`List<FieldDeclaration>`	`parseFieldDeclarations(Element element)`
`protected void`	`parseHumanPerformer(Element taskElement, TaskDefinition taskDefinition)`
`protected void`	`parseHumanPerformerResourceAssignment(Element performerElement, TaskDefinition taskDefinition)`
`protected void`	`parseImports()` Parses the rootElement importing structures
`ActivityImpl`	`parseInclusiveGateway(Element inclusiveGwElement, ScopeImpl scope)` Parses an inclusive gateway declaration.
`protected void`	`parseInputParameter(Element elementWithParameters, CallableElement callableElement)`
`ActivityImpl`	`parseIntermediateCatchEvent(Element intermediateEventElement, ScopeImpl scopeElement, ActivityImpl eventBasedGateway)`
`protected void`	`parseIntermediateCatchEvents(Element scopeElement, ScopeImpl parentScope, Map<String,Element> intermediateCatchEventElements)`
`ConditionalEventDefinition`	`parseIntermediateConditionalEventDefinition(Element element, ActivityImpl conditionalActivity)` Parses the given element as intermediate conditional event.
`protected void`	`parseIntermediateLinkEventCatchBehavior(Element intermediateEventElement, ActivityImpl activity, Element linkEventDefinitionElement)`
`protected void`	`parseIntermediateMessageEventDefinition(Element messageEventDefinition, ActivityImpl nestedActivity)`
`protected void`	`parseIntermediateSignalEventDefinition(Element element, ActivityImpl signalActivity)`
`ActivityImpl`	`parseIntermediateThrowEvent(Element intermediateEventElement, ScopeImpl scopeElement)`
`protected void`	`parseIntermediateTimerEventDefinition(Element timerEventDefinition, ActivityImpl timerActivity)`
`protected void`	`parseLanes(Element laneSetElement, LaneSet laneSet)`
`protected void`	`parseLaneSets(Element parentElement, ProcessDefinitionEntity processDefinition)`
`ActivityImpl`	`parseManualTask(Element manualTaskElement, ScopeImpl scope)` Parses a manual task.
`protected EventSubscriptionDeclaration`	`parseMessageEventDefinition(Element messageEventDefinition, String messageElementId)`
`void`	`parseMessages()` Parses the messages of the given definitions file.
`ScopeImpl`	`parseMultiInstanceLoopCharacteristics(Element activityElement, ScopeImpl scope)` Parses loopCharacteristics (standardLoop/Multi-instance) of an activity, if any is defined.
`protected void`	`parseOutputParameter(Element callActivityElement, ActivityImpl activity, CallableElement callableElement)`
`ActivityImpl`	`parseParallelGateway(Element parallelGwElement, ScopeImpl scope)` Parses a parallel gateway declaration.
`protected void`	`parsePotentialOwner(Element taskElement, TaskDefinition taskDefinition)`
`protected void`	`parsePotentialOwnerResourceAssignment(Element performerElement, TaskDefinition taskDefinition)`
`protected void`	`parsePotentialStarterResourceAssignment(Element performerElement, ProcessDefinitionEntity processDefinition)`
`protected ParameterValueProvider`	`parsePriority(Element element, String priorityAttribute)`
`ProcessDefinitionEntity`	`parseProcess(Element processElement)` Parses one process (ie anything inside a <process> element).
`protected void`	`parseProcessDefinitionCustomExtensions(Element scopeElement, ProcessDefinition definition)`
`void`	`parseProcessDefinitions()` Parses all the process definitions defined within the 'definitions' root element.
`protected void`	`parseProcessDefinitionStartEvent(ActivityImpl startEventActivity, Element startEventElement, Element parentElement, ScopeImpl scope)`
`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.
`void`	`parseProperty(Element propertyElement, ActivityImpl activity)` Parses one property definition.
`void`	`parsePropertyCustomExtensions(ActivityImpl activity, Element propertyElement, String propertyName, String propertyType)` Parses the custom extensions for properties.
`ActivityImpl`	`parseReceiveTask(Element receiveTaskElement, ScopeImpl scope)` Parses a receive task.
`protected String`	`parseResultVariable(Element element)`
`protected void`	`parseRootElement()` Parses the 'definitions' root element
`void`	`parseScope(Element scopeElement, ScopeImpl parentScope)` Parses a scope: a process, subprocess, etc.
`protected void`	`parseScopeStartEvent(ActivityImpl startEventActivity, Element startEventElement, Element parentElement, ActivityImpl scopeActivity)`
`ActivityImpl`	`parseScriptTask(Element scriptTaskElement, ScopeImpl scope)` Parses a scriptTask declaration.
`protected ScriptTaskActivityBehavior`	`parseScriptTaskElement(Element scriptTaskElement)` Returns a `ScriptTaskActivityBehavior` for the script task element corresponding to the script source or resource specified.
`ActivityImpl`	`parseSendTask(Element sendTaskElement, ScopeImpl scope)` Parses a sendTask declaration.
`void`	`parseSequenceFlow(Element processElement, ScopeImpl scope, Map<String,Element> compensationHandlers)` Parses all sequence flow of a scope.
`void`	`parseSequenceFlowConditionExpression(Element seqFlowElement, TransitionImpl seqFlow)` Parses a condition expression on a sequence flow.
`ActivityImpl`	`parseServiceTask(Element serviceTaskElement, ScopeImpl scope)` Parses a serviceTask declaration.
`ActivityImpl`	`parseServiceTaskLike(String elementName, Element serviceTaskElement, ScopeImpl scope)`
`protected void`	`parseShellServiceTask(ActivityImpl activity, Element serviceTaskElement, List<FieldDeclaration> fieldDeclarations)`
`protected void`	`parseSignalCatchEventDefinition(Element element, ActivityImpl signalActivity, boolean isStartEvent)`
`protected EventSubscriptionDeclaration`	`parseSignalEventDefinition(Element signalEventDefinitionElement, boolean isThrowing, String signalElementId)` Parses the Signal Event Definition XML including payload definition.
`protected void`	`parseSignals()` Parses the signals of the given definitions file.
`protected void`	`parseStartAuthorization(Element scopeElement, ProcessDefinition definition)`
`void`	`parseStartEvents(Element parentElement, ScopeImpl scope)` Parses the start events of a certain level in the process (process, subprocess or another scope).
`protected void`	`parseStartFormHandlers(List<Element> startEventElements, ProcessDefinitionEntity processDefinition)`
`protected FieldDeclaration`	`parseStringFieldDeclaration(Element fieldDeclarationElement, Element serviceTaskElement, String fieldName)`
`ActivityImpl`	`parseSubProcess(Element subProcessElement, ScopeImpl scope)` Parses a subprocess (formally known as an embedded subprocess): a subprocess defined within another process definition.
`ActivityImpl`	`parseTask(Element taskElement, ScopeImpl scope)` Parses a task with no specific type (behaves as passthrough).
`TaskDefinition`	`parseTaskDefinition(Element taskElement, String taskDefinitionKey, ActivityImpl activity, ProcessDefinitionEntity processDefinition)`
`protected TaskListener`	`parseTaskListener(Element taskListenerElement, String taskElementId)`
`protected void`	`parseTaskListeners(Element userTaskElement, ActivityImpl activity, TaskDefinition taskDefinition)`
`protected void`	`parseTenantId(Element callingActivityElement, ActivityImpl activity, BaseCallableElement callableElement, String attrName)`
`protected CompensateEventDefinition`	`parseThrowCompensateEventDefinition(Element compensateEventDefinitionElement, ScopeImpl scopeElement, String parentElementId)`
`protected TaskListener`	`parseTimeoutTaskListener(Element taskListenerElement, ActivityImpl timerActivity, TaskDefinition taskDefinition)`
`protected TimerDeclarationImpl`	`parseTimer(Element timerEventDefinition, ActivityImpl timerActivity, String jobHandlerType)`
`protected void`	`parseTimerStartEventDefinition(Element timerEventDefinition, ActivityImpl timerActivity, ProcessDefinitionEntity processDefinition)`
`protected void`	`parseTimerStartEventDefinitionForEventSubprocess(Element timerEventDefinition, ActivityImpl timerActivity, boolean interrupting)`
`protected ParameterValueProvider`	`parseTopic(Element element, String topicAttribute)`
`protected ActivityImpl`	`parseTransaction(Element transactionElement, ScopeImpl scope)`
`ActivityImpl`	`parseUserTask(Element userTaskElement, ScopeImpl scope)` Parses a userTask declaration.
`protected void`	`parseUserTaskCustomExtensions(Element taskElement, ActivityImpl activity, TaskDefinition taskDefinition)`
`protected void`	`parseVersion(Element callingActivityElement, ActivityImpl activity, BaseCallableElement callableElement, String bindingAttributeName, String versionAttributeName)`
`protected void`	`parseVersionTag(Element callingActivityElement, ActivityImpl activity, BaseCallableElement callableElement, String bindingAttributeName, String versionTagAttributeName)`
`protected void`	`removeMessageJobDeclarationWithJobConfiguration(ActivityImpl activity, String jobConfiguration)` Removes a job declaration which belongs to the given activity and has the given job configuration.
`protected String`	`resolveName(String name)`
`protected void`	`selectInitial(List<ActivityImpl> startEventActivities, ProcessDefinitionEntity processDefinition, Element parentElement)`
`protected void`	`setActivityAsyncDelegates(ActivityImpl activity)` Sets the delegates for the activity, which will be called if the attribute asyncAfter or asyncBefore was changed.
`protected void`	`setErrorCodeVariableOnErrorEventDefinition(Element errorEventDefinition, ErrorEventDefinition definition)` Sets the value for "camunda:errorCodeVariable" on the passed definition if it's present.
`protected void`	`setErrorMessageVariableOnErrorEventDefinition(Element errorEventDefinition, ErrorEventDefinition definition)` Sets the value for "camunda:errorMessageVariable" on the passed definition if it's present.
`BpmnParse`	`sourceInputStream(InputStream inputStream)`
`BpmnParse`	`sourceResource(String resource)`
`BpmnParse`	`sourceResource(String resource, ClassLoader classLoader)`
`BpmnParse`	`sourceString(String string)`
`BpmnParse`	`sourceUrl(String url)`
`BpmnParse`	`sourceUrl(URL url)`
`void`	`validateActivities(List<ActivityImpl> activities)`
`protected void`	`validateActivity(ActivityImpl activity)`
`protected void`	`validateCatchCompensateEventDefinition(Element compensateEventDefinitionElement, String parentElementId)`
`void`	`validateExclusiveGateway(ActivityImpl activity)`
`protected void`	`validateFieldDeclarationsForEmail(Element serviceTaskElement, List<FieldDeclaration> fieldDeclarations)`
`protected void`	`validateFieldDeclarationsForShell(Element serviceTaskElement, List<FieldDeclaration> fieldDeclarations)`
`protected void`	`validateOutgoingFlows(ActivityImpl activity)`

Methods inherited from class org.camunda.bpm.engine.impl.util.xml.Parse
addError, addError, addError, addError, addError, addWarning, addWarning, addWarning, getProblems, getRootElement, hasErrors, hasWarnings, logWarnings, resolveAccessExternalSchemaProperty, setEnableXxeProcessing, setSchemaResource, setStreamSource, throwExceptionForErrors, xxeProcessing

Methods inherited from class org.xml.sax.helpers.DefaultHandler
characters, endDocument, endElement, endPrefixMapping, error, fatalError, ignorableWhitespace, notationDecl, processingInstruction, resolveEntity, setDocumentLocator, skippedEntity, startDocument, startElement, startPrefixMapping, unparsedEntityDecl, warning

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

MULTI_INSTANCE_BODY_ID_SUFFIX

public static final String MULTI_INSTANCE_BODY_ID_SUFFIX

See Also:: Constant Field Values

LOG

protected static final BpmnParseLogger LOG

PROPERTYNAME_DOCUMENTATION

public static final String PROPERTYNAME_DOCUMENTATION

See Also:: Constant Field Values

PROPERTYNAME_INITIATOR_VARIABLE_NAME

public static final String PROPERTYNAME_INITIATOR_VARIABLE_NAME

See Also:: Constant Field Values

PROPERTYNAME_HAS_CONDITIONAL_EVENTS

public static final String PROPERTYNAME_HAS_CONDITIONAL_EVENTS

See Also:: Constant Field Values

PROPERTYNAME_CONDITION

public static final String PROPERTYNAME_CONDITION

See Also:: Constant Field Values

PROPERTYNAME_CONDITION_TEXT

public static final String PROPERTYNAME_CONDITION_TEXT

See Also:: Constant Field Values

PROPERTYNAME_VARIABLE_DECLARATIONS

public static final String PROPERTYNAME_VARIABLE_DECLARATIONS

See Also:: Constant Field Values

PROPERTYNAME_TIMER_DECLARATION

public static final String PROPERTYNAME_TIMER_DECLARATION

See Also:: Constant Field Values

PROPERTYNAME_MESSAGE_JOB_DECLARATION

public static final String PROPERTYNAME_MESSAGE_JOB_DECLARATION

See Also:: Constant Field Values

PROPERTYNAME_ISEXPANDED

public static final String PROPERTYNAME_ISEXPANDED

See Also:: Constant Field Values

PROPERTYNAME_START_TIMER

public static final String PROPERTYNAME_START_TIMER

See Also:: Constant Field Values

PROPERTYNAME_COMPENSATION_HANDLER_ID

public static final String PROPERTYNAME_COMPENSATION_HANDLER_ID

See Also:: Constant Field Values

PROPERTYNAME_IS_FOR_COMPENSATION

public static final String PROPERTYNAME_IS_FOR_COMPENSATION

See Also:: Constant Field Values

PROPERTYNAME_EVENT_SUBSCRIPTION_JOB_DECLARATION

public static final String PROPERTYNAME_EVENT_SUBSCRIPTION_JOB_DECLARATION

See Also:: Constant Field Values

PROPERTYNAME_THROWS_COMPENSATION

public static final String PROPERTYNAME_THROWS_COMPENSATION

See Also:: Constant Field Values

PROPERTYNAME_CONSUMES_COMPENSATION

public static final String PROPERTYNAME_CONSUMES_COMPENSATION

See Also:: Constant Field Values

PROPERTYNAME_JOB_PRIORITY

public static final String PROPERTYNAME_JOB_PRIORITY

See Also:: Constant Field Values

PROPERTYNAME_TASK_PRIORITY

public static final String PROPERTYNAME_TASK_PRIORITY

See Also:: Constant Field Values

PROPERTYNAME_EXTERNAL_TASK_TOPIC

public static final String PROPERTYNAME_EXTERNAL_TASK_TOPIC

See Also:: Constant Field Values

PROPERTYNAME_CLASS

public static final String PROPERTYNAME_CLASS

See Also:: Constant Field Values

PROPERTYNAME_EXPRESSION

public static final String PROPERTYNAME_EXPRESSION

See Also:: Constant Field Values

PROPERTYNAME_DELEGATE_EXPRESSION

public static final String PROPERTYNAME_DELEGATE_EXPRESSION

See Also:: Constant Field Values

PROPERTYNAME_VARIABLE_MAPPING_CLASS

public static final String PROPERTYNAME_VARIABLE_MAPPING_CLASS

See Also:: Constant Field Values

PROPERTYNAME_VARIABLE_MAPPING_DELEGATE_EXPRESSION

public static final String PROPERTYNAME_VARIABLE_MAPPING_DELEGATE_EXPRESSION

See Also:: Constant Field Values

PROPERTYNAME_RESOURCE

public static final String PROPERTYNAME_RESOURCE

See Also:: Constant Field Values

PROPERTYNAME_LANGUAGE

public static final String PROPERTYNAME_LANGUAGE

See Also:: Constant Field Values

TYPE
```
public static final String TYPE
```
See Also:

Constant Field Values

TRUE
```
public static final String TRUE
```
See Also:

Constant Field Values

INTERRUPTING

public static final String INTERRUPTING

See Also:: Constant Field Values

CONDITIONAL_EVENT_DEFINITION

public static final String CONDITIONAL_EVENT_DEFINITION

See Also:: Constant Field Values

ESCALATION_EVENT_DEFINITION

public static final String ESCALATION_EVENT_DEFINITION

See Also:: Constant Field Values

COMPENSATE_EVENT_DEFINITION

public static final String COMPENSATE_EVENT_DEFINITION

See Also:: Constant Field Values

TIMER_EVENT_DEFINITION

public static final String TIMER_EVENT_DEFINITION

See Also:: Constant Field Values

SIGNAL_EVENT_DEFINITION

public static final String SIGNAL_EVENT_DEFINITION

See Also:: Constant Field Values

MESSAGE_EVENT_DEFINITION

public static final String MESSAGE_EVENT_DEFINITION

See Also:: Constant Field Values

ERROR_EVENT_DEFINITION

public static final String ERROR_EVENT_DEFINITION

See Also:: Constant Field Values

CANCEL_EVENT_DEFINITION

public static final String CANCEL_EVENT_DEFINITION

See Also:: Constant Field Values

LINK_EVENT_DEFINITION

public static final String LINK_EVENT_DEFINITION

See Also:: Constant Field Values

CONDITION_EXPRESSION

public static final String CONDITION_EXPRESSION

See Also:: Constant Field Values

CONDITION
```
public static final String CONDITION
```
See Also:

Constant Field Values

VARIABLE_EVENTS

public static final List<String> VARIABLE_EVENTS

PROPERTYNAME_TYPE

@Deprecated
public static final String PROPERTYNAME_TYPE

Deprecated. use BpmnProperties.TYPE

PROPERTYNAME_ERROR_EVENT_DEFINITIONS
```
@Deprecated
public static final String PROPERTYNAME_ERROR_EVENT_DEFINITIONS
```
Deprecated. use BpmnProperties.ERROR_EVENT_DEFINITIONS

POTENTIAL_STARTER

protected static final String POTENTIAL_STARTER

See Also:: Constant Field Values

CANDIDATE_STARTER_USERS_EXTENSION

protected static final String CANDIDATE_STARTER_USERS_EXTENSION

See Also:: Constant Field Values

CANDIDATE_STARTER_GROUPS_EXTENSION

protected static final String CANDIDATE_STARTER_GROUPS_EXTENSION

See Also:: Constant Field Values

ATTRIBUTEVALUE_T_FORMAL_EXPRESSION

protected static final String ATTRIBUTEVALUE_T_FORMAL_EXPRESSION

See Also:: Constant Field Values

PROPERTYNAME_IS_MULTI_INSTANCE

public static final String PROPERTYNAME_IS_MULTI_INSTANCE

See Also:: Constant Field Values

CAMUNDA_BPMN_EXTENSIONS_NS

public static final Namespace CAMUNDA_BPMN_EXTENSIONS_NS

XSI_NS
```
public static final Namespace XSI_NS
```

BPMN_DI_NS

public static final Namespace BPMN_DI_NS

OMG_DI_NS

public static final Namespace OMG_DI_NS

BPMN_DC_NS

public static final Namespace BPMN_DC_NS

ALL
```
public static final String ALL
```
See Also:

Constant Field Values

deployment
```
protected DeploymentEntity deployment
```
The deployment to which the parsed process definitions will be added.

processDefinitions
```
protected List<ProcessDefinitionEntity> processDefinitions
```
The end result of the parsing: a list of process definition.

errors
```
protected Map<String,Error> errors
```
Mapping of found errors in BPMN 2.0 file

escalations

protected Map<String,Escalation> escalations

Mapping of found escalation elements

jobDeclarations
```
protected Map<String,List<JobDeclaration<?,?>>> jobDeclarations
```
Mapping from a process definition key to his containing list of job declarations

sequenceFlows
```
protected Map<String,TransitionImpl> sequenceFlows
```
A map for storing sequence flow based on their id during parsing.

elementIds
```
protected List<String> elementIds
```
A list of all element IDs. This allows us to parse only what we actually support but still validate the references among elements we do not support.

participantProcesses
```
protected Map<String,String> participantProcesses
```
A map for storing the process references of participants

messages
```
protected Map<String,MessageDefinition> messages
```
Mapping containing values stored during the first phase of parsing since other elements can reference these messages. All the map's elements are defined outside the process definition(s), which means that this map doesn't need to be re-initialized for each new process definition.

signals

protected Map<String,SignalDefinition> signals

expressionManager

protected ExpressionManager expressionManager

parseListeners

protected List<BpmnParseListener> parseListeners

importers

protected Map<String,XMLImporter> importers

prefixs
```
protected Map<String,String> prefixs
```

targetNamespace
```
protected String targetNamespace
```

HUMAN_PERFORMER

protected static final String HUMAN_PERFORMER

See Also:: Constant Field Values

POTENTIAL_OWNER

protected static final String POTENTIAL_OWNER

See Also:: Constant Field Values

RESOURCE_ASSIGNMENT_EXPR

protected static final String RESOURCE_ASSIGNMENT_EXPR

See Also:: Constant Field Values

FORMAL_EXPRESSION

protected static final String FORMAL_EXPRESSION

See Also:: Constant Field Values

USER_PREFIX

protected static final String USER_PREFIX

See Also:: Constant Field Values

GROUP_PREFIX

protected static final String GROUP_PREFIX

See Also:: Constant Field Values

ASSIGNEE_EXTENSION

protected static final String ASSIGNEE_EXTENSION

See Also:: Constant Field Values

CANDIDATE_USERS_EXTENSION

protected static final String CANDIDATE_USERS_EXTENSION

See Also:: Constant Field Values

CANDIDATE_GROUPS_EXTENSION

protected static final String CANDIDATE_GROUPS_EXTENSION

See Also:: Constant Field Values

DUE_DATE_EXTENSION

protected static final String DUE_DATE_EXTENSION

See Also:: Constant Field Values

FOLLOW_UP_DATE_EXTENSION

protected static final String FOLLOW_UP_DATE_EXTENSION

See Also:: Constant Field Values

PRIORITY_EXTENSION

protected static final String PRIORITY_EXTENSION

See Also:: Constant Field Values

Constructor Detail
- BpmnParse
```
public BpmnParse(BpmnParser parser)
```
  Constructor to be called by the BpmnParser.

Method Detail

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.

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 ActivityImpl parseServiceTaskLike(String elementName,
                                         Element serviceTaskElement,
                                         ScopeImpl scope)

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)

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)

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.

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)

Class BpmnParse

Property Summary

Properties inherited from class org.camunda.bpm.engine.impl.util.xml.Parse