Classes
Overview
The Classes package contains subpackages that deal with the basic
modeling concepts of UML, and in particular classes and their
relationships.
Package Structure
Figure 2 describes the dependencies (i.e., package merges) between the
subpackages of the package Classes.
Due to the size of the Kernel package, this chapter has been divided
according to diagrams, where each diagram of Kernel is turned into a
separate section.
· "Kernel the Root Diagram"
· "Kernel the Namespaces
Diagram"
· "Kernel the
Multiplicities
Diagram"
· "Kernel the Expressions
Diagram"
· "Kernel the Constraints
Diagram"
· "Kernel the Instances
Diagram"
· "Kernel the
Classifiers Diagram"
· "Kernel the Features Diagram"
· "Kernel the Operations
Diagram"
· "Kernel the Classes Diagram"
· "Kernel the DataTypes
Diagram"
· "Kernel the Packages
Diagram"
The packages AssociationClasses and PowerTypes are
closely related to the Kernel diagrams, but are described in separate
sections (See
"AssociationClasses" and
"PowerTypes" , respectively). The
packages Dependencies and Interfaces are described in
separate sections (See "Dependencies"
and "Interfaces" ,
respectively).
In those cases where any of the latter four packages add to the
definitions of classes originally defined in Kernel, the
description of the additions is found under the original class.
Reusing packages from UML 2.0
Infrastructure
The Kernel package represents the core modeling concepts of the
UML, including classes, associations, and packages. This part is mostly
reused from the infrastructure library, since many of these concepts
are the same as those that are used in for example MOF. The Kernel
package is the central part of the UML, and primarily reuses the Constructs
and Abstractions packages of the InfrastructureLibrary.
The reuse is accomplished by merging Constructs with the
relevant subpackages of Abstractions. In many cases, the reused
classes are extended in the Kernel with additional features,
associations, or superclasses. In subsequent diagrams showing abstract
syntax, the subclassing of elements from the infrastructure library is
always elided since this information only adds to the complexity
without increasing understandability. Each metaclass is completely
described as part of this chapter; the text
from the infrastructure library is repeated here.
It should also be noted that while Abstractions contained
several subpackages, Kernel is a flat structure that like Constructs
only contains metaclasses. The reason for this distinction is that
parts of the infrastructure library have been designed for flexibility
and reuse, while the Kernel in reusing the infrastructure
library has to bring together the different aspects of the reused
metaclasses. In order to organize this chapter, we therefore use
diagrams rather than packages as the main grouping
mechanism.
The packages that are explicitly merged from the
InfrastructureLibrary::Core are the following:
· Abstractions::Instances
· Abstractions::MultiplicityExpressions
· Abstractions::Literals
· Abstractions::Generalizations
· Constructs
All other packages of the InfrastructureLibrary::Core are implicitly
merged through the ones that are explicitly merged.