State Machine

• Prepare a new actifsource Project named ch.actifsource.tutorial.statemachine as seen in the Actifsource Tutorial Simple Service
• Use the following package structure

• Create a simple state machine
• Instantiate the state machine and see its deficits

Create a Generic State Machine Model

• Create a Generic Domain Model named Design in the Package generic using the DiagramEditor
• The Design shall contain the following Domain Classes
  • Statemachine Event State Transition

• Insert a Composition between

  • Statemachine and Event
  • Statemachine and State
  • State and Transition

• Insert a Association between

  • Transition and State

• Adjust the Cardinalities as shown above

• Warning: The layout for the relations transition and targetState might differ in your editor

Create a Specific State Machine

• Create a Statemachine named Statemachine1 in the Package specific

• Add the Events start and stop
• Add the States Initialized Started and Stopped as shown above

Part III Decorating Relation Aspect

• Learn how to decorate a relation with a list of resources in order to prevent the mixing of instances from different Statemachines

Add a Decorating Relation Aspect

• In State open the Composition transition
• Press Enter on aspect[DecoratingRelationAspect]

• Select ResourceSelectorAspectImplementation
• Click OK

• Let's look at a possible Transition for every Event
• The Composition transition is found in State
• We have to navigate from State to Event
  • Navigate backwards from State via state to Statemachine
  • Navigate forward from Statemachine via event to Event

• Enter the Selector State.-state.event using Content Assist (Ctrl+Space)

• Implementing a DecoratingRelationAspect asks for a subclass of Decorator

• Decorator has a useRelation target which is used to store the specific decorating Resource

  • Shown as: decoratingRelation[target]

• Open Quick Assist by clicking the light bulb or press Ctrl+1

• Use Quick Assist to let Transition extend Decorator

• Open Transition
• By default a Class extends NamedResource
• The Quick Assist Action changed the extends statement from NamedResource to Decorator

• Quick Assist has done the following
  • Added extend Decorator
  • Added Association event

• The range of Decorator.target is Resource and therefore untyped in the context of your domain
• The new Association target extends Decorator.target but with Event as its range
• When writing template code, you are able to access Transition.event typed as Event

Use the Decorating Relation Aspect

• Open the specific Statemachine Statemachine1
• Add new Events and observe the decoratingRelation transition

• In the State Initialized create a new Transition for transition[start]
• Select Started as targetState

• Configure the State instances Started and Stopped as shown above

• Content Assist (Ctrl+Sapce) in actifsource shows all instances of a desired type; It is often useful to restrict this selection
• Learn how to apply range restrictions to filter instances for a given type

Without Range Restriction

• Let's discover the needs for a range restriction aspect
• Create a Statemachine named Statemachine2 in the Package specific
• Add the Event instances open and close
• Add the States instances Initialize Opened and Closed

• Create any new Transition
• Use Content Assist (Ctrl+Space) to add a targetState of type State

Add a Range Restriction Aspect

• In Transition open the useRelation targetState

• Press Enter on aspect[RangeRestrictionAspect]

• Select ResourceSelectorAspectImplementation
• Click OK

• Let's restrict the range of targetState to instances of States owned by the own Statemachine

• The useRelation targetState is found in Transition

• We have to navigate from Transition to all States of the Statemachine

  • Navigate backwards from Transition via transition to State
  • Navigate backwards from State via state to Statemachine
  • Navigate forward from Statemachine via state to State

• Enter the Selector Transition.-transition.-state.state using Content Assist (Ctrl+Space)

Use the Range Restriction Aspect

• Use Content Assist (Ctrl+Space) again to add the targetState Opened of type State

• Get familiar with Decorating Relations and Range Restrictions
• Write an actifsource Code Template to generate a state machine

• Write a code template for instances of Statemachine

Write a code template for Statemachines

• Create a package ch.actifsource.tutorial.statemachine.template
• Select the new package and choose New->Template from the context menu.

• Insert StatemachineImpl as Template Name
• Choose the Base Type ch.actifsource.tutorial.statemachine.generic.Statemachine
• Click Finish

• Insert Statemachine.name on the Filename Line and make sure that the language (C++) is automatically detected.
• Write the skeleton for a class Statemachine.name

Next, we define an enumeration variable with the all the States of a Statemachine as enumerators. This variable stores the current state of a Statemachine

• Write the declaration of enumeration variable m_aState
• Insert a LineContext in the enumeration list and choose the Selector Statemachine.state with the support of the Content Assist
• Insert State.name in the newly created LineContext. Append a ','. Then mark the ',' and select NotLast to make sure that there is no comma after the last entry in the enumeration list.

We define a member function for each event of our Statemachine which will later handle all the possible transitions triggered by the event:

• Create a new LineContext and choose Statemachine.event as the selector of the line context
• Write the skeleton of a function returning void named Event.name

We write a switch-statement with the current state m_aState as control variable and define a LineContext that iterates over all Transitions referring to an Event through the relation Transition.event

• Create a switch-statement with the m_aState as control variable
• Create a LineContext inside the switch-statement
• Choose Event.-event as the Selector of the new LineContext

We create a LineContext that iterates over all States that refer to a Transition through the relation State.transition

• Create a LineContext on the same line as LineContext that we have crated before
• Choose Transition.-transition as the Selector of the new LineContext

We write a case-statement for each State that is (indirectly) referring to an Event through State.transition.event

• Insert a case State.name and add a break at the end of the case-statement

We update the current state as follows: We first select for an Event the Transitions that refer to the Event trough Transition.event For each Transition we select the States that are connected to Transition by State.transition For each State it holds that if the current state m_aState is equal to State then the new State of the Statemachine is Transition.targetState

• Write code to assign Transition.targetState.name to the variable m_aState

In order to generate code from the template we have implemented before, we setup the project properties for Actifsource:

• Select the project ch.actifsource.tutorial.statemachine and choose Project->Properties from the main menu

• In the Properties dialog choose Actifsource and select the tab Target Folders

• In the dialog Select Target Folder, click on the button Create folder

• Enter src as Folder Name in the New Folder dialog

• Click on OK in the New Folder dialog and then in the Select Target Folder dialog

• Check the settings on the Target Folders tab and close the dialog by clicking on OK

The code generator now applies the template StatemachineImpl to the two Statemachine instances and stores the resulting files to the src folder:

• Open the src folder and check that the two files Statemachine1Impl.hpp and Statemachine2Impl.hpp have been generated
• If the files have not been generated, make sure that Generate Automatically is active under Project in the main menu

• Open the newly generated files and inspect and compare the code for the two Statemachines
• Learn how to extend the Statemachine by conditional transitions and actions executed together with a transition by working through the Actifsource Tutorial Code Snippet
• Complete the generated classes by adding a member function initialize()