Diagram Statemachine
Statemachine
Each controller has a state machine. It is generated automatically when the controller is created. The state machine describes the sequence or logic of a controller. The state machine is based on the specification of a UML state machine.
The statemachine has a graphical representation (diagram). This supports the developer when creating states and transitions.
The UML state diagram shows the different states a [controller] can be in and the transitions between these states. A state represents a stage in the behavior pattern of a controller. It is possible to have start and end states. An initial state, also called creation state, is the state in which a controller is at startup, while an end state is a state from which no transitions lead out. A transition is a transition from one state to another and is triggered by an event that is either internal or external to the controller.
class Statemachine extends AStatemachine, AStatemachineStart, RootVariableName, ASmDecorator, AJunctionProperty
StateOverride
The state that is overwritten becomes a super state. The existing functions of the overwritten state are no longer executed. However, it is possible to call the existing functions with a super call.
class StateOverride extends AStateExtension, Statemachine
StatemachineExtension
In the statemachine extension, elements of the statemachine overwritten or extended and new elements can be added.
class StatemachineExtension extends AStatemachine, AJunctionProperty
AStatemachine
abstract class AStatemachine extends Decorator, AnnotableComment
StateBase
abstract class StateBase extends TargetState, AState
DomainDiagram
class DomainDiagram extends NamedResource
State
SuperState
class SuperState extends StateBase, AStatemachineStart, AJunctionProperty
SuperState_WithBusyFinal
This state extends the SuperState with an initialization function. When this state is created, a start state, a transition state and a target state are created.
class SuperState_WithBusyFinal extends SuperState
TargetState
abstract class TargetState extends Resource
History
class History extends TargetState
TransitionOverwrite
class TransitionOverwrite extends Decorator
Transition
class Transition extends Resource, AnnotableComment
Junction
This type of pseudostate is used to connect multiple transitions into compound paths between states. For example, a junction can be used to merge multiple incoming transitions into a single outgoing transition representing a shared continuation path. Or, it can be used to split an incoming transition into multiple outgoing transition segments with different guard constraints.
Hint: All guards of transitions of all coming junctions are checked in the cyclic part of the source state.
class Junction extends NamedResource, AnnotableComment, TargetState
AStateExtension
abstract class AStateExtension extends TargetState
StateExtension
The state that is extended basically remains as it is. It can simply be extended by function or transitions. It is also possible to overwrite single functions or transitions. Further additional states and junctions can be created.
class StateExtension extends AStateExtension, AJunctionProperty
TransitionExtend
class TransitionExtend extends Resource
AJunctionExtension
abstract class AJunctionExtension extends TargetState
JunctionExtension
The junction that is extended basically remains as it is. It can simply be extended by transitions. It is also possible to overwrite single transitions.
class JunctionExtension extends AJunctionExtension