Software Disclaimer

Class UML 2.3::Association

Description:

An association describes a set of tuples whose values refer to typed instances. An instance of an association is called a link. A link is a tuple with one value for each end of the association, where each value is an instance of the type of the end.

Direct Superclasses: Classifier, Relationship

Direct Subclasses: Extension, CommunicationPath, AssociationClass

Class Precedence List: Association, Classifier, TemplateableElement, Type, PackageableElement, ParameterableElement, Namespace, RedefinableElement, NamedElement, Relationship, Element

Properties:

endType : Type (1 *); -- source Association
isDerived : Boolean (1 1); -- source Association
memberEnd : Property (2 *); -- source Association
navigableOwnedEnd : Property (0 *); -- source Association
ownedEnd : Property (0 *); -- source Association
attribute : Property (0 *); -- source Classifier
collaborationUse : CollaborationUse (0 *); -- source Classifier
feature : Feature (0 *); -- source Classifier
general : Classifier (0 *); -- source Classifier
generalization : Generalization (0 *); -- source Classifier
inheritedMember : NamedElement (0 *); -- source Classifier
isAbstract : Boolean (1 1); -- source Classifier

If true, the Classifier does not provide a complete declaration and can typically not be instantiated. An abstract classifier is intended to be used by other classifiers e.g. as the target of general metarelationships or generalization relationships.
Default value: FALSE

isFinalSpecialization : Boolean (1 1); -- source Classifier
ownedTemplateSignature : RedefinableTemplateSignature (0 1); -- source Classifier
ownedUseCase : UseCase (0 *); -- source Classifier
powertypeExtent : GeneralizationSet (0 *); -- source Classifier
redefinedClassifier : Classifier (0 *); -- source Classifier
representation : CollaborationUse (0 1); -- source Classifier
substitution : Substitution (0 *); -- source Classifier
templateParameter : ClassifierTemplateParameter (0 1); -- source Classifier
useCase : UseCase (0 *); -- source Classifier
templateBinding : TemplateBinding (0 *); -- source TemplateableElement
package : Package (0 1); -- source Type
visibility : VisibilityKind (1 1); -- source PackageableElement
owningTemplateParameter : TemplateParameter (0 1); -- source ParameterableElement
elementImport : ElementImport (0 *); -- source Namespace
importedMember : PackageableElement (0 *); -- source Namespace
member : NamedElement (0 *); -- source Namespace
ownedMember : NamedElement (0 *); -- source Namespace
ownedRule : Constraint (0 *); -- source Namespace
packageImport : PackageImport (0 *); -- source Namespace
isLeaf : Boolean (1 1); -- source RedefinableElement
redefinedElement : RedefinableElement (0 *); -- source RedefinableElement
redefinitionContext : Classifier (0 *); -- source RedefinableElement
clientDependency : Dependency (0 *); -- source NamedElement
name : String (0 1); -- source NamedElement
nameExpression : StringExpression (0 1); -- source NamedElement
namespace : Namespace (0 1); -- source NamedElement
qualifiedName : String (0 1); -- source NamedElement
relatedElement : Element (1 *); -- source Relationship
ownedComment : Comment (0 *); -- source Element
ownedElement : Element (0 *); -- source Element
owner : Element (0 1); -- source Element

Constraints:

Signature: CMOF_14_3_29() : Boolean;
Description: 14.3 [29] Each Association memberEnd Property must be typed by a Class.
Expression: memberEnd.type.oclIsKindOf(Class)

Signature: CMOF_14_3_1() : Boolean;
Description: 14.3 [1] The multiplicity of Association::memberEnd is limited to 2 rather than 2..* (i.e., n-ary Associations are not supported); unlike EMOF, CMOF associations can have navigable association-owned ends. see also: https://sites.google.com/site/metamodelingantipatterns/catalog/mof/association-does-not-have-two-member-ends
Expression: memberEnd->size() = 2 and ownedEnd->size() < 2

Signature: specialized_end_types() : Boolean;
Description: 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.
The OCL used here is not normative.
Editor's notes: Needs further investigation: (1) POD my parser has a bug that reads 1.0 instead of 1 and then .. (2) Why the empty sequence.
Expression: true
Original: Sequence{1 ..self.memberEnd->size()}-> forAll(i | self.general->select(oclIsKindOf(Association)).oclAsType(Association)-> forAll(ga |self.memberEnd->at(i).type.conformsTo(ga.memberEnd->at(i).type)))

Signature: specialized_end_number() : Boolean;
Description: An association specializing another association has the same number of ends as the other association.
The OCL used here is not normative.
Editor's notes: ->collect(...) before oclAsType. It's not a property. The infamous shorthand does not apply.
Expression: parents()->select(oclIsKindOf(Association))->collect(oclAsType(Association))->forAll(p | p.memberEnd->size() = self.memberEnd->size())
Original: parents()->select(oclIsKindOf(Association)).oclAsType(Association)->forAll(p | p.memberEnd->size() = self.memberEnd->size())

Signature: binary_associations() : Boolean;
Description: Only binary associations can be aggregations.
The OCL used here is not normative.
Editor's notes: Association has no aggregation attribute.
Expression: true
Original: self.memberEnd->exists(aggregation <> Aggregation::none) implies self.memberEnd->size() = 2

Signature: association_ends() : Boolean;
Description: Association ends of associations with more than two ends must be owned by the association.
The OCL used here is not normative.
Editor's notes: should be implies
Expression: memberEnd->size() > 2 implies ownedEnd->includesAll(memberEnd)
Original: if memberEnd->size() > 2 then ownedEnd->includesAll(memberEnd)

Operations:

Signature: endType.1() : Type;
Description: endType is derived from the types of the member ends.
Expression: result = self.memberEnd->collect(e | e.type)



Send questions or comments to xmi-interop@omg.org.