BpmnParse (camunda BPM Javadocs 7.5.9-ee)

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

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`
`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`
`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.
`protected Map<String,Error>`	`errors` Mapping of found errors in BPMN 2.0 file
`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`
`protected Map<String,List<JobDeclaration<?,?>>>`	`jobDeclarations` Mapping from a process definition key to his containing list of job declarations
`protected static BpmnParseLogger`	`LOG`
`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_COMPENSATION_HANDLER_ID`
`static String`	`PROPERTYNAME_CONDITION`
`static String`	`PROPERTYNAME_CONDITION_TEXT`
`static String`	`PROPERTYNAME_CONSUMES_COMPENSATION`
`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_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_MESSAGE_JOB_DECLARATION`
`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`
`protected static String`	`RESOURCE_ASSIGNMENT_EXPR`
`protected Map<String,TransitionImpl>`	`sequenceFlows` A map for storing sequence flow based on their id during parsing.
`protected Map<String,SignalDefinition>`	`signals`
`protected String`	`targetNamespace`
`protected static String`	`USER_PREFIX`
`static Namespace`	`XSI_NS`

Fields inherited from class org.camunda.bpm.engine.impl.util.xml.Parse
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

Methods
Modifier and Type	Method and Description
`protected void`	`addErrorEventDefinition(ErrorEventDefinition errorEventDefinition, ScopeImpl catchingScope)`
`protected void`	`addEscalationEventDefinition(ScopeImpl catchingScope, EscalationEventDefinition escalationEventDefinition, Element element)`
`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)`
`protected void`	`addTimerDeclaration(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)`
`protected ParameterValueProvider`	`createParameterValueProvider(Object value, ExpressionManager expressionManager)`
`BpmnParse`	`deployment(DeploymentEntity deployment)`
`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)` 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)`
`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`	`isExternalTaskType(String type)`
`protected boolean`	`isValidEventNameForScope(String eventName, Element listenerElement)` 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)`
`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)`
`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 DecisionTableResultMapper`	`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)` 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 callActivityElement, ActivityImpl activity, CallableElement callableElement)`
`ActivityImpl`	`parseIntermediateCatchEvent(Element intermediateEventElement, ScopeImpl scopeElement, ActivityImpl eventBasedGateway)`
`protected void`	`parseIntermediateCatchEvents(Element scopeElement, ScopeImpl parentScope, Map<String,Element> intermediateCatchEventElements)`
`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)`
`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)`
`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, ProcessDefinitionEntity processDefinition)`
`protected TaskListener`	`parseTaskListener(Element taskListenerElement)`
`protected void`	`parseTaskListeners(Element userTaskElement, TaskDefinition taskDefinition)`
`protected void`	`parseTenantId(Element callingActivityElement, ActivityImpl activity, BaseCallableElement callableElement, String attrName)`
`protected CompensateEventDefinition`	`parseThrowCompensateEventDefinition(Element compensateEventDefinitionElement, ScopeImpl scopeElement)`
`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 ActivityImpl`	`parseTransaction(Element transactionElement, ScopeImpl scope)`
`ActivityImpl`	`parseUserTask(Element userTaskElement, ScopeImpl scope)` Parses a userTask declaration.
`protected void`	`parseUserTaskCustomExtensions(Element taskElement, TaskDefinition taskDefinition)`
`protected void`	`parseVersion(Element callingActivityElement, ActivityImpl activity, BaseCallableElement callableElement, String bindingAttributeName, String versionAttributeName)`
`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.
`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)`
`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, addWarning, addWarning, getProblems, getRootElement, hasErrors, hasWarnings, logWarnings, setSchemaResource, setStreamSource, throwExceptionForErrors

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_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_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

parseMessageEventDefinition

protected EventSubscriptionDeclaration parseMessageEventDefinition(Element messageEventDefinition)

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)

hasMultipleEventDefinitionsWithSameName

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

addEventSubscriptionJobDeclaration

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

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)

validateCatchCompensateEventDefinition

protected void validateCatchCompensateEventDefinition(Element compensateEventDefinitionElement)

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 DecisionTableResultMapper 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)

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)

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,
                                 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,
                                 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,
                      TaskDefinition taskDefinition)

parseTaskListener

protected TaskListener parseTaskListener(Element taskListenerElement)

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)

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)
```
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)

addEscalationEventDefinition

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

addTimerDeclaration

protected void addTimerDeclaration(ScopeImpl scope,
                       TimerDeclarationImpl timerDeclaration)

addVariableDeclaration

protected void addVariableDeclaration(ScopeImpl scope,
                          VariableDeclaration variableDeclaration)

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)

parseInputParameter

protected void parseInputParameter(Element callActivityElement,
                       ActivityImpl activity,
                       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)

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.

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)

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)
```
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)

isExclusive

protected boolean isExclusive(Element element)

isAsyncBefore

protected boolean isAsyncBefore(Element element)

isAsyncAfter

protected boolean isAsyncAfter(Element element)

isExternalTaskType

protected boolean isExternalTaskType(String type)

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)

Class BpmnParse

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class org.xml.sax.helpers.DefaultHandler

Methods inherited from class java.lang.Object

Field Detail

MULTI_INSTANCE_BODY_ID_SUFFIX

LOG

PROPERTYNAME_DOCUMENTATION

PROPERTYNAME_INITIATOR_VARIABLE_NAME

PROPERTYNAME_CONDITION

PROPERTYNAME_CONDITION_TEXT

PROPERTYNAME_VARIABLE_DECLARATIONS

PROPERTYNAME_TIMER_DECLARATION

PROPERTYNAME_MESSAGE_JOB_DECLARATION

PROPERTYNAME_ISEXPANDED

PROPERTYNAME_START_TIMER

PROPERTYNAME_COMPENSATION_HANDLER_ID

PROPERTYNAME_IS_FOR_COMPENSATION

PROPERTYNAME_EVENT_SUBSCRIPTION_JOB_DECLARATION

PROPERTYNAME_THROWS_COMPENSATION

PROPERTYNAME_CONSUMES_COMPENSATION

PROPERTYNAME_JOB_PRIORITY

PROPERTYNAME_TASK_PRIORITY

PROPERTYNAME_TYPE

PROPERTYNAME_ERROR_EVENT_DEFINITIONS

POTENTIAL_STARTER

CANDIDATE_STARTER_USERS_EXTENSION

CANDIDATE_STARTER_GROUPS_EXTENSION

ATTRIBUTEVALUE_T_FORMAL_EXPRESSION

PROPERTYNAME_IS_MULTI_INSTANCE

CAMUNDA_BPMN_EXTENSIONS_NS

XSI_NS

BPMN_DI_NS

OMG_DI_NS

BPMN_DC_NS

ALL

deployment

processDefinitions

errors

escalations

jobDeclarations

sequenceFlows

elementIds

participantProcesses

messages

signals

expressionManager

parseListeners

importers

prefixs

targetNamespace

HUMAN_PERFORMER

POTENTIAL_OWNER

RESOURCE_ASSIGNMENT_EXPR

FORMAL_EXPRESSION

USER_PREFIX

GROUP_PREFIX

ASSIGNEE_EXTENSION

CANDIDATE_USERS_EXTENSION

CANDIDATE_GROUPS_EXTENSION

DUE_DATE_EXTENSION

FOLLOW_UP_DATE_EXTENSION

PRIORITY_EXTENSION

Constructor Detail

BpmnParse

Method Detail

deployment

execute

parseRootElement

collectElementIds

parseDefinitionsAttributes

resolveName

parseImports

getImporter

parseMessages

parseSignals