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.