Protocol State Machine

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.
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.
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).
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.
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.
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.
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 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.
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.
Template Parameter (Template Parameter)
A template parameter exposes a parameterable element as a formal template parameter of a template.
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.

Nested Elements

Rules

Arbitrary number of elements 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.
- Association End (Association End)
  A property is a structural feature of a classifier that characterizes instances of the classifier.
  
  A property may represents an attribute and might also represent an association end. It relates an instance of the class to a value or set of values of the type of the attribute.
  
  A property related by memberEnd or its specializations to an association represents an end of the association. The type of the property is the type of the end of the association.
  
  An association End is a property that has a reference to an association.
- Attribute (Attribute)
  A property is a structural feature of a classifier that characterizes instances of the classifier.
  
  A property may represents an attribute and might also represent an association end. It relates an instance of the class to a value or set of values of the type of the attribute.
  
  A property related by memberEnd or its specializations to an association represents an end of the association. The type of the property is the type of the end of the association.
  
  An attribute is a property that has no reference to an association.
- Choice (Pseudo State)
  Choice vertices which, when reached, result in the dynamic evaluation of the guards of the triggers of its outgoing transitions. This realizes a dynamic conditional branch. It allows splitting of transitions into multiple outgoing paths such that the decision on which path to take may be a function of the results of prior actions performed in the same run-tocompletion step. If more than one of the guards evaluates to true, an arbitrary one is selected. If none of the guards evaluates to true, then the model is considered ill-formed. (To avoid this, it is recommended to define one outgoing transition with the predefined else guard for every choice vertex.) Choice vertices should be distinguished from static branch points that are based on junction points.
- 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.
- Collaboration Use (Collaboration Use)
  A collaboration use represents one particular use of a collaboration to explain the relationships between the properties of a classifier.
  
  A collaboration use shows how the pattern described by a collaboration is applied in a given context, by binding specific entities from that context to the roles of the collaboration. Depending on the context, these entities could be structural features of a classifier, instance specifications, or even roles in some containing collaboration. There may be multiple occurrences of a given collaboration within a classifier, each involving a different set of roles and connectors.
  
  A given role or connector may be involved in multiple occurrences of the same or different collaborations. Associated dependencies map features of the collaboration type to features in the classifier. These dependencies indicate which role in the classifier plays which role in the collaboration.
- 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.
- Connector (Connector)
  Specifies a link that enables communication between two or more instances. This link may be an instance of anassociation, or it may represent the possibility of the instances being able to communicate because their identitiesare known by virtue of being passed in as parameters, held in variables or slots, or because the communicatinginstances are the same instance.
  
  The link may be realized by something as simple as a pointer or by something ascomplex as a network connection. In contrast to associations, which specify links between any instance of theassociated classifiers, connectors specify links between instances playing the connected parts only.
- Constraint (Constraint)
  A constraint is a condition or restriction expressed in natural language text or in a machine readable language for the purpose of declaring some of the semantics of an element.
- 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.
- Deep History (Pseudo State)
  DeepHistory represents the most recent active configuration of the composite state that directly contains this pseudostate; e.g. the state configuration that was active when the composite state was last exited. A composite state can have at most one deep history vertex. At most one transition may originate from the history connector to the default deep history state. This transition is taken in case the composite state had never been active before. Entry actions of states entered on the path to the state represented by a deep history are performed.
- 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).
- Entry Point (Pseudo State)
  An entry point pseudostate is an entry point of a state machine or composite state. In each region of the state machine or composite state it has a single transition to a vertex within the same region.
- 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.
- Exit Point (Pseudo State)
  An exit point pseudostate is an exit point of a state machine or composite state. Entering an exit point within any region of the composite state or state machine referenced by a submachine state implies the exit of this composite state or submachine state and the triggering of the transition that has this exit point as source in the state machine enclosing the submachine or composite state.
- 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.
- Fork (Pseudo State)
  Fork vertices serve to split an incoming transition into two or more transitions terminating on orthogonal target vertices (i.e. vertices in different regions of a composite state). The segments outgoing from a fork vertex must not have guards or triggers.
- 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.
- Initial (Pseudo State)
  An initial pseudostate represents a default vertex that is the source for a single transition to the default state of a composite state. There can be at most one initial vertex in a region. The outgoing transition from the initial vertex may have a behavior, but not a trigger or guard.
- 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.
- Join (Pseudo State)
  Join vertices serve to merge several transitions emanating from source vertices in different orthogonal regions. The transitions entering a join vertex cannot have guards or triggers.
- Junction (Pseudo State)
  Junction vertices are semantic-free vertices that are used to chain together multiple transitions. They are used to construct compound transition paths between states. For example, a junction can be used to converge multiple incoming transitions into a single outgoing transition representing a shared transition path (this is known as an merge). Conversely, they can be used to split an incoming transition into multiple outgoing transition segments with different guard conditions. This realizes a static conditional branch. (In the latter case, outgoing transitions whose guard conditions evaluate to false are disabled. A predefined guard denoted 'else' may be defined for at most one outgoing transition. This transition is enabled if all the guards labeling the other transitions are false.) Static conditional branches are distinct from dynamic conditional branches that are realized by choice vertices.
- 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.
- Parameter (Parameter)
  A parameter is a specification of an argument used to pass information into or out of an invocation of a behavioral feature. Parameters are allowed to be treated as connectable elements. Parameters have support for streaming, exceptions, and parameter sets.
- Port (Port)
  A port is a property of a classifier that specifies a distinct interaction point between that classifier and its environment or between the (behavior of the) classifier and its internal parts.
  
  Ports are connected to properties of the classifier by connectors through which requests can be made to invoke the behavioral features of a classifier.
  
  A Port may specify the services a classifier provides (offers) to its environment as well as the services that a classifier expects (requires) of its environment. A port has an associated protocol state machine.
- 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.
- 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.
- 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.
- Shallow History (Pseudo State)
  ShallowHistory represents the most recent active substate of its containing state (but not the substates of that substate). A composite state can have at most one shallow history vertex. A transition coming into the shallow history vertex is equivalent to a transition coming into the most recent active substate of a state. At most one transition may originate from the history connector to the default shallow history state. This transition is taken in case the composite state had never been active before. Entry actions of states entered on the path to the state represented by a shallow history are performed.
- 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 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.
- Template Signature (Template Signature)
  A template signature bundles the set of formal template parameters for a templated element.
- Terminate (Pseudo State)
  Entering a terminate pseudostate implies that the execution of this state machine by means of its context object is terminated. The state machine does not exit any states nor does it perform any exit actions other than those associated with the transition leading to the terminate pseudostate. Entering a terminate pseudostate is equivalent to invoking a DestroyObjectAction.
- Trigger (Trigger)
  A trigger relates an event to a behavior that may affect an instance of the classifier. A trigger specification may be qualified by the port on which the event occurred.
- 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.

Diagrams

Rules

Arbitrary number of elements of the following kinds:
- Class Diagram (Class Diagram)
  A Class Diagram is a diagram that shows classes and interfaces and their relationships. However a class diagram may also show packages and all kind of classifier elements.
- Component Diagram (Component Diagram)
  A Component Diagram is a diagram that shows components, interfaces and artifacts and their relationships. However a component diagram may also show packages and all kind of classifier elements.
- Deployment Diagram (Deployment Diagram)
  A Deployment Diagram is a diagram that shows nodes and artifacts and their relationships. However a deployment diagram may also show packages and all kind of classifier elements.
- Freeform Diagram (Freeform Diagram)
  A Free Form diagram is a diagram in which you can make free drawings without the restriction of using UML.
- Interaction Overview Diagram (Interaction Overview Diagram)
  An Interaction Overview Diagram is a visual representation of a control flow of interaction..
- Object Diagram (Object Diagram)
  An Object Diagram is a diagram that shows instance specification, links and slots.
- Statechart Diagram (Statechart Diagram)
  A State Machine Diagram is a diagram that shows a state machine for some element. A state machine is composed of states and transitions. States may be divided into substates.
- Structure Diagram (Structure Diagram)
  A Structure Diagram is a diagram that shows the static structure of an element.
- Use Case Diagram (Use Case Diagram)
  A Use-Case Diagram is a diagram that shows actors and use cases and their relationships. However a Use-Case Diagram may also show packages and all kind of classifier elements.

Relations

Rules

Arbitrary number of elements of the following kinds:
- Abstraction (Abstraction)
  An abstraction is a relationship that relates two elements or sets of elements that represent the same concept at different levels of abstraction or from different viewpoints.
- Component Realization (Component Realization)
  The realization concept is specialized to (optionally) define the classifiers that realize the contract offered by a component in terms of its provided and required interfaces.
  
  The component forms an abstraction from these various
  classifiers.
- Dependency (Dependency)
  A dependency is a relationship that signifies that a single or a set of model elements requires other model elements for their specification or implementation.
  
  This means that the complete semantics of the depending elements is either semantically or structurally dependent on the definition of the supplier element(s).
- Element Import (Element Import)
  An element import identifies an element in another package, and allows the element to be referenced using its name without a qualifier.
- Generalization (Generalization)
  A generalization is a taxonomic relationship between a more general classifier and a more specific classifier. Each instance of the specific classifier is also an indirect instance of the general classifier. Thus, the specific classifier inherits the features of the more general classifier.
  
  A generalization relates a specific classifier to a more general classifier, and is owned by the specific classifier.
- Information Flow (Information Flow)
  An information flow specifies that one or more information items circulates from its sources to its targets.
  
  Informationflows require some kind of information channel for transmitting information items from the source to the destination. An information channel is represented in various ways depending on the nature of its sources and targets. It may berepresented by connectors, links, associations, or even dependencies.
  
  For example, if the source and destination are partsin some composite structure such as a collaboration, then the information channel is likely to be represented by aconnector between them. Or, if the source and target are objects (which are a kind of instance specification), they may berepresented by a link that joins the two, and so on.
- Interface Realization (Interface Realization)
  An interface realization is a specialized realization relationship between a classifier and an interface. This relationship signifies that the realizing classifier conforms to the contract specified by the interface.
- Package Import (Package Import)
  A package import is a relationship that allows the use of unqualified names to refer to package members from other namespaces.
- Protocol Conformance (Protocol Conformance)
  Protocol state machines can be redefined into more specific protocol state machines, or into behavioral state machines.
  
  Protocol conformance declares that the specific protocol state machine specifies a protocol that conforms to the general state machine one, or that the specific behavioral state machine abide by the protocol of the general protocol state machine.
- Realization (Realization)
  Realization is a specialized abstraction relationship between two sets of model elements, one representing a specification (the supplier) and the other represents an implementation of the latter (the client). Realization can be used to model stepwise refinement, optimizations, transformations, templates, model synthesis, framework composition, etc.
- Substitution (Substitution)
  A substitution is a relationship between two classifiers signifies that the substituting classifier complies with the contract specified by the contract classifier. This implies that instances of the substituting classifier are runtime substitutable where instances of the contract classifier are expected.
- Templatebinding (Templatebinding)
  A template binding represents a relationship between a templateable element and a template. A template binding specifies the substitutions of actual parameters for the formal parameters of the template.
- Usage (Usage)
  A usage is a relationship in which one element requires another element (or set of elements) for its full implementation or operation. A usage is a dependency in which the client requires the presence of the supplier.

Protocol State Machine

Protocol State Machine

Properties

Rules

Parent

Nested Elements

Rules

Diagrams

Rules

Relations

Rules

Usage