Kernel the
Classifiers Diagram
The Classifiers diagram of the Kernel package is shown in Figure 22.
In order to locate the metaclasses that are referenced from this
diagram,
· See "DirectedRelationship (from
Kernel)".
· See "NamedElement
(from Kernel, Dependencies)" .
· See "Namespace (from
Kernel)" .
· See
"PackageableElement (from Kernel)".
Classifier (from Kernel, Dependencies,
PowerTypes)
A classifier is a classification of instances -- it describes a set of
instances that have features in common.
Description
A classifier is a namespace whose members can include features.
Classifier is an abstract metaclass.
A classifier is a type and can own generalizations, thereby making it
possible to define generalization relationships to other classifiers. A
classifier can specify a generalization hierarchy by referencing its
general classifiers.
A classifier is a redefinable element, meaning that it is possible to
redefine nested classifiers.
Attributes
- isAbstract: Boolean 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 is false.
Associations
- attribute: Property [*] Refers to all of the
Properties that are direct (i.e. not inherited or imported) attributes
of the classifier. Subsets Classifier::feature and is a
derived union.
- / feature : Feature [*] Specifies each feature
defined in the classifier. Subsets Namespace::member. This is a
derived union.
- / general : Classifier[*] Specifies the general
Classifiers for this Classifier. This is derived.
- generalization: Generalization[*]
Specifies the Generalization relationships for this
Classifier. These Generalizations navigate to more general classifiers
in the generalization hierarchy. Subsets Element::ownedElement.
- / inheritedMember: NamedElement[*] Specifies all
elements inherited by this classifier from the general classifiers.
Subsets Namespace::member. This is derived.
- package: Package [0..1] Specifies
the owning package of this classifier, if any. Subsets NamedElement::namespace.
- redefinedClassifier: Classifier [*]
References the Classifiers that are redefined by this Classifier.
Subsets RedefinableElement::redefinedElement.
Package Dependencies ("Dependencies"
on page 105)
- substitution : Substitution References the
substitutions that are owned by this Classifier. Subsets Element::ownedElement
and NamedElement::clientDependency.)
Package PowerTypes ("PowerTypes" on
page 120)
- powertypeExtent : GeneralizationSet Designates the
GeneralizationSet of which the associated Classifier is a power type.
Constraints
[1] The general classifiers are the classifiers referenced by the
generalization relationships.
general = self.parents()
[2] Generalization hierarchies must be directed and acyclical. A
classifier can not be both a transitively general and transitively
specific classifier of the same classifier.
not self.allParents()->includes(self)
[3] A classifier may only specialize classifiers of a valid type.
self.parents()->forAll(c | self.maySpecializeType(c))
[4] The inheritedMember association is derived by inheriting the
inheritable members of the parents.
self.inheritedMember->includesAll(self.inherit(self.parents()->collect(p
| p.inheritableMembers(self)))
Package PowerTypes ("PowerTypes" on
page 120)
[5] The Classifier that maps to a GeneralizationSet may neither be
a specific nor a general Classifier in any of the Generalization
relationships defined for that GeneralizationSet. In other words, a
power type may not be an instance of itself nor may its instances also
be its subclasses.
Additional Operations
[1] The query allFeatures() gives all of the features in the
namespace of the classifier. In general, through mechanisms such as
inheritance, this will be a larger set than feature.
Classifier::allFeatures(): Set(Feature);
allFeatures = member->select(oclIsKindOf(Feature))
[2] The query parents() gives all of the immediate ancestors of a
generalized Classifier.
Classifier::parents(): Set(Classifier);
parents = generalization.general
[3] The query allParents() gives all of the direct and indirect
ancestors of a generalized Classifier.
Classifier::allParents(): Set(Classifier);
allParents = self.parents()->union(self.parents()->collect(p |
p.allParents())
[4] The query inheritableMembers() gives all of the members of a
classifier that may be inherited in one of its descendants,subject to
whatever visibility restrictions apply.
Classifier::inheritableMembers(c: Classifier): Set(NamedElement);
pre: c.allParents()->includes(self)
inheritableMembers = member->select(m | c.hasVisibilityOf(m))
[5] The query hasVisibilityOf() determines whether a named element is
visible in the classifier. By default all are visible. It is only
called when the argument is something owned by a parent.
Classifier::hasVisibilityOf(n: NamedElement) : Boolean;
pre: self.allParents()->collect(c | c.member)->includes(n)
hasVisibilityOf =true
[6] The query conformsTo() gives true for a classifier that defines a
type that conforms to another. This is used, for example,in the
specification of signature conformance for operations.
Classifier::conformsTo(other: Classifier): Boolean;
conformsTo = (self=other) or (self.allParents()->includes(other))
[7] The query inherit() defines how to inherit a set of elements. Here
the operation is defined to inherit them all. It is intended to be
redefined in circumstances where inheritance is affected by
redefinition.
Classifier::inherit(inhs: Set(NamedElement)): Set(NamedElement);
inherit = inhs
[8] The query maySpecializeType() determines whether this classifier
may have a generalization relationship to classifiers of the specified
type. By default a classifier may specialize classifiers of the same or
a more general type. It is intended to be redefined by classifiers that
have different specialization constraints.
Classifier::maySpecializeType(c : Classifier) : Boolean;
maySpecializeType = self.oclIsKindOf(c.oclType)
Semantics
A classifier is a classification of instances according to their
features.
A Classifier may participate in generalization relationships with other
Classifiers. An instance of a specific Classifier is also an (indirect)
instance of each of the general Classifiers. Therefore, features
specified for instances of the general classifier are implicitly
specified for instances of the specific classifier. Any constraint
applying to instances of the general classifier also applies to
instances of the specific classifier.
The specific semantics of how generalization affects each concrete
subtype of Classifier varies. All instances of a classifier have values
corresponding to the classifier's attributes.
A Classifier defines a type. Type conformance between generalizable
Classifiers is defined so that a Classifier conforms to itself and to
all of its ancestors in the generalization hierarchy.
Package PowerTypes ("PowerTypes" on
page 120)
The notion of power type was
inspired by the notion of power set. A power set is defined as a set
whose instances are subsets.
In essence, then, a power type is a class whose instances are
subclasses. The powertypeExtent association relates a Classifier with a
set of generalizations which a) have a common specific Classifier, and
b) represent a subclass partitioning of that class.
Semantic Variation Points
The precise lifecycle semantics of aggregation is a semantic
variation point.
Notation
The default notation for a classifier is a solid-outline rectangle
containing the classifier's name, and optionally with compartments
separated by horizontal lines containing features or other members of
the classifier. The specific type of classifier can be shown in
guillemets above the name. Some specializations of Classifier have
their own distinct notations.
The name of an abstract Classifier is shown in italics.
An attribute can be shown as a text string that can be parsed into the
various properties of an attribute. The basic syntax is (with optional
parts shown in braces):
[visibility] [/] name [:
type] [multiplicity] [= default] [{
property-string }]
In the following bullets, each of these parts is described:
- visibility is a visibility symbol such as +, -, #,
or~. See VisibilityKind
(from
Kernel) .
- / means the attribute is derived.
- name is the name of the attribute.
- type identifies a classifier that is the
attribute's type.
- multiplicity shows the attribute's multiplicity in
square
brackets. The term may be omitted when a multiplicity of 1 (exactly
one) is to be assumed. See
MultiplicityElement (from Kernel)
- default is an expression for the default value or
values of
the attribute.
- property-string indicates property values that
apply to the
attribute. The property string is optional (the braces are omitted if
no properties are specified).
The following property strings can be applied to an attribute:
{readOnly}, {union}, {subsets <property-name>}, {redefines
<property-name>}, {ordered}, {bag}, {seq} or {sequence}, and
{composite}.
An attribute with the same name as an attribute that would have been
inherited is interpreted to be a redefinition, without the need for a
{redefines <x>} property string. Note that a redefined attribute
is not inherited into a namespace where it is redefined, so its name
can be reused in the featuring classifier, either for the redefining
attribute, or alternately for some other attribute.
Presentation Options
Any compartment may be suppressed. A separator line is not drawn
for a suppressed compartment. If a compartment is suppressed, no
inference can be drawn about the presence or absence of elements in it.
Compartment names can be used to remove ambiguity, if necessary.
An abstract Classifier can be shown using the keyword {abstract} after
or below the name of the Classifier.
The type, visibility, default, multiplicity, property string may be
suppressed from being displayed, even if there are values in the model.
The individual properties of an attribute can be shown in columns
rather than as a continuous string.
Style Guidelines
Attribute names typically begin with a lowercase letter. Multiword
names are often formed by concatenating the words and using lowercase
for all letter except for upcasing the first letter of each word but
the first.
Examples
The attributes in Figure 23
are explained below.
· ClassA::name is an attribute with type String.
· ClassA::shape is an attribute with type Rectangle.
· ClassA::size is a public attribute of type Integer with
multiplicity 0..1.
· ClassA::area is a derived attribute with type Integer. It is
marked as read-only.
· ClassA::height is an attribute of type Integer with a default
initial value of 5.
· ClassA::width is an attribute of type Integer
· ClassB::id is an attribute that redefines ClassA::name.
· ClassB::shape is an attribute that redefines ClassA::shape. It
has type Square, a specialization of Rectangle.
· ClassB::height is an attribute that redefines ClassA::height.
It has a default of 7 for ClassB instances which overrides the ClassA
default of 5.
· ClassB::width is a derived attribute that redefines
ClassA::width, which is not derived.
An attribute may also be shown using association notation, with no
adornments at the tail of the arrow as shown in Figure 24.
Package PowerTypes ("PowerTypes")
For example, a Bank Account Type classifier could have a powertype
association with a GeneralizationSet. This GeneralizationSet could then
associate with two Generalizations where the class (i.e., general
Classifier) Bank Account has two specific subclasses (i.e.,
Classifiers): Checking Account and Savings Account. Checking Account
and Savings Account, then, are instances of the power type: Bank
Account Type. In other words, Checking Account and Savings Account are both:
instances of Bank Account Type, as well as subclasses of Bank Account.
(For more explanation and examples, see Examples in the
GeneralizationSet section, below.)
Generalization (from Kernel,
PowerTypes)
A generalization is a taxonomic relationship between a more general
classifier and a more specific classifier. Each instance of the
specific classifier is also an indirect instance of the general
classifier. Thus, the specific classifier inherits the features
of the more general classifier.
Description
A generalization relates a specific classifier to a more general
classifier, and is owned by the specific classifier.
Package PowerTypes ("PowerTypes")
A generalization can be designated as being a member of a particular
generalization set.
Attributes
- isSubstitutable: Boolean
[0..1] Indicates whether the
specific classifier can be used whereever the general classifier can be
used. If true, the execution traces of the specific classifier
will be a superset of the execution traces of the general classifier.
Associations
- general: Classifier [1] References the general classifier
in the Generalization relationship. Subsets DirectedRelationship::target.
- specific: Classifier [1] References the specializing
classifier in the Generalization relationship. Subsets DirectedRelationship::source
and Element::owner.
Package PowerTypes ("PowerTypes" on
page 120)
- generalizationSet Designates a set in which instances of
Generalization is considered members.
Constraints
No additional constraints.
Package PowerTypes ("PowerTypes" on
page 120)
[1] Every Generalization associated with a given GeneralizationSet
must have the same general Classifier. That is, all Generalizations for
a particular GeneralizationSet must have the same superclass.
Semantics
Where a generalization relates a specific classifier to a general
classifier, each instance of the specific classifier is also an
instance of the general classifier. Therefore, features specified for
instances of the general classifier are implicitly specified for
instances of the specific classifier. Any constraint applying to
instances of the general classifier also applies to instances of the
specific classifier.
Package PowerTypes ("PowerTypes" on
page 120)
Each Generalization is a binary relationship that relates a
specific Classifier to a more general Classifier (i.e., a subclass).
Each GeneralizationSet contains a particular set of Generalization
relationships that collectively describe the way in which a
specific Classifier (or class) may be partitioned. The
generalizationSet associates those instances of a Generalization with a
particular GeneralizationSet.
For example, one Generalization could relate Person as a general
Classifier with a Female Person as the specific Classifier. Another
Generalization could also relate Person as a general Classifier, but
have Male Person as the specific Classifier. These two Generalizations
could be associated with the same GeneralizationSet, because they
specify one way of partitioning the Person class.
Notation
A Generalization is shown as a line with an hollow triangle as an
arrowhead between the symbols representing the involved classifiers.
The arrowhead points to the symbol representing the general classifier.
This notation is referred to as the "separate target style". See the
example section below.
Package PowerTypes ("PowerTypes" on
page 120)
A generalization is shown as a line with an hollow triangle as an
arrowhead between the symbols representing the involved classifiers.
The arrowhead points to the symbol representing the general classifier.
When these relationships are named, that name designates the
GeneralizationSet to which the Generalization belongs. Each
GeneralizationSet has a name (which it inherits since it is a subclass
of PackableElement). Therefore, all Generalization relationships with
the same GeneralizationSet
name are part of the same GeneralizationSet. This notation form is
depicted in a), below.When two or more lines are drawn to the same
arrowhead, as illustrated in b) below, the specific Classifiers are
part of the same GeneralizationSet. When diagrammed in the way, the
lines do not need to be labeled separately; instead the
generalization set need only be labeled once. The labels are optional
because the GeneralizationSet is clearly designated.
Lastly in c) below, a GeneralizationSet can be designated by drawing a
dashed line across those lines with separate arrowheads that are meant
to be part of the same set, as illustrated at the bottom of the figure
below. Here, as with b), the GeneralizationSet may be labeled with a
single name, instead of each line labeled separately. However, such
labels are optional because the UML Superstructure 2.0 Draft Adopted
Specification
GeneralizationSet is clearly designated.

Multiple Generalization relationships that reference the same general
classifier can be connected together in the "shared target
style". See the example section below.
Package PowerTypes ("PowerTypes" on page
120)
In the illustration below, the Person class can be specialized as
either a Female Person or a Male Person. Furthermore, Person's can be
specialized as an Employee. Here, Female Person or a Male Person of
Person constitute one GeneralizationSet and Manager another. This
illustration employs the notation forms depicted in the diagram above.
RedefinableElement (from
Kernel)
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.
Description
A redefinable element is a named element that can be redefined in
the context of a generalization. RedefinableElement is an abstract
metaclass.
Attributes
- isLeaf: Boolean 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. Default value is false.
Associations
- / redefinedElement:
RedefinableElement[*] The
redefinable element that is being redefined by this element. This is a
derived union.
- / redefinitionContext:
Classifier[*]
References the contexts that this element may be redefined from. This
is a derived union.
Constraints
[1] 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.
self.redefinedElement->forAll(e | self.isRedefinitionContextValid(e))
[2] A redefining element must be consistent with each redefined element.
self.redefinedElement->forAll(re | re.isConsistentWith(self))
Additional Operations
[1] 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.
RedefinableElement::isConsistentWith(redefinee: RedefinableElement):
Boolean;
pre: redefinee.isRedefinitionContextValid(self)
isConsistentWith = false
[2] 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.
RedefinableElement::isRedefinitionContexValid(redefinable:
RedefinableElement): Boolean;
isRedefinitionContextValid = self.redefinitionContext->exists(c |
redefinable.redefinitionContext->exists(c |
c.allParents()->includes(r))
)
Semantics
A RedefinableElement represents the general ability to be redefined
in the context of a generalization relationship. The detailed semantics
of redefinition varies for each specialization of RedefinableElement.
A redefinable element is a specification concerning instances of
a classifier that is one of the element's redefinition contexts.
For a classifier that specializes that more general classifier
(directly or indirectly), another element can redefine the element from
the general classifier in order to augment, constrain, or override the
specification as it applies more specifically to instances of the
specializing classifier.
A redefining element must be consistent with the element it redefines,
but it can add specific constraints or other details that are
particular to instances of the specializing redefinition context that
do not contradict invariant constraints in the general context.
A redefinable element may be redefined multiple times. Furthermore, one
redefining element may redefine multiple inherited redefinable elements.
Semantic Variation Points
There are various degrees of compatibility between the redefined
element and the redefining element, such as name compatibility (the
redefining element has the same name as the redefined element),
structural compatibility (the client visible properties of the
redefined element are also properties of the redefining element), or
behavioral compatibility (the redefining element is substitutable for
the redefined element). Any kind of compatibility involves a constraint
on redefinitions. The
particular constraint chosen is a semantic variation point.
Notation
No general notation. See the subclasses of RedefinableElement for
the specific notation used.