Package Import

An element of one of the following kinds:

Activity (Activity)
An activity is the specification of parameterized behavior as the coordinated sequencing of subordinate units whose individual elements are actions.
Actor (Actor)
An actor specifies a role played by a user or any other system that interacts with the subject.
Artifact (Artifact)
An artifact is the specification of a physical piece of information that is used or produced by a software development process, or by deployment and operation of a system.

Examples of artifacts include model files, source files, scripts, and binary executable files, a table in a database system, a development deliverable, or a word-processing document, a mail message. An artifact is the source of a deployment to a node.
Association (Association)
An association describes a set of tuples whose values refer to typed instances. An instance of an association is called a link.
Class (Class)
A class describes a set of objects that share the same specifications of features, constraints, and semantics.

A class may be designated as active (i.e., each of its instances having its own thread of control) or passive (i.e., each of its instances executing within the context of some other object).

A class may also specify which signals the instances of this class handle. A class has the capability to have an internal structure and ports. Class has derived association that indicates how it may be extended through one or more stereotypes. Stereotype is the only kind of metaclass that cannot be extended by stereotypes.
Collaboration (Collaboration)
A collaboration defines a set of co-operating roles used collectively to illustrate a specific functionality.

A collaboration should only show the roles and attributes required to accomplish its defined task or function. Isolating the primary roles is an exercise in simplifying the structure and clarifying the behavior, and also provides for re-use. A collaboration often implements a pattern.
Communication Path (Communication Path)
A communication path is an association between two deployment targets, through which they are able to exchange signals and messages.
Component (Component)
A component represents a modular part of a system that encapsulates its contents and whose manifestation is replaceable within its environment.

In the namespace of a component, all model elements that are involved in or related to its definition are either owned or imported explicitly. This may include, for example, use cases and dependencies (e.g. mappings), packages, components, and artifacts.
Data Type (Data Type)
A data type is a type whose instances are identified only by their value. A data type may contain attributes to support the modeling of structured data types.
Deployment Specification (Deployment Specification)
A deployment specification specifies a set of properties that determine execution parameters of a component artifact that is deployed on a node.

A deployment specification can be aimed at a specific type of container. An artifact that reifies or implements deployment specification properties is a deployment descriptor.
Device (Device)
A device is a physical computational resource with processing capability upon which artifacts may be deployed for execution.

Devices may be complex (i.e., they may consist of other devices).
Enumeration (Enumeration)
An enumeration is a data type whose values are enumerated in the model as enumeration literals.
Execution Environment (Execution Environment)
An execution environment is a node that offers an execution environment for specific types of components that are deployed on it in the form of executable artifacts.
Extension (Extension)
An extension is used to indicate that the properties of a metaclass are extended through a stereotype, and gives the ability to flexibly add (and later remove) stereotypes to classes.
Final State (Final State)
A special kind of state signifying that the enclosing region is completed.

If the enclosing region is directly contained in a state machine and all other regions in the state machine also are completed, then it means that the entire state machine is completed.
Information Item (Information Item)
An information item is an abstraction of all kinds of information that can be exchanged between objects. It is a kind of
classifier intended for representing information in a very abstract way, one which cannot be instantiated.
Interaction (Interaction)
An interaction is a unit of behavior that focuses on the observable exchange of information between connectable elements.
Interface (Interface)
An interface is a kind of classifier that represents a declaration of a set of coherent public features and obligations.

An interface specifies a contract; any instance of a classifier that realizes the interface must fulfill that contract.

The obligations that may be associated with an interface are in the form of various kinds of constraints (such as pre- and post-conditions) or protocol specifications, which may impose ordering restrictions on interactions through the interface.

Interfaces may include receptions (in addition to operations). Since an interface specifies conformance characteristics, it does not own detailed behavior specifications. Instead, interfaces may own a protocol state machine that specifies event sequences and pre/post conditions for the operations and receptions described by the interface.
Model (Model)
A model captures a view of a physical system. It is an abstraction of the physical system, with a certain purpose.

This purpose determines what is to be included in the model and what is irrelevant. Thus the model completely describes those aspects of the physical system that are relevant to the purpose of the model, at the appropriate level of detail.
Node (Node)
A node is computational resource upon which artifacts may be deployed for execution. Nodes can be interconnected through communication paths to define network structures.
Opaque Behavior (Opaque Behavior)
An behavior with implementation-specific semantics.
Operation (Operation)
An operation is a behavioral feature of a classifier that specifies the name, type, parameters, and constraints for invoking an associated behavior. An operation may invoke both the execution of method behaviors as well as other behavioral responses.
Package (Package)
A package is used to group elements, and provides a namespace for the grouped elements.

A package can have one or more profile applications to indicate which profiles have been applied.
Primitive Type (Primitive Type)
A primitive type defines a predefined data type, without any relevant substructure (i.e., it has no parts in the context of UML). A primitive datatype may have an algebra and operations defined outside of UML, for example, mathematically.
Profile (Profile)
A profile defines limited extensions to a reference metamodel with the purpose of adapting the metamodel to a specific platform or domain.
Protocol (Protocol)
Only available together with the Real-Time Extension of RSA.
Protocol State Machine (Protocol State Machine)
A protocol state machine is always defined in the context of a classifier. It specifies which operations of the classifier can be called in which state and under which condition, thus specifying the allowed call sequences on the classifier's operations.

A protocol state machine presents the possible and permitted transitions on the instances of its context classifier, together with the operations which carry the transitions. In this manner, an instance lifecycle can be created for a classifier, by specifying the order in which the operations can be activated and the states through which an instance progresses during its existence.
Protocol Transition (Protocol Transition)
A protocol transition specifies a legal transition for an operation.

Transitions of protocol state machines have the following information: a pre condition (guard), on trigger, and a post condition.

Every protocol transition is associated to zero or one operation (referred BehavioralFeature) that belongs to the context classifier of the protocol state machine.
Reception (Reception)
A reception is a declaration stating that a classifier is prepared to react to the receipt of a signal. A reception designates a signal and specifies the expected behavioral response.

The details of handling a signal are specified by the behavior associated with the reception or the classifier itself.
Region (Region)
A region is an orthogonal part of either a composite state or a state machine. It contains states and transitions.
Signal (Signal)
A signal is a specification of send request instances communicated between objects. The receiving object handles the received request instances as specified by its receptions. The data carried by a send request (which was passed to it by the send invocation occurrence that caused that request) are represented as attributes of the signal.

A signal is defined independently of the classifiers handling the signal occurrence.
State (State)
A state models a situation during which some (usually implicit) invariant condition holds.

The states of protocol state machines are exposed to the users of their context classifiers. A protocol state represents an exposed stable situation of its context classifier: when an instance of the classifier is not processing any operation, users of this instance can always know its state configuration.
State Machine (State Machine)
State machines can be used to express the behavior of part of a system.

Behavior is modeled as a traversal of a graph of state nodes interconnected by one or more joined transition arcs that are triggered by the dispatching of series of (event) occurrences. During this traversal, the state machine executes a series of activities associated with various elements of the state machine.
Stereotype (Stereotype)
A stereotype defines how an existing metaclass may be extended, and enables the use of platform or domain specific terminology or notation in place of, or in addition to, the ones used for the extended metaclass.
Structured Activity Node (Structured Activity Node)
A structured activity node is an executable activity node that may have an expansion into subordinate nodes as an activity group. The subordinate nodes must belong to only one structured activity node, although they may be nested.

Because of the concurrent nature of the execution of actions within and across activities, it can be difficult to guarantee the consistent access and modification of object memory.
In order to avoid race conditions or other concurrency-related problems, it is sometimes necessary to isolate the effects of a group of actions from the effects of actions outside the group. This may be indicated by setting the mustIsolate attribute to true on a structured activity node.

If a structured activity node is "isolated," then any object used by an action within the node cannot be accessed by any action outside the node until the structured activity node as a whole completes. Any concurrent actions that would result in accessing such objects are required to have their execution deferred until the completion of the node.
Transition (Transition)
A transition is a directed relationship between a source vertex and a target vertex.

It may be part of a compound transition, which takes the state machine from one state configuration to another, representing the complete response of the state machine to an occurrence of an event of a particular type.
Use Case (Use Case)
A use case is the specification of a set of actions performed by a system, which yields an observable result that is, typically, of value for one or more actors or other stakeholders of the system.

Package Import 3

Package Import 3

Properties

Rules

Imports

Imported