|
standard library package SysML { |
|
doc |
|
|
|
|
|
|
|
|
|
private import ScalarValues::*; |
|
public import Systems::*; |
|
|
|
package Systems { |
|
public import KerML::Kernel::*; |
|
|
|
metadata def AcceptActionUsage specializes ActionUsage { |
|
derived ref item receiverArgument : Expression[0..1]; |
|
derived ref item payloadParameter : ReferenceUsage[1..1] subsets nestedReference, parameter; |
|
derived ref item payloadArgument : Expression[0..1]; |
|
} |
|
|
|
metadata def ActionDefinition specializes Behavior, OccurrenceDefinition { |
|
derived ref item 'action' : ActionUsage[0..*] ordered subsets step, usage; |
|
} |
|
|
|
metadata def ActionUsage specializes Step, OccurrenceUsage { |
|
derived ref item actionDefinition : Behavior[0..*] ordered redefines behavior, occurrenceDefinition; |
|
} |
|
|
|
metadata def ActorMembership specializes ParameterMembership { |
|
derived item ownedActorParameter : PartUsage[1..1] redefines ownedMemberParameter; |
|
} |
|
|
|
metadata def AllocationDefinition specializes ConnectionDefinition { |
|
derived ref item 'allocation' : AllocationUsage[0..*] ordered subsets usage; |
|
} |
|
|
|
metadata def AllocationUsage specializes ConnectionUsage { |
|
derived ref item allocationDefinition : AllocationDefinition[0..*] ordered redefines connectionDefinition; |
|
} |
|
|
|
metadata def AnalysisCaseDefinition specializes CaseDefinition { |
|
derived ref item resultExpression : Expression[0..1] subsets expression, ownedFeature; |
|
} |
|
|
|
metadata def AnalysisCaseUsage specializes CaseUsage { |
|
derived ref item analysisCaseDefinition : AnalysisCaseDefinition[0..1] redefines caseDefinition; |
|
derived ref item resultExpression : Expression[0..1] subsets ownedFeature; |
|
} |
|
|
|
metadata def AssertConstraintUsage specializes ConstraintUsage, Invariant { |
|
derived ref item assertedConstraint : ConstraintUsage[1..1]; |
|
} |
|
|
|
metadata def AssignmentActionUsage specializes ActionUsage { |
|
derived ref item targetArgument : Expression[0..1]; |
|
derived ref item valueExpression : Expression[0..1]; |
|
derived ref item referent : Feature[1..1] subsets member; |
|
} |
|
|
|
metadata def AttributeDefinition specializes DataType, Definition; |
|
|
|
metadata def AttributeUsage specializes Usage { |
|
derived attribute isReference : Boolean[1..1] redefines isReference; |
|
|
|
derived ref item attributeDefinition : DataType[0..*] ordered redefines definition; |
|
} |
|
|
|
metadata def BindingConnectorAsUsage specializes BindingConnector, ConnectorAsUsage; |
|
|
|
metadata def CalculationDefinition specializes Function, ActionDefinition { |
|
derived ref item calculation : CalculationUsage[0..*] ordered subsets 'action', expression; |
|
} |
|
|
|
metadata def CalculationUsage specializes Expression, ActionUsage { |
|
derived ref item calculationDefinition : Function[0..1] ordered redefines function, actionDefinition; |
|
} |
|
|
|
metadata def CaseDefinition specializes CalculationDefinition { |
|
derived ref item objectiveRequirement : RequirementUsage[0..1] ordered subsets usage; |
|
derived ref item subjectParameter : Usage[1..1] subsets parameter, usage; |
|
derived ref item actorParameter : PartUsage[0..*] ordered subsets parameter, usage; |
|
} |
|
|
|
metadata def CaseUsage specializes CalculationUsage { |
|
derived ref item objectiveRequirement : RequirementUsage[0..1] ordered subsets usage; |
|
derived ref item caseDefinition : CaseDefinition[0..1] redefines calculationDefinition; |
|
derived ref item subjectParameter : Usage[1..1] subsets parameter, usage; |
|
derived ref item actorParameter : PartUsage[0..*] ordered subsets parameter, usage; |
|
} |
|
|
|
metadata def ConcernDefinition specializes RequirementDefinition; |
|
|
|
metadata def ConcernUsage specializes RequirementUsage { |
|
derived ref item concernDefinition : ConcernDefinition[0..1] redefines requirementDefinition; |
|
} |
|
|
|
metadata def ConjugatedPortDefinition specializes PortDefinition { |
|
derived ref item originalPortDefinition : PortDefinition[1..1] redefines owningNamespace; |
|
derived ref item ownedPortConjugator : PortConjugation[1..1] redefines ownedConjugator; |
|
} |
|
|
|
metadata def ConjugatedPortTyping specializes FeatureTyping { |
|
ref item conjugatedPortDefinition : ConjugatedPortDefinition[1..1] redefines type; |
|
derived ref item portDefinition : PortDefinition[1..1]; |
|
} |
|
|
|
metadata def ConnectionDefinition specializes AssociationStructure, PartDefinition { |
|
derived ref item connectionEnd : Usage[0..*] ordered redefines associationEnd; |
|
} |
|
|
|
metadata def ConnectionUsage specializes ConnectorAsUsage, PartUsage { |
|
derived ref item connectionDefinition : AssociationStructure[0..*] ordered subsets itemDefinition redefines association; |
|
} |
|
|
|
abstract metadata def ConnectorAsUsage specializes Usage, Connector; |
|
|
|
metadata def ConstraintDefinition specializes OccurrenceDefinition, Predicate; |
|
|
|
metadata def ConstraintUsage specializes BooleanExpression, OccurrenceUsage { |
|
derived ref item constraintDefinition : Predicate[0..1] redefines predicate; |
|
} |
|
|
|
abstract metadata def ControlNode specializes ActionUsage; |
|
|
|
metadata def DecisionNode specializes ControlNode; |
|
|
|
metadata def Definition specializes Classifier { |
|
attribute isVariation : Boolean[1..1]; |
|
|
|
derived ref item 'variant' : Usage[0..*] subsets ownedMember; |
|
derived item variantMembership : VariantMembership[0..*] subsets ownedMembership; |
|
derived ref item usage : Usage[0..*] ordered subsets feature; |
|
derived ref item directedUsage : Usage[0..*] ordered subsets usage, directedFeature; |
|
derived ref item ownedUsage : Usage[0..*] ordered subsets ownedFeature, usage; |
|
derived ref item ownedReference : ReferenceUsage[0..*] ordered subsets ownedUsage; |
|
derived ref item ownedAttribute : AttributeUsage[0..*] ordered subsets ownedUsage; |
|
derived ref item ownedEnumeration : EnumerationUsage[0..*] ordered subsets ownedAttribute; |
|
derived ref item ownedOccurrence : OccurrenceUsage[0..*] ordered subsets ownedUsage; |
|
derived ref item ownedItem : ItemUsage[0..*] ordered subsets ownedOccurrence; |
|
derived ref item ownedPart : PartUsage[0..*] ordered subsets ownedItem; |
|
derived ref item ownedPort : PortUsage[0..*] ordered subsets ownedUsage; |
|
derived ref item ownedConnection : ConnectorAsUsage[0..*] ordered subsets ownedPart; |
|
derived ref item ownedFlow : FlowConnectionUsage[0..*] subsets ownedConnection; |
|
derived ref item ownedInterface : InterfaceUsage[0..*] ordered subsets ownedConnection; |
|
derived ref item ownedAllocation : AllocationUsage[0..*] ordered subsets ownedConnection; |
|
derived ref item ownedAction : ActionUsage[0..*] ordered subsets ownedOccurrence; |
|
derived ref item ownedState : StateUsage[0..*] ordered subsets ownedAction; |
|
derived ref item ownedTransition : TransitionUsage[0..*] subsets ownedUsage; |
|
derived ref item ownedCalculation : CalculationUsage[0..*] ordered subsets ownedAction; |
|
derived ref item ownedConstraint : ConstraintUsage[0..*] ordered subsets ownedOccurrence; |
|
derived ref item ownedRequirement : RequirementUsage[0..*] ordered subsets ownedConstraint; |
|
derived ref item ownedConcern : ConcernUsage[0..*] subsets ownedRequirement; |
|
derived ref item ownedCase : CaseUsage[0..*] ordered subsets ownedCalculation; |
|
derived ref item ownedAnalysisCase : AnalysisCaseUsage[0..*] ordered subsets ownedCase; |
|
derived ref item ownedVerificationCase : VerificationCaseUsage[0..*] ordered subsets ownedCase; |
|
derived ref item ownedUseCase : UseCaseUsage[0..*] ordered subsets ownedCase; |
|
derived ref item ownedView : ViewUsage[0..*] ordered subsets ownedPart; |
|
derived ref item ownedViewpoint : ViewpointUsage[0..*] ordered subsets ownedRequirement; |
|
derived ref item ownedRendering : RenderingUsage[0..*] ordered subsets ownedPart; |
|
derived ref item ownedMetadata : MetadataUsage[0..*] ordered subsets ownedItem; |
|
} |
|
|
|
metadata def EnumerationDefinition specializes AttributeDefinition { |
|
attribute isVariation : Boolean[1..1] redefines isVariation; |
|
|
|
derived ref item enumeratedValue : EnumerationUsage[0..*] ordered redefines 'variant'; |
|
} |
|
|
|
metadata def EnumerationUsage specializes AttributeUsage { |
|
derived ref item enumerationDefinition : EnumerationDefinition[1..1] redefines attributeDefinition; |
|
} |
|
|
|
metadata def EventOccurrenceUsage specializes OccurrenceUsage { |
|
derived attribute isReference : Boolean[1..1] redefines isReference; |
|
|
|
derived ref item eventOccurrence : OccurrenceUsage[1..1]; |
|
} |
|
|
|
metadata def ExhibitStateUsage specializes StateUsage, PerformActionUsage { |
|
derived ref item exhibitedState : StateUsage[1..1] redefines performedAction; |
|
} |
|
|
|
abstract metadata def Expose specializes Import { |
|
attribute visibility : VisibilityKind[1..1] redefines visibility; |
|
attribute isImportAll : Boolean[1..1] redefines isImportAll; |
|
} |
|
|
|
metadata def FlowConnectionDefinition specializes Interaction, ConnectionDefinition, ActionDefinition; |
|
|
|
metadata def FlowConnectionUsage specializes ConnectionUsage, ItemFlow, ActionUsage { |
|
derived ref item flowConnectionDefinition : Interaction[0..*] ordered redefines actionDefinition, connectionDefinition, interaction; |
|
} |
|
|
|
metadata def ForLoopActionUsage specializes LoopActionUsage { |
|
derived ref item seqArgument : Expression[1..1]; |
|
derived ref item loopVariable : ReferenceUsage[1..1]; |
|
} |
|
|
|
metadata def ForkNode specializes ControlNode; |
|
|
|
metadata def FramedConcernMembership specializes RequirementConstraintMembership { |
|
attribute kind : RequirementConstraintKind[1..1] redefines kind; |
|
|
|
derived item ownedConcern : ConcernUsage[1..1] redefines ownedConstraint; |
|
derived ref item referencedConcern : ConcernUsage[1..1] redefines referencedConstraint; |
|
} |
|
|
|
metadata def IfActionUsage specializes ActionUsage { |
|
derived ref item elseAction : ActionUsage[0..1]; |
|
derived ref item thenAction : ActionUsage[1..1]; |
|
derived ref item ifArgument : Expression[1..1]; |
|
} |
|
|
|
metadata def IncludeUseCaseUsage specializes UseCaseUsage, PerformActionUsage { |
|
derived ref item useCaseIncluded : UseCaseUsage[1..1] redefines performedAction; |
|
} |
|
|
|
metadata def InterfaceDefinition specializes ConnectionDefinition { |
|
derived ref item interfaceEnd : PortUsage[0..*] ordered redefines connectionEnd; |
|
} |
|
|
|
metadata def InterfaceUsage specializes ConnectionUsage { |
|
derived ref item interfaceDefinition : InterfaceDefinition[0..*] redefines connectionDefinition; |
|
} |
|
|
|
metadata def ItemDefinition specializes Structure, OccurrenceDefinition; |
|
|
|
metadata def ItemUsage specializes OccurrenceUsage { |
|
derived ref item itemDefinition : Structure[0..*] ordered subsets occurrenceDefinition; |
|
} |
|
|
|
metadata def JoinNode specializes ControlNode; |
|
|
|
metadata def LifeClass specializes Class { |
|
attribute isSufficient : Boolean[1..1] redefines isSufficient; |
|
} |
|
|
|
abstract metadata def LoopActionUsage specializes ActionUsage { |
|
derived ref item bodyAction : ActionUsage[1..1]; |
|
} |
|
|
|
metadata def MembershipExpose specializes MembershipImport, Expose; |
|
|
|
metadata def MergeNode specializes ControlNode; |
|
|
|
metadata def MetadataDefinition specializes ItemDefinition, Metaclass; |
|
|
|
metadata def MetadataUsage specializes ItemUsage, MetadataFeature { |
|
derived ref item metadataDefinition : Metaclass[0..1] redefines itemDefinition, metaclass; |
|
} |
|
|
|
metadata def NamespaceExpose specializes Expose, NamespaceImport; |
|
|
|
metadata def ObjectiveMembership specializes FeatureMembership { |
|
derived item ownedObjectiveRequirement : RequirementUsage[1..1] redefines ownedMemberFeature; |
|
} |
|
|
|
metadata def OccurrenceDefinition specializes Definition, Class { |
|
attribute isIndividual : Boolean[1..1]; |
|
|
|
derived ref item lifeClass : LifeClass[0..1] subsets ownedMember; |
|
} |
|
|
|
metadata def OccurrenceUsage specializes Usage { |
|
attribute isIndividual : Boolean[1..1]; |
|
attribute portionKind : PortionKind[0..1]; |
|
|
|
derived ref item occurrenceDefinition : Class[0..*] ordered redefines definition; |
|
derived ref item individualDefinition : OccurrenceDefinition[0..1] subsets occurrenceDefinition; |
|
} |
|
|
|
metadata def PartDefinition specializes ItemDefinition; |
|
|
|
metadata def PartUsage specializes ItemUsage { |
|
derived ref item partDefinition : PartDefinition[0..*] ordered subsets itemDefinition; |
|
} |
|
|
|
metadata def PerformActionUsage specializes ActionUsage, EventOccurrenceUsage { |
|
derived ref item performedAction : ActionUsage[1..1] redefines eventOccurrence; |
|
} |
|
|
|
metadata def PortConjugation specializes Conjugation { |
|
ref item originalPortDefinition : PortDefinition[1..1] redefines originalType; |
|
derived ref item conjugatedPortDefinition : ConjugatedPortDefinition[1..1] redefines owningType; |
|
} |
|
|
|
metadata def PortDefinition specializes OccurrenceDefinition, Structure { |
|
derived ref item conjugatedPortDefinition : ConjugatedPortDefinition[0..1] subsets ownedMember; |
|
} |
|
|
|
metadata def PortUsage specializes OccurrenceUsage { |
|
derived ref item portDefinition : PortDefinition[0..*] ordered redefines occurrenceDefinition; |
|
} |
|
|
|
enum def PortionKind { |
|
enum 'timeslice'; |
|
enum 'snapshot'; |
|
} |
|
|
|
metadata def ReferenceUsage specializes Usage { |
|
derived attribute isReference : Boolean[1..1] redefines isReference; |
|
} |
|
|
|
metadata def RenderingDefinition specializes PartDefinition { |
|
derived ref item 'rendering' : RenderingUsage[0..*] ordered subsets usage; |
|
} |
|
|
|
metadata def RenderingUsage specializes PartUsage { |
|
derived ref item renderingDefinition : RenderingDefinition[0..1] redefines partDefinition; |
|
} |
|
|
|
enum def RequirementConstraintKind { |
|
enum assumption; |
|
enum 'requirement'; |
|
} |
|
|
|
metadata def RequirementConstraintMembership specializes FeatureMembership { |
|
attribute kind : RequirementConstraintKind[1..1]; |
|
|
|
derived item ownedConstraint : ConstraintUsage[1..1] redefines ownedMemberFeature; |
|
derived ref item referencedConstraint : ConstraintUsage[1..1]; |
|
} |
|
|
|
metadata def RequirementDefinition specializes ConstraintDefinition { |
|
attribute reqId : String[0..1] redefines declaredShortName; |
|
derived attribute text : String[0..*]; |
|
|
|
derived ref item subjectParameter : Usage[1..1] subsets parameter, usage; |
|
derived ref item actorParameter : PartUsage[0..*] ordered subsets usage, parameter; |
|
derived ref item stakeholderParameter : PartUsage[0..*] ordered subsets parameter, usage; |
|
derived ref item assumedConstraint : ConstraintUsage[0..*] ordered subsets ownedFeature; |
|
derived ref item requiredConstraint : ConstraintUsage[0..*] ordered subsets ownedFeature; |
|
derived ref item framedConcern : ConcernUsage[0..*] ordered subsets requiredConstraint; |
|
} |
|
|
|
metadata def RequirementUsage specializes ConstraintUsage { |
|
attribute reqId : String[0..1] redefines declaredShortName; |
|
derived attribute text : String[0..*]; |
|
|
|
derived ref item requirementDefinition : RequirementDefinition[0..1] redefines constraintDefinition; |
|
derived ref item requiredConstraint : ConstraintUsage[0..*] ordered subsets ownedFeature; |
|
derived ref item assumedConstraint : ConstraintUsage[0..*] ordered subsets ownedFeature; |
|
derived ref item subjectParameter : Usage[1..1] subsets parameter, usage; |
|
derived ref item framedConcern : ConcernUsage[0..*] ordered subsets requiredConstraint; |
|
derived ref item actorParameter : PartUsage[0..*] ordered subsets usage, parameter; |
|
derived ref item stakeholderParameter : PartUsage[0..*] ordered subsets parameter, usage; |
|
} |
|
|
|
metadata def RequirementVerificationMembership specializes RequirementConstraintMembership { |
|
attribute kind : RequirementConstraintKind[1..1] redefines kind; |
|
|
|
derived item ownedRequirement : RequirementUsage[1..1] redefines ownedConstraint; |
|
derived ref item verifiedRequirement : RequirementUsage[1..1] redefines referencedConstraint; |
|
} |
|
|
|
metadata def SatisfyRequirementUsage specializes RequirementUsage, AssertConstraintUsage { |
|
derived ref item satisfiedRequirement : RequirementUsage[1..1] redefines assertedConstraint; |
|
derived ref item satisfyingFeature : Feature[1..1]; |
|
} |
|
|
|
metadata def SendActionUsage specializes ActionUsage { |
|
derived ref item receiverArgument : Expression[0..1]; |
|
derived ref item payloadArgument : Expression[1..1]; |
|
derived ref item senderArgument : Expression[0..1]; |
|
} |
|
|
|
metadata def StakeholderMembership specializes ParameterMembership { |
|
derived item ownedStakeholderParameter : PartUsage[1..1] redefines ownedMemberParameter; |
|
} |
|
|
|
metadata def StateDefinition specializes ActionDefinition { |
|
attribute isParallel : Boolean[1..1]; |
|
|
|
derived ref item 'state' : StateUsage[0..*] ordered subsets 'action'; |
|
derived ref item entryAction : ActionUsage[0..1]; |
|
derived ref item doAction : ActionUsage[0..1]; |
|
derived ref item exitAction : ActionUsage[0..1]; |
|
} |
|
|
|
enum def StateSubactionKind { |
|
enum 'entry'; |
|
enum 'do'; |
|
enum 'exit'; |
|
} |
|
|
|
metadata def StateSubactionMembership specializes FeatureMembership { |
|
attribute kind : StateSubactionKind[1..1]; |
|
|
|
derived item 'action' : ActionUsage[1..1] redefines ownedMemberFeature; |
|
} |
|
|
|
metadata def StateUsage specializes ActionUsage { |
|
attribute isParallel : Boolean[1..1]; |
|
|
|
derived ref item stateDefinition : Behavior[0..*] ordered redefines actionDefinition; |
|
derived ref item entryAction : ActionUsage[0..1]; |
|
derived ref item doAction : ActionUsage[0..1]; |
|
derived ref item exitAction : ActionUsage[0..1]; |
|
} |
|
|
|
metadata def SubjectMembership specializes ParameterMembership { |
|
derived item ownedSubjectParameter : Usage[1..1] redefines ownedMemberParameter; |
|
} |
|
|
|
metadata def SuccessionAsUsage specializes ConnectorAsUsage, Succession; |
|
|
|
metadata def SuccessionFlowConnectionUsage specializes SuccessionItemFlow, FlowConnectionUsage; |
|
|
|
enum def TransitionFeatureKind { |
|
enum trigger; |
|
enum guard; |
|
enum effect; |
|
} |
|
|
|
metadata def TransitionFeatureMembership specializes FeatureMembership { |
|
attribute kind : TransitionFeatureKind[1..1]; |
|
|
|
derived item transitionFeature : Step[1..1] redefines ownedMemberFeature; |
|
} |
|
|
|
metadata def TransitionUsage specializes ActionUsage { |
|
derived ref item source : ActionUsage[1..1]; |
|
derived ref item target : ActionUsage[1..1]; |
|
derived ref item triggerAction : AcceptActionUsage[0..*] subsets ownedFeature; |
|
derived ref item guardExpression : Expression[0..*] subsets ownedFeature; |
|
derived ref item effectAction : ActionUsage[0..*] subsets feature; |
|
derived ref item 'succession' : Succession[1..1] subsets ownedMember; |
|
} |
|
|
|
metadata def TriggerInvocationExpression specializes InvocationExpression { |
|
attribute kind : TriggerKind[1..1]; |
|
} |
|
|
|
enum def TriggerKind { |
|
enum 'when'; |
|
enum 'at'; |
|
enum 'after'; |
|
} |
|
|
|
metadata def Usage specializes Feature { |
|
attribute isVariation : Boolean[1..1]; |
|
derived attribute isReference : Boolean[1..1]; |
|
|
|
derived ref item 'variant' : Usage[0..*] subsets ownedMember; |
|
derived item variantMembership : VariantMembership[0..*] subsets ownedMembership; |
|
derived ref item owningDefinition : Definition[0..1] subsets owningType; |
|
derived ref item owningUsage : Usage[0..1] subsets owningType; |
|
derived ref item definition : Classifier[0..*] ordered redefines type; |
|
derived ref item usage : Usage[0..*] ordered subsets feature; |
|
derived ref item directedUsage : Usage[0..*] ordered subsets usage, directedFeature; |
|
derived ref item nestedUsage : Usage[0..*] ordered subsets ownedFeature, usage; |
|
derived ref item nestedReference : ReferenceUsage[0..*] ordered subsets nestedUsage; |
|
derived ref item nestedAttribute : AttributeUsage[0..*] ordered subsets nestedUsage; |
|
derived ref item nestedEnumeration : EnumerationUsage[0..*] ordered subsets nestedAttribute; |
|
derived ref item nestedOccurrence : OccurrenceUsage[0..*] ordered subsets nestedUsage; |
|
derived ref item nestedItem : ItemUsage[0..*] ordered subsets nestedOccurrence; |
|
derived ref item nestedPart : PartUsage[0..*] ordered subsets nestedItem; |
|
derived ref item nestedPort : PortUsage[0..*] ordered subsets nestedUsage; |
|
derived ref item nestedConnection : ConnectorAsUsage[0..*] ordered subsets nestedPart; |
|
derived ref item nestedFlow : FlowConnectionUsage[0..*] subsets nestedConnection; |
|
derived ref item nestedInterface : InterfaceUsage[0..*] ordered subsets nestedConnection; |
|
derived ref item nestedAllocation : AllocationUsage[0..*] ordered subsets nestedConnection; |
|
derived ref item nestedAction : ActionUsage[0..*] ordered subsets nestedOccurrence; |
|
derived ref item nestedState : StateUsage[0..*] ordered subsets nestedAction; |
|
derived ref item nestedTransition : TransitionUsage[0..*] subsets nestedUsage; |
|
derived ref item nestedCalculation : CalculationUsage[0..*] ordered subsets nestedAction; |
|
derived ref item nestedConstraint : ConstraintUsage[0..*] ordered subsets nestedOccurrence; |
|
derived ref item nestedRequirement : RequirementUsage[0..*] ordered subsets nestedConstraint; |
|
derived ref item nestedConcern : ConcernUsage[0..*] subsets nestedRequirement; |
|
derived ref item nestedCase : CaseUsage[0..*] ordered subsets nestedCalculation; |
|
derived ref item nestedAnalysisCase : AnalysisCaseUsage[0..*] ordered subsets nestedCase; |
|
derived ref item nestedVerificationCase : VerificationCaseUsage[0..*] ordered subsets nestedCase; |
|
derived ref item nestedUseCase : UseCaseUsage[0..*] ordered subsets nestedCase; |
|
derived ref item nestedView : ViewUsage[0..*] ordered subsets nestedPart; |
|
derived ref item nestedViewpoint : ViewpointUsage[0..*] ordered subsets nestedRequirement; |
|
derived ref item nestedRendering : RenderingUsage[0..*] ordered subsets nestedPart; |
|
derived ref item nestedMetadata : MetadataUsage[0..*] ordered subsets nestedItem; |
|
} |
|
|
|
metadata def UseCaseDefinition specializes CaseDefinition { |
|
derived ref item includedUseCase : UseCaseUsage[0..*] ordered; |
|
} |
|
|
|
metadata def UseCaseUsage specializes CaseUsage { |
|
derived ref item useCaseDefinition : UseCaseDefinition[0..1] redefines caseDefinition; |
|
derived ref item includedUseCase : UseCaseUsage[0..*] ordered; |
|
} |
|
|
|
metadata def VariantMembership specializes OwningMembership { |
|
derived item ownedVariantUsage : Usage[1..1] redefines ownedMemberElement; |
|
} |
|
|
|
metadata def VerificationCaseDefinition specializes CaseDefinition { |
|
derived ref item verifiedRequirement : RequirementUsage[0..*] ordered; |
|
} |
|
|
|
metadata def VerificationCaseUsage specializes CaseUsage { |
|
derived ref item verificationCaseDefinition : VerificationCaseDefinition[0..1] subsets caseDefinition; |
|
derived ref item verifiedRequirement : RequirementUsage[0..*] ordered; |
|
} |
|
|
|
metadata def ViewDefinition specializes PartDefinition { |
|
derived ref item 'view' : ViewUsage[0..*] ordered subsets usage; |
|
derived ref item satisfiedViewpoint : ViewpointUsage[0..*] ordered subsets ownedRequirement; |
|
derived ref item viewRendering : RenderingUsage[0..1]; |
|
derived ref item viewCondition : Expression[0..*] ordered subsets ownedMember; |
|
} |
|
|
|
metadata def ViewRenderingMembership specializes FeatureMembership { |
|
derived item ownedRendering : RenderingUsage[1..1] redefines ownedMemberFeature; |
|
derived ref item referencedRendering : RenderingUsage[1..1]; |
|
} |
|
|
|
metadata def ViewUsage specializes PartUsage { |
|
derived ref item viewDefinition : ViewDefinition[0..1] redefines partDefinition; |
|
derived ref item satisfiedViewpoint : ViewpointUsage[0..*] ordered subsets nestedRequirement; |
|
derived ref item exposedElement : Element[0..*] ordered subsets member; |
|
derived ref item viewRendering : RenderingUsage[0..1]; |
|
derived ref item viewCondition : Expression[0..*] ordered subsets ownedMember; |
|
} |
|
|
|
metadata def ViewpointDefinition specializes RequirementDefinition { |
|
derived ref item viewpointStakeholder : PartUsage[0..*] ordered; |
|
} |
|
|
|
metadata def ViewpointUsage specializes RequirementUsage { |
|
derived ref item viewpointDefinition : ViewpointDefinition[0..1] redefines requirementDefinition; |
|
derived ref item viewpointStakeholder : PartUsage[0..*] ordered; |
|
} |
|
|
|
metadata def WhileLoopActionUsage specializes LoopActionUsage { |
|
derived ref item whileArgument : Expression[1..1]; |
|
derived ref item untilArgument : Expression[0..1]; |
|
} |
|
|
|
} |
|
|
|
} |
|
|
