| Previous | Table of Contents | Next |
An association defines a semantic relationship between classifiers. Associations have two or more named ends. Associations
with two or more ends are called “n-ary? whereas associations with exactly two ends are called “binary.? Each end, depending
upon its multiplicity, connects to zero or more instances of some classifier.
In the metamodel, an Association is a declaration of a semantic relationship between Classifiers, such as Classes. Associations
must have two, and may have more, association ends. Each end is connected to a Classifier; the same Classifier may be connected
to more than one association end in the same association. (Refer to the ObjectModel’s Instance package, below, for a description
of how Associations are instantiated.)
Because Associations are classifiers, they own and order their association ends (which are Attributes) via the ClassifierFeature
association. In addition, because Associations are Classes, they can also own more traditional StructuralFeatures such as
Attributes. Consequently, they may act in a manner similar to “association classes? described by some other object models.
An association may represent an aggregation; that is, a whole/part relationship. In this case, the association end attached
to the whole element is designated, and the other association end represents the parts of the aggregation.
Associations can be of three different kinds: (1) ordinary association, (2) composite aggregate, and (3) shareable aggregate.
Since the aggregate construct can have several different meanings depending on the application area, CWM gives a more precise
meaning to two of these constructs; that is, association and composite aggregate and leaves the shareable aggregate more loosely
defined in between. Only binary Associations can have composite or sharable aggregation semantics.
Composite aggregation is a strong form of aggregation, which requires that a part instance be included in at most one composite
at a time and that the composite object has sole responsibility for the disposition of its parts. This means that the composite
object is responsible for the creation and destruction of the parts. In implementation terms, it is responsible for their
memory allocation. If a composite object is destroyed, it must destroy all of its parts. It may remove a part and give it
to another composite object, which then assumes responsibility for it. If the multiplicity from a part to composite is zero-to-one,
the composite may remove the part and the part may assume responsibility for itself, otherwise it may not live apart from
a composite.
A consequence of these rules is that a composite aggregation implies propagation semantics; that is, some of the dynamic semantics
of the whole is propagated to its parts. For example, if the whole is copied or destroyed, then so are the parts as well (because
a part may belong to at most one composite).
A classifier on the composite end of an association may have parts that are classifiers and associations. At the instance
level, an instance of a part element is considered “part of? the instance of a composite element. If an association is part
of a composite and it connects two classes that are also part of the same composite, then an instance of the association will
connect objects that are part of the same composite object of which the instance is part.
A shareable aggregation denotes weak ownership; that is, the part may be included in several aggregates and its owner may
also change over time. However, the semantics of a shareable aggregation does not imply deletion of the parts when an aggregate
referencing it is deleted. Both kinds of aggregations define a transitive, antisymmetric relationship; that is, the instances
form a directed, non-cyclic graph. Composition instances form a strict tree (or rather a forest).
Superclasses
Class
Constraints
An Association must have at least two AssociationEnds. [C-5-1]
The AssociationEnds must have a unique name within the association. [C-5-2]
At most one AssociationEnd may be an aggregation or composition. [C-5-3]
If an Association has three or more AssociationEnds, then no AssociationEnd may be an aggregation or composition. [C-5-4]
The connected Classifiers of the AssociationEnds should be included in the Namespace of the Association, or be Classifiers
with public visibility in other Namespaces to which the Association has access. [C-5-5]
An association end is an endpoint of an association that connects the association to a classifier. Each association end is
part of one association. The association ends of each association are ordered.
In the metamodel an AssociationEnd is part of an Association and specifies the connection of an Association to some other
Classifier. Because AssociationEnds are a kind of StructuralFeature, they are owned and ordered by Association instances via
the ClassifierFeature association. The StructuralFeatureType association is used to identify the Classifier to which the
AssociationEnd is attached. Each AssociationEnd has a name and defines a set of properties of the connection.
The multiplicity property of an association end specifies how many instances of the classifier at a given end (the one bearing
the multiplicity value) may be associated with a single instance of the classifier at the other end. The association end also
states whether or not the connection may be traversed towards the instance playing that role in the connection (the isNavigable
attribute); that is, if the instance is directly reachable via the association.
Superclasses
StructuralFeature
Attributes
aggregation
When placed on one end (the “target? end), specifies whether the class on the target end is an aggregation with respect to the class on the other end (the “source? end). Only one end of an association can be an aggregation.type:multiplicity: |
|||||
| AggregationKind | |||||
| exactly one |
isNavigable
When placed on a target end, specifies whether traversal from a source instance to its associated target instances is possible. A value of true means that the association can be navigated by the source class and the target rolename can be used in navigation expressions. Specification of navigability for each direction is defined independently.type:multiplicity: |
|||||
| Boolean | |||||
| exactly one |
Constraints
An AssociationEnd must have an owning Association. [C-5-6]
The Classifier of an AssociationEnd cannot be an Interface or a DataType if the association is navigable away from that end.
[C-5-7]
An Instance may not belong by composition to more than one composite Instance. [C-5-8]
An AssociationEnd with composite or shared aggregation semantics must be owned by an Association. [C-5-9]
A generalization is a taxonomic relationship between a more general element and a more specific element. The more specific
element is fully consistent with the more general element (it has all of its properties, members, and relationships) and may
contain additional information.
In the metamodel a Generalization is a directed inheritance relationship, uniting a Classifier with a more general Classifier
in a hierarchy. Generalization is a subtyping relationship; that is, an instance of the more general (“parent?) Classifier
may be substituted by an instance of the more specific (“child?) Classifier.
To understand inheritance fully, it is necessary to understand the concept of a full descriptor and a segment descriptor.
A full descriptor is the full description needed to describe an instance of a metamodel object. It contains a description
of all of the attributes, associations, and operations that the object contains.
In a pre-object-oriented language, the full descriptor of a data structure was declared directly in its entirety. In an object-oriented
language, the description of an object is built out of incremental segments that are combined using inheritance to produce
a full descriptor for an object. The segments are the modeling elements that are actually declared in a model. Each classifier
contains a list of features and other relationships that it adds to what it inherits from its ancestors. The mechanism of
inheritance defines how full descriptors are produced from a set of segments connected by generalization. The full descriptors
are implicit, but they define the structure of actual instances. Features of a classifier that have private visibility are
not visible to descendants of the classifier.
If a classifier has no parent, then its full descriptor is the same as its segment descriptor. If a classifier has one or
more parents, then its full descriptor contains the union of the features from its own segment descriptor and the segment
descriptors of all of its ancestors. No attribute, operation, or association end with the same signature may be declared in
more than one of the segments (in other words, they may not be redefined). A method may be declared in more than one segment.
A method declared in any segment supersedes and replaces a method with the same signature declared in any ancestor. If two
or more methods nevertheless remain, then they conflict and the model is ill formed. The constraints on the full descriptor
are the union of the constraints on the segment itself and all of its ancestors. If any of them are inconsistent, then the
model is ill formed.
In any full descriptor for a classifier, each method must have a corresponding operation. In a concrete classifier, each operation
in its full descriptor must have a corresponding method in the full descriptor.
Superclasses
ModelElement
References
child
Designates a Classifier that occupies the child or specialization position of the Generalization relationship.class:defined by:multiplicity: |
|||||
| Classifier | |||||
| ChildElement::child | |||||
| exactly one |
parent
Designates a Classifier that occupies the parent or generalization position of the Generalization relationship.class:defined by:multiplicity: |
|||||
| Classifier | |||||
| ParentElement::parent | |||||
| exactly one |