Diagram Controller

Controller

The controller is the central element of a UP application. A controller defines the smallest, intrinsically functional unit.

A controller essentially consists of two main elements: * Interface and data * [UP - Statemachine]

In addition, the controller has the definition of relations to [Child] controllers.

A controller can also be described as an instantiable type that is instantiated in the [UP - ControllerTree].

class Controller extends NamedResource, AControllerDescription, AnnotableComment, DatatypeLibraryOwner, RootVariableLibrary, RootVariableName, AOoDomainRoot, ACallingBaseElement, AResourceWithType

ControllerInterface

Definition of public informations of a [Controller]. A Controller interface can implement other interfaces and inherits all its elements.

class ControllerInterface extends NamedResource, AnnotableComment, DatatypeLibraryOwner

InterfaceLocal

The local interface holds all the private data of a controller.

class InterfaceLocal extends Resource, AnnotableComment

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

AbstractMessageReactionFunctions

abstract class AbstractMessageReactionFunctions extends Resource

VariableLibrary

class VariableLibrary extends AVariableLibrary

ControllerInstance

The ControllerInstance is an instance of a controller. A controller is instantiated in the ControllerTree.

The controller instance is the application-specific version of the corresponding controller. In the context of the ControllerTree, various elements are defined which define the uniqueness.

class ControllerInstance extends AnnotableComment, RangeChildFieldRef, BaseTreeElementInstance

ControllerLogbook

The controller logbook contains all elements of a controller to be logged.

class ControllerLogbook extends NamedResource, ANotAvailableOnS7Tia

AVariableLibrary

abstract class AVariableLibrary extends NamedResource, AnnotableComment, DatatypeLibraryOwner, AAutoPrefix, AOoDomainRoot

AStatemachine

abstract class AStatemachine extends Decorator, AnnotableComment

StatemachineExtension

In the statemachine extension, elements of the statemachine overwritten or extended and new elements can be added.

class StatemachineExtension extends AStatemachine, 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

ControllerActions

Each controller has ControllerActions. These can be implemented without independently of the state machine

class ControllerActions extends Resource

Function

abstract class Function extends Resource

UserObjectLink

class UserObjectLink extends NamedResource

ChildIterator

class ChildIterator extends Resource

ChildIteratorData

class ChildIteratorData extends Resource, ASubFieldSelector

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

StateBase

abstract class StateBase extends TargetState, AState

NotExistBehaviour

This class defines the behaviour of statemachine if controller exist flag is false. Without any definitions, native single answer implementation is active.

Use singleAnswerOverwrite definition to change single answer behaviour dependent of requested command.

Define a function to implemement another specific behaviour during single answer mode.

class NotExistBehaviour extends Resource

UserObjectLinkInstance

class UserObjectLinkInstance extends Decorator

UserObjectInterface

class UserObjectInterface extends NamedResource, DatatypeLibraryOwner, AnnotableComment

AUserObject

abstract class AUserObject extends NamedResource, AnnotableComment

UserObject

class UserObject extends AUserObjectInterface, APlatformUserObject

UserObjectWrapper

The UserObjectWrapper can be used to call function blocks outside the controller construct. Relations can be drawn from any controller. The UserObjectWrapper also has two Code Snippet regions. One for the initialization and one for a cyclic call.

class UserObjectWrapper extends AUserObjectInterface

GlobalVariable

class GlobalVariable extends BaseArrayVariable, InterfaceOptions