Enum bpxe_bpmn_schema::FlowElement

pub enum FlowElement {
    AdHocSubProcess(AdHocSubProcess),
    BoundaryEvent(BoundaryEvent),
    BusinessRuleTask(BusinessRuleTask),
    CallActivity(CallActivity),
    CallChoreography(CallChoreography),
    ChoreographyTask(ChoreographyTask),
    ComplexGateway(ComplexGateway),
    DataObject(DataObject),
    DataObjectReference(DataObjectReference),
    DataStoreReference(DataStoreReference),
    EndEvent(EndEvent),
    Event(Event),
    EventBasedGateway(EventBasedGateway),
    ExclusiveGateway(ExclusiveGateway),
    ImplicitThrowEvent(ImplicitThrowEvent),
    InclusiveGateway(InclusiveGateway),
    IntermediateCatchEvent(IntermediateCatchEvent),
    IntermediateThrowEvent(IntermediateThrowEvent),
    ManualTask(ManualTask),
    ParallelGateway(ParallelGateway),
    ReceiveTask(ReceiveTask),
    ScriptTask(ScriptTask),
    SendTask(SendTask),
    SequenceFlow(SequenceFlow),
    ServiceTask(ServiceTask),
    StartEvent(StartEvent),
    SubChoreography(SubChoreography),
    SubProcess(SubProcess),
    Task(Task),
    Transaction(Transaction),
    UserTask(UserTask),
}

Auto-generated from BPNM schema

(See codegen-rust.xsl)

Variants

AdHocSubProcess(AdHocSubProcess)

BoundaryEvent(BoundaryEvent)

BusinessRuleTask(BusinessRuleTask)

CallActivity(CallActivity)

CallChoreography(CallChoreography)

ChoreographyTask(ChoreographyTask)

ComplexGateway(ComplexGateway)

DataObject(DataObject)

DataObjectReference(DataObjectReference)

DataStoreReference(DataStoreReference)

EndEvent(EndEvent)

Event(Event)

EventBasedGateway(EventBasedGateway)

ExclusiveGateway(ExclusiveGateway)

ImplicitThrowEvent(ImplicitThrowEvent)

InclusiveGateway(InclusiveGateway)

IntermediateCatchEvent(IntermediateCatchEvent)

IntermediateThrowEvent(IntermediateThrowEvent)

ManualTask(ManualTask)

ParallelGateway(ParallelGateway)

ReceiveTask(ReceiveTask)

ScriptTask(ScriptTask)

SendTask(SendTask)

SequenceFlow(SequenceFlow)

ServiceTask(ServiceTask)

StartEvent(StartEvent)

SubChoreography(SubChoreography)

SubProcess(SubProcess)

Task(Task)

Transaction(Transaction)

UserTask(UserTask)

Implementations

impl FlowElement

pub fn into_inner(self) -> Box<dyn DocumentElement>

Trait Implementations

impl Cast<dyn ActivityType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ActivityType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ActivityType + 'static)>

impl Cast<dyn ActivityTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ActivityTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ActivityTypeMut + 'static)>

impl Cast<dyn AdHocSubProcessType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn AdHocSubProcessType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn AdHocSubProcessType + 'static)>

impl Cast<dyn AdHocSubProcessTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn AdHocSubProcessTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn AdHocSubProcessTypeMut + 'static)>

impl Cast<dyn ArtifactType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ArtifactType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ArtifactType + 'static)>

impl Cast<dyn ArtifactTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ArtifactTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ArtifactTypeMut + 'static)>

impl Cast<dyn AssignmentType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn AssignmentType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn AssignmentType + 'static)>

impl Cast<dyn AssignmentTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn AssignmentTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn AssignmentTypeMut + 'static)>

impl Cast<dyn AssociationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn AssociationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn AssociationType + 'static)>

impl Cast<dyn AssociationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn AssociationTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn AssociationTypeMut + 'static)>

impl Cast<dyn AuditingType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn AuditingType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn AuditingType + 'static)>

impl Cast<dyn AuditingTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn AuditingTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn AuditingTypeMut + 'static)>

impl Cast<dyn BaseElementType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn BaseElementType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn BaseElementType + 'static)>

impl Cast<dyn BaseElementTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn BaseElementTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn BaseElementTypeMut + 'static)>

impl Cast<dyn BaseElementWithMixedContentType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn BaseElementWithMixedContentType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn BaseElementWithMixedContentType + 'static)>

impl Cast<dyn BaseElementWithMixedContentTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn BaseElementWithMixedContentTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn BaseElementWithMixedContentTypeMut + 'static)>

impl Cast<dyn BoundaryEventType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn BoundaryEventType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn BoundaryEventType + 'static)>

impl Cast<dyn BoundaryEventTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn BoundaryEventTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn BoundaryEventTypeMut + 'static)>

impl Cast<dyn BusinessRuleTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn BusinessRuleTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn BusinessRuleTaskType + 'static)>

impl Cast<dyn BusinessRuleTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn BusinessRuleTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn BusinessRuleTaskTypeMut + 'static)>

impl Cast<dyn CallActivityType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CallActivityType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CallActivityType + 'static)>

impl Cast<dyn CallActivityTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CallActivityTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CallActivityTypeMut + 'static)>

impl Cast<dyn CallChoreographyType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CallChoreographyType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CallChoreographyType + 'static)>

impl Cast<dyn CallChoreographyTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CallChoreographyTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CallChoreographyTypeMut + 'static)>

impl Cast<dyn CallConversationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CallConversationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CallConversationType + 'static)>

impl Cast<dyn CallConversationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CallConversationTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CallConversationTypeMut + 'static)>

impl Cast<dyn CallableElementType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CallableElementType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CallableElementType + 'static)>

impl Cast<dyn CallableElementTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CallableElementTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CallableElementTypeMut + 'static)>

impl Cast<dyn CancelEventDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CancelEventDefinitionType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CancelEventDefinitionType + 'static)>

impl Cast<dyn CancelEventDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CancelEventDefinitionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn CancelEventDefinitionTypeMut + 'static)>

impl Cast<dyn CatchEventType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CatchEventType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CatchEventType + 'static)>

impl Cast<dyn CatchEventTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CatchEventTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CatchEventTypeMut + 'static)>

impl Cast<dyn CategoryType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CategoryType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CategoryType + 'static)>

impl Cast<dyn CategoryTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CategoryTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CategoryTypeMut + 'static)>

impl Cast<dyn CategoryValueType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CategoryValueType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CategoryValueType + 'static)>

impl Cast<dyn CategoryValueTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CategoryValueTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CategoryValueTypeMut + 'static)>

impl Cast<dyn ChoreographyActivityType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ChoreographyActivityType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ChoreographyActivityType + 'static)>

impl Cast<dyn ChoreographyActivityTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ChoreographyActivityTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ChoreographyActivityTypeMut + 'static)>

impl Cast<dyn ChoreographyTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ChoreographyTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ChoreographyTaskType + 'static)>

impl Cast<dyn ChoreographyTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ChoreographyTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ChoreographyTaskTypeMut + 'static)>

impl Cast<dyn ChoreographyType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ChoreographyType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ChoreographyType + 'static)>

impl Cast<dyn ChoreographyTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ChoreographyTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ChoreographyTypeMut + 'static)>

impl Cast<dyn CollaborationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CollaborationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CollaborationType + 'static)>

impl Cast<dyn CollaborationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CollaborationTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CollaborationTypeMut + 'static)>

impl Cast<dyn CompensateEventDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CompensateEventDefinitionType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn CompensateEventDefinitionType + 'static)>

impl Cast<dyn CompensateEventDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CompensateEventDefinitionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn CompensateEventDefinitionTypeMut + 'static)>

impl Cast<dyn ComplexBehaviorDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ComplexBehaviorDefinitionType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ComplexBehaviorDefinitionType + 'static)>

impl Cast<dyn ComplexBehaviorDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ComplexBehaviorDefinitionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ComplexBehaviorDefinitionTypeMut + 'static)>

impl Cast<dyn ComplexGatewayType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ComplexGatewayType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ComplexGatewayType + 'static)>

impl Cast<dyn ComplexGatewayTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ComplexGatewayTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ComplexGatewayTypeMut + 'static)>

impl Cast<dyn ConditionalEventDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ConditionalEventDefinitionType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ConditionalEventDefinitionType + 'static)>

impl Cast<dyn ConditionalEventDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ConditionalEventDefinitionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ConditionalEventDefinitionTypeMut + 'static)>

impl Cast<dyn ConversationAssociationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ConversationAssociationType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ConversationAssociationType + 'static)>

impl Cast<dyn ConversationAssociationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ConversationAssociationTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ConversationAssociationTypeMut + 'static)>

impl Cast<dyn ConversationLinkType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ConversationLinkType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ConversationLinkType + 'static)>

impl Cast<dyn ConversationLinkTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ConversationLinkTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ConversationLinkTypeMut + 'static)>

impl Cast<dyn ConversationNodeType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ConversationNodeType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ConversationNodeType + 'static)>

impl Cast<dyn ConversationNodeTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ConversationNodeTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ConversationNodeTypeMut + 'static)>

impl Cast<dyn ConversationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ConversationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ConversationType + 'static)>

impl Cast<dyn ConversationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ConversationTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ConversationTypeMut + 'static)>

impl Cast<dyn CorrelationKeyType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CorrelationKeyType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CorrelationKeyType + 'static)>

impl Cast<dyn CorrelationKeyTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CorrelationKeyTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CorrelationKeyTypeMut + 'static)>

impl Cast<dyn CorrelationPropertyBindingType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CorrelationPropertyBindingType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn CorrelationPropertyBindingType + 'static)>

impl Cast<dyn CorrelationPropertyBindingTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CorrelationPropertyBindingTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn CorrelationPropertyBindingTypeMut + 'static)>

impl Cast<dyn CorrelationPropertyRetrievalExpressionType + 'static> for FlowElement

fn cast(
    &self
) -> Option<&(dyn CorrelationPropertyRetrievalExpressionType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn CorrelationPropertyRetrievalExpressionType + 'static)>

impl Cast<dyn CorrelationPropertyRetrievalExpressionTypeMut + 'static> for FlowElement

fn cast(
    &self
) -> Option<&(dyn CorrelationPropertyRetrievalExpressionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn CorrelationPropertyRetrievalExpressionTypeMut + 'static)>

impl Cast<dyn CorrelationPropertyType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CorrelationPropertyType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn CorrelationPropertyType + 'static)>

impl Cast<dyn CorrelationPropertyTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CorrelationPropertyTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn CorrelationPropertyTypeMut + 'static)>

impl Cast<dyn CorrelationSubscriptionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CorrelationSubscriptionType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn CorrelationSubscriptionType + 'static)>

impl Cast<dyn CorrelationSubscriptionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn CorrelationSubscriptionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn CorrelationSubscriptionTypeMut + 'static)>

impl Cast<dyn DataAssociationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataAssociationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataAssociationType + 'static)>

impl Cast<dyn DataAssociationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataAssociationTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataAssociationTypeMut + 'static)>

impl Cast<dyn DataInputAssociationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataInputAssociationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataInputAssociationType + 'static)>

impl Cast<dyn DataInputAssociationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataInputAssociationTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn DataInputAssociationTypeMut + 'static)>

impl Cast<dyn DataInputType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataInputType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataInputType + 'static)>

impl Cast<dyn DataInputTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataInputTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataInputTypeMut + 'static)>

impl Cast<dyn DataObjectReferenceType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataObjectReferenceType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataObjectReferenceType + 'static)>

impl Cast<dyn DataObjectReferenceTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataObjectReferenceTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn DataObjectReferenceTypeMut + 'static)>

impl Cast<dyn DataObjectType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataObjectType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataObjectType + 'static)>

impl Cast<dyn DataObjectTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataObjectTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataObjectTypeMut + 'static)>

impl Cast<dyn DataOutputAssociationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataOutputAssociationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataOutputAssociationType + 'static)>

impl Cast<dyn DataOutputAssociationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataOutputAssociationTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn DataOutputAssociationTypeMut + 'static)>

impl Cast<dyn DataOutputType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataOutputType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataOutputType + 'static)>

impl Cast<dyn DataOutputTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataOutputTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataOutputTypeMut + 'static)>

impl Cast<dyn DataStateType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataStateType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataStateType + 'static)>

impl Cast<dyn DataStateTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataStateTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataStateTypeMut + 'static)>

impl Cast<dyn DataStoreReferenceType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataStoreReferenceType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataStoreReferenceType + 'static)>

impl Cast<dyn DataStoreReferenceTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataStoreReferenceTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataStoreReferenceTypeMut + 'static)>

impl Cast<dyn DataStoreType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataStoreType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataStoreType + 'static)>

impl Cast<dyn DataStoreTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DataStoreTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DataStoreTypeMut + 'static)>

impl Cast<dyn DefinitionsType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DefinitionsType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DefinitionsType + 'static)>

impl Cast<dyn DefinitionsTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DefinitionsTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DefinitionsTypeMut + 'static)>

impl Cast<dyn DocumentationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DocumentationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DocumentationType + 'static)>

impl Cast<dyn DocumentationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn DocumentationTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn DocumentationTypeMut + 'static)>

impl Cast<dyn EndEventType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EndEventType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EndEventType + 'static)>

impl Cast<dyn EndEventTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EndEventTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EndEventTypeMut + 'static)>

impl Cast<dyn EndPointType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EndPointType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EndPointType + 'static)>

impl Cast<dyn EndPointTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EndPointTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EndPointTypeMut + 'static)>

impl Cast<dyn ErrorEventDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ErrorEventDefinitionType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ErrorEventDefinitionType + 'static)>

impl Cast<dyn ErrorEventDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ErrorEventDefinitionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ErrorEventDefinitionTypeMut + 'static)>

impl Cast<dyn ErrorType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ErrorType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ErrorType + 'static)>

impl Cast<dyn ErrorTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ErrorTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ErrorTypeMut + 'static)>

impl Cast<dyn EscalationEventDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EscalationEventDefinitionType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn EscalationEventDefinitionType + 'static)>

impl Cast<dyn EscalationEventDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EscalationEventDefinitionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn EscalationEventDefinitionTypeMut + 'static)>

impl Cast<dyn EscalationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EscalationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EscalationType + 'static)>

impl Cast<dyn EscalationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EscalationTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EscalationTypeMut + 'static)>

impl Cast<dyn EventBasedGatewayType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EventBasedGatewayType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EventBasedGatewayType + 'static)>

impl Cast<dyn EventBasedGatewayTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EventBasedGatewayTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EventBasedGatewayTypeMut + 'static)>

impl Cast<dyn EventDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EventDefinitionType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EventDefinitionType + 'static)>

impl Cast<dyn EventDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EventDefinitionTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EventDefinitionTypeMut + 'static)>

impl Cast<dyn EventType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EventType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EventType + 'static)>

impl Cast<dyn EventTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn EventTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn EventTypeMut + 'static)>

impl Cast<dyn ExclusiveGatewayType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ExclusiveGatewayType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ExclusiveGatewayType + 'static)>

impl Cast<dyn ExclusiveGatewayTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ExclusiveGatewayTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ExclusiveGatewayTypeMut + 'static)>

impl Cast<dyn ExpressionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ExpressionType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ExpressionType + 'static)>

impl Cast<dyn ExpressionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ExpressionTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ExpressionTypeMut + 'static)>

impl Cast<dyn ExtensionElementsType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ExtensionElementsType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ExtensionElementsType + 'static)>

impl Cast<dyn ExtensionElementsTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ExtensionElementsTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ExtensionElementsTypeMut + 'static)>

impl Cast<dyn ExtensionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ExtensionType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ExtensionType + 'static)>

impl Cast<dyn ExtensionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ExtensionTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ExtensionTypeMut + 'static)>

impl Cast<dyn FlowElementType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn FlowElementType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn FlowElementType + 'static)>

impl Cast<dyn FlowElementTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn FlowElementTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn FlowElementTypeMut + 'static)>

impl Cast<dyn FlowNodeType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn FlowNodeType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn FlowNodeType + 'static)>

impl Cast<dyn FlowNodeTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn FlowNodeTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn FlowNodeTypeMut + 'static)>

impl Cast<dyn FormalExpressionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn FormalExpressionType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn FormalExpressionType + 'static)>

impl Cast<dyn FormalExpressionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn FormalExpressionTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn FormalExpressionTypeMut + 'static)>

impl Cast<dyn GatewayType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GatewayType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GatewayType + 'static)>

impl Cast<dyn GatewayTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GatewayTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GatewayTypeMut + 'static)>

impl Cast<dyn GlobalBusinessRuleTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalBusinessRuleTaskType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn GlobalBusinessRuleTaskType + 'static)>

impl Cast<dyn GlobalBusinessRuleTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalBusinessRuleTaskTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn GlobalBusinessRuleTaskTypeMut + 'static)>

impl Cast<dyn GlobalChoreographyTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalChoreographyTaskType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn GlobalChoreographyTaskType + 'static)>

impl Cast<dyn GlobalChoreographyTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalChoreographyTaskTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn GlobalChoreographyTaskTypeMut + 'static)>

impl Cast<dyn GlobalConversationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalConversationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GlobalConversationType + 'static)>

impl Cast<dyn GlobalConversationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalConversationTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GlobalConversationTypeMut + 'static)>

impl Cast<dyn GlobalManualTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalManualTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GlobalManualTaskType + 'static)>

impl Cast<dyn GlobalManualTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalManualTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GlobalManualTaskTypeMut + 'static)>

impl Cast<dyn GlobalScriptTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalScriptTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GlobalScriptTaskType + 'static)>

impl Cast<dyn GlobalScriptTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalScriptTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GlobalScriptTaskTypeMut + 'static)>

impl Cast<dyn GlobalTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GlobalTaskType + 'static)>

impl Cast<dyn GlobalTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GlobalTaskTypeMut + 'static)>

impl Cast<dyn GlobalUserTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalUserTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GlobalUserTaskType + 'static)>

impl Cast<dyn GlobalUserTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GlobalUserTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GlobalUserTaskTypeMut + 'static)>

impl Cast<dyn GroupType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GroupType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GroupType + 'static)>

impl Cast<dyn GroupTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn GroupTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn GroupTypeMut + 'static)>

impl Cast<dyn HumanPerformerType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn HumanPerformerType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn HumanPerformerType + 'static)>

impl Cast<dyn HumanPerformerTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn HumanPerformerTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn HumanPerformerTypeMut + 'static)>

impl Cast<dyn ImplicitThrowEventType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ImplicitThrowEventType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ImplicitThrowEventType + 'static)>

impl Cast<dyn ImplicitThrowEventTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ImplicitThrowEventTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ImplicitThrowEventTypeMut + 'static)>

impl Cast<dyn ImportType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ImportType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ImportType + 'static)>

impl Cast<dyn ImportTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ImportTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ImportTypeMut + 'static)>

impl Cast<dyn InclusiveGatewayType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn InclusiveGatewayType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn InclusiveGatewayType + 'static)>

impl Cast<dyn InclusiveGatewayTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn InclusiveGatewayTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn InclusiveGatewayTypeMut + 'static)>

impl Cast<dyn InputOutputBindingType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn InputOutputBindingType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn InputOutputBindingType + 'static)>

impl Cast<dyn InputOutputBindingTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn InputOutputBindingTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn InputOutputBindingTypeMut + 'static)>

impl Cast<dyn InputOutputSpecificationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn InputOutputSpecificationType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn InputOutputSpecificationType + 'static)>

impl Cast<dyn InputOutputSpecificationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn InputOutputSpecificationTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn InputOutputSpecificationTypeMut + 'static)>

impl Cast<dyn InputSetType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn InputSetType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn InputSetType + 'static)>

impl Cast<dyn InputSetTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn InputSetTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn InputSetTypeMut + 'static)>

impl Cast<dyn InterfaceType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn InterfaceType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn InterfaceType + 'static)>

impl Cast<dyn InterfaceTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn InterfaceTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn InterfaceTypeMut + 'static)>

impl Cast<dyn IntermediateCatchEventType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn IntermediateCatchEventType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn IntermediateCatchEventType + 'static)>

impl Cast<dyn IntermediateCatchEventTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn IntermediateCatchEventTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn IntermediateCatchEventTypeMut + 'static)>

impl Cast<dyn IntermediateThrowEventType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn IntermediateThrowEventType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn IntermediateThrowEventType + 'static)>

impl Cast<dyn IntermediateThrowEventTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn IntermediateThrowEventTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn IntermediateThrowEventTypeMut + 'static)>

impl Cast<dyn ItemDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ItemDefinitionType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ItemDefinitionType + 'static)>

impl Cast<dyn ItemDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ItemDefinitionTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ItemDefinitionTypeMut + 'static)>

impl Cast<dyn LaneSetType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn LaneSetType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn LaneSetType + 'static)>

impl Cast<dyn LaneSetTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn LaneSetTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn LaneSetTypeMut + 'static)>

impl Cast<dyn LaneType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn LaneType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn LaneType + 'static)>

impl Cast<dyn LaneTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn LaneTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn LaneTypeMut + 'static)>

impl Cast<dyn LinkEventDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn LinkEventDefinitionType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn LinkEventDefinitionType + 'static)>

impl Cast<dyn LinkEventDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn LinkEventDefinitionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn LinkEventDefinitionTypeMut + 'static)>

impl Cast<dyn LoopCharacteristicsType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn LoopCharacteristicsType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn LoopCharacteristicsType + 'static)>

impl Cast<dyn LoopCharacteristicsTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn LoopCharacteristicsTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn LoopCharacteristicsTypeMut + 'static)>

impl Cast<dyn ManualTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ManualTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ManualTaskType + 'static)>

impl Cast<dyn ManualTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ManualTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ManualTaskTypeMut + 'static)>

impl Cast<dyn MessageEventDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn MessageEventDefinitionType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn MessageEventDefinitionType + 'static)>

impl Cast<dyn MessageEventDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn MessageEventDefinitionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn MessageEventDefinitionTypeMut + 'static)>

impl Cast<dyn MessageFlowAssociationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn MessageFlowAssociationType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn MessageFlowAssociationType + 'static)>

impl Cast<dyn MessageFlowAssociationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn MessageFlowAssociationTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn MessageFlowAssociationTypeMut + 'static)>

impl Cast<dyn MessageFlowType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn MessageFlowType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn MessageFlowType + 'static)>

impl Cast<dyn MessageFlowTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn MessageFlowTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn MessageFlowTypeMut + 'static)>

impl Cast<dyn MessageType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn MessageType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn MessageType + 'static)>

impl Cast<dyn MessageTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn MessageTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn MessageTypeMut + 'static)>

impl Cast<dyn MonitoringType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn MonitoringType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn MonitoringType + 'static)>

impl Cast<dyn MonitoringTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn MonitoringTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn MonitoringTypeMut + 'static)>

impl Cast<dyn MultiInstanceLoopCharacteristicsType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn MultiInstanceLoopCharacteristicsType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn MultiInstanceLoopCharacteristicsType + 'static)>

impl Cast<dyn MultiInstanceLoopCharacteristicsTypeMut + 'static> for FlowElement

fn cast(
    &self
) -> Option<&(dyn MultiInstanceLoopCharacteristicsTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn MultiInstanceLoopCharacteristicsTypeMut + 'static)>

impl Cast<dyn OperationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn OperationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn OperationType + 'static)>

impl Cast<dyn OperationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn OperationTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn OperationTypeMut + 'static)>

impl Cast<dyn OutputSetType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn OutputSetType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn OutputSetType + 'static)>

impl Cast<dyn OutputSetTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn OutputSetTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn OutputSetTypeMut + 'static)>

impl Cast<dyn ParallelGatewayType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ParallelGatewayType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ParallelGatewayType + 'static)>

impl Cast<dyn ParallelGatewayTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ParallelGatewayTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ParallelGatewayTypeMut + 'static)>

impl Cast<dyn ParticipantAssociationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ParticipantAssociationType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ParticipantAssociationType + 'static)>

impl Cast<dyn ParticipantAssociationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ParticipantAssociationTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ParticipantAssociationTypeMut + 'static)>

impl Cast<dyn ParticipantMultiplicityType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ParticipantMultiplicityType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ParticipantMultiplicityType + 'static)>

impl Cast<dyn ParticipantMultiplicityTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ParticipantMultiplicityTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ParticipantMultiplicityTypeMut + 'static)>

impl Cast<dyn ParticipantType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ParticipantType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ParticipantType + 'static)>

impl Cast<dyn ParticipantTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ParticipantTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ParticipantTypeMut + 'static)>

impl Cast<dyn PartnerEntityType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn PartnerEntityType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn PartnerEntityType + 'static)>

impl Cast<dyn PartnerEntityTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn PartnerEntityTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn PartnerEntityTypeMut + 'static)>

impl Cast<dyn PartnerRoleType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn PartnerRoleType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn PartnerRoleType + 'static)>

impl Cast<dyn PartnerRoleTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn PartnerRoleTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn PartnerRoleTypeMut + 'static)>

impl Cast<dyn PerformerType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn PerformerType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn PerformerType + 'static)>

impl Cast<dyn PerformerTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn PerformerTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn PerformerTypeMut + 'static)>

impl Cast<dyn PotentialOwnerType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn PotentialOwnerType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn PotentialOwnerType + 'static)>

impl Cast<dyn PotentialOwnerTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn PotentialOwnerTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn PotentialOwnerTypeMut + 'static)>

impl Cast<dyn ProcessType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ProcessType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ProcessType + 'static)>

impl Cast<dyn ProcessTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ProcessTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ProcessTypeMut + 'static)>

impl Cast<dyn PropertyType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn PropertyType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn PropertyType + 'static)>

impl Cast<dyn PropertyTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn PropertyTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn PropertyTypeMut + 'static)>

impl Cast<dyn ReceiveTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ReceiveTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ReceiveTaskType + 'static)>

impl Cast<dyn ReceiveTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ReceiveTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ReceiveTaskTypeMut + 'static)>

impl Cast<dyn RelationshipType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn RelationshipType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn RelationshipType + 'static)>

impl Cast<dyn RelationshipTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn RelationshipTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn RelationshipTypeMut + 'static)>

impl Cast<dyn RenderingType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn RenderingType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn RenderingType + 'static)>

impl Cast<dyn RenderingTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn RenderingTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn RenderingTypeMut + 'static)>

impl Cast<dyn ResourceAssignmentExpressionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ResourceAssignmentExpressionType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ResourceAssignmentExpressionType + 'static)>

impl Cast<dyn ResourceAssignmentExpressionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ResourceAssignmentExpressionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ResourceAssignmentExpressionTypeMut + 'static)>

impl Cast<dyn ResourceParameterBindingType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ResourceParameterBindingType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ResourceParameterBindingType + 'static)>

impl Cast<dyn ResourceParameterBindingTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ResourceParameterBindingTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn ResourceParameterBindingTypeMut + 'static)>

impl Cast<dyn ResourceParameterType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ResourceParameterType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ResourceParameterType + 'static)>

impl Cast<dyn ResourceParameterTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ResourceParameterTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ResourceParameterTypeMut + 'static)>

impl Cast<dyn ResourceRoleType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ResourceRoleType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ResourceRoleType + 'static)>

impl Cast<dyn ResourceRoleTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ResourceRoleTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ResourceRoleTypeMut + 'static)>

impl Cast<dyn ResourceType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ResourceType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ResourceType + 'static)>

impl Cast<dyn ResourceTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ResourceTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ResourceTypeMut + 'static)>

impl Cast<dyn RootElementType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn RootElementType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn RootElementType + 'static)>

impl Cast<dyn RootElementTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn RootElementTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn RootElementTypeMut + 'static)>

impl Cast<dyn ScriptTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ScriptTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ScriptTaskType + 'static)>

impl Cast<dyn ScriptTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ScriptTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ScriptTaskTypeMut + 'static)>

impl Cast<dyn ScriptType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ScriptType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ScriptType + 'static)>

impl Cast<dyn ScriptTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ScriptTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ScriptTypeMut + 'static)>

impl Cast<dyn SendTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SendTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SendTaskType + 'static)>

impl Cast<dyn SendTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SendTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SendTaskTypeMut + 'static)>

impl Cast<dyn SequenceFlowType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SequenceFlowType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SequenceFlowType + 'static)>

impl Cast<dyn SequenceFlowTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SequenceFlowTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SequenceFlowTypeMut + 'static)>

impl Cast<dyn ServiceTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ServiceTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ServiceTaskType + 'static)>

impl Cast<dyn ServiceTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ServiceTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ServiceTaskTypeMut + 'static)>

impl Cast<dyn SignalEventDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SignalEventDefinitionType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SignalEventDefinitionType + 'static)>

impl Cast<dyn SignalEventDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SignalEventDefinitionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn SignalEventDefinitionTypeMut + 'static)>

impl Cast<dyn SignalType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SignalType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SignalType + 'static)>

impl Cast<dyn SignalTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SignalTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SignalTypeMut + 'static)>

impl Cast<dyn StandardLoopCharacteristicsType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn StandardLoopCharacteristicsType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn StandardLoopCharacteristicsType + 'static)>

impl Cast<dyn StandardLoopCharacteristicsTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn StandardLoopCharacteristicsTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn StandardLoopCharacteristicsTypeMut + 'static)>

impl Cast<dyn StartEventType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn StartEventType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn StartEventType + 'static)>

impl Cast<dyn StartEventTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn StartEventTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn StartEventTypeMut + 'static)>

impl Cast<dyn SubChoreographyType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SubChoreographyType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SubChoreographyType + 'static)>

impl Cast<dyn SubChoreographyTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SubChoreographyTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SubChoreographyTypeMut + 'static)>

impl Cast<dyn SubConversationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SubConversationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SubConversationType + 'static)>

impl Cast<dyn SubConversationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SubConversationTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SubConversationTypeMut + 'static)>

impl Cast<dyn SubProcessType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SubProcessType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SubProcessType + 'static)>

impl Cast<dyn SubProcessTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn SubProcessTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn SubProcessTypeMut + 'static)>

impl Cast<dyn TaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn TaskType + 'static)>

impl Cast<dyn TaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn TaskTypeMut + 'static)>

impl Cast<dyn TerminateEventDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TerminateEventDefinitionType + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn TerminateEventDefinitionType + 'static)>

impl Cast<dyn TerminateEventDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TerminateEventDefinitionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn TerminateEventDefinitionTypeMut + 'static)>

impl Cast<dyn TextAnnotationType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TextAnnotationType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn TextAnnotationType + 'static)>

impl Cast<dyn TextAnnotationTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TextAnnotationTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn TextAnnotationTypeMut + 'static)>

impl Cast<dyn TextType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TextType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn TextType + 'static)>

impl Cast<dyn TextTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TextTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn TextTypeMut + 'static)>

impl Cast<dyn ThrowEventType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ThrowEventType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ThrowEventType + 'static)>

impl Cast<dyn ThrowEventTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn ThrowEventTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn ThrowEventTypeMut + 'static)>

impl Cast<dyn TimerEventDefinitionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TimerEventDefinitionType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn TimerEventDefinitionType + 'static)>

impl Cast<dyn TimerEventDefinitionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TimerEventDefinitionTypeMut + 'static)>

fn cast_mut(
    &mut self
) -> Option<&mut (dyn TimerEventDefinitionTypeMut + 'static)>

impl Cast<dyn TransactionType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TransactionType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn TransactionType + 'static)>

impl Cast<dyn TransactionTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn TransactionTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn TransactionTypeMut + 'static)>

impl Cast<dyn UserTaskType + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn UserTaskType + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn UserTaskType + 'static)>

impl Cast<dyn UserTaskTypeMut + 'static> for FlowElement

fn cast(&self) -> Option<&(dyn UserTaskTypeMut + 'static)>

fn cast_mut(&mut self) -> Option<&mut (dyn UserTaskTypeMut + 'static)>

impl Clone for FlowElement

fn clone(&self) -> FlowElement

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FlowElement

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FlowElement

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl DocumentElement for FlowElement

fn element(&self) -> Element

impl DocumentElementContainer for FlowElement

fn find_by_id_mut(&mut self, id: &str) -> Option<&mut dyn DocumentElement>

Find an element by ID and return a mutable reference

fn find_by_id(&self, id: &str) -> Option<&dyn DocumentElement>

Find an element by ID

impl From<AdHocSubProcess> for FlowElement

fn from(original: AdHocSubProcess) -> FlowElement

Performs the conversion.

impl From<BoundaryEvent> for FlowElement

fn from(original: BoundaryEvent) -> FlowElement

Performs the conversion.

impl From<BusinessRuleTask> for FlowElement

fn from(original: BusinessRuleTask) -> FlowElement

Performs the conversion.

impl From<CallActivity> for FlowElement

fn from(original: CallActivity) -> FlowElement

Performs the conversion.

impl From<CallChoreography> for FlowElement

fn from(original: CallChoreography) -> FlowElement

Performs the conversion.

impl From<ChoreographyTask> for FlowElement

fn from(original: ChoreographyTask) -> FlowElement

Performs the conversion.

impl From<ComplexGateway> for FlowElement

fn from(original: ComplexGateway) -> FlowElement

Performs the conversion.

impl From<DataObject> for FlowElement

fn from(original: DataObject) -> FlowElement

Performs the conversion.

impl From<DataObjectReference> for FlowElement

fn from(original: DataObjectReference) -> FlowElement

Performs the conversion.

impl From<DataStoreReference> for FlowElement

fn from(original: DataStoreReference) -> FlowElement

Performs the conversion.

impl From<EndEvent> for FlowElement

fn from(original: EndEvent) -> FlowElement

Performs the conversion.

impl From<Event> for FlowElement

fn from(original: Event) -> FlowElement

Performs the conversion.

impl From<EventBasedGateway> for FlowElement

fn from(original: EventBasedGateway) -> FlowElement

Performs the conversion.

impl From<ExclusiveGateway> for FlowElement

fn from(original: ExclusiveGateway) -> FlowElement

Performs the conversion.

impl From<ImplicitThrowEvent> for FlowElement

fn from(original: ImplicitThrowEvent) -> FlowElement

Performs the conversion.

impl From<InclusiveGateway> for FlowElement

fn from(original: InclusiveGateway) -> FlowElement

Performs the conversion.

impl From<IntermediateCatchEvent> for FlowElement

fn from(original: IntermediateCatchEvent) -> FlowElement

Performs the conversion.

impl From<IntermediateThrowEvent> for FlowElement

fn from(original: IntermediateThrowEvent) -> FlowElement

Performs the conversion.

impl From<ManualTask> for FlowElement

fn from(original: ManualTask) -> FlowElement

Performs the conversion.

impl From<ParallelGateway> for FlowElement

fn from(original: ParallelGateway) -> FlowElement

Performs the conversion.

impl From<ReceiveTask> for FlowElement

fn from(original: ReceiveTask) -> FlowElement

Performs the conversion.

impl From<ScriptTask> for FlowElement

fn from(original: ScriptTask) -> FlowElement

Performs the conversion.

impl From<SendTask> for FlowElement

fn from(original: SendTask) -> FlowElement

Performs the conversion.

impl From<SequenceFlow> for FlowElement

fn from(original: SequenceFlow) -> FlowElement

Performs the conversion.

impl From<ServiceTask> for FlowElement

fn from(original: ServiceTask) -> FlowElement

Performs the conversion.

impl From<StartEvent> for FlowElement

fn from(original: StartEvent) -> FlowElement

Performs the conversion.

impl From<SubChoreography> for FlowElement

fn from(original: SubChoreography) -> FlowElement

Performs the conversion.

impl From<SubProcess> for FlowElement

fn from(original: SubProcess) -> FlowElement

Performs the conversion.

impl From<Task> for FlowElement

fn from(original: Task) -> FlowElement

Performs the conversion.

impl From<Transaction> for FlowElement

fn from(original: Transaction) -> FlowElement

Performs the conversion.

impl From<UserTask> for FlowElement

fn from(original: UserTask) -> FlowElement

Performs the conversion.

impl Hash for FlowElement

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<FlowElement> for FlowElement

fn eq(&self, other: &FlowElement) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &FlowElement) -> bool

This method tests for !=.

impl Serialize for FlowElement

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FlowElement

impl<'__input> XmlRead<'__input> for FlowElement

fn from_reader(reader: &mut XmlReader<'__input>) -> XmlResult<Self>

pub fn from_str(text: &'a str) -> Result<Self, XmlError>