Access is a stereotyped permission dependency between two namespaces, denoting that the public contents of the target namespace are accessible to the namespace of the source package.
This tag definition, which only applies to profile packages, lists the metaelements that are used by the associated profile. The value associated with this tag definition is a set of strings, where each string represents the name of an applicable metaelement. Note that the use of applicable subset does not necessarily exclude the use of any metaelements, but clearly identifies which ones are referenced from the associated profile. Further note that the tag definition applies only to the immediately associated profile. If a profile combines several other profiles using import or generalizations, the applicable subset only applies to the immediately associated profile. The absence of an applicable subset tag definition means that the whole UML metamodel is applicable.
This dependency is used to indicate which profiles are applicable to a package. Typically, the client is an ordinary package or a model (but could be any other kind of package), while the supplier is a profile package. This means that the profile applies transitively to the model elements contained in the client package, including the client package itself.
Specifies a real association (default and redundant, but may be included AssociationEnd for emphasis).
Association is a constraint applied to a link-end, specifying that the corresponding instance is visible via association.
Specifies a class that supports another more central or fundamental
class, typically by implementing secondary logic or control flow. The
class that the auxiliary supports may be defined explicitly using a
Focus class or implicitly by a dependency relationship. Auxiliary
classes are typically used together with Focus classes, and are
particularly useful for specifying the secondary business logic or
control flow of components during design. See also: <>.
Specifies a Flow relationship, source and target of which represent the same instance at different points in time, but each with potentially different values, state instance, and roles. A Become Dependency from A to B means that instance A becomes B with possibly new values, state instance, and roles at a different moment in time/space.
A boundary is a class that lies on the periphery of a system, but within it. It interacts with actors outside the system as well as with entity, control, and other boundary classes within the system.
Call is a stereotyped usage dependency whose source is an operation and whose target is an operation. The relationship may also be subsumed to the class containing an operation, with the meaning that there exists an operation in the class to which the dependency applies. A call dependency specifies that the source operation or an operation in the source class invokes the target operation or an operation in the target class. A call dependency may connect a source operation to any target operation that is within scope including, but not limited to, operations of the enclosing classifier and operations of other visible classifiers.
Specifies a constraint applied to a set of generalizations with the same
discriminator and the same parent, indicating that any instance of the
parent must be an instance of at least one child within the set of
generalizations. If a parent has a single discriminator, the set of its child
generalizations being complete implies that the parent is abstract. The
connotation of declaring a set of generalizations complete is that all of the
children with the given discriminator have been declared and that
additional ones are not expected (in other words, the set of generalizations
is closed), and designs may assume with some confidence that the set of
children is fixed. If a new child is nevertheless added in the future, existing
models may be adversely affected and may require modification.
A control is a class whose objects manage interactions between collections of objects.
A control class usually has behavior that is specific for one use case, and a control object usually does not outlive the use case realizations in which it participates.
Specifies a Flow relationship, the source and target of which are different instances, but each with the same values, state instance, and roles (but a distinct identity). A Copy Dependency from A to B means that B is an exact copy of A. Future changes in A are not necessarily reflected in B.
Specifies that the designated feature creates an instance of the BehavioralFeature classifier to which the feature is attached. May be promoted to the Classifier containing the feature.
Create is a stereotyped call event denoting that the instance receiving that event has just been created. For state machines, it triggers the initial transition at the topmost level of the state machine (and is the only kind of trigger that may be applied to an initial transition).
Create is a stereotyped usage dependency denoting that the client classifier creates instances of the supplier classifier.
(Name for the stereotyped class is Derivation.) Specifies a derivation relationship among model elements that are usually, but not necessarily, of the same type. A derived dependency specifies that the client may be computed from the supplier. The mapping specifies the computation. The client may be implemented for design reasons, such as efficiency, even though it is logically redundant.
A true value indicates that the model element can be completely derived from other model elements and is therefore logically redundant. In an analysis model, the element may be included to define a useful name or concept. In a design model, the usual intent is that the element should exist in the implementation to avoid the need for recomputation.
Specifies that the designated feature destroys an instance of the BehavioralFeature classifier to which the feature is attached. May be promoted to the classifier containing the feature.
Destroy is a stereotyped call event denoting that the instance receiving the event is being destroyed.
Specifies a constraint applied to a set of generalizations, indicating that
instance of the parent may be an instance of no more than one of the given
children within the set of generalizations. This is the default semantics of
generalization.
An entity is a passive class; that is, its objects do not initiate interactions on their own. An entity object may participate in many different use case realizations and usually outlives any single interaction.
A facade is a stereotyped package containing only references to model elements owned by another package. It is used to provide a public view of some of the contents of a package. A facade does not contain any model elements of its own.
Specifies a class that defines the core logic or control flow for one or more auxiliary classes that support it. Support classes may be defined explicitly using Auxiliary classes or implicitly by dependency relationships. Focus classes are typically used together with one or more Auxiliary classes, and are particularly useful for specifying the core business logic or control flow of components during design. See also: <>.
Friend is a stereotyped permission dependency whose source is a model element, such as an operation, class, or package, and whose target is a model element in a different package, such as an operation, class or package. A friend relationship grants the source access to the target regardless of the declared visibility. It extends the visibility of the supplier so that the client can see into the supplier.
Specifies that the target is a global value that is known to all elements AssociationEnd rather than an actual association.
Global is a constraint applied to a link-end, specifying that the corresponding instance is visible because it is in a global scope relative to the link.
Specifies the implementation of a class in some programming
language (for example, C++, Smalltalk, Java) in which an instance
may not have more than one class. This is in contrast to Class, for
which an instance may have multiple classes at one time and may
gain or lose classes over time, and an object (a child of instance) may
dynamically have multiple classes.
An Implementation class is said to realize a Type if it provides all of
the operations defined for the Type with the same behavior as
specified for the Type operations. An Implementation Class may
realize a number of different Types. Note that the physical attributes
and associations of the Implementation class do not have to be the
same as those of any Type it realizes and that the Implementation
Class may provide methods for its operations in terms of its physical
attributes and associations. See also: <>.
Specifies that the child inherits the implementation of the parent (its attributes, operations and methods) but does not make public the supplier s interfaces nor guarantee to support them, thereby violating substitutability. This is private inheritance and is usually used only for programming implementation purposes.
Specifies the implementation of a class in some programming Class language in which an instance may not have more than one class. This is in contrast to a general UML Class, for which an instance may have multiple classes at one time and may gain or lose classes over time, and an object (a child of instance) may dynamically have multiple classes.
Import is a stereotyped permission dependency between two namespaces, denoting that the public contents of the target package are added to the namespace of the source package.
Specifies a constraint applied to a set of generalizations with the same discriminator, indicating that an instance of the parent need not be an instance of a child within the set (but there is no guarantee that such an instance will actually exist). Being incomplete implies that the parent is concrete. The connotation of declaring a set of generalizations incomplete is that all of the children with the given discriminator have not necessarily been declared and that additional ones might be added; therefore, users should not count on the set of children being fixed.
Specifies a constraint that must be attached to a set of classifiers or relationships. It indicates that the conditions of the constraint must hold over time (for the time period of concern in the particular containing element) for the classifiers or relationships and their instances.
Local is a constraint applied to a link-end, specifying that the corresponding instance is visible because it is in a local scope relative to the link.
Specifies that the relationship represents a local variable within a AssociationEnd procedure rather than an actual association.
A metamodel is a stereotyped model denoting that the model is an abstraction of another model, i.e., it is a model of a model. Hence, if M2 is a model of the model M1, then M2 is a metamodel of M1. It follows then that classes in M1 are instances of metaclasses in M2. The stereotype can be recursively applied, as in the case of a 4-layer metamodel architecture.
This dependency means that the supplier package is being used as a model library associated with a profile. The client is a package that is stereotyped as a profile and the supplier is a non-profile package that contains shared model elements, such as classes and data types.
A model library is a stereotyped package that contains model elements that are intended to be reused by other packages. A model library differs from a profile in that a model library does not extend the metamodel using stereotypes and tagged definitions. A model library is analogous to a class library in some programming languages.
Specifies a constraint applied to a set of generalizations, indicating that an instance of one child may be simultaneously an instance of another child in the set (but there is no guarantee that such an instance will actually exist).
Parameter is a constraint applied to a link-end, specifying that the corresponding instance is visible because it is in a parameter scope relative to the link.
Specifies that the relationship represents a procedure parameter rather than AssociationEnd an actual association.
Persistence denotes the permanence of the state of the constrained element, marking it as transitory (its state is destroyed when the instance is destroyed) or persistent (its state is not destroyed when the instance is destroyed).
Specifies a constraint that must be attached to an operation, and denotes that the conditions of the constraint must hold after the invocation of the operation.
Specifies that the classifier is a metaclass whose instances are siblings
marked by the same discriminator. For example, the metaclass
TreeSpecies might be a power type for the subclasses of Tree that
represent different species, such as AppleTree, BananaTree, and
CherryTree.
Specifies a constraint that must be attached to an operation, and denotes that the conditions of the constraint must hold for the invocation of the operation.
A profile is a stereotyped package that contains model elements that have been customized for a specific domain or purpose using extension mechanisms, such as stereotypes, tagged definitions, and constraints. A profile may also specify model libraries on which it depends and the metamodel subset that it extends. (The latter is specified via an applicableSubset tag definition.)
(Name for the stereotyped class is Realization.) Specifies a realization relationship between a specification model element or elements (the supplier) and a model element or elements that implement it (the client). The implementation model element is required to support all of the operations or received signals that the specification model element declares. The implementation model element must make or inherit its own declarations of the operations and signal receptions. The mapping specifies the relationship between the two. The mapping may or may not be computable. Realization can be used to model stepwise refinement, optimizations, transformations, templates, model synthesis, framework composition, etc.
Specifies that the relationship represents a reference to the object that AssociationEnd owns an operation or action rather than an actual association.
Self is a constraint applied to a link-end, specifying that the corresponding instance is visible because it is the dispatcher of the request.
<> Usage Send is a stereotyped usage dependency whose source is an operation and whose target is a signal, specifying that the source sends the target signal.
Specifies a constraint that must be attached to a state vertex in a state machine that has a classifier for a context. The stereotype indicates that the constraint holds for instances of the classifier when an instance is in that state.
A stub is a stereotyped package representing a package that is incompletely transferred; specifically, a stub provides the public parts of the package, but nothing more.
A systemModel is a stereotyped model that contains a collection of models of the same physical system. A systemModel also contains all relationships and constraints between model elements contained in different models.
This stereotype should be applied to tag definition which values describes group names of other tag definitions.
Used for tags grouping in MagicDraw model elements specifications, TaggedValues tabs.
A time-out message the sender sends for a given period of time while waiting for acknowledgment by recipient. The sender is freed up if the acknowledgment does not occur within the duration specified in the description.
TopLevel is a stereotype of package denoting the top-most package in a containment hierarchy. The topLevel stereotype defines the outer limit for looking up names, as namespaces see outwards. A topLevel subsystem represents the top of the subsystem containment hierarchy, i.e., it is the model element that represents the boundary of the entire physical system being modeled.
(Name for the stereotyped class is Trace.) Specifies a trace relationship between model elements or sets of model elements that represent the same concept in different models. Traces are mainly used for tracking requirements and changes across models. Since model changes can occur in both directions, the directionality of the dependency can often be ignored. The mapping specifies the relationship between the two, but it is rarely computable and is usually informal.
Specifies a domain of objects together with the operations applicable
to the objects, without defining the physical implementation of those
objects. A type may not contain any methods, maintain its own thread
of control, or be nested. However, it may have attributes and
associations. The associations of a Type are defined solely for the
purpose of specifying the behavior of the type's operations and do not
represent the implementation of state data.
Usage applies only to transitions leading into or out of an object flow state. It has a value of uses or modifies. A value of uses indicates that the action of the state at the other end of the transition from the object flow state uses but does not modify the object represented by the object flow state. A value of modifies indicates that the action of the state at the other end of the transition from the object flow state modifies and may use the object represented by the object flow state.
A use case model specifies the services a system provides to its users; that is, the different ways of using the system, and whose top-level package is a use case system.
Specifies a classifier that has no instances, but rather denotes a named collection of non-member attributes and operations, all of which are class-scoped.
The {xor} constraint is applied to a set of associations, specifying that
over that set, exactly one is manifest for each associated instance. Xor is
an exclusive or (not inclusive or) constraint.