PTOLEMY II - CiteSeerX

Introduction
grams, the only constructors available for a class are those shown in the box defining the class. Figure
1.21 does not show all the constructors of these classes, for simplicity.
Classes shown in boxes outlined with dashed lines, such as NamedObj in figure 1.21, are fully
described elsewhere. This is not standard UML notation, but it gives us a convenient way to partition
diagrams. Often, these classes belong to another package.
A.2.3 Interfaces
Figure 1.21 also shows two examples of interfaces, Executable and Actor. An interface is indicated
by the label “” and by italics in the name. An interface defines a set of methods
without providing an implementation for them. It cannot be instantiated, and therefore has no constructors.
When a class implements an interface, the object model shows the relationship with a dotted-line
with an arrow. Any concrete class (one that can be instantiated) that implements an interface must provide
implementations of all its methods. In our object models, we do not show those methods explicitly
in the concrete class, just like inherited methods, but their presence is implicit in the relationship to
the interface.
One interface can extend another. For example, in figure 1.21, Actor extends Executable. This
means that any concrete class that implements Actor must implement the methods of Actor and Executable.
We will occasionally show abstract classes, which are like interfaces in that they cannot be instantiated,
but unlike interfaces in that they may provide default implementations for some methods and
may even have private members. Abstract classes are indicated by italics in the class name. There are
no abstract classes in figure 1.21.
A.2.4 Associations
Inheritance and implementation are types of associations between entities in the object model.
Associations of other types are indicated by other lines, often annotated with ranges like “0..n” or with
diamonds on one end or the other.
Aggregations are shown as associations with diamonds. For example, an Entity is an aggregation
of any number (0..n) instances of Port. More strongly, we say that a Port is contained by 0 or 1
instances of Entity. By containment, we mean that a port can only be contained by a single Entity. In a
weaker form of aggregation, more than one aggregate may refer to the same component. The stronger
form of aggregation (containment) is indicated by the filled diamond, while the weaker form is indicated
by the unfilled diamond. There are no unfilled diamonds in figure 1.21. In fact, they are fairly
rare in Ptolemy II, since many of its architectural features depend on containment relationships, where
an object can have at most one container.
The relationship between Entity and CompositeEntity is particularly interesting. An instance of
CompositeEntity can contain any number of instances of Entity, but CompositeEntity is derived from
Entity. Thus, a CompositeEntity can contain any number of instances of either Entity or CompositeEntity.
This is the classic Composite design pattern [42], which supports arbitrarily deeply nested containment
hierarchies.
In figure 1.21, a CompositeActor is an aggregation of AtomicActors and CompositeActors. These
two aggregation relations are derived from the aggregation relationship between Entity and CompositeEntity.
This derived association is indicated with a dashed line with an open arrowhead.
Heterogeneous Concurrent Modeling and Design 43