blob: b5771f7f13a05392961ed8bedb53a2dd285df60b [file] [log] [blame]
<?xml version="1.0" encoding="UTF-8"?>
<xmi:XMI xmi:version="2.1" xmlns:xmi="http://schema.omg.org/spec/XMI/2.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:Ecore="http://www.eclipse.org/uml2/schemas/Ecore/5" xmlns:Standard="http://www.eclipse.org/uml2/schemas/Standard/1" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" xmlns:uml="http://www.eclipse.org/uml2/2.1.0/UML" xsi:schemaLocation="http://www.eclipse.org/uml2/schemas/Ecore/5 pathmap://UML_PROFILES/Ecore.profile.uml#_z1OFcHjqEdy8S4Cr8Rc_NA http://www.eclipse.org/uml2/schemas/Standard/1 pathmap://UML_PROFILES/Standard.profile.uml#_yzU58YinEdqtvbnfB2L_5w">
<uml:Model xmi:id="_0" name="uml">
<packageImport xmi:id="_packageImport.0">
<importedPackage xmi:type="uml:Model" href="Ecore.metamodel.uml#_0"/>
</packageImport>
<packagedElement xmi:type="uml:PrimitiveType" xmi:id="Integer" name="Integer" visibility="private">
<ownedComment xmi:id="Integer-_ownedComment.0" annotatedElement="Integer">
<body>An integer is a primitive type representing integer values.</body>
</ownedComment>
</packagedElement>
<packagedElement xmi:type="uml:PrimitiveType" xmi:id="Boolean" name="Boolean" visibility="private">
<ownedComment xmi:id="Boolean-_ownedComment.0" annotatedElement="Boolean">
<body>A Boolean type is used for logical expression, consisting of the predefined values true and false.</body>
</ownedComment>
</packagedElement>
<packagedElement xmi:type="uml:PrimitiveType" xmi:id="String" name="String" visibility="private">
<ownedComment xmi:id="String-_ownedComment.0" annotatedElement="String">
<body>A string is a sequence of characters in some suitable character set used to display information about the model. Character sets may include non-Roman alphabets and characters.</body>
</ownedComment>
</packagedElement>
<packagedElement xmi:type="uml:PrimitiveType" xmi:id="UnlimitedNatural" name="UnlimitedNatural" visibility="private">
<ownedComment xmi:id="UnlimitedNatural-_ownedComment.0" annotatedElement="UnlimitedNatural">
<body>An unlimited natural is a primitive type representing unlimited natural values.</body>
</ownedComment>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="Comment" name="Comment">
<ownedComment xmi:id="Comment-_ownedComment.0" annotatedElement="Comment">
<body>A comment is a textual annotation that can be attached to a set of elements.</body>
</ownedComment>
<generalization xmi:id="Comment-_generalization.0" general="Element"/>
<ownedAttribute xmi:id="Comment-body" name="body" type="String">
<ownedComment xmi:id="Comment-body-_ownedComment.0" annotatedElement="Comment-body">
<body>Specifies a string that is the comment.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Comment-body-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Comment-body-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="Comment-annotatedElement" name="annotatedElement" type="Element" association="A_annotatedElement_comment">
<ownedComment xmi:id="Comment-annotatedElement-_ownedComment.0" annotatedElement="Comment-annotatedElement">
<body>References the Element(s) being commented.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Comment-annotatedElement-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Comment-annotatedElement-_lowerValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="DirectedRelationship" name="DirectedRelationship" isAbstract="true">
<ownedComment xmi:id="DirectedRelationship-_ownedComment.0" annotatedElement="DirectedRelationship">
<body>A directed relationship represents a relationship between a collection of source model elements and a collection of target model elements.</body>
</ownedComment>
<generalization xmi:id="DirectedRelationship-_generalization.0" general="Relationship"/>
<ownedAttribute xmi:id="DirectedRelationship-source" name="source" type="Element" isReadOnly="true" isDerived="true" isDerivedUnion="true" subsettedProperty="Relationship-relatedElement" association="A_source_directedRelationship">
<ownedComment xmi:id="DirectedRelationship-source-_ownedComment.0" annotatedElement="DirectedRelationship-source">
<body>Specifies the sources of the DirectedRelationship.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DirectedRelationship-source-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DirectedRelationship-source-_lowerValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="DirectedRelationship-target" name="target" type="Element" isReadOnly="true" isDerived="true" isDerivedUnion="true" subsettedProperty="Relationship-relatedElement" association="A_target_directedRelationship">
<ownedComment xmi:id="DirectedRelationship-target-_ownedComment.0" annotatedElement="DirectedRelationship-target">
<body>Specifies the targets of the DirectedRelationship.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DirectedRelationship-target-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DirectedRelationship-target-_lowerValue" value="1"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="LiteralSpecification" name="LiteralSpecification" isAbstract="true">
<ownedComment xmi:id="LiteralSpecification-_ownedComment.0" annotatedElement="LiteralSpecification">
<body>A literal specification identifies a literal constant being modeled.</body>
</ownedComment>
<generalization xmi:id="LiteralSpecification-_generalization.0" general="ValueSpecification"/>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="LiteralInteger" name="LiteralInteger">
<ownedComment xmi:id="LiteralInteger-_ownedComment.0" annotatedElement="LiteralInteger">
<body>A literal integer is a specification of an integer value.</body>
</ownedComment>
<generalization xmi:id="LiteralInteger-_generalization.0" general="LiteralSpecification"/>
<ownedAttribute xmi:id="LiteralInteger-value" name="value" type="Integer">
<ownedComment xmi:id="LiteralInteger-value-_ownedComment.0" annotatedElement="LiteralInteger-value">
<body>The specified Integer value.</body>
</ownedComment>
<defaultValue xmi:type="uml:LiteralInteger" xmi:id="LiteralInteger-value-_defaultValue" type="Integer"/>
</ownedAttribute>
<ownedOperation xmi:id="LiteralInteger-stringValue" name="stringValue" visibility="protected" isQuery="true">
<ownedParameter xmi:id="LiteralInteger-stringValue-_ownedParameter.0" type="String" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="LiteralInteger-isComputable" name="isComputable" isQuery="true" redefinedOperation="ValueSpecification-isComputable" bodyCondition="LiteralInteger-isComputable-spec">
<ownedComment xmi:id="LiteralInteger-isComputable-_ownedComment.0" annotatedElement="LiteralInteger-isComputable">
<body>The query isComputable() is redefined to be true.</body>
</ownedComment>
<ownedRule xmi:id="LiteralInteger-isComputable-spec" name="spec" constrainedElement="LiteralInteger-isComputable">
<specification xmi:type="uml:OpaqueExpression" xmi:id="LiteralInteger-isComputable-spec-_specification">
<language>OCL</language>
<body>result = true</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="LiteralInteger-isComputable-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="LiteralInteger-integerValue" name="integerValue" isQuery="true" redefinedOperation="ValueSpecification-integerValue" bodyCondition="LiteralInteger-integerValue-spec">
<ownedComment xmi:id="LiteralInteger-integerValue-_ownedComment.0" annotatedElement="LiteralInteger-integerValue">
<body>The query integerValue() gives the value.</body>
</ownedComment>
<ownedRule xmi:id="LiteralInteger-integerValue-spec" name="spec" constrainedElement="LiteralInteger-integerValue">
<specification xmi:type="uml:OpaqueExpression" xmi:id="LiteralInteger-integerValue-spec-_specification">
<language>OCL</language>
<body>result = value</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="LiteralInteger-integerValue-_ownedParameter.0" type="Integer" direction="return"/>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="LiteralString" name="LiteralString">
<ownedComment xmi:id="LiteralString-_ownedComment.0" annotatedElement="LiteralString">
<body>A literal string is a specification of a string value.</body>
</ownedComment>
<generalization xmi:id="LiteralString-_generalization.0" general="LiteralSpecification"/>
<ownedAttribute xmi:id="LiteralString-value" name="value" type="String">
<ownedComment xmi:id="LiteralString-value-_ownedComment.0" annotatedElement="LiteralString-value">
<body>The specified String value.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="LiteralString-value-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="LiteralString-value-_lowerValue"/>
</ownedAttribute>
<ownedOperation xmi:id="LiteralString-integerValue" name="integerValue" visibility="protected" isQuery="true">
<ownedParameter xmi:id="LiteralString-integerValue-_ownedParameter.0" type="Integer" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="LiteralString-unlimitedValue" name="unlimitedValue" visibility="protected" isQuery="true">
<ownedParameter xmi:id="LiteralString-unlimitedValue-_ownedParameter.0" type="UnlimitedNatural" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="LiteralString-isComputable" name="isComputable" isQuery="true" redefinedOperation="ValueSpecification-isComputable" bodyCondition="LiteralString-isComputable-spec">
<ownedComment xmi:id="LiteralString-isComputable-_ownedComment.0" annotatedElement="LiteralString-isComputable">
<body>The query isComputable() is redefined to be true.</body>
</ownedComment>
<ownedRule xmi:id="LiteralString-isComputable-spec" name="spec" constrainedElement="LiteralString-isComputable">
<specification xmi:type="uml:OpaqueExpression" xmi:id="LiteralString-isComputable-spec-_specification">
<language>OCL</language>
<body>result = true</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="LiteralString-isComputable-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="LiteralString-stringValue" name="stringValue" isQuery="true" redefinedOperation="ValueSpecification-stringValue" bodyCondition="LiteralString-stringValue-spec">
<ownedComment xmi:id="LiteralString-stringValue-_ownedComment.0" annotatedElement="LiteralString-stringValue">
<body>The query stringValue() gives the value.</body>
</ownedComment>
<ownedRule xmi:id="LiteralString-stringValue-spec" name="spec" constrainedElement="LiteralString-stringValue">
<specification xmi:type="uml:OpaqueExpression" xmi:id="LiteralString-stringValue-spec-_specification">
<language>OCL</language>
<body>result = value</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="LiteralString-stringValue-_ownedParameter.0" type="String" direction="return"/>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="LiteralBoolean" name="LiteralBoolean">
<ownedComment xmi:id="LiteralBoolean-_ownedComment.0" annotatedElement="LiteralBoolean">
<body>A literal Boolean is a specification of a Boolean value.</body>
</ownedComment>
<generalization xmi:id="LiteralBoolean-_generalization.0" general="LiteralSpecification"/>
<ownedAttribute xmi:id="LiteralBoolean-value" name="value" type="Boolean">
<ownedComment xmi:id="LiteralBoolean-value-_ownedComment.0" annotatedElement="LiteralBoolean-value">
<body>The specified Boolean value.</body>
</ownedComment>
<defaultValue xmi:type="uml:LiteralBoolean" xmi:id="LiteralBoolean-value-_defaultValue" type="Boolean"/>
</ownedAttribute>
<ownedOperation xmi:id="LiteralBoolean-stringValue" name="stringValue" visibility="protected" isQuery="true">
<ownedParameter xmi:id="LiteralBoolean-stringValue-_ownedParameter.0" type="String" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="LiteralBoolean-isComputable" name="isComputable" isQuery="true" redefinedOperation="ValueSpecification-isComputable" bodyCondition="LiteralBoolean-isComputable-spec">
<ownedComment xmi:id="LiteralBoolean-isComputable-_ownedComment.0" annotatedElement="LiteralBoolean-isComputable">
<body>The query isComputable() is redefined to be true.</body>
</ownedComment>
<ownedRule xmi:id="LiteralBoolean-isComputable-spec" name="spec" constrainedElement="LiteralBoolean-isComputable">
<specification xmi:type="uml:OpaqueExpression" xmi:id="LiteralBoolean-isComputable-spec-_specification">
<language>OCL</language>
<body>result = true</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="LiteralBoolean-isComputable-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="LiteralBoolean-booleanValue" name="booleanValue" isQuery="true" redefinedOperation="ValueSpecification-booleanValue" bodyCondition="LiteralBoolean-booleanValue-spec">
<ownedComment xmi:id="LiteralBoolean-booleanValue-_ownedComment.0" annotatedElement="LiteralBoolean-booleanValue">
<body>The query booleanValue() gives the value.</body>
</ownedComment>
<ownedRule xmi:id="LiteralBoolean-booleanValue-spec" name="spec" constrainedElement="LiteralBoolean-booleanValue">
<specification xmi:type="uml:OpaqueExpression" xmi:id="LiteralBoolean-booleanValue-spec-_specification">
<language>OCL</language>
<body>result = value</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="LiteralBoolean-booleanValue-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="LiteralNull" name="LiteralNull">
<ownedComment xmi:id="LiteralNull-_ownedComment.0" annotatedElement="LiteralNull">
<body>A literal null specifies the lack of a value.</body>
</ownedComment>
<generalization xmi:id="LiteralNull-_generalization.0" general="LiteralSpecification"/>
<ownedOperation xmi:id="LiteralNull-isComputable" name="isComputable" isQuery="true" redefinedOperation="ValueSpecification-isComputable" bodyCondition="LiteralNull-isComputable-spec">
<ownedComment xmi:id="LiteralNull-isComputable-_ownedComment.0" annotatedElement="LiteralNull-isComputable">
<body>The query isComputable() is redefined to be true.</body>
</ownedComment>
<ownedRule xmi:id="LiteralNull-isComputable-spec" name="spec" constrainedElement="LiteralNull-isComputable">
<specification xmi:type="uml:OpaqueExpression" xmi:id="LiteralNull-isComputable-spec-_specification">
<language>OCL</language>
<body>result = true</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="LiteralNull-isComputable-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="LiteralNull-isNull" name="isNull" isQuery="true" redefinedOperation="ValueSpecification-isNull" bodyCondition="LiteralNull-isNull-spec">
<ownedComment xmi:id="LiteralNull-isNull-_ownedComment.0" annotatedElement="LiteralNull-isNull">
<body>The query isNull() returns true.</body>
</ownedComment>
<ownedRule xmi:id="LiteralNull-isNull-spec" name="spec" constrainedElement="LiteralNull-isNull">
<specification xmi:type="uml:OpaqueExpression" xmi:id="LiteralNull-isNull-spec-_specification">
<language>OCL</language>
<body>result = true</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="LiteralNull-isNull-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="Constraint" name="Constraint">
<ownedComment xmi:id="Constraint-_ownedComment.0" annotatedElement="Constraint">
<body>A constraint is a condition or restriction expressed in natural language text or in a machine readable language for the purpose of declaring some of the semantics of an element.</body>
</ownedComment>
<ownedRule xmi:id="Constraint-not_apply_to_self" name="not_apply_to_self" constrainedElement="Constraint">
<ownedComment xmi:id="Constraint-not_apply_to_self-_ownedComment.0" annotatedElement="Constraint-not_apply_to_self">
<body>A constraint cannot be applied to itself.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="Constraint-not_apply_to_self-_specification">
<language>OCL</language>
<body>not constrainedElement->includes(self)</body>
</specification>
</ownedRule>
<ownedRule xmi:id="Constraint-value_specification_boolean" name="value_specification_boolean" constrainedElement="Constraint">
<ownedComment xmi:id="Constraint-value_specification_boolean-_ownedComment.0" annotatedElement="Constraint-value_specification_boolean">
<body>The value specification for a constraint must evaluate to a Boolean value.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="Constraint-value_specification_boolean-_specification">
<language>OCL</language>
<body>self.specification().booleanValue().isOclKindOf(Boolean)</body>
</specification>
</ownedRule>
<ownedRule xmi:id="Constraint-boolean_value" name="boolean_value" constrainedElement="Constraint">
<ownedComment xmi:id="Constraint-boolean_value-_ownedComment.0" annotatedElement="Constraint-boolean_value">
<body>The value specification for a constraint must evaluate to a Boolean value.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="Constraint-boolean_value-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="Constraint-no_side_effects" name="no_side_effects" constrainedElement="Constraint">
<ownedComment xmi:id="Constraint-no_side_effects-_ownedComment.0" annotatedElement="Constraint-no_side_effects">
<body>Evaluating the value specification for a constraint must not have side effects.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="Constraint-no_side_effects-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="Constraint-not_applied_to_self" name="not_applied_to_self" constrainedElement="Constraint">
<ownedComment xmi:id="Constraint-not_applied_to_self-_ownedComment.0" annotatedElement="Constraint-not_applied_to_self">
<body>A constraint cannot be applied to itself.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="Constraint-not_applied_to_self-_specification">
<language>OCL</language>
<body>not constrainedElement->includes(self)</body>
</specification>
</ownedRule>
<generalization xmi:id="Constraint-_generalization.0" general="PackageableElement"/>
<ownedAttribute xmi:id="Constraint-constrainedElement" name="constrainedElement" type="Element" isOrdered="true" association="A_constrainedElement_constraint">
<ownedComment xmi:id="Constraint-constrainedElement-_ownedComment.0" annotatedElement="Constraint-constrainedElement">
<body>The ordered set of Elements referenced by this Constraint.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Constraint-constrainedElement-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Constraint-constrainedElement-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="Constraint-specification" name="specification" type="ValueSpecification" aggregation="composite" subsettedProperty="Element-ownedElement" association="A_specification_owningConstraint">
<ownedComment xmi:id="Constraint-specification-_ownedComment.0" annotatedElement="Constraint-specification">
<body>A condition that must be true when evaluated in order for the constraint to be satisfied.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Constraint-specification-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Constraint-specification-_lowerValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="Constraint-context" name="context" type="Namespace" subsettedProperty="NamedElement-namespace" association="A_ownedRule_context">
<ownedComment xmi:id="Constraint-context-_ownedComment.0" annotatedElement="Constraint-context">
<body>Specifies the namespace that owns the NamedElement.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Constraint-context-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Constraint-context-_lowerValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="ElementImport" name="ElementImport">
<ownedComment xmi:id="ElementImport-_ownedComment.0" annotatedElement="ElementImport">
<body>An element import identifies an element in another package, and allows the element to be referenced using its name without a qualifier.</body>
</ownedComment>
<ownedRule xmi:id="ElementImport-visibility_public_or_private" name="visibility_public_or_private" constrainedElement="ElementImport">
<ownedComment xmi:id="ElementImport-visibility_public_or_private-_ownedComment.0" annotatedElement="ElementImport-visibility_public_or_private">
<body>The visibility of an ElementImport is either public or private.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="ElementImport-visibility_public_or_private-_specification">
<language>OCL</language>
<body>self.visibility = #public or self.visibility = #private</body>
</specification>
</ownedRule>
<ownedRule xmi:id="ElementImport-imported_element_is_public" name="imported_element_is_public" constrainedElement="ElementImport">
<ownedComment xmi:id="ElementImport-imported_element_is_public-_ownedComment.0" annotatedElement="ElementImport-imported_element_is_public">
<body>An importedElement has either public visibility or no visibility at all.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="ElementImport-imported_element_is_public-_specification">
<language>OCL</language>
<body>self.importedElement.visibility.notEmpty() implies self.importedElement.visibility = #public</body>
</specification>
</ownedRule>
<generalization xmi:id="ElementImport-_generalization.0" general="DirectedRelationship"/>
<ownedAttribute xmi:id="ElementImport-visibility" name="visibility" type="VisibilityKind">
<ownedComment xmi:id="ElementImport-visibility-_ownedComment.0" annotatedElement="ElementImport-visibility">
<body>Specifies the visibility of the imported PackageableElement within the importing Package. The default visibility is the same as that of the imported element. If the imported element does not have a visibility, it is possible to add visibility to the element import.</body>
</ownedComment>
<defaultValue xmi:type="uml:InstanceValue" xmi:id="ElementImport-visibility-_defaultValue" type="VisibilityKind" instance="VisibilityKind-public"/>
</ownedAttribute>
<ownedAttribute xmi:id="ElementImport-alias" name="alias" type="String">
<ownedComment xmi:id="ElementImport-alias-_ownedComment.0" annotatedElement="ElementImport-alias">
<body>Specifies the name that should be added to the namespace of the importing package in lieu of the name of the imported packagable element. The aliased name must not clash with any other member name in the importing package. By default, no alias is used.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="ElementImport-alias-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="ElementImport-alias-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="ElementImport-importedElement" name="importedElement" type="PackageableElement" subsettedProperty="DirectedRelationship-target" association="A_importedElement_elementImport">
<ownedComment xmi:id="ElementImport-importedElement-_ownedComment.0" annotatedElement="ElementImport-importedElement">
<body>Specifies the PackageableElement whose name is to be added to a Namespace.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="ElementImport-importedElement-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="ElementImport-importedElement-_lowerValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="ElementImport-importingNamespace" name="importingNamespace" type="Namespace" subsettedProperty="DirectedRelationship-source Element-owner" association="A_elementImport_importingNamespace">
<ownedComment xmi:id="ElementImport-importingNamespace-_ownedComment.0" annotatedElement="ElementImport-importingNamespace">
<body>Specifies the Namespace that imports a PackageableElement from another Package.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="ElementImport-importingNamespace-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="ElementImport-importingNamespace-_lowerValue" value="1"/>
</ownedAttribute>
<ownedOperation xmi:id="ElementImport-getName" name="getName" isQuery="true" bodyCondition="ElementImport-getName-spec">
<ownedComment xmi:id="ElementImport-getName-_ownedComment.0" annotatedElement="ElementImport-getName">
<body>The query getName() returns the name under which the imported PackageableElement will be known in the importing namespace.</body>
</ownedComment>
<ownedRule xmi:id="ElementImport-getName-spec" name="spec" constrainedElement="ElementImport-getName">
<specification xmi:type="uml:OpaqueExpression" xmi:id="ElementImport-getName-spec-_specification">
<language>OCL</language>
<body>result = if self.alias->notEmpty() then&#xA; self.alias&#xA;else&#xA; self.importedElement.name&#xA;endif</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="ElementImport-getName-_ownedParameter.0" type="String" direction="return"/>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="TypedElement" name="TypedElement" isAbstract="true">
<ownedComment xmi:id="TypedElement-_ownedComment.0" annotatedElement="TypedElement">
<body>A typed element is a kind of named element that represents an element with a type.</body>
</ownedComment>
<ownedComment xmi:id="TypedElement-_ownedComment.1" annotatedElement="TypedElement">
<body>A typed element has a type.</body>
</ownedComment>
<generalization xmi:id="TypedElement-_generalization.0" general="NamedElement"/>
<ownedAttribute xmi:id="TypedElement-type" name="type" type="Type" association="A_type_typedElement">
<ownedComment xmi:id="TypedElement-type-_ownedComment.0" annotatedElement="TypedElement-type">
<body>This information is derived from the return result for this Operation.</body>
</ownedComment>
<ownedComment xmi:id="TypedElement-type-_ownedComment.1" annotatedElement="TypedElement-type">
<body>The type of the TypedElement.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="TypedElement-type-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="TypedElement-type-_lowerValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="Feature" name="Feature" isAbstract="true">
<ownedComment xmi:id="Feature-_ownedComment.0" annotatedElement="Feature">
<body>A feature declares a behavioral or structural characteristic of instances of classifiers.</body>
</ownedComment>
<generalization xmi:id="Feature-_generalization.0" general="RedefinableElement"/>
<ownedAttribute xmi:id="Feature-isStatic" name="isStatic" type="Boolean">
<ownedComment xmi:id="Feature-isStatic-_ownedComment.0" annotatedElement="Feature-isStatic">
<body>Specifies whether this feature characterizes individual instances classified by the classifier (false) or the classifier itself (true).</body>
</ownedComment>
<defaultValue xmi:type="uml:LiteralBoolean" xmi:id="Feature-isStatic-_defaultValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="Feature-featuringClassifier" name="featuringClassifier" type="Classifier" isReadOnly="true" isDerived="true" isDerivedUnion="true" association="A_feature_featuringClassifier">
<ownedComment xmi:id="Feature-featuringClassifier-_ownedComment.0" annotatedElement="Feature-featuringClassifier">
<body>The Classifiers that have this Feature as a feature.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Feature-featuringClassifier-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Feature-featuringClassifier-_lowerValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="RedefinableElement" name="RedefinableElement" isAbstract="true">
<ownedComment xmi:id="RedefinableElement-_ownedComment.0" annotatedElement="RedefinableElement">
<body>A redefinable element is an element that, when defined in the context of a classifier, can be redefined more specifically or differently in the context of another classifier that specializes (directly or indirectly) the context classifier.</body>
</ownedComment>
<ownedRule xmi:id="RedefinableElement-redefinition_context_valid" name="redefinition_context_valid" constrainedElement="RedefinableElement">
<ownedComment xmi:id="RedefinableElement-redefinition_context_valid-_ownedComment.0" annotatedElement="RedefinableElement-redefinition_context_valid">
<body>At least one of the redefinition contexts of the redefining element must be a specialization of at least one of the redefinition contexts for each redefined element.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="RedefinableElement-redefinition_context_valid-_specification">
<language>OCL</language>
<body>self.redefinedElement->forAll(e | self.isRedefinitionContextValid(e))</body>
</specification>
</ownedRule>
<ownedRule xmi:id="RedefinableElement-redefinition_consistent" name="redefinition_consistent" constrainedElement="RedefinableElement">
<ownedComment xmi:id="RedefinableElement-redefinition_consistent-_ownedComment.0" annotatedElement="RedefinableElement-redefinition_consistent">
<body>A redefining element must be consistent with each redefined element.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="RedefinableElement-redefinition_consistent-_specification">
<language>OCL</language>
<body>self.redefinedElement->forAll(re | re.isConsistentWith(self))</body>
</specification>
</ownedRule>
<generalization xmi:id="RedefinableElement-_generalization.0" general="NamedElement"/>
<ownedAttribute xmi:id="RedefinableElement-isLeaf" name="isLeaf" type="Boolean">
<ownedComment xmi:id="RedefinableElement-isLeaf-_ownedComment.0" annotatedElement="RedefinableElement-isLeaf">
<body>Indicates whether it is possible to further specialize a RedefinableElement. If the value is true, then it is not possible to further specialize the RedefinableElement.</body>
</ownedComment>
<defaultValue xmi:type="uml:LiteralBoolean" xmi:id="RedefinableElement-isLeaf-_defaultValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="RedefinableElement-redefinedElement" name="redefinedElement" type="RedefinableElement" isReadOnly="true" isDerived="true" isDerivedUnion="true" association="A_redefinedElement_redefinableElement">
<ownedComment xmi:id="RedefinableElement-redefinedElement-_ownedComment.0" annotatedElement="RedefinableElement-redefinedElement">
<body>The redefinable element that is being redefined by this element.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="RedefinableElement-redefinedElement-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="RedefinableElement-redefinedElement-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="RedefinableElement-redefinitionContext" name="redefinitionContext" type="Classifier" isReadOnly="true" isDerived="true" isDerivedUnion="true" association="A_redefinitionContext_redefinableElement">
<ownedComment xmi:id="RedefinableElement-redefinitionContext-_ownedComment.0" annotatedElement="RedefinableElement-redefinitionContext">
<body>References the contexts that this element may be redefined from.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="RedefinableElement-redefinitionContext-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="RedefinableElement-redefinitionContext-_lowerValue"/>
</ownedAttribute>
<ownedOperation xmi:id="RedefinableElement-isConsistentWith" name="isConsistentWith" isQuery="true" precondition="RedefinableElement-isConsistentWith-_ownedRule.0" bodyCondition="RedefinableElement-isConsistentWith-spec">
<ownedComment xmi:id="RedefinableElement-isConsistentWith-_ownedComment.0" annotatedElement="RedefinableElement-isConsistentWith">
<body>The query isConsistentWith() specifies, for any two RedefinableElements in a context in which redefinition is possible, whether redefinition would be logically consistent. By default, this is false; this operation must be overridden for subclasses of RedefinableElement to define the consistency conditions.</body>
</ownedComment>
<ownedRule xmi:id="RedefinableElement-isConsistentWith-_ownedRule.0" constrainedElement="RedefinableElement-isConsistentWith">
<specification xmi:type="uml:OpaqueExpression" xmi:id="RedefinableElement-isConsistentWith-_ownedRule.0-_specification">
<language>OCL</language>
<body>redefinee.isRedefinitionContextValid(self)</body>
</specification>
</ownedRule>
<ownedRule xmi:id="RedefinableElement-isConsistentWith-spec" name="spec" constrainedElement="RedefinableElement-isConsistentWith">
<specification xmi:type="uml:OpaqueExpression" xmi:id="RedefinableElement-isConsistentWith-spec-_specification">
<language>OCL</language>
<body>result = false</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="RedefinableElement-isConsistentWith-_ownedParameter.0" type="Boolean" direction="return"/>
<ownedParameter xmi:id="RedefinableElement-isConsistentWith-redefinee" name="redefinee" type="RedefinableElement"/>
</ownedOperation>
<ownedOperation xmi:id="RedefinableElement-isRedefinitionContextValid" name="isRedefinitionContextValid" isQuery="true" bodyCondition="RedefinableElement-isRedefinitionContextValid-spec">
<ownedComment xmi:id="RedefinableElement-isRedefinitionContextValid-_ownedComment.0" annotatedElement="RedefinableElement-isRedefinitionContextValid">
<body>The query isRedefinitionContextValid() specifies whether the redefinition contexts of this RedefinableElement are properly related to the redefinition contexts of the specified RedefinableElement to allow this element to redefine the other. By default at least one of the redefinition contexts of this element must be a specialization of at least one of the redefinition contexts of the specified element.</body>
</ownedComment>
<ownedRule xmi:id="RedefinableElement-isRedefinitionContextValid-spec" name="spec" constrainedElement="RedefinableElement-isRedefinitionContextValid">
<specification xmi:type="uml:OpaqueExpression" xmi:id="RedefinableElement-isRedefinitionContextValid-spec-_specification">
<language>OCL</language>
<body>result = redefinitionContext->exists(c | c.allParents()->includes(redefined.redefinitionContext)))</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="RedefinableElement-isRedefinitionContextValid-_ownedParameter.0" type="Boolean" direction="return"/>
<ownedParameter xmi:id="RedefinableElement-isRedefinitionContextValid-redefined" name="redefined" type="RedefinableElement" effect="read"/>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="StructuralFeature" name="StructuralFeature" isAbstract="true">
<ownedComment xmi:id="StructuralFeature-_ownedComment.0" annotatedElement="StructuralFeature">
<body>A structural feature is a typed feature of a classifier that specifies the structure of instances of the classifier.</body>
</ownedComment>
<ownedComment xmi:id="StructuralFeature-_ownedComment.1" annotatedElement="StructuralFeature">
<body>By specializing multiplicity element, it supports a multiplicity that specifies valid cardinalities for the collection of values associated with an instantiation of the structural feature.</body>
</ownedComment>
<generalization xmi:id="StructuralFeature-_generalization.0" general="Feature"/>
<generalization xmi:id="StructuralFeature-_generalization.1" general="TypedElement"/>
<generalization xmi:id="StructuralFeature-_generalization.2" general="MultiplicityElement"/>
<ownedAttribute xmi:id="StructuralFeature-isReadOnly" name="isReadOnly" type="Boolean">
<ownedComment xmi:id="StructuralFeature-isReadOnly-_ownedComment.0" annotatedElement="StructuralFeature-isReadOnly">
<body>States whether the feature's value may be modified by a client.</body>
</ownedComment>
<defaultValue xmi:type="uml:LiteralBoolean" xmi:id="StructuralFeature-isReadOnly-_defaultValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="Slot" name="Slot">
<ownedComment xmi:id="Slot-_ownedComment.0" annotatedElement="Slot">
<body>A slot specifies that an entity modeled by an instance specification has a value or values for a specific structural feature.</body>
</ownedComment>
<generalization xmi:id="Slot-_generalization.0" general="Element"/>
<ownedAttribute xmi:id="Slot-owningInstance" name="owningInstance" type="InstanceSpecification" subsettedProperty="Element-owner" association="A_slot_owningInstance">
<ownedComment xmi:id="Slot-owningInstance-_ownedComment.0" annotatedElement="Slot-owningInstance">
<body>The instance specification that owns this slot.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Slot-owningInstance-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Slot-owningInstance-_lowerValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="Slot-definingFeature" name="definingFeature" type="StructuralFeature" association="A_definingFeature_slot">
<ownedComment xmi:id="Slot-definingFeature-_ownedComment.0" annotatedElement="Slot-definingFeature">
<body>The structural feature that specifies the values that may be held by the slot.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Slot-definingFeature-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Slot-definingFeature-_lowerValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="Slot-value" name="value" type="ValueSpecification" isOrdered="true" aggregation="composite" subsettedProperty="Element-ownedElement" association="A_value_owningSlot">
<ownedComment xmi:id="Slot-value-_ownedComment.0" annotatedElement="Slot-value">
<body>The value or values corresponding to the defining feature for the owning instance specification.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Slot-value-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Slot-value-_lowerValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="PackageImport" name="PackageImport">
<ownedComment xmi:id="PackageImport-_ownedComment.0" annotatedElement="PackageImport">
<body>A package import is a relationship that allows the use of unqualified names to refer to package members from other namespaces.</body>
</ownedComment>
<ownedRule xmi:id="PackageImport-public_or_private" name="public_or_private" constrainedElement="PackageImport">
<ownedComment xmi:id="PackageImport-public_or_private-_ownedComment.0" annotatedElement="PackageImport-public_or_private">
<body>The visibility of a PackageImport is either public or private.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="PackageImport-public_or_private-_specification">
<language>OCL</language>
<body>self.visibility = #public or self.visibility = #private</body>
</specification>
</ownedRule>
<generalization xmi:id="PackageImport-_generalization.0" general="DirectedRelationship"/>
<ownedAttribute xmi:id="PackageImport-visibility" name="visibility" type="VisibilityKind">
<ownedComment xmi:id="PackageImport-visibility-_ownedComment.0" annotatedElement="PackageImport-visibility">
<body>Specifies the visibility of the imported PackageableElements within the importing Namespace, i.e., whether imported elements will in turn be visible to other packages that use that importingPackage as an importedPackage. If the PackageImport is public, the imported elements will be visible outside the package, while if it is private they will not.</body>
</ownedComment>
<defaultValue xmi:type="uml:InstanceValue" xmi:id="PackageImport-visibility-_defaultValue" type="VisibilityKind" instance="VisibilityKind-public"/>
</ownedAttribute>
<ownedAttribute xmi:id="PackageImport-importingNamespace" name="importingNamespace" type="Namespace" subsettedProperty="DirectedRelationship-source Element-owner" association="A_packageImport_importingNamespace">
<ownedComment xmi:id="PackageImport-importingNamespace-_ownedComment.0" annotatedElement="PackageImport-importingNamespace">
<body>Specifies the Namespace that imports the members from a Package.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="PackageImport-importingNamespace-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="PackageImport-importingNamespace-_lowerValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="PackageImport-importedPackage" name="importedPackage" type="Package" subsettedProperty="DirectedRelationship-target" association="A_importedPackage_packageImport">
<ownedComment xmi:id="PackageImport-importedPackage-_ownedComment.0" annotatedElement="PackageImport-importedPackage">
<body>Specifies the Package whose members are imported into a Namespace.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="PackageImport-importedPackage-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="PackageImport-importedPackage-_lowerValue" value="1"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="DataType" name="DataType">
<ownedComment xmi:id="DataType-_ownedComment.0" annotatedElement="DataType">
<body>A data type is a type whose instances are identified only by their value. A data type may contain attributes to support the modeling of structured data types.</body>
</ownedComment>
<generalization xmi:id="DataType-_generalization.0" general="Classifier"/>
<ownedAttribute xmi:id="DataType-ownedAttribute" name="ownedAttribute" type="Property" isOrdered="true" aggregation="composite" subsettedProperty="Classifier-attribute Namespace-ownedMember" association="A_ownedAttribute_datatype">
<ownedComment xmi:id="DataType-ownedAttribute-_ownedComment.0" annotatedElement="DataType-ownedAttribute">
<body>The Attributes owned by the DataType.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DataType-ownedAttribute-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DataType-ownedAttribute-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="DataType-ownedOperation" name="ownedOperation" type="Operation" isOrdered="true" aggregation="composite" subsettedProperty="Classifier-feature Namespace-ownedMember" association="A_ownedOperation_datatype">
<ownedComment xmi:id="DataType-ownedOperation-_ownedComment.0" annotatedElement="DataType-ownedOperation">
<body>The Operations owned by the DataType.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DataType-ownedOperation-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DataType-ownedOperation-_lowerValue"/>
</ownedAttribute>
<ownedOperation xmi:id="DataType-createOwnedOperation" name="createOwnedOperation">
<ownedComment xmi:id="DataType-createOwnedOperation-_ownedComment.0" annotatedElement="DataType-createOwnedOperation">
<body>Creates an operation with the specified name, parameter names, parameter types, and return type (or null) as an owned operation of this data type.</body>
</ownedComment>
<ownedParameter xmi:id="DataType-createOwnedOperation-_ownedParameter.0" type="Operation" direction="return"/>
<ownedParameter xmi:id="DataType-createOwnedOperation-name" name="name" type="String" effect="read">
<ownedComment xmi:id="DataType-createOwnedOperation-name-_ownedComment.0" annotatedElement="DataType-createOwnedOperation-name">
<body>The name for the new operation, or null.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DataType-createOwnedOperation-name-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DataType-createOwnedOperation-name-_lowerValue"/>
</ownedParameter>
<ownedParameter xmi:id="DataType-createOwnedOperation-parameterNames" name="parameterNames" type="String" effect="read">
<ownedComment xmi:id="DataType-createOwnedOperation-parameterNames-_ownedComment.0" annotatedElement="DataType-createOwnedOperation-parameterNames">
<body>The parameter names for the new operation, or null.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DataType-createOwnedOperation-parameterNames-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DataType-createOwnedOperation-parameterNames-_lowerValue"/>
</ownedParameter>
<ownedParameter xmi:id="DataType-createOwnedOperation-parameterTypes" name="parameterTypes" type="Type" effect="read">
<ownedComment xmi:id="DataType-createOwnedOperation-parameterTypes-_ownedComment.0" annotatedElement="DataType-createOwnedOperation-parameterTypes">
<body>The parameter types for the new operation, or null.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DataType-createOwnedOperation-parameterTypes-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DataType-createOwnedOperation-parameterTypes-_lowerValue"/>
</ownedParameter>
<ownedParameter xmi:id="DataType-createOwnedOperation-returnType" name="returnType" type="Type" effect="read">
<ownedComment xmi:id="DataType-createOwnedOperation-returnType-_ownedComment.0" annotatedElement="DataType-createOwnedOperation-returnType">
<body>The return type for the new operation, or null.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DataType-createOwnedOperation-returnType-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DataType-createOwnedOperation-returnType-_lowerValue"/>
</ownedParameter>
</ownedOperation>
<ownedOperation xmi:id="DataType-createOwnedAttribute" name="createOwnedAttribute">
<ownedComment xmi:id="DataType-createOwnedAttribute-_ownedComment.0" annotatedElement="DataType-createOwnedAttribute">
<body>Creates a property with the specified name, type, lower bound, and upper bound as an owned attribute of this data type.</body>
</ownedComment>
<ownedParameter xmi:id="DataType-createOwnedAttribute-_ownedParameter.0" type="Property" direction="return"/>
<ownedParameter xmi:id="DataType-createOwnedAttribute-name" name="name" type="String" effect="read">
<ownedComment xmi:id="DataType-createOwnedAttribute-name-_ownedComment.0" annotatedElement="DataType-createOwnedAttribute-name">
<body>The name for the new attribute, or null.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DataType-createOwnedAttribute-name-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DataType-createOwnedAttribute-name-_lowerValue"/>
</ownedParameter>
<ownedParameter xmi:id="DataType-createOwnedAttribute-type" name="type" type="Type" effect="read">
<ownedComment xmi:id="DataType-createOwnedAttribute-type-_ownedComment.0" annotatedElement="DataType-createOwnedAttribute-type">
<body>The type for the new attribute, or null.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DataType-createOwnedAttribute-type-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DataType-createOwnedAttribute-type-_lowerValue"/>
</ownedParameter>
<ownedParameter xmi:id="DataType-createOwnedAttribute-lower" name="lower" type="Integer" effect="read">
<ownedComment xmi:id="DataType-createOwnedAttribute-lower-_ownedComment.0" annotatedElement="DataType-createOwnedAttribute-lower">
<body>The lower bound for the new attribute.</body>
</ownedComment>
</ownedParameter>
<ownedParameter xmi:id="DataType-createOwnedAttribute-upper" name="upper" type="UnlimitedNatural" effect="read">
<ownedComment xmi:id="DataType-createOwnedAttribute-upper-_ownedComment.0" annotatedElement="DataType-createOwnedAttribute-upper">
<body>The upper bound for the new attribute.</body>
</ownedComment>
</ownedParameter>
</ownedOperation>
<ownedOperation xmi:id="DataType-inherit" name="inherit" isQuery="true" redefinedOperation="Classifier-inherit" bodyCondition="DataType-inherit-spec">
<ownedComment xmi:id="DataType-inherit-_ownedComment.0" annotatedElement="DataType-inherit">
<body>The inherit operation is overridden to exclude redefined properties.</body>
</ownedComment>
<ownedRule xmi:id="DataType-inherit-spec" name="spec" constrainedElement="DataType-inherit">
<specification xmi:type="uml:OpaqueExpression" xmi:id="DataType-inherit-spec-_specification">
<language>OCL</language>
<body>result = inhs->excluding(inh | ownedMember->select(oclIsKindOf(RedefinableElement))->select(redefinedElement->includes(inh)))</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="DataType-inherit-_ownedParameter.0" type="NamedElement" direction="return">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DataType-inherit-_ownedParameter.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DataType-inherit-_ownedParameter.0-_lowerValue"/>
</ownedParameter>
<ownedParameter xmi:id="DataType-inherit-inhs" name="inhs" type="NamedElement">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="DataType-inherit-inhs-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="DataType-inherit-inhs-_lowerValue"/>
</ownedParameter>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="Enumeration" name="Enumeration">
<ownedComment xmi:id="Enumeration-_ownedComment.0" annotatedElement="Enumeration">
<body>An enumeration is a data type whose values are enumerated in the model as enumeration literals.</body>
</ownedComment>
<generalization xmi:id="Enumeration-_generalization.0" general="DataType"/>
<ownedAttribute xmi:id="Enumeration-ownedLiteral" name="ownedLiteral" type="EnumerationLiteral" isOrdered="true" aggregation="composite" subsettedProperty="Namespace-ownedMember" association="A_ownedLiteral_enumeration">
<ownedComment xmi:id="Enumeration-ownedLiteral-_ownedComment.0" annotatedElement="Enumeration-ownedLiteral">
<body>The ordered set of literals for this Enumeration.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Enumeration-ownedLiteral-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Enumeration-ownedLiteral-_lowerValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="EnumerationLiteral" name="EnumerationLiteral">
<ownedComment xmi:id="EnumerationLiteral-_ownedComment.0" annotatedElement="EnumerationLiteral">
<body>An enumeration literal is a user-defined data value for an enumeration.</body>
</ownedComment>
<generalization xmi:id="EnumerationLiteral-_generalization.0" general="InstanceSpecification"/>
<ownedAttribute xmi:id="EnumerationLiteral-enumeration" name="enumeration" type="Enumeration" subsettedProperty="NamedElement-namespace" association="A_ownedLiteral_enumeration">
<ownedComment xmi:id="EnumerationLiteral-enumeration-_ownedComment.0" annotatedElement="EnumerationLiteral-enumeration">
<body>The Enumeration that this EnumerationLiteral is a member of.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="EnumerationLiteral-enumeration-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="EnumerationLiteral-enumeration-_lowerValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="PrimitiveType" name="PrimitiveType">
<ownedComment xmi:id="PrimitiveType-_ownedComment.0" annotatedElement="PrimitiveType">
<body>A primitive type defines a predefined data type, without any relevant substructure (i.e., it has no parts in the context of UML). A primitive datatype may have an algebra and operations defined outside of UML, for example, mathematically.</body>
</ownedComment>
<generalization xmi:id="PrimitiveType-_generalization.0" general="DataType"/>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="Association" name="Association">
<ownedComment xmi:id="Association-_ownedComment.0" annotatedElement="Association">
<body>An association describes a set of tuples whose values refer to typed instances. An instance of an association is called a link.</body>
</ownedComment>
<ownedRule xmi:id="Association-specialized_end_number" name="specialized_end_number" constrainedElement="Association">
<ownedComment xmi:id="Association-specialized_end_number-_ownedComment.0" annotatedElement="Association-specialized_end_number">
<body>An association specializing another association has the same number of ends as the other association.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="Association-specialized_end_number-_specification">
<language>OCL</language>
<body>self.parents()->forAll(p | p.memberEnd.size() = self.memberEnd.size())</body>
</specification>
</ownedRule>
<ownedRule xmi:id="Association-specialized_end_types" name="specialized_end_types" constrainedElement="Association">
<ownedComment xmi:id="Association-specialized_end_types-_ownedComment.0" annotatedElement="Association-specialized_end_types">
<body>When an association specializes another association, every end of the specific association corresponds to an end of the general association, and the specific end reaches the same type or a subtype of the more general end.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="Association-specialized_end_types-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="Association-binary_associations" name="binary_associations" constrainedElement="Association">
<ownedComment xmi:id="Association-binary_associations-_ownedComment.0" annotatedElement="Association-binary_associations">
<body>Only binary associations can be aggregations.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="Association-binary_associations-_specification">
<language>OCL</language>
<body>self.memberEnd->exists(aggregation &lt;> Aggregation::none) implies self.memberEnd->size() = 2</body>
</specification>
</ownedRule>
<ownedRule xmi:id="Association-association_ends" name="association_ends" constrainedElement="Association">
<ownedComment xmi:id="Association-association_ends-_ownedComment.0" annotatedElement="Association-association_ends">
<body>Association ends of associations with more than two ends must be owned by the association.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="Association-association_ends-_specification">
<language>OCL</language>
<body>if memberEnd->size() > 2 then ownedEnd->includesAll(memberEnd)</body>
</specification>
</ownedRule>
<generalization xmi:id="Association-_generalization.0" general="Relationship"/>
<generalization xmi:id="Association-_generalization.1" general="Classifier"/>
<ownedAttribute xmi:id="Association-isDerived" name="isDerived" type="Boolean">
<ownedComment xmi:id="Association-isDerived-_ownedComment.0" annotatedElement="Association-isDerived">
<body>Specifies whether the association is derived from other model elements such as other associations or constraints.</body>
</ownedComment>
<defaultValue xmi:type="uml:LiteralBoolean" xmi:id="Association-isDerived-_defaultValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="Association-ownedEnd" name="ownedEnd" type="Property" isOrdered="true" aggregation="composite" subsettedProperty="Association-memberEnd Classifier-feature Namespace-ownedMember" association="A_ownedEnd_owningAssociation">
<ownedComment xmi:id="Association-ownedEnd-_ownedComment.0" annotatedElement="Association-ownedEnd">
<body>The ends that are owned by the association itself.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Association-ownedEnd-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Association-ownedEnd-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="Association-endType" name="endType" type="Type" isOrdered="true" isReadOnly="true" isDerived="true" subsettedProperty="Relationship-relatedElement" association="A_endType_association">
<ownedComment xmi:id="Association-endType-_ownedComment.0" annotatedElement="Association-endType">
<body>References the classifiers that are used as types of the ends of the association.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Association-endType-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Association-endType-_lowerValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="Association-memberEnd" name="memberEnd" type="Property" isOrdered="true" subsettedProperty="Namespace-member" association="A_memberEnd_association">
<ownedComment xmi:id="Association-memberEnd-_ownedComment.0" annotatedElement="Association-memberEnd">
<body>Each end represents participation of instances of the classifier connected to the end in links of the association.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Association-memberEnd-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Association-memberEnd-_lowerValue" value="2"/>
</ownedAttribute>
<ownedAttribute xmi:id="Association-navigableOwnedEnd" name="navigableOwnedEnd" type="Property" subsettedProperty="Association-ownedEnd" association="A_navigableOwnedEnd_association">
<ownedComment xmi:id="Association-navigableOwnedEnd-_ownedComment.0" annotatedElement="Association-navigableOwnedEnd">
<body>The navigable ends that are owned by the association itself.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Association-navigableOwnedEnd-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Association-navigableOwnedEnd-_lowerValue"/>
</ownedAttribute>
<ownedOperation xmi:id="Association-isBinary" name="isBinary">
<ownedComment xmi:id="Association-isBinary-_ownedComment.0" annotatedElement="Association-isBinary">
<body>Determines whether this association is a binary association, i.e. whether it has exactly two member ends.</body>
</ownedComment>
<ownedParameter xmi:id="Association-isBinary-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="Association-endType.1" name="endType" isQuery="true" bodyCondition="Association-endType.1-spec">
<ownedComment xmi:id="Association-endType.1-_ownedComment.0" annotatedElement="Association-endType.1">
<body>endType is derived from the types of the member ends.</body>
</ownedComment>
<ownedRule xmi:id="Association-endType.1-spec" name="spec" constrainedElement="Association-endType.1 Association-endType">
<specification xmi:type="uml:OpaqueExpression" xmi:id="Association-endType.1-spec-_specification">
<language>OCL</language>
<body>result = self.memberEnd->collect(e | e.type)</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="Association-endType.1-_ownedParameter.0" type="Type" isOrdered="true" direction="return">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Association-endType.1-_ownedParameter.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Association-endType.1-_ownedParameter.0-_lowerValue"/>
</ownedParameter>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="Relationship" name="Relationship" isAbstract="true">
<ownedComment xmi:id="Relationship-_ownedComment.0" annotatedElement="Relationship">
<body>Relationship is an abstract concept that specifies some kind of relationship between elements.</body>
</ownedComment>
<generalization xmi:id="Relationship-_generalization.0" general="Element"/>
<ownedAttribute xmi:id="Relationship-relatedElement" name="relatedElement" type="Element" isReadOnly="true" isDerived="true" isDerivedUnion="true" association="A_relatedElement_relationship">
<ownedComment xmi:id="Relationship-relatedElement-_ownedComment.0" annotatedElement="Relationship-relatedElement">
<body>Specifies the elements related by the Relationship.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Relationship-relatedElement-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Relationship-relatedElement-_lowerValue" value="1"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="PackageMerge" name="PackageMerge">
<ownedComment xmi:id="PackageMerge-_ownedComment.0" annotatedElement="PackageMerge">
<body>A package merge defines how the contents of one package are extended by the contents of another package.</body>
</ownedComment>
<generalization xmi:id="PackageMerge-_generalization.0" general="DirectedRelationship"/>
<ownedAttribute xmi:id="PackageMerge-receivingPackage" name="receivingPackage" type="Package" subsettedProperty="DirectedRelationship-source Element-owner" association="A_receivingPackage_packageMerge">
<ownedComment xmi:id="PackageMerge-receivingPackage-_ownedComment.0" annotatedElement="PackageMerge-receivingPackage">
<body>References the Package that is being extended with the contents of the merged package of the PackageMerge.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="PackageMerge-receivingPackage-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="PackageMerge-receivingPackage-_lowerValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="PackageMerge-mergedPackage" name="mergedPackage" type="Package" subsettedProperty="DirectedRelationship-target" association="A_mergedPackage_packageMerge">
<ownedComment xmi:id="PackageMerge-mergedPackage-_ownedComment.0" annotatedElement="PackageMerge-mergedPackage">
<body>References the Package that is to be merged with the receiving package of the PackageMerge.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="PackageMerge-mergedPackage-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="PackageMerge-mergedPackage-_lowerValue" value="1"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="InstanceValue" name="InstanceValue">
<ownedComment xmi:id="InstanceValue-_ownedComment.0" annotatedElement="InstanceValue">
<body>An instance value is a value specification that identifies an instance.</body>
</ownedComment>
<generalization xmi:id="InstanceValue-_generalization.0" general="ValueSpecification"/>
<ownedAttribute xmi:id="InstanceValue-instance" name="instance" type="InstanceSpecification" association="A_instance_instanceValue">
<ownedComment xmi:id="InstanceValue-instance-_ownedComment.0" annotatedElement="InstanceValue-instance">
<body>The instance that is the specified value.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="InstanceValue-instance-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="InstanceValue-instance-_lowerValue" value="1"/>
</ownedAttribute>
<ownedOperation xmi:id="InstanceValue-stringValue" name="stringValue" visibility="protected" isQuery="true">
<ownedParameter xmi:id="InstanceValue-stringValue-_ownedParameter.0" type="String" direction="return"/>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="LiteralUnlimitedNatural" name="LiteralUnlimitedNatural">
<ownedComment xmi:id="LiteralUnlimitedNatural-_ownedComment.0" annotatedElement="LiteralUnlimitedNatural">
<body>A literal unlimited natural is a specification of an unlimited natural number.</body>
</ownedComment>
<generalization xmi:id="LiteralUnlimitedNatural-_generalization.0" general="LiteralSpecification"/>
<ownedAttribute xmi:id="LiteralUnlimitedNatural-value" name="value" type="UnlimitedNatural">
<ownedComment xmi:id="LiteralUnlimitedNatural-value-_ownedComment.0" annotatedElement="LiteralUnlimitedNatural-value">
<body>The specified UnlimitedNatural value.</body>
</ownedComment>
<defaultValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="LiteralUnlimitedNatural-value-_defaultValue" type="UnlimitedNatural"/>
</ownedAttribute>
<ownedOperation xmi:id="LiteralUnlimitedNatural-stringValue" name="stringValue" visibility="protected" isQuery="true">
<ownedParameter xmi:id="LiteralUnlimitedNatural-stringValue-_ownedParameter.0" type="String" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="LiteralUnlimitedNatural-isComputable" name="isComputable" isQuery="true" redefinedOperation="ValueSpecification-isComputable" bodyCondition="LiteralUnlimitedNatural-isComputable-spec">
<ownedComment xmi:id="LiteralUnlimitedNatural-isComputable-_ownedComment.0" annotatedElement="LiteralUnlimitedNatural-isComputable">
<body>The query isComputable() is redefined to be true.</body>
</ownedComment>
<ownedRule xmi:id="LiteralUnlimitedNatural-isComputable-spec" name="spec" constrainedElement="LiteralUnlimitedNatural-isComputable">
<specification xmi:type="uml:OpaqueExpression" xmi:id="LiteralUnlimitedNatural-isComputable-spec-_specification">
<language>OCL</language>
<body>result = true</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="LiteralUnlimitedNatural-isComputable-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="LiteralUnlimitedNatural-unlimitedValue" name="unlimitedValue" isQuery="true" redefinedOperation="ValueSpecification-unlimitedValue" bodyCondition="LiteralUnlimitedNatural-unlimitedValue-spec">
<ownedComment xmi:id="LiteralUnlimitedNatural-unlimitedValue-_ownedComment.0" annotatedElement="LiteralUnlimitedNatural-unlimitedValue">
<body>The query unlimitedValue() gives the value.</body>
</ownedComment>
<ownedRule xmi:id="LiteralUnlimitedNatural-unlimitedValue-spec" name="spec" constrainedElement="LiteralUnlimitedNatural-unlimitedValue">
<specification xmi:type="uml:OpaqueExpression" xmi:id="LiteralUnlimitedNatural-unlimitedValue-spec-_specification">
<language>OCL</language>
<body>result = value</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="LiteralUnlimitedNatural-unlimitedValue-_ownedParameter.0" type="UnlimitedNatural" direction="return"/>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="Type" name="Type" isAbstract="true">
<ownedComment xmi:id="Type-_ownedComment.0" annotatedElement="Type">
<body>A type is a named element that is used as the type for a typed element. A type can be contained in a package.</body>
</ownedComment>
<ownedComment xmi:id="Type-_ownedComment.1" annotatedElement="Type">
<body>A type constrains the values represented by a typed element.</body>
</ownedComment>
<generalization xmi:id="Type-_generalization.0" general="PackageableElement"/>
<ownedAttribute xmi:id="Type-package" name="package" type="Package" subsettedProperty="NamedElement-namespace" association="A_ownedType_package">
<ownedComment xmi:id="Type-package-_ownedComment.0" annotatedElement="Type-package">
<body>Specifies the owning package of this classifier, if any.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Type-package-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Type-package-_lowerValue"/>
</ownedAttribute>
<ownedOperation xmi:id="Type-createAssociation" name="createAssociation">
<ownedComment xmi:id="Type-createAssociation-_ownedComment.0" annotatedElement="Type-createAssociation">
<body>Creates a(n) (binary) association between this type and the specified other type, with the specified navigabilities, aggregations, names, lower bounds, and upper bounds, and owned by this type's nearest package.</body>
</ownedComment>
<ownedParameter xmi:id="Type-createAssociation-_ownedParameter.0" type="Association" direction="return"/>
<ownedParameter xmi:id="Type-createAssociation-end1IsNavigable" name="end1IsNavigable" type="Boolean" effect="read">
<ownedComment xmi:id="Type-createAssociation-end1IsNavigable-_ownedComment.0" annotatedElement="Type-createAssociation-end1IsNavigable">
<body>The navigability for the first end of the new association.</body>
</ownedComment>
</ownedParameter>
<ownedParameter xmi:id="Type-createAssociation-end1Aggregation" name="end1Aggregation" type="AggregationKind" effect="read">
<ownedComment xmi:id="Type-createAssociation-end1Aggregation-_ownedComment.0" annotatedElement="Type-createAssociation-end1Aggregation">
<body>The aggregation for the first end of the new association.</body>
</ownedComment>
</ownedParameter>
<ownedParameter xmi:id="Type-createAssociation-end1Name" name="end1Name" type="String" effect="read">
<ownedComment xmi:id="Type-createAssociation-end1Name-_ownedComment.0" annotatedElement="Type-createAssociation-end1Name">
<body>The name for the first end of the new association.</body>
</ownedComment>
</ownedParameter>
<ownedParameter xmi:id="Type-createAssociation-end1Lower" name="end1Lower" type="Integer" effect="read">
<ownedComment xmi:id="Type-createAssociation-end1Lower-_ownedComment.0" annotatedElement="Type-createAssociation-end1Lower">
<body>The lower bound for the first end of the new association.</body>
</ownedComment>
</ownedParameter>
<ownedParameter xmi:id="Type-createAssociation-end1Upper" name="end1Upper" type="UnlimitedNatural" effect="read">
<ownedComment xmi:id="Type-createAssociation-end1Upper-_ownedComment.0" annotatedElement="Type-createAssociation-end1Upper">
<body>The upper bound for the first end of the new association.</body>
</ownedComment>
</ownedParameter>
<ownedParameter xmi:id="Type-createAssociation-end1Type" name="end1Type" type="Type" effect="read">
<ownedComment xmi:id="Type-createAssociation-end1Type-_ownedComment.0" annotatedElement="Type-createAssociation-end1Type">
<body>The type for the first end of the new association.</body>
</ownedComment>
</ownedParameter>
<ownedParameter xmi:id="Type-createAssociation-end2IsNavigable" name="end2IsNavigable" type="Boolean" effect="read">
<ownedComment xmi:id="Type-createAssociation-end2IsNavigable-_ownedComment.0" annotatedElement="Type-createAssociation-end2IsNavigable">
<body>The navigability for the second end of the new association.</body>
</ownedComment>
</ownedParameter>
<ownedParameter xmi:id="Type-createAssociation-end2Aggregation" name="end2Aggregation" type="AggregationKind" effect="read">
<ownedComment xmi:id="Type-createAssociation-end2Aggregation-_ownedComment.0" annotatedElement="Type-createAssociation-end2Aggregation">
<body>The aggregation for the second end of the new association.</body>
</ownedComment>
</ownedParameter>
<ownedParameter xmi:id="Type-createAssociation-end2Name" name="end2Name" type="String" effect="read">
<ownedComment xmi:id="Type-createAssociation-end2Name-_ownedComment.0" annotatedElement="Type-createAssociation-end2Name">
<body>The name for the second end of the new association.</body>
</ownedComment>
</ownedParameter>
<ownedParameter xmi:id="Type-createAssociation-end2Lower" name="end2Lower" type="Integer" effect="read">
<ownedComment xmi:id="Type-createAssociation-end2Lower-_ownedComment.0" annotatedElement="Type-createAssociation-end2Lower">
<body>The lower bound for the second end of the new association.</body>
</ownedComment>
</ownedParameter>
<ownedParameter xmi:id="Type-createAssociation-end2Upper" name="end2Upper" type="UnlimitedNatural" effect="read">
<ownedComment xmi:id="Type-createAssociation-end2Upper-_ownedComment.0" annotatedElement="Type-createAssociation-end2Upper">
<body>The upper bound for the second end of the new association.</body>
</ownedComment>
</ownedParameter>
</ownedOperation>
<ownedOperation xmi:id="Type-getAssociations" name="getAssociations">
<ownedComment xmi:id="Type-getAssociations-_ownedComment.0" annotatedElement="Type-getAssociations">
<body>Retrieves the associations in which this type is involved.</body>
</ownedComment>
<ownedParameter xmi:id="Type-getAssociations-_ownedParameter.0" type="Association" direction="return">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Type-getAssociations-_ownedParameter.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Type-getAssociations-_ownedParameter.0-_lowerValue"/>
</ownedParameter>
</ownedOperation>
<ownedOperation xmi:id="Type-conformsTo" name="conformsTo" isQuery="true" bodyCondition="Type-conformsTo-spec">
<ownedComment xmi:id="Type-conformsTo-_ownedComment.0" annotatedElement="Type-conformsTo">
<body>The query conformsTo() gives true for a type that conforms to another. By default, two types do not conform to each other. This query is intended to be redefined for specific conformance situations.</body>
</ownedComment>
<ownedRule xmi:id="Type-conformsTo-spec" name="spec" constrainedElement="Type-conformsTo">
<specification xmi:type="uml:OpaqueExpression" xmi:id="Type-conformsTo-spec-_specification">
<language>OCL</language>
<body>result = false</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="Type-conformsTo-_ownedParameter.0" type="Boolean" direction="return"/>
<ownedParameter xmi:id="Type-conformsTo-other" name="other" type="Type"/>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="Expression" name="Expression">
<ownedComment xmi:id="Expression-_ownedComment.0" annotatedElement="Expression">
<body>An expression is a structured tree of symbols that denotes a (possibly empty) set of values when evaluated in a context.</body>
</ownedComment>
<ownedComment xmi:id="Expression-_ownedComment.1" annotatedElement="Expression">
<body>An expression represents a node in an expression tree, which may be non-terminal or terminal. It defines a symbol, and has a possibly empty sequence of operands which are value specifications.</body>
</ownedComment>
<generalization xmi:id="Expression-_generalization.0" general="ValueSpecification"/>
<ownedAttribute xmi:id="Expression-symbol" name="symbol" type="String">
<ownedComment xmi:id="Expression-symbol-_ownedComment.0" annotatedElement="Expression-symbol">
<body>The symbol associated with the node in the expression tree.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Expression-symbol-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Expression-symbol-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="Expression-operand" name="operand" type="ValueSpecification" isOrdered="true" aggregation="composite" subsettedProperty="Element-ownedElement" association="A_operand_expression">
<ownedComment xmi:id="Expression-operand-_ownedComment.0" annotatedElement="Expression-operand">
<body>Specifies a sequence of operands.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="Expression-operand-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="Expression-operand-_lowerValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Enumeration" xmi:id="AggregationKind" name="AggregationKind" visibility="private">
<ownedComment xmi:id="AggregationKind-_ownedComment.0" annotatedElement="AggregationKind">
<body>AggregationKind is an enumeration type that specifies the literals for defining the kind of aggregation of a property.</body>
</ownedComment>
<ownedLiteral xmi:id="AggregationKind-none" name="none">
<ownedComment xmi:id="AggregationKind-none-_ownedComment.0" annotatedElement="AggregationKind-none">
<body>Indicates that the property has no aggregation.</body>
</ownedComment>
</ownedLiteral>
<ownedLiteral xmi:id="AggregationKind-shared" name="shared">
<ownedComment xmi:id="AggregationKind-shared-_ownedComment.0" annotatedElement="AggregationKind-shared">
<body>Indicates that the property has a shared aggregation.</body>
</ownedComment>
</ownedLiteral>
<ownedLiteral xmi:id="AggregationKind-composite" name="composite">
<ownedComment xmi:id="AggregationKind-composite-_ownedComment.0" annotatedElement="AggregationKind-composite">
<body>Indicates that the property is aggregated compositely, i.e., the composite object has responsibility for the existence and storage of the composed objects (parts).</body>
</ownedComment>
</ownedLiteral>
</packagedElement>
<packagedElement xmi:type="uml:Enumeration" xmi:id="ParameterDirectionKind" name="ParameterDirectionKind" visibility="private">
<ownedComment xmi:id="ParameterDirectionKind-_ownedComment.0" annotatedElement="ParameterDirectionKind">
<body>Parameter direction kind is an enumeration type that defines literals used to specify direction of parameters.</body>
</ownedComment>
<ownedLiteral xmi:id="ParameterDirectionKind-in" name="in">
<ownedComment xmi:id="ParameterDirectionKind-in-_ownedComment.0" annotatedElement="ParameterDirectionKind-in">
<body>Indicates that parameter values are passed into the behavioral element by the caller.</body>
</ownedComment>
</ownedLiteral>
<ownedLiteral xmi:id="ParameterDirectionKind-inout" name="inout">
<ownedComment xmi:id="ParameterDirectionKind-inout-_ownedComment.0" annotatedElement="ParameterDirectionKind-inout">
<body>Indicates that parameter values are passed into a behavioral element by the caller and then back out to the caller from the behavioral element.</body>
</ownedComment>
</ownedLiteral>
<ownedLiteral xmi:id="ParameterDirectionKind-out" name="out">
<ownedComment xmi:id="ParameterDirectionKind-out-_ownedComment.0" annotatedElement="ParameterDirectionKind-out">
<body>Indicates that parameter values are passed from a behavioral element out to the caller.</body>
</ownedComment>
</ownedLiteral>
<ownedLiteral xmi:id="ParameterDirectionKind-return" name="return">
<ownedComment xmi:id="ParameterDirectionKind-return-_ownedComment.0" annotatedElement="ParameterDirectionKind-return">
<body>Indicates that parameter values are passed as return values from a behavioral element back to the caller.</body>
</ownedComment>
</ownedLiteral>
</packagedElement>
<packagedElement xmi:type="uml:Enumeration" xmi:id="VisibilityKind" name="VisibilityKind" visibility="private">
<ownedComment xmi:id="VisibilityKind-_ownedComment.0" annotatedElement="VisibilityKind">
<body>VisibilityKind is an enumeration type that defines literals to determine the visibility of elements in a model.</body>
</ownedComment>
<ownedOperation xmi:id="VisibilityKind-bestVisibility" name="bestVisibility" isQuery="true" precondition="VisibilityKind-bestVisibility-_ownedRule.0" bodyCondition="VisibilityKind-bestVisibility-spec">
<ownedComment xmi:id="VisibilityKind-bestVisibility-_ownedComment.0" annotatedElement="VisibilityKind-bestVisibility">
<body>The query bestVisibility() examines a set of VisibilityKinds, and returns public as the preferred visibility.</body>
</ownedComment>
<ownedRule xmi:id="VisibilityKind-bestVisibility-_ownedRule.0" constrainedElement="VisibilityKind-bestVisibility">
<specification xmi:type="uml:OpaqueExpression" xmi:id="VisibilityKind-bestVisibility-_ownedRule.0-_specification">
<language>OCL</language>
<body>pre: not vis->includes(#protected) and not vis->includes(#package)</body>
</specification>
</ownedRule>
<ownedRule xmi:id="VisibilityKind-bestVisibility-spec" name="spec" constrainedElement="VisibilityKind-bestVisibility">
<specification xmi:type="uml:OpaqueExpression" xmi:id="VisibilityKind-bestVisibility-spec-_specification">
<language>OCL</language>
<body>result = if vis->includes(#public) then #public else #private endif</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="VisibilityKind-bestVisibility-_ownedParameter.0" type="VisibilityKind" direction="return"/>
<ownedParameter xmi:id="VisibilityKind-bestVisibility-vis" name="vis" type="VisibilityKind">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="VisibilityKind-bestVisibility-vis-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="VisibilityKind-bestVisibility-vis-_lowerValue"/>
</ownedParameter>
</ownedOperation>
<ownedLiteral xmi:id="VisibilityKind-public" name="public">
<ownedComment xmi:id="VisibilityKind-public-_ownedComment.0" annotatedElement="VisibilityKind-public">
<body>A public element is visible to all elements that can access the contents of the namespace that owns it.</body>
</ownedComment>
</ownedLiteral>
<ownedLiteral xmi:id="VisibilityKind-private" name="private">
<ownedComment xmi:id="VisibilityKind-private-_ownedComment.0" annotatedElement="VisibilityKind-private">
<body>A private element is only visible inside the namespace that owns it.</body>
</ownedComment>
</ownedLiteral>
<ownedLiteral xmi:id="VisibilityKind-protected" name="protected">
<ownedComment xmi:id="VisibilityKind-protected-_ownedComment.0" annotatedElement="VisibilityKind-protected">
<body>A protected element is visible to elements that have a generalization relationship to the namespace that owns it.</body>
</ownedComment>
</ownedLiteral>
<ownedLiteral xmi:id="VisibilityKind-package" name="package">
<ownedComment xmi:id="VisibilityKind-package-_ownedComment.0" annotatedElement="VisibilityKind-package">
<body>A package element is owned by a namespace that is not a package, and is visible to elements that are in the same package as its owning namespace. Only named elements that are not owned by packages can be marked as having package visibility. Any element marked as having package visibility is visible to all elements within the nearest enclosing package (given that other owning elements have proper visibility). Outside the nearest enclosing package, an element marked as having package visibility is not visible.</body>
</ownedComment>
</ownedLiteral>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedElement_owner" name="A_ownedElement_owner" visibility="private" memberEnd="Element-ownedElement Element-owner"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_source_directedRelationship" name="A_source_directedRelationship" visibility="private" memberEnd="DirectedRelationship-source A_source_directedRelationship-_ownedEnd.0">
<ownedEnd xmi:id="A_source_directedRelationship-_ownedEnd.0" type="DirectedRelationship" association="A_source_directedRelationship">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_source_directedRelationship-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_source_directedRelationship-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_target_directedRelationship" name="A_target_directedRelationship" visibility="private" memberEnd="DirectedRelationship-target A_target_directedRelationship-_ownedEnd.0">
<ownedEnd xmi:id="A_target_directedRelationship-_ownedEnd.0" type="DirectedRelationship" association="A_target_directedRelationship">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_target_directedRelationship-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_target_directedRelationship-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_constrainedElement_constraint" name="A_constrainedElement_constraint" visibility="private" memberEnd="Constraint-constrainedElement A_constrainedElement_constraint-_ownedEnd.0">
<ownedEnd xmi:id="A_constrainedElement_constraint-_ownedEnd.0" type="Constraint" association="A_constrainedElement_constraint">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_constrainedElement_constraint-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_constrainedElement_constraint-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_type_typedElement" name="A_type_typedElement" visibility="private" memberEnd="TypedElement-type A_type_typedElement-_ownedEnd.0">
<ownedEnd xmi:id="A_type_typedElement-_ownedEnd.0" type="TypedElement" association="A_type_typedElement">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_type_typedElement-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_type_typedElement-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_generalization_specific" name="A_generalization_specific" visibility="private" memberEnd="Classifier-generalization Generalization-specific"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_general_generalization" name="A_general_generalization" visibility="private" memberEnd="Generalization-general A_general_generalization-_ownedEnd.0">
<ownedEnd xmi:id="A_general_generalization-_ownedEnd.0" type="Generalization" association="A_general_generalization">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_general_generalization-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_general_generalization-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_feature_featuringClassifier" name="A_feature_featuringClassifier" visibility="private" memberEnd="Classifier-feature Feature-featuringClassifier"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedParameter_ownerFormalParam" name="A_ownedParameter_ownerFormalParam" visibility="private" memberEnd="BehavioralFeature-ownedParameter A_ownedParameter_ownerFormalParam-ownerFormalParam">
<ownedEnd xmi:id="A_ownedParameter_ownerFormalParam-ownerFormalParam" name="ownerFormalParam" type="BehavioralFeature" subsettedProperty="NamedElement-namespace" association="A_ownedParameter_ownerFormalParam">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_ownedParameter_ownerFormalParam-ownerFormalParam-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_ownedParameter_ownerFormalParam-ownerFormalParam-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_classifier_instanceSpecification" name="A_classifier_instanceSpecification" visibility="private" memberEnd="InstanceSpecification-classifier A_classifier_instanceSpecification-_ownedEnd.0">
<ownedEnd xmi:id="A_classifier_instanceSpecification-_ownedEnd.0" type="InstanceSpecification" association="A_classifier_instanceSpecification">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_classifier_instanceSpecification-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_classifier_instanceSpecification-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_slot_owningInstance" name="A_slot_owningInstance" visibility="private" memberEnd="InstanceSpecification-slot Slot-owningInstance"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_definingFeature_slot" name="A_definingFeature_slot" visibility="private" memberEnd="Slot-definingFeature A_definingFeature_slot-_ownedEnd.0">
<ownedEnd xmi:id="A_definingFeature_slot-_ownedEnd.0" type="Slot" association="A_definingFeature_slot">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_definingFeature_slot-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_definingFeature_slot-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_annotatedElement_comment" name="A_annotatedElement_comment" visibility="private" memberEnd="Comment-annotatedElement A_annotatedElement_comment-_ownedEnd.0">
<ownedEnd xmi:id="A_annotatedElement_comment-_ownedEnd.0" type="Comment" association="A_annotatedElement_comment">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_annotatedElement_comment-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_annotatedElement_comment-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedComment_owningElement" name="A_ownedComment_owningElement" visibility="private" memberEnd="Element-ownedComment A_ownedComment_owningElement-owningElement">
<ownedEnd xmi:id="A_ownedComment_owningElement-owningElement" name="owningElement" type="Element" subsettedProperty="Element-owner" association="A_ownedComment_owningElement">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_ownedComment_owningElement-owningElement-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_ownedComment_owningElement-owningElement-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_importedElement_elementImport" name="A_importedElement_elementImport" visibility="private" memberEnd="ElementImport-importedElement A_importedElement_elementImport-_ownedEnd.0">
<ownedEnd xmi:id="A_importedElement_elementImport-_ownedEnd.0" type="ElementImport" association="A_importedElement_elementImport">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_importedElement_elementImport-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_importedElement_elementImport-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_inheritedMember_classifier" name="A_inheritedMember_classifier" visibility="private" memberEnd="Classifier-inheritedMember A_inheritedMember_classifier-_ownedEnd.0">
<ownedEnd xmi:id="A_inheritedMember_classifier-_ownedEnd.0" type="Classifier" association="A_inheritedMember_classifier">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_inheritedMember_classifier-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_inheritedMember_classifier-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_nestedClassifier_class" name="A_nestedClassifier_class" visibility="private" memberEnd="Class-nestedClassifier A_nestedClassifier_class-class">
<ownedEnd xmi:id="A_nestedClassifier_class-class" name="class" type="Class" subsettedProperty="NamedElement-namespace RedefinableElement-redefinitionContext" association="A_nestedClassifier_class">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_nestedClassifier_class-class-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_nestedClassifier_class-class-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedAttribute_class" name="A_ownedAttribute_class" visibility="private" memberEnd="Class-ownedAttribute Property-class"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedOperation_class" name="A_ownedOperation_class" visibility="private" memberEnd="Class-ownedOperation Operation-class"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_precondition_preContext" name="A_precondition_preContext" visibility="private" memberEnd="Operation-precondition A_precondition_preContext-preContext">
<ownedEnd xmi:id="A_precondition_preContext-preContext" name="preContext" type="Operation" subsettedProperty="Constraint-context" association="A_precondition_preContext">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_precondition_preContext-preContext-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_precondition_preContext-preContext-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_postcondition_postContext" name="A_postcondition_postContext" visibility="private" memberEnd="Operation-postcondition A_postcondition_postContext-postContext">
<ownedEnd xmi:id="A_postcondition_postContext-postContext" name="postContext" type="Operation" subsettedProperty="Constraint-context" association="A_postcondition_postContext">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_postcondition_postContext-postContext-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_postcondition_postContext-postContext-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_redefinedOperation_operation" name="A_redefinedOperation_operation" visibility="private" memberEnd="Operation-redefinedOperation A_redefinedOperation_operation-_ownedEnd.0">
<ownedEnd xmi:id="A_redefinedOperation_operation-_ownedEnd.0" type="Operation" association="A_redefinedOperation_operation">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_redefinedOperation_operation-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_redefinedOperation_operation-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_redefinedProperty_property" name="A_redefinedProperty_property" visibility="private" memberEnd="Property-redefinedProperty A_redefinedProperty_property-_ownedEnd.0">
<ownedEnd xmi:id="A_redefinedProperty_property-_ownedEnd.0" type="Property" association="A_redefinedProperty_property">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_redefinedProperty_property-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_redefinedProperty_property-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedEnd_owningAssociation" name="A_ownedEnd_owningAssociation" visibility="private" memberEnd="Association-ownedEnd Property-owningAssociation"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedAttribute_datatype" name="A_ownedAttribute_datatype" visibility="private" memberEnd="DataType-ownedAttribute Property-datatype"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedOperation_datatype" name="A_ownedOperation_datatype" visibility="private" memberEnd="DataType-ownedOperation Operation-datatype"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedLiteral_enumeration" name="A_ownedLiteral_enumeration" visibility="private" memberEnd="Enumeration-ownedLiteral EnumerationLiteral-enumeration"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_elementImport_importingNamespace" name="A_elementImport_importingNamespace" visibility="private" memberEnd="Namespace-elementImport ElementImport-importingNamespace"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_packageImport_importingNamespace" name="A_packageImport_importingNamespace" visibility="private" memberEnd="Namespace-packageImport PackageImport-importingNamespace"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_importedPackage_packageImport" name="A_importedPackage_packageImport" visibility="private" memberEnd="PackageImport-importedPackage A_importedPackage_packageImport-_ownedEnd.0">
<ownedEnd xmi:id="A_importedPackage_packageImport-_ownedEnd.0" type="PackageImport" association="A_importedPackage_packageImport">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_importedPackage_packageImport-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_importedPackage_packageImport-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_redefinedClassifier_classifier" name="A_redefinedClassifier_classifier" visibility="private" memberEnd="Classifier-redefinedClassifier A_redefinedClassifier_classifier-_ownedEnd.0">
<ownedEnd xmi:id="A_redefinedClassifier_classifier-_ownedEnd.0" type="Classifier" association="A_redefinedClassifier_classifier">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_redefinedClassifier_classifier-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_redefinedClassifier_classifier-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_specification_owningConstraint" name="A_specification_owningConstraint" visibility="private" memberEnd="Constraint-specification A_specification_owningConstraint-owningConstraint">
<ownedEnd xmi:id="A_specification_owningConstraint-owningConstraint" name="owningConstraint" type="Constraint" subsettedProperty="Element-owner" association="A_specification_owningConstraint">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_specification_owningConstraint-owningConstraint-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_specification_owningConstraint-owningConstraint-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_defaultValue_owningParameter" name="A_defaultValue_owningParameter" visibility="private" memberEnd="Parameter-defaultValue A_defaultValue_owningParameter-owningParameter">
<ownedEnd xmi:id="A_defaultValue_owningParameter-owningParameter" name="owningParameter" type="Parameter" subsettedProperty="Element-owner" association="A_defaultValue_owningParameter">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_defaultValue_owningParameter-owningParameter-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_defaultValue_owningParameter-owningParameter-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_defaultValue_owningProperty" name="A_defaultValue_owningProperty" visibility="private" memberEnd="Property-defaultValue A_defaultValue_owningProperty-owningProperty">
<ownedEnd xmi:id="A_defaultValue_owningProperty-owningProperty" name="owningProperty" type="Property" subsettedProperty="Element-owner" association="A_defaultValue_owningProperty">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_defaultValue_owningProperty-owningProperty-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_defaultValue_owningProperty-owningProperty-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedRule_context" name="A_ownedRule_context" visibility="private" memberEnd="Namespace-ownedRule Constraint-context"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_member_namespace" name="A_member_namespace" visibility="private" memberEnd="Namespace-member A_member_namespace-_ownedEnd.0">
<ownedEnd xmi:id="A_member_namespace-_ownedEnd.0" type="Namespace" association="A_member_namespace">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_member_namespace-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_member_namespace-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_relatedElement_relationship" name="A_relatedElement_relationship" visibility="private" memberEnd="Relationship-relatedElement A_relatedElement_relationship-_ownedEnd.0">
<ownedEnd xmi:id="A_relatedElement_relationship-_ownedEnd.0" type="Relationship" association="A_relatedElement_relationship">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_relatedElement_relationship-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_relatedElement_relationship-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_endType_association" name="A_endType_association" visibility="private" memberEnd="Association-endType A_endType_association-_ownedEnd.0">
<ownedEnd xmi:id="A_endType_association-_ownedEnd.0" type="Association" association="A_endType_association">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_endType_association-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_endType_association-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_upperValue_owningUpper" name="A_upperValue_owningUpper" visibility="private" memberEnd="MultiplicityElement-upperValue A_upperValue_owningUpper-owningUpper">
<ownedEnd xmi:id="A_upperValue_owningUpper-owningUpper" name="owningUpper" type="MultiplicityElement" subsettedProperty="Element-owner" association="A_upperValue_owningUpper">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_upperValue_owningUpper-owningUpper-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_upperValue_owningUpper-owningUpper-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_lowerValue_owningLower" name="A_lowerValue_owningLower" visibility="private" memberEnd="MultiplicityElement-lowerValue A_lowerValue_owningLower-owningLower">
<ownedEnd xmi:id="A_lowerValue_owningLower-owningLower" name="owningLower" type="MultiplicityElement" subsettedProperty="Element-owner" association="A_lowerValue_owningLower">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_lowerValue_owningLower-owningLower-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_lowerValue_owningLower-owningLower-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_receivingPackage_packageMerge" name="A_receivingPackage_packageMerge" visibility="private" memberEnd="PackageMerge-receivingPackage Package-packageMerge"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_mergedPackage_packageMerge" name="A_mergedPackage_packageMerge" visibility="private" memberEnd="PackageMerge-mergedPackage A_mergedPackage_packageMerge-_ownedEnd.0">
<ownedEnd xmi:id="A_mergedPackage_packageMerge-_ownedEnd.0" type="PackageMerge" association="A_mergedPackage_packageMerge">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_mergedPackage_packageMerge-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_mergedPackage_packageMerge-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_instance_instanceValue" name="A_instance_instanceValue" visibility="private" memberEnd="InstanceValue-instance A_instance_instanceValue-_ownedEnd.0">
<ownedEnd xmi:id="A_instance_instanceValue-_ownedEnd.0" type="InstanceValue" association="A_instance_instanceValue">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_instance_instanceValue-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_instance_instanceValue-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_value_owningSlot" name="A_value_owningSlot" visibility="private" memberEnd="Slot-value A_value_owningSlot-owningSlot">
<ownedEnd xmi:id="A_value_owningSlot-owningSlot" name="owningSlot" type="Slot" subsettedProperty="Element-owner" association="A_value_owningSlot">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_value_owningSlot-owningSlot-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_value_owningSlot-owningSlot-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_specification_owningInstanceSpec" name="A_specification_owningInstanceSpec" visibility="private" memberEnd="InstanceSpecification-specification A_specification_owningInstanceSpec-owningInstanceSpec">
<ownedEnd xmi:id="A_specification_owningInstanceSpec-owningInstanceSpec" name="owningInstanceSpec" type="InstanceSpecification" subsettedProperty="Element-owner" association="A_specification_owningInstanceSpec">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_specification_owningInstanceSpec-owningInstanceSpec-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_specification_owningInstanceSpec-owningInstanceSpec-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_packagedElement_owningPackage" name="A_packagedElement_owningPackage" visibility="private" memberEnd="Package-packagedElement A_packagedElement_owningPackage-owningPackage">
<ownedEnd xmi:id="A_packagedElement_owningPackage-owningPackage" name="owningPackage" type="Package" subsettedProperty="NamedElement-namespace" association="A_packagedElement_owningPackage">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_packagedElement_owningPackage-owningPackage-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_packagedElement_owningPackage-owningPackage-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_importedMember_namespace" name="A_importedMember_namespace" visibility="private" memberEnd="Namespace-importedMember A_importedMember_namespace-_ownedEnd.0">
<ownedEnd xmi:id="A_importedMember_namespace-_ownedEnd.0" type="Namespace" association="A_importedMember_namespace">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_importedMember_namespace-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_importedMember_namespace-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_opposite_property" name="A_opposite_property" visibility="private" memberEnd="Property-opposite A_opposite_property-_ownedEnd.0">
<ownedEnd xmi:id="A_opposite_property-_ownedEnd.0" type="Property" association="A_opposite_property">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_opposite_property-_ownedEnd.0-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_opposite_property-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_subsettedProperty_property" name="A_subsettedProperty_property" visibility="private" memberEnd="Property-subsettedProperty A_subsettedProperty_property-_ownedEnd.0">
<ownedEnd xmi:id="A_subsettedProperty_property-_ownedEnd.0" type="Property" association="A_subsettedProperty_property">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_subsettedProperty_property-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_subsettedProperty_property-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_memberEnd_association" name="A_memberEnd_association" visibility="private" memberEnd="Association-memberEnd Property-association"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedType_package" name="A_ownedType_package" visibility="private" memberEnd="Package-ownedType Type-package"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_nestedPackage_nestingPackage" name="A_nestedPackage_nestingPackage" visibility="private" memberEnd="Package-nestedPackage Package-nestingPackage"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_redefinedElement_redefinableElement" name="A_redefinedElement_redefinableElement" visibility="private" memberEnd="RedefinableElement-redefinedElement A_redefinedElement_redefinableElement-_ownedEnd.0">
<ownedEnd xmi:id="A_redefinedElement_redefinableElement-_ownedEnd.0" type="RedefinableElement" association="A_redefinedElement_redefinableElement">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_redefinedElement_redefinableElement-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_redefinedElement_redefinableElement-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_redefinitionContext_redefinableElement" name="A_redefinitionContext_redefinableElement" visibility="private" memberEnd="RedefinableElement-redefinitionContext A_redefinitionContext_redefinableElement-_ownedEnd.0">
<ownedEnd xmi:id="A_redefinitionContext_redefinableElement-_ownedEnd.0" type="RedefinableElement" association="A_redefinitionContext_redefinableElement">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_redefinitionContext_redefinableElement-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_redefinitionContext_redefinableElement-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_general_classifier" name="A_general_classifier" visibility="private" memberEnd="Classifier-general A_general_classifier-_ownedEnd.0">
<ownedEnd xmi:id="A_general_classifier-_ownedEnd.0" type="Classifier" association="A_general_classifier">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_general_classifier-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_general_classifier-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_superClass_class" name="A_superClass_class" visibility="private" memberEnd="Class-superClass A_superClass_class-_ownedEnd.0">
<ownedEnd xmi:id="A_superClass_class-_ownedEnd.0" type="Class" association="A_superClass_class">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_superClass_class-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_superClass_class-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_bodyCondition_bodyContext" name="A_bodyCondition_bodyContext" visibility="private" memberEnd="Operation-bodyCondition A_bodyCondition_bodyContext-bodyContext">
<ownedEnd xmi:id="A_bodyCondition_bodyContext-bodyContext" name="bodyContext" type="Operation" subsettedProperty="Constraint-context" association="A_bodyCondition_bodyContext">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_bodyCondition_bodyContext-bodyContext-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_bodyCondition_bodyContext-bodyContext-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_type_operation" name="A_type_operation" visibility="private" memberEnd="Operation-type A_type_operation-_ownedEnd.0">
<ownedEnd xmi:id="A_type_operation-_ownedEnd.0" type="Operation" association="A_type_operation">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_type_operation-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_type_operation-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_ownedParameter_operation" name="A_ownedParameter_operation" visibility="private" memberEnd="Operation-ownedParameter Parameter-operation"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_operand_expression" name="A_operand_expression" visibility="private" memberEnd="Expression-operand A_operand_expression-expression">
<ownedEnd xmi:id="A_operand_expression-expression" name="expression" type="Expression" subsettedProperty="Element-owner" association="A_operand_expression">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_operand_expression-expression-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_operand_expression-expression-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_raisedException_operation" name="A_raisedException_operation" visibility="private" memberEnd="Operation-raisedException A_raisedException_operation-_ownedEnd.0">
<ownedEnd xmi:id="A_raisedException_operation-_ownedEnd.0" type="Operation" association="A_raisedException_operation">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_raisedException_operation-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_raisedException_operation-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_navigableOwnedEnd_association" name="A_navigableOwnedEnd_association" visibility="private" memberEnd="Association-navigableOwnedEnd A_navigableOwnedEnd_association-_ownedEnd.0">
<ownedEnd xmi:id="A_navigableOwnedEnd_association-_ownedEnd.0" type="Association" association="A_navigableOwnedEnd_association">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_navigableOwnedEnd_association-_ownedEnd.0-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_navigableOwnedEnd_association-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="OpaqueExpression" name="OpaqueExpression">
<ownedComment xmi:id="OpaqueExpression-_ownedComment.0" annotatedElement="OpaqueExpression">
<body>An opaque expression is an uninterpreted textual statement that denotes a (possibly empty) set of values when evaluated in a context.</body>
</ownedComment>
<ownedComment xmi:id="OpaqueExpression-_ownedComment.1" annotatedElement="OpaqueExpression">
<body>Provides a mechanism for precisely defining the behavior of an opaque expression. An opaque expression is defined by a behavior restricted to return one result.</body>
</ownedComment>
<ownedRule xmi:id="OpaqueExpression-language_body_size" name="language_body_size" constrainedElement="OpaqueExpression">
<ownedComment xmi:id="OpaqueExpression-language_body_size-_ownedComment.0" annotatedElement="OpaqueExpression-language_body_size">
<body>If the language attribute is not empty, then the size of the body and language arrays must be the same.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="OpaqueExpression-language_body_size-_specification">
<language>OCL</language>
<body>language->notEmpty() implies (body->size() = language->size())</body>
</specification>
</ownedRule>
<ownedRule xmi:id="OpaqueExpression-only_return_result_parameters" name="only_return_result_parameters" constrainedElement="OpaqueExpression">
<ownedComment xmi:id="OpaqueExpression-only_return_result_parameters-_ownedComment.0" annotatedElement="OpaqueExpression-only_return_result_parameters">
<body>The behavior may only have return result parameters.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="OpaqueExpression-only_return_result_parameters-_specification">
<language>OCL</language>
<body>self.behavior.notEmpty() implies&#xD;&#xA; self.behavior.ownedParameters->select(p | p.direction&lt;>#return)->isEmpty()</body>
</specification>
</ownedRule>
<ownedRule xmi:id="OpaqueExpression-one_return_result_parameter" name="one_return_result_parameter" constrainedElement="OpaqueExpression">
<ownedComment xmi:id="OpaqueExpression-one_return_result_parameter-_ownedComment.0" annotatedElement="OpaqueExpression-one_return_result_parameter">
<body>The behavior must have exactly one return result parameter.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="OpaqueExpression-one_return_result_parameter-_specification">
<language>OCL</language>
<body>self.behavior.notEmpty() implies&#xD;&#xA; self.behavior.ownedParameter->select(p | p.direction=#return)->size() = 1</body>
</specification>
</ownedRule>
<generalization xmi:id="OpaqueExpression-_generalization.0" general="ValueSpecification"/>
<ownedAttribute xmi:id="OpaqueExpression-body" name="body" type="String" isOrdered="true" isUnique="false" aggregation="composite">
<ownedComment xmi:id="OpaqueExpression-body-_ownedComment.0" annotatedElement="OpaqueExpression-body">
<body>The text of the expression, possibly in multiple languages.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="OpaqueExpression-body-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="OpaqueExpression-body-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="OpaqueExpression-language" name="language" type="String" isOrdered="true" aggregation="composite">
<ownedComment xmi:id="OpaqueExpression-language-_ownedComment.0" annotatedElement="OpaqueExpression-language">
<body>Specifies the languages in which the expression is stated. The interpretation of the expression body depends on the languages. If the languages are unspecified, they might be implicit from the expression body or the context. Languages are matched to body strings by order.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="OpaqueExpression-language-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="OpaqueExpression-language-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="OpaqueExpression-result" name="result" type="Parameter" isReadOnly="true" isDerived="true" association="A_result_opaqueExpression">
<ownedComment xmi:id="OpaqueExpression-result-_ownedComment.0" annotatedElement="OpaqueExpression-result">
<body>Restricts an opaque expression to return exactly one return result. When the invocation of the opaque expression completes, a single set of values is returned to its owner. This association is derived from the single return result parameter of the associated behavior.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="OpaqueExpression-result-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="OpaqueExpression-result-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="OpaqueExpression-behavior" name="behavior" type="Behavior" association="A_behavior_opaqueExpression">
<ownedComment xmi:id="OpaqueExpression-behavior-_ownedComment.0" annotatedElement="OpaqueExpression-behavior">
<body>Specifies the behavior of the opaque expression.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="OpaqueExpression-behavior-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="OpaqueExpression-behavior-_lowerValue"/>
</ownedAttribute>
<ownedOperation xmi:id="OpaqueExpression-getResult" name="getResult" visibility="protected" isQuery="true">
<ownedParameter xmi:id="OpaqueExpression-getResult-_ownedParameter.0" type="Parameter" direction="return">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="OpaqueExpression-getResult-_ownedParameter.0-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="OpaqueExpression-getResult-_ownedParameter.0-_lowerValue"/>
</ownedParameter>
</ownedOperation>
<ownedOperation xmi:id="OpaqueExpression-stringValue" name="stringValue" visibility="protected" isQuery="true">
<ownedParameter xmi:id="OpaqueExpression-stringValue-_ownedParameter.0" type="String" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="OpaqueExpression-value" name="value" isQuery="true" precondition="OpaqueExpression-value-_ownedRule.0" bodyCondition="OpaqueExpression-value-spec">
<ownedComment xmi:id="OpaqueExpression-value-_ownedComment.0" annotatedElement="OpaqueExpression-value">
<body>The query value() gives an integer value for an expression intended to produce one.</body>
</ownedComment>
<ownedRule xmi:id="OpaqueExpression-value-_ownedRule.0" constrainedElement="OpaqueExpression-value">
<specification xmi:type="uml:OpaqueExpression" xmi:id="OpaqueExpression-value-_ownedRule.0-_specification">
<language>OCL</language>
<body>self.isIntegral()</body>
</specification>
</ownedRule>
<ownedRule xmi:id="OpaqueExpression-value-spec" name="spec" constrainedElement="OpaqueExpression-value">
<specification xmi:type="uml:OpaqueExpression" xmi:id="OpaqueExpression-value-spec-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="OpaqueExpression-value-_ownedParameter.0" type="Integer" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="OpaqueExpression-isIntegral" name="isIntegral" isQuery="true" bodyCondition="OpaqueExpression-isIntegral-spec">
<ownedComment xmi:id="OpaqueExpression-isIntegral-_ownedComment.0" annotatedElement="OpaqueExpression-isIntegral">
<body>The query isIntegral() tells whether an expression is intended to produce an integer.</body>
</ownedComment>
<ownedRule xmi:id="OpaqueExpression-isIntegral-spec" name="spec" constrainedElement="OpaqueExpression-isIntegral">
<specification xmi:type="uml:OpaqueExpression" xmi:id="OpaqueExpression-isIntegral-spec-_specification">
<language>OCL</language>
<body>result = false</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="OpaqueExpression-isIntegral-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="OpaqueExpression-isPositive" name="isPositive" isQuery="true" precondition="OpaqueExpression-isPositive-_ownedRule.0" bodyCondition="OpaqueExpression-isPositive-spec">
<ownedComment xmi:id="OpaqueExpression-isPositive-_ownedComment.0" annotatedElement="OpaqueExpression-isPositive">
<body>The query isPositive() tells whether an integer expression has a positive value.</body>
</ownedComment>
<ownedRule xmi:id="OpaqueExpression-isPositive-_ownedRule.0" constrainedElement="OpaqueExpression-isPositive">
<specification xmi:type="uml:OpaqueExpression" xmi:id="OpaqueExpression-isPositive-_ownedRule.0-_specification">
<language>OCL</language>
<body>self.isIntegral()</body>
</specification>
</ownedRule>
<ownedRule xmi:id="OpaqueExpression-isPositive-spec" name="spec" constrainedElement="OpaqueExpression-isPositive">
<specification xmi:type="uml:OpaqueExpression" xmi:id="OpaqueExpression-isPositive-spec-_specification">
<language>OCL</language>
<body>result = false</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="OpaqueExpression-isPositive-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="OpaqueExpression-isNonNegative" name="isNonNegative" isQuery="true" precondition="OpaqueExpression-isNonNegative-_ownedRule.0" bodyCondition="OpaqueExpression-isNonNegative-spec">
<ownedComment xmi:id="OpaqueExpression-isNonNegative-_ownedComment.0" annotatedElement="OpaqueExpression-isNonNegative">
<body>The query isNonNegative() tells whether an integer expression has a non-negative value.</body>
</ownedComment>
<ownedRule xmi:id="OpaqueExpression-isNonNegative-_ownedRule.0" constrainedElement="OpaqueExpression-isNonNegative">
<specification xmi:type="uml:OpaqueExpression" xmi:id="OpaqueExpression-isNonNegative-_ownedRule.0-_specification">
<language>OCL</language>
<body>self.isIntegral()</body>
</specification>
</ownedRule>
<ownedRule xmi:id="OpaqueExpression-isNonNegative-spec" name="spec" constrainedElement="OpaqueExpression-isNonNegative">
<specification xmi:type="uml:OpaqueExpression" xmi:id="OpaqueExpression-isNonNegative-spec-_specification">
<language>OCL</language>
<body>result = false</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="OpaqueExpression-isNonNegative-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="OpaqueBehavior" name="OpaqueBehavior">
<ownedComment xmi:id="OpaqueBehavior-_ownedComment.0" annotatedElement="OpaqueBehavior">
<body>An behavior with implementation-specific semantics.</body>
</ownedComment>
<generalization xmi:id="OpaqueBehavior-_generalization.0" general="Behavior"/>
<ownedAttribute xmi:id="OpaqueBehavior-body" name="body" type="String" isOrdered="true" isUnique="false" aggregation="composite">
<ownedComment xmi:id="OpaqueBehavior-body-_ownedComment.0" annotatedElement="OpaqueBehavior-body">
<body>Specifies the behavior in one or more languages.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="OpaqueBehavior-body-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="OpaqueBehavior-body-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="OpaqueBehavior-language" name="language" type="String" isOrdered="true" aggregation="composite">
<ownedComment xmi:id="OpaqueBehavior-language-_ownedComment.0" annotatedElement="OpaqueBehavior-language">
<body>Languages the body strings use in the same order as the body strings.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="OpaqueBehavior-language-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="OpaqueBehavior-language-_lowerValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="FunctionBehavior" name="FunctionBehavior">
<ownedComment xmi:id="FunctionBehavior-_ownedComment.0" annotatedElement="FunctionBehavior">
<body>A function behavior is an opaque behavior that does not access or modify any objects or other external data.</body>
</ownedComment>
<ownedRule xmi:id="FunctionBehavior-one_output_parameter" name="one_output_parameter" constrainedElement="FunctionBehavior">
<ownedComment xmi:id="FunctionBehavior-one_output_parameter-_ownedComment.0" annotatedElement="FunctionBehavior-one_output_parameter">
<body>A function behavior has at least one output parameter.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="FunctionBehavior-one_output_parameter-_specification">
<language>OCL</language>
<body>self.ownedParameters->&#xD;&#xA; select(p | p.direction=#out or p.direction=#inout or p.direction=#return)->size() >= 1</body>
</specification>
</ownedRule>
<ownedRule xmi:id="FunctionBehavior-types_of_parameters" name="types_of_parameters" constrainedElement="FunctionBehavior">
<ownedComment xmi:id="FunctionBehavior-types_of_parameters-_ownedComment.0" annotatedElement="FunctionBehavior-types_of_parameters">
<body>The types of parameters are all data types, which may not nest anything but other datatypes.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="FunctionBehavior-types_of_parameters-_specification">
<language>OCL</language>
<body>def: hasAllDataTypeAttributes(d : DataType) : Boolean =&#xD;&#xA; d.ownedAttribute->forAll(a |&#xD;&#xA; a.type.oclIsTypeOf(DataType) and&#xD;&#xA; hasAllDataTypeAttributes(a.type))&#xD;&#xA;self.ownedParameters->forAll(p | p.type.notEmpty() and&#xD;&#xA; p.oclIsTypeOf(DataType) and hasAllDataTypeAttributes(p))</body>
</specification>
</ownedRule>
<generalization xmi:id="FunctionBehavior-_generalization.0" general="OpaqueBehavior"/>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_behavioredClassifier_ownedBehavior" name="A_behavioredClassifier_ownedBehavior" visibility="private" memberEnd="A_behavioredClassifier_ownedBehavior-_ownedEnd.0 BehavioredClassifier-ownedBehavior">
<ownedEnd xmi:id="A_behavioredClassifier_ownedBehavior-_ownedEnd.0" type="BehavioredClassifier" association="A_behavioredClassifier_ownedBehavior">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_behavioredClassifier_ownedBehavior-_ownedEnd.0-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_behavioredClassifier_ownedBehavior-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_classifierBehavior_behavioredClassifier" name="A_classifierBehavior_behavioredClassifier" visibility="private" memberEnd="BehavioredClassifier-classifierBehavior A_classifierBehavior_behavioredClassifier-_ownedEnd.0">
<ownedEnd xmi:id="A_classifierBehavior_behavioredClassifier-_ownedEnd.0" type="BehavioredClassifier" association="A_classifierBehavior_behavioredClassifier">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_classifierBehavior_behavioredClassifier-_ownedEnd.0-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_classifierBehavior_behavioredClassifier-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_redefinedBehavior_behavior" name="A_redefinedBehavior_behavior" visibility="private" memberEnd="Behavior-redefinedBehavior A_redefinedBehavior_behavior-_ownedEnd.0">
<ownedEnd xmi:id="A_redefinedBehavior_behavior-_ownedEnd.0" type="Behavior" association="A_redefinedBehavior_behavior">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_redefinedBehavior_behavior-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_redefinedBehavior_behavior-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_method_specification" name="A_method_specification" visibility="private" memberEnd="BehavioralFeature-method Behavior-specification"/>
<packagedElement xmi:type="uml:Association" xmi:id="A_behavior_ownedParameter" name="A_behavior_ownedParameter" visibility="private" memberEnd="A_behavior_ownedParameter-_ownedEnd.0 Behavior-ownedParameter">
<ownedEnd xmi:id="A_behavior_ownedParameter-_ownedEnd.0" type="Behavior" association="A_behavior_ownedParameter">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_behavior_ownedParameter-_ownedEnd.0-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_behavior_ownedParameter-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_result_opaqueExpression" name="A_result_opaqueExpression" visibility="private" memberEnd="OpaqueExpression-result A_result_opaqueExpression-_ownedEnd.0">
<ownedEnd xmi:id="A_result_opaqueExpression-_ownedEnd.0" type="OpaqueExpression" association="A_result_opaqueExpression">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_result_opaqueExpression-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_result_opaqueExpression-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_behavior_opaqueExpression" name="A_behavior_opaqueExpression" visibility="private" memberEnd="OpaqueExpression-behavior A_behavior_opaqueExpression-_ownedEnd.0">
<ownedEnd xmi:id="A_behavior_opaqueExpression-_ownedEnd.0" type="OpaqueExpression" association="A_behavior_opaqueExpression">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_behavior_opaqueExpression-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_behavior_opaqueExpression-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_context_behavior" name="A_context_behavior" visibility="private" memberEnd="Behavior-context A_context_behavior-_ownedEnd.0">
<ownedEnd xmi:id="A_context_behavior-_ownedEnd.0" type="Behavior" association="A_context_behavior">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_context_behavior-_ownedEnd.0-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_context_behavior-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_precondition_behavior" name="A_precondition_behavior" visibility="private" memberEnd="Behavior-precondition A_precondition_behavior-_ownedEnd.0">
<ownedEnd xmi:id="A_precondition_behavior-_ownedEnd.0" type="Behavior" subsettedProperty="Constraint-context" association="A_precondition_behavior">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_precondition_behavior-_ownedEnd.0-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_precondition_behavior-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Association" xmi:id="A_postcondition_behavior" name="A_postcondition_behavior" visibility="private" memberEnd="Behavior-postcondition A_postcondition_behavior-_ownedEnd.0">
<ownedEnd xmi:id="A_postcondition_behavior-_ownedEnd.0" type="Behavior" subsettedProperty="Constraint-context" association="A_postcondition_behavior">
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="A_postcondition_behavior-_ownedEnd.0-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="A_postcondition_behavior-_ownedEnd.0-_lowerValue"/>
</ownedEnd>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="OpaqueAction" name="OpaqueAction">
<ownedComment xmi:id="OpaqueAction-_ownedComment.0" annotatedElement="OpaqueAction">
<body>An action with implementation-specific semantics.</body>
</ownedComment>
<generalization xmi:id="OpaqueAction-_generalization.0" general="Action"/>
<ownedAttribute xmi:id="OpaqueAction-body" name="body" type="String" isOrdered="true" isUnique="false" aggregation="composite">
<ownedComment xmi:id="OpaqueAction-body-_ownedComment.0" annotatedElement="OpaqueAction-body">
<body>Specifies the action in one or more languages.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="OpaqueAction-body-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="OpaqueAction-body-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="OpaqueAction-language" name="language" type="String" isOrdered="true" aggregation="composite">
<ownedComment xmi:id="OpaqueAction-language-_ownedComment.0" annotatedElement="OpaqueAction-language">
<body>Languages the body strings use, in the same order as the body strings</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="OpaqueAction-language-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="OpaqueAction-language-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="OpaqueAction-inputValue" name="inputValue" type="InputPin" aggregation="composite" subsettedProperty="Action-input" association="A_inputValue_opaqueAction">
<ownedComment xmi:id="OpaqueAction-inputValue-_ownedComment.0" annotatedElement="OpaqueAction-inputValue">
<body>Provides input to the action.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="OpaqueAction-inputValue-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="OpaqueAction-inputValue-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="OpaqueAction-outputValue" name="outputValue" type="OutputPin" aggregation="composite" subsettedProperty="Action-output" association="A_outputValue_opaqueAction">
<ownedComment xmi:id="OpaqueAction-outputValue-_ownedComment.0" annotatedElement="OpaqueAction-outputValue">
<body>Takes output from the action.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="OpaqueAction-outputValue-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="OpaqueAction-outputValue-_lowerValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="CallAction" name="CallAction" isAbstract="true">
<ownedComment xmi:id="CallAction-_ownedComment.0" annotatedElement="CallAction">
<body>CallAction is an abstract class for actions that invoke behavior and receive return values.</body>
</ownedComment>
<ownedRule xmi:id="CallAction-synchronous_call" name="synchronous_call" constrainedElement="CallAction">
<ownedComment xmi:id="CallAction-synchronous_call-_ownedComment.0" annotatedElement="CallAction-synchronous_call">
<body>Only synchronous call actions can have result pins.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="CallAction-synchronous_call-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="CallAction-number_and_order" name="number_and_order" constrainedElement="CallAction">
<ownedComment xmi:id="CallAction-number_and_order-_ownedComment.0" annotatedElement="CallAction-number_and_order">
<body>The number and order of argument pins must be the same as the number and order of parameters of the invoked behavior or behavioral feature. Pins are matched to parameters by order.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="CallAction-number_and_order-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="CallAction-type_ordering_multiplicity" name="type_ordering_multiplicity" constrainedElement="CallAction">
<ownedComment xmi:id="CallAction-type_ordering_multiplicity-_ownedComment.0" annotatedElement="CallAction-type_ordering_multiplicity">
<body>The type, ordering, and multiplicity of an argument pin must be the same as the corresponding parameter of the behavior or behavioral feature.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="CallAction-type_ordering_multiplicity-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<generalization xmi:id="CallAction-_generalization.0" general="InvocationAction"/>
<ownedAttribute xmi:id="CallAction-isSynchronous" name="isSynchronous" type="Boolean">
<ownedComment xmi:id="CallAction-isSynchronous-_ownedComment.0" annotatedElement="CallAction-isSynchronous">
<body>If true, the call is synchronous and the caller waits for completion of the invoked behavior.&#xD;
If false, the call is asynchronous and the caller proceeds immediately and does not expect a return values.&#xD;
</body>
</ownedComment>
<defaultValue xmi:type="uml:LiteralBoolean" xmi:id="CallAction-isSynchronous-_defaultValue" value="true"/>
</ownedAttribute>
<ownedAttribute xmi:id="CallAction-result" name="result" type="OutputPin" isOrdered="true" aggregation="composite" subsettedProperty="Action-output" association="A_result_callAction">
<ownedComment xmi:id="CallAction-result-_ownedComment.0" annotatedElement="CallAction-result">
<body>A list of output pins where the results of performing the invocation are placed.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="CallAction-result-_upperValue" value="*"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="CallAction-result-_lowerValue"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="SendSignalAction" name="SendSignalAction">
<ownedComment xmi:id="SendSignalAction-_ownedComment.0" annotatedElement="SendSignalAction">
<body>A send signal action is an action that creates a signal instance from its inputs, and transmits it to the target object, where it may cause the firing of a state machine transition or the execution of an activity. The argument values are available to the execution of associated behaviors. The requestor continues execution immediately. Any reply message is ignored and is not transmitted to the requestor. If the input is already a signal instance, use a send object action.</body>
</ownedComment>
<ownedRule xmi:id="SendSignalAction-number_order" name="number_order" constrainedElement="SendSignalAction">
<ownedComment xmi:id="SendSignalAction-number_order-_ownedComment.0" annotatedElement="SendSignalAction-number_order">
<body>The number and order of argument pins must be the same as the number and order of attributes in the signal.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="SendSignalAction-number_order-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="SendSignalAction-type_ordering_multiplicity" name="type_ordering_multiplicity" constrainedElement="SendSignalAction">
<ownedComment xmi:id="SendSignalAction-type_ordering_multiplicity-_ownedComment.0" annotatedElement="SendSignalAction-type_ordering_multiplicity">
<body>The type, ordering, and multiplicity of an argument pin must be the same as the corresponding attribute of the signal.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="SendSignalAction-type_ordering_multiplicity-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<generalization xmi:id="SendSignalAction-_generalization.0" general="InvocationAction"/>
<ownedAttribute xmi:id="SendSignalAction-target" name="target" type="InputPin" aggregation="composite" subsettedProperty="Action-input" association="A_target_sendSignalAction">
<ownedComment xmi:id="SendSignalAction-target-_ownedComment.0" annotatedElement="SendSignalAction-target">
<body>The target object to which the signal is sent.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="SendSignalAction-target-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="SendSignalAction-target-_lowerValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="SendSignalAction-signal" name="signal" type="Signal" association="A_signal_sendSignalAction">
<ownedComment xmi:id="SendSignalAction-signal-_ownedComment.0" annotatedElement="SendSignalAction-signal">
<body>The type of signal transmitted to the target object.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="SendSignalAction-signal-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="SendSignalAction-signal-_lowerValue" value="1"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="CallOperationAction" name="CallOperationAction">
<ownedComment xmi:id="CallOperationAction-_ownedComment.0" annotatedElement="CallOperationAction">
<body>A call operation action is an action that transmits an operation call request to the target object, where it may cause the invocation of associated behavior. The argument values of the action are available to the execution of the invoked behavior. If the action is marked synchronous, the execution of the call operation action waits until the execution of the invoked behavior completes and a reply transmission is returned to the caller; otherwise execution of the action is complete when the invocation of the operation is established and the execution of the invoked operation proceeds concurrently with the execution of the calling behavior. Any values returned as part of the reply transmission are put on the result output pins of the call operation action. Upon receipt of the reply transmission, execution of the call operation action is complete.</body>
</ownedComment>
<ownedRule xmi:id="CallOperationAction-argument_pin_equal_parameter" name="argument_pin_equal_parameter" constrainedElement="CallOperationAction">
<ownedComment xmi:id="CallOperationAction-argument_pin_equal_parameter-_ownedComment.0" annotatedElement="CallOperationAction-argument_pin_equal_parameter">
<body>The number of argument pins and the number of owned parameters of the operation of type in and in-out must be equal.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="CallOperationAction-argument_pin_equal_parameter-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="CallOperationAction-result_pin_equal_parameter" name="result_pin_equal_parameter" constrainedElement="CallOperationAction">
<ownedComment xmi:id="CallOperationAction-result_pin_equal_parameter-_ownedComment.0" annotatedElement="CallOperationAction-result_pin_equal_parameter">
<body>The number of result pins and the number of owned parameters of the operation of type return, out, and in-out must be equal.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="CallOperationAction-result_pin_equal_parameter-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="CallOperationAction-type_ordering_multiplicity" name="type_ordering_multiplicity" constrainedElement="CallOperationAction">
<ownedComment xmi:id="CallOperationAction-type_ordering_multiplicity-_ownedComment.0" annotatedElement="CallOperationAction-type_ordering_multiplicity">
<body>The type, ordering, and multiplicity of an argument or result pin is derived from the corresponding owned parameter of the operation.&#xD;
</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="CallOperationAction-type_ordering_multiplicity-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="CallOperationAction-type_target_pin" name="type_target_pin" constrainedElement="CallOperationAction">
<ownedComment xmi:id="CallOperationAction-type_target_pin-_ownedComment.0" annotatedElement="CallOperationAction-type_target_pin">
<body>The type of the target pin must be the same as the type that owns the operation.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="CallOperationAction-type_target_pin-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<generalization xmi:id="CallOperationAction-_generalization.0" general="CallAction"/>
<ownedAttribute xmi:id="CallOperationAction-operation" name="operation" type="Operation" association="A_operation_callOperationAction">
<ownedComment xmi:id="CallOperationAction-operation-_ownedComment.0" annotatedElement="CallOperationAction-operation">
<body>The operation to be invoked by the action execution.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="CallOperationAction-operation-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="CallOperationAction-operation-_lowerValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="CallOperationAction-target" name="target" type="InputPin" aggregation="composite" subsettedProperty="Action-input" association="A_target_callOperationAction">
<ownedComment xmi:id="CallOperationAction-target-_ownedComment.0" annotatedElement="CallOperationAction-target">
<body>The target object to which the request is sent. The classifier of the target object is used to dynamically determine a behavior to invoke. This object constitutes the context of the execution of the operation.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="CallOperationAction-target-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="CallOperationAction-target-_lowerValue" value="1"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="CallBehaviorAction" name="CallBehaviorAction">
<ownedComment xmi:id="CallBehaviorAction-_ownedComment.0" annotatedElement="CallBehaviorAction">
<body>A call behavior action is a call action that invokes a behavior directly rather than invoking a behavioral feature that, in turn, results in the invocation of that behavior. The argument values of the action are available to the execution of the invoked behavior. For synchronous calls the execution of the call behavior action waits until the execution of the invoked behavior completes and a result is returned on its output pin. The action completes immediately without a result, if the call is asynchronous. In particular, the invoked behavior may be an activity.</body>
</ownedComment>
<ownedRule xmi:id="CallBehaviorAction-argument_pin_equal_parameter" name="argument_pin_equal_parameter" constrainedElement="CallBehaviorAction">
<ownedComment xmi:id="CallBehaviorAction-argument_pin_equal_parameter-_ownedComment.0" annotatedElement="CallBehaviorAction-argument_pin_equal_parameter">
<body>The number of argument pins and the number of parameters of the behavior of type in and in-out must be equal.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="CallBehaviorAction-argument_pin_equal_parameter-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="CallBehaviorAction-result_pin_equal_parameter" name="result_pin_equal_parameter" constrainedElement="CallBehaviorAction">
<ownedComment xmi:id="CallBehaviorAction-result_pin_equal_parameter-_ownedComment.0" annotatedElement="CallBehaviorAction-result_pin_equal_parameter">
<body>The number of result pins and the number of parameters of the behavior of type return, out, and in-out must be equal.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="CallBehaviorAction-result_pin_equal_parameter-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="CallBehaviorAction-type_ordering_multiplicity" name="type_ordering_multiplicity" constrainedElement="CallBehaviorAction">
<ownedComment xmi:id="CallBehaviorAction-type_ordering_multiplicity-_ownedComment.0" annotatedElement="CallBehaviorAction-type_ordering_multiplicity">
<body>The type, ordering, and multiplicity of an argument or result pin is derived from the corresponding parameter of the behavior.&#xD;
</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="CallBehaviorAction-type_ordering_multiplicity-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<generalization xmi:id="CallBehaviorAction-_generalization.0" general="CallAction"/>
<ownedAttribute xmi:id="CallBehaviorAction-behavior" name="behavior" type="Behavior" association="A_behavior_callBehaviorAction">
<ownedComment xmi:id="CallBehaviorAction-behavior-_ownedComment.0" annotatedElement="CallBehaviorAction-behavior">
<body>The invoked behavior. It must be capable of accepting and returning control.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="CallBehaviorAction-behavior-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="CallBehaviorAction-behavior-_lowerValue" value="1"/>
</ownedAttribute>
</packagedElement>
<packagedElement xmi:type="uml:Class" xmi:id="MultiplicityElement" name="MultiplicityElement" isAbstract="true">
<ownedComment xmi:id="MultiplicityElement-_ownedComment.0" annotatedElement="MultiplicityElement">
<body>A multiplicity is a definition of an inclusive interval of non-negative integers beginning with a lower bound and ending with a (possibly infinite) upper bound. A multiplicity element embeds this information to specify the allowable cardinalities for an instantiation of this element.</body>
</ownedComment>
<ownedRule xmi:id="MultiplicityElement-upper_gt_0" name="upper_gt_0" constrainedElement="MultiplicityElement">
<ownedComment xmi:id="MultiplicityElement-upper_gt_0-_ownedComment.0" annotatedElement="MultiplicityElement-upper_gt_0">
<body>A multiplicity must define at least one valid cardinality that is greater than zero.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-upper_gt_0-_specification">
<language>OCL</language>
<body>upperBound()->notEmpty() implies upperBound() > 0</body>
</specification>
</ownedRule>
<ownedRule xmi:id="MultiplicityElement-lower_ge_0" name="lower_ge_0" constrainedElement="MultiplicityElement">
<ownedComment xmi:id="MultiplicityElement-lower_ge_0-_ownedComment.0" annotatedElement="MultiplicityElement-lower_ge_0">
<body>The lower bound must be a non-negative integer literal.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-lower_ge_0-_specification">
<language>OCL</language>
<body>lowerBound()->notEmpty() implies lowerBound() >= 0</body>
</specification>
</ownedRule>
<ownedRule xmi:id="MultiplicityElement-upper_ge_lower" name="upper_ge_lower" constrainedElement="MultiplicityElement">
<ownedComment xmi:id="MultiplicityElement-upper_ge_lower-_ownedComment.0" annotatedElement="MultiplicityElement-upper_ge_lower">
<body>The upper bound must be greater than or equal to the lower bound.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-upper_ge_lower-_specification">
<language>OCL</language>
<body>(upperBound()->notEmpty() and lowerBound()->notEmpty()) implies upperBound() >= lowerBound()</body>
</specification>
</ownedRule>
<ownedRule xmi:id="MultiplicityElement-value_specification_no_side_effects" name="value_specification_no_side_effects" constrainedElement="MultiplicityElement">
<ownedComment xmi:id="MultiplicityElement-value_specification_no_side_effects-_ownedComment.0" annotatedElement="MultiplicityElement-value_specification_no_side_effects">
<body>If a non-literal ValueSpecification is used for the lower or upper bound, then evaluating that specification must not have side effects.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-value_specification_no_side_effects-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<ownedRule xmi:id="MultiplicityElement-value_specification_constant" name="value_specification_constant" constrainedElement="MultiplicityElement">
<ownedComment xmi:id="MultiplicityElement-value_specification_constant-_ownedComment.0" annotatedElement="MultiplicityElement-value_specification_constant">
<body>If a non-literal ValueSpecification is used for the lower or upper bound, then that specification must be a constant expression.</body>
</ownedComment>
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-value_specification_constant-_specification">
<language>OCL</language>
<body>true</body>
</specification>
</ownedRule>
<generalization xmi:id="MultiplicityElement-_generalization.0" general="Element"/>
<ownedAttribute xmi:id="MultiplicityElement-isOrdered" name="isOrdered" type="Boolean">
<ownedComment xmi:id="MultiplicityElement-isOrdered-_ownedComment.0" annotatedElement="MultiplicityElement-isOrdered">
<body>For a multivalued multiplicity, this attribute specifies whether the values in an instantiation of this element are sequentially ordered.</body>
</ownedComment>
<defaultValue xmi:type="uml:LiteralBoolean" xmi:id="MultiplicityElement-isOrdered-_defaultValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="MultiplicityElement-isUnique" name="isUnique" type="Boolean">
<ownedComment xmi:id="MultiplicityElement-isUnique-_ownedComment.0" annotatedElement="MultiplicityElement-isUnique">
<body>For a multivalued multiplicity, this attributes specifies whether the values in an instantiation of this element are unique.</body>
</ownedComment>
<defaultValue xmi:type="uml:LiteralBoolean" xmi:id="MultiplicityElement-isUnique-_defaultValue" value="true"/>
</ownedAttribute>
<ownedAttribute xmi:id="MultiplicityElement-upper" name="upper" type="UnlimitedNatural" isDerived="true">
<ownedComment xmi:id="MultiplicityElement-upper-_ownedComment.0" annotatedElement="MultiplicityElement-upper">
<body>Specifies the upper bound of the multiplicity interval.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="MultiplicityElement-upper-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="MultiplicityElement-upper-_lowerValue"/>
<defaultValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="MultiplicityElement-upper-_defaultValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="MultiplicityElement-lower" name="lower" type="Integer" isDerived="true">
<ownedComment xmi:id="MultiplicityElement-lower-_ownedComment.0" annotatedElement="MultiplicityElement-lower">
<body>Specifies the lower bound of the multiplicity interval.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="MultiplicityElement-lower-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="MultiplicityElement-lower-_lowerValue"/>
<defaultValue xmi:type="uml:LiteralInteger" xmi:id="MultiplicityElement-lower-_defaultValue" value="1"/>
</ownedAttribute>
<ownedAttribute xmi:id="MultiplicityElement-upperValue" name="upperValue" type="ValueSpecification" aggregation="composite" subsettedProperty="Element-ownedElement" association="A_upperValue_owningUpper">
<ownedComment xmi:id="MultiplicityElement-upperValue-_ownedComment.0" annotatedElement="MultiplicityElement-upperValue">
<body>The specification of the upper bound for this multiplicity.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="MultiplicityElement-upperValue-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="MultiplicityElement-upperValue-_lowerValue"/>
</ownedAttribute>
<ownedAttribute xmi:id="MultiplicityElement-lowerValue" name="lowerValue" type="ValueSpecification" aggregation="composite" subsettedProperty="Element-ownedElement" association="A_lowerValue_owningLower">
<ownedComment xmi:id="MultiplicityElement-lowerValue-_ownedComment.0" annotatedElement="MultiplicityElement-lowerValue">
<body>The specification of the lower bound for this multiplicity.</body>
</ownedComment>
<upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="MultiplicityElement-lowerValue-_upperValue" value="1"/>
<lowerValue xmi:type="uml:LiteralInteger" xmi:id="MultiplicityElement-lowerValue-_lowerValue"/>
</ownedAttribute>
<ownedOperation xmi:id="MultiplicityElement-setLower" name="setLower" visibility="protected">
<ownedParameter xmi:id="MultiplicityElement-setLower-newLower" name="newLower" visibility="protected" type="Integer" effect="read"/>
</ownedOperation>
<ownedOperation xmi:id="MultiplicityElement-setUpper" name="setUpper" visibility="protected">
<ownedParameter xmi:id="MultiplicityElement-setUpper-newUpper" name="newUpper" visibility="protected" type="UnlimitedNatural" effect="read"/>
</ownedOperation>
<ownedOperation xmi:id="MultiplicityElement-lower.1" name="lower" isQuery="true" bodyCondition="MultiplicityElement-lower.1-spec">
<ownedComment xmi:id="MultiplicityElement-lower.1-_ownedComment.0" annotatedElement="MultiplicityElement-lower.1">
<body>The derived lower attribute must equal the lowerBound.</body>
</ownedComment>
<ownedRule xmi:id="MultiplicityElement-lower.1-spec" name="spec" constrainedElement="MultiplicityElement-lower.1 MultiplicityElement-lower">
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-lower.1-spec-_specification">
<language>OCL</language>
<body>result = lowerBound()</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="MultiplicityElement-lower.1-_ownedParameter.0" type="Integer" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="MultiplicityElement-upper.1" name="upper" isQuery="true" bodyCondition="MultiplicityElement-upper.1-spec">
<ownedComment xmi:id="MultiplicityElement-upper.1-_ownedComment.0" annotatedElement="MultiplicityElement-upper.1">
<body>The derived upper attribute must equal the upperBound.</body>
</ownedComment>
<ownedRule xmi:id="MultiplicityElement-upper.1-spec" name="spec" constrainedElement="MultiplicityElement-upper.1 MultiplicityElement-upper">
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-upper.1-spec-_specification">
<language>OCL</language>
<body>result = upperBound()</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="MultiplicityElement-upper.1-_ownedParameter.0" type="UnlimitedNatural" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="MultiplicityElement-isMultivalued" name="isMultivalued" isQuery="true" precondition="MultiplicityElement-isMultivalued-_ownedRule.0" bodyCondition="MultiplicityElement-isMultivalued-spec">
<ownedComment xmi:id="MultiplicityElement-isMultivalued-_ownedComment.0" annotatedElement="MultiplicityElement-isMultivalued">
<body>The query isMultivalued() checks whether this multiplicity has an upper bound greater than one.</body>
</ownedComment>
<ownedRule xmi:id="MultiplicityElement-isMultivalued-_ownedRule.0" constrainedElement="MultiplicityElement-isMultivalued">
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-isMultivalued-_ownedRule.0-_specification">
<language>OCL</language>
<body>upperBound()->notEmpty()</body>
</specification>
</ownedRule>
<ownedRule xmi:id="MultiplicityElement-isMultivalued-spec" name="spec" constrainedElement="MultiplicityElement-isMultivalued">
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-isMultivalued-spec-_specification">
<language>OCL</language>
<body>result = upperBound() > 1</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="MultiplicityElement-isMultivalued-_ownedParameter.0" type="Boolean" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="MultiplicityElement-includesCardinality" name="includesCardinality" isQuery="true" precondition="MultiplicityElement-includesCardinality-_ownedRule.0" bodyCondition="MultiplicityElement-includesCardinality-spec">
<ownedComment xmi:id="MultiplicityElement-includesCardinality-_ownedComment.0" annotatedElement="MultiplicityElement-includesCardinality">
<body>The query includesCardinality() checks whether the specified cardinality is valid for this multiplicity.</body>
</ownedComment>
<ownedRule xmi:id="MultiplicityElement-includesCardinality-_ownedRule.0" constrainedElement="MultiplicityElement-includesCardinality">
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-includesCardinality-_ownedRule.0-_specification">
<language>OCL</language>
<body>upperBound()->notEmpty() and lowerBound()->notEmpty()</body>
</specification>
</ownedRule>
<ownedRule xmi:id="MultiplicityElement-includesCardinality-spec" name="spec" constrainedElement="MultiplicityElement-includesCardinality">
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-includesCardinality-spec-_specification">
<language>OCL</language>
<body>result = (lowerBound() &lt;= C) and (upperBound() >= C)</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="MultiplicityElement-includesCardinality-_ownedParameter.0" type="Boolean" direction="return"/>
<ownedParameter xmi:id="MultiplicityElement-includesCardinality-C" name="C" type="Integer"/>
</ownedOperation>
<ownedOperation xmi:id="MultiplicityElement-includesMultiplicity" name="includesMultiplicity" isQuery="true" precondition="MultiplicityElement-includesMultiplicity-_ownedRule.0" bodyCondition="MultiplicityElement-includesMultiplicity-spec">
<ownedComment xmi:id="MultiplicityElement-includesMultiplicity-_ownedComment.0" annotatedElement="MultiplicityElement-includesMultiplicity">
<body>The query includesMultiplicity() checks whether this multiplicity includes all the cardinalities allowed by the specified multiplicity.</body>
</ownedComment>
<ownedRule xmi:id="MultiplicityElement-includesMultiplicity-_ownedRule.0" constrainedElement="MultiplicityElement-includesMultiplicity">
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-includesMultiplicity-_ownedRule.0-_specification">
<language>OCL</language>
<body>self.upperBound()->notEmpty() and self.lowerBound()->notEmpty() and M.upperBound()->notEmpty() and M.lowerBound()->notEmpty()</body>
</specification>
</ownedRule>
<ownedRule xmi:id="MultiplicityElement-includesMultiplicity-spec" name="spec" constrainedElement="MultiplicityElement-includesMultiplicity">
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-includesMultiplicity-spec-_specification">
<language>OCL</language>
<body>result = (self.lowerBound() &lt;= M.lowerBound()) and (self.upperBound() >= M.upperBound())</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="MultiplicityElement-includesMultiplicity-_ownedParameter.0" type="Boolean" direction="return"/>
<ownedParameter xmi:id="MultiplicityElement-includesMultiplicity-M" name="M" type="MultiplicityElement"/>
</ownedOperation>
<ownedOperation xmi:id="MultiplicityElement-lowerBound" name="lowerBound" isQuery="true" bodyCondition="MultiplicityElement-lowerBound-spec">
<ownedComment xmi:id="MultiplicityElement-lowerBound-_ownedComment.0" annotatedElement="MultiplicityElement-lowerBound">
<body>The query lowerBound() returns the lower bound of the multiplicity as an integer.</body>
</ownedComment>
<ownedRule xmi:id="MultiplicityElement-lowerBound-spec" name="spec" constrainedElement="MultiplicityElement-lowerBound">
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-lowerBound-spec-_specification">
<language>OCL</language>
<body>result = if lowerValue->isEmpty() then 1 else lowerValue.integerValue() endif</body>
</specification>
</ownedRule>
<ownedParameter xmi:id="MultiplicityElement-lowerBound-_ownedParameter.0" type="Integer" direction="return"/>
</ownedOperation>
<ownedOperation xmi:id="MultiplicityElement-upperBound" name="upperBound" isQuery="true" bodyCondition="MultiplicityElement-upperBound-spec">
<ownedComment xmi:id="MultiplicityElement-upperBound-_ownedComment.0" annotatedElement="MultiplicityElement-upperBound">
<body>The query upperBound() returns the upper bound of the multiplicity for a bounded multiplicity as an unlimited natural.</body>
</ownedComment>
<ownedRule xmi:id="MultiplicityElement-upperBound-spec" name="spec" constrainedElement="MultiplicityElement-upperBound">
<specification xmi:type="uml:OpaqueExpression" xmi:id="MultiplicityElement-upperBound-spec-_specification">
<language>OCL</language>
<body>result = if upperValue->isEmpty() then 1 else upperValue.unlimitedValue() endif</body>
</specification>
</ownedRule>