Final State
![[navigator]](images/navigator.png "Populate Explorer View")
![[guidelinePackage]](images/guidelinePackage.png "Guideline Package")
General UML Guidelines
![[bullet]](images/bullet.gif)
State Machines
Final State (Final State)
Final State General UML Guidelines
State Machines
Final State (Final State)
![[help_web]](images/help_web.png "Show help for an Item Guidelines Page")
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.
![[collapsed]](images/collapsed.png "Expand section")
![[expanded]](images/expanded.png "Collapse section")
Properties
Parent
Region (Region)
A region is an orthogonal part of either a composite state or a state machine. It contains states and transitions.
Nested Elements
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.
Connection Point Reference (Connection Point Reference)
A connection point reference represents a usage (as part of a submachine state) of an entry/exit point defined in the statemachine reference by the submachine state.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Activity (Activity)
An activity is the specification of parameterized behavior as the coordinated sequencing of subordinate units whose individual elements are actions.
Interaction (Interaction)
An interaction is a unit of behavior that focuses on the observable exchange of information between connectable elements.
Opaque Behavior (Opaque Behavior)
An behavior with implementation-specific semantics.
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.
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.
Outgoing
Protocol Transition (Protocol Transition)
Transition (Transition)
IncomingProtocol Transition (Protocol Transition)Transition (Transition)
Diagrams
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.
Relations
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.
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.
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.
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.
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.
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.
UsageAbstraction (Abstraction)Dependency (Dependency)Information Flow (Information Flow)Protocol Transition (Protocol Transition)Realization (Realization)Substitution (Substitution)Transition (Transition)Usage (Usage)Protocol Transition (Protocol Transition)Transition (Transition)Model Guidelines generated by ![[Adocus_icon_small]](images/Adocus_icon_small.png){kind=icon} Adocus ![[MetaModelAgent_small]](images/MetaModelAgent_small.png) MetaModelAgent version 4.2.0.007
| Tuesday, 14 February 2017 15:17 |