Class UML 2.3::StateMachine
Description:
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.
Direct Superclasses: BehaviorDirect Subclasses: ProtocolStateMachineClass Precedence List: StateMachine,
Behavior,
Class,
EncapsulatedClassifier,
StructuredClassifier,
BehavioredClassifier,
Classifier,
TemplateableElement,
Type,
PackageableElement,
ParameterableElement,
Namespace,
RedefinableElement,
NamedElement,
ElementProperties:
connectionPoint :
Pseudostate (0 *); -- source
StateMachine extendedStateMachine :
StateMachine (0 *); -- source
StateMachine region :
Region (1 *); -- source
StateMachine submachineState :
State (0 *); -- source
StateMachine context :
BehavioredClassifier (0 1); -- source
Behavior isReentrant : Boolean (1 1); -- source
Behavior ownedParameter :
Parameter (0 *); -- source
Behavior ownedParameterSet :
ParameterSet (0 *); -- source
Behavior postcondition :
Constraint (0 *); -- source
Behavior precondition :
Constraint (0 *); -- source
Behavior redefinedBehavior :
Behavior (0 *); -- source
Behavior specification :
BehavioralFeature (0 1); -- source
Behavior Designates a behavioral feature that the behavior implements. The behavioral
feature must be owned by the classifier that owns the behavior or be inherited
by it. The parameters of the behavioral feature and the implementing behavior
must match. A behavior does not need to have a specification, in which
case it either is the classifer behavior of a BehavioredClassifier or it
can only be invoked by another behavior of the classifier.
Opposite: BehavioralFeature.method
extension :
Extension (0 *); -- source
Class isAbstract : Boolean (1 1); -- source
Class If true, the Classifier does not provide a complete declaration and can
typically not be instantiated. An abstract classifier is intended to be
used by other classifiers e.g. as the target of general metarelationships
or generalization relationships.
Redefines: Classifier.isAbstract
Default value: FALSE
isActive : Boolean (1 1); -- source
Class nestedClassifier :
Classifier (0 *); -- source
Class ownedAttribute :
Property (0 *); -- source
Class ownedOperation :
Operation (0 *); -- source
Class ownedReception :
Reception (0 *); -- source
Class superClass :
Class (0 *); -- source
Class ownedPort :
Port (0 *); -- source
EncapsulatedClassifier ownedConnector :
Connector (0 *); -- source
StructuredClassifier part :
Property (0 *); -- source
StructuredClassifier role :
ConnectableElement (0 *); -- source
StructuredClassifier classifierBehavior :
Behavior (0 1); -- source
BehavioredClassifier interfaceRealization :
InterfaceRealization (0 *); -- source
BehavioredClassifier ownedBehavior :
Behavior (0 *); -- source
BehavioredClassifier ownedTrigger :
Trigger (0 *); -- source
BehavioredClassifier attribute :
Property (0 *); -- source
Classifier collaborationUse :
CollaborationUse (0 *); -- source
Classifier feature :
Feature (0 *); -- source
Classifier generalization :
Generalization (0 *); -- source
Classifier inheritedMember :
NamedElement (0 *); -- source
Classifier isFinalSpecialization : Boolean (1 1); -- source
Classifier ownedTemplateSignature :
RedefinableTemplateSignature (0 1); -- source
Classifier ownedUseCase :
UseCase (0 *); -- source
Classifier powertypeExtent :
GeneralizationSet (0 *); -- source
Classifier redefinedClassifier :
Classifier (0 *); -- source
Classifier representation :
CollaborationUse (0 1); -- source
Classifier substitution :
Substitution (0 *); -- source
Classifier templateParameter :
ClassifierTemplateParameter (0 1); -- source
Classifier useCase :
UseCase (0 *); -- source
Classifier templateBinding :
TemplateBinding (0 *); -- source
TemplateableElement The optional bindings from this element to templates.
{
composite}
Subsets: Element.ownedElement
Opposite: TemplateBinding.boundElement
package :
Package (0 1); -- source
Type visibility :
VisibilityKind (1 1); -- source
PackageableElement owningTemplateParameter :
TemplateParameter (0 1); -- source
ParameterableElement elementImport :
ElementImport (0 *); -- source
Namespace importedMember :
PackageableElement (0 *); -- source
Namespace member :
NamedElement (0 *); -- source
Namespace ownedMember :
NamedElement (0 *); -- source
Namespace ownedRule :
Constraint (0 *); -- source
Namespace Specifies a set of Constraints owned by this Namespace.
{
composite}
Subsets: Namespace.ownedMember
Opposite: Constraint.context
packageImport :
PackageImport (0 *); -- source
Namespace isLeaf : Boolean (1 1); -- source
RedefinableElement redefinedElement :
RedefinableElement (0 *); -- source
RedefinableElement redefinitionContext :
Classifier (0 *); -- source
RedefinableElement clientDependency :
Dependency (0 *); -- source
NamedElement name : String (0 1); -- source
NamedElement nameExpression :
StringExpression (0 1); -- source
NamedElement namespace :
Namespace (0 1); -- source
NamedElement qualifiedName : String (0 1); -- source
NamedElement A name which allows the NamedElement to be identified within a hierarchy
of nested Namespaces. It is constructed from the names of the containing
namespaces starting at the root of the hierarchy and ending with the name
of the NamedElement itself.
{
readonly,
derived}
ownedComment :
Comment (0 *); -- source
Element ownedElement :
Element (0 *); -- source
Element owner :
Element (0 1); -- source
ElementConstraints:
Signature: method() : Boolean;
Description: A state machine as the method for a behavioral feature cannot have entry/exit
connection points.
Expression: specification->notEmpty() implies connectionPoint->isEmpty()
Signature: context_classifier() : Boolean;
Description: The context classifier of the method state machine of a behavioral feature
must be the classifier that owns the behavioral feature.
Expression: specification->notEmpty() implies (context->notEmpty() and specification->featuringClassifier->exists (c | c = context))
Signature: connection_points() : Boolean;
Description: The connection points of a state machine are pseudostates of kind entry
point or exit point.
The OCL used here is not normative.Editor's notes: connectionPoint not conectionPoint
Expression: connectionPoint->forAll (c | c.kind = #entryPoint or c.kind = #exitPoint)
Original: conectionPoint->forAll (c | c.kind = #entryPoint or c.kind = #exitPoint)
Signature: classifier_context() : Boolean;
Description: The classifier context of a state machine cannot be an interface.
Expression: context->notEmpty() implies not context.oclIsKindOf(Interface)
Operations:
Signature: isRedefinitionContextValid(redefined : StateMachine; ) : Boolean;
Description: The query isRedefinitionContextValid() specifies whether the redefinition contexts of a statemachine are properly related to the redefinition contexts of the specified statemachine to allow this element to redefine the other. The containing classifier of a redefining statemachine must redefine the containing classifier of the redefined statemachine.
Expression: result = true
Signature: isConsistentWith(redefinee : RedefinableElement; ) : Boolean;
Description: The query isConsistentWith() specifies that a redefining state machine is consistent with a redefined state machine provided that the redefining state machine is an extension of the redefined state machine: Regions are inherited and regions can be added, inherited regions can be redefined. In case of multiple redefining state machines, extension implies that the redefining state machine gets orthogonal regions for each of the redefined state machines.
Expression: result = true
Signature: ancestor(s1 : State; s2 : State; ) : Boolean;
Description: The query ancestor(s1, s2) checks whether s1 is an ancestor state of state s2.
Expression: result =
if (s2 = s1) then
true
else
if (s2.container->isEmpty() or not s2.container.owner.oclIsKindOf(State)) then
false
else
ancestor(s1, s2.container.owner.oclAsType(State))
endif
endif
Signature: LCA(s1 : State; s2 : State; ) : Namespace;
Description: The operation LCA(s1,s2) returns an orthogonal state or region which is the least common ancestor of states s1 and s2, based on the statemachine containment hierarchy.
Expression: true
Send questions or comments to
[email protected].