jkrumow / tbstatemachine Goto Github PK

Hello,

I am playing with the state machine and I have the following example

  TBSMStateMachine *sm = [TBSMStateMachine stateMachineWithName:@"SM"];
  TBSMStateMachine *smA = [TBSMStateMachine stateMachineWithName:@"SMA"];
  TBSMSubState *a = [TBSMSubState subStateWithName:@"A"];
  TBSMState *a1 = [TBSMState stateWithName:@"A1"];
  TBSMState *a2 = [TBSMState stateWithName:@"A2"];
  smA.states = @[a1,a2];
  a.stateMachine = smA;
  sm.states = @[a];
  sm.initialState = a;
  [sm setUp:nil];

I've noticed that A1 is the default state of SMA by default and it's enterBlock is called at setup.

It is not possible to be in state A and not be in the same time in state A1?

Please help me understand what I am missing,

Thank you

• update API to switch by paths instead of single states:
  • traverse state machine hierarchy and create path
  • find LCA from source state's path and destination state's path
  • change -switchState:data:action: to -switchPath:data:action:
  • change -enter:(id<TBStateMachineNode>)state data:(NSDictionary *)data to -enter:(NSArray *)state data:(NSDictionary *)data
  • change -exit:(id<TBStateMachineNode>)state data:(NSDictionary *)data to -exit:(NSArray *)state data:(NSDictionary *)data

When scheduleEvent:data: is called from different concurrent threads:

• correct execution sequence of events
• correct execution sequence of state switching

Hi,
How can I create a parent state which listen to event, transition its substates and still listen to the same event.

Generally speaking:
I have 3 states: stateA, stateB, stateC
and one event eventA with attached data dataA

Statemachine is in stateA and receives eventA.
if dataA is valid statemachine should switch to stateB if not it should switch to stateC.
What is best practice for doing it with your library.

Here is my current implementation, but I am not sure that it is a good practice.

[waitingForFirstVideoFrame addHandlerForEvent:ZZMRecordingSessionVideoFrameEvent
                                               target:recording
                                                 kind:TBSMTransitionExternal
                                               action:nil
        guard:^BOOL(TBSMState * _Nullable sourceState, TBSMState * _Nullable targetState, ZZMFrame *videoFrame) {
            BOOL setup = [self startRecordingWithFrame:videoFrame];
            if (!setup) {
                [_stateMachine switchState:sourceState targetState:die action:nil data:nil];
            }
            return setup;
        }];

Thank you in advance.

Add a property parallelQueue. Perform dispatch_apply when a queue is set, use a simple for loop otherwise.

Do you have any links or papers that describe hierarchical state machine well? Maybe adding them to the README will be nice.

• separation into target - action - guard
• remove return values from action block - use target
• execute action between exit and enter in switch state

Since it is supported by cocoapods 0.38.

Minimal implementation can be as following.
[stateMachine umpleRepresentation];

#=>
class CourseSection
{
  status
  {
    Planned {
      openRegistration -> NotEnoughStudents;
    }
    Open {
      cancel -> Cancelled;
      NotEnoughStudents {
        closeRegistration -> Cancelled;
        register [getClassSize() > getMinimumClassSize()] -> EnoughStudents;
      }
      EnoughStudents {
        closeRegistration -> Closed;
        register [getClassSize() > getMaximumClassSize()] -> Closed;
      }
    }
    Cancelled {}
    Closed {}
  }
}

Graphical representation:
http://cruise.eecs.uottawa.ca/umpleonline/umple.php?model=160218638587&diagramtype=state

• queue events (RTC model)

• it should be possible to register event handlers
• it should be possible to define enter and exit blocks
  • enter block will be executed before the enter block of the respective substate
  • exit block will be executed after the exit block of the respective substate

A state should be able to define a given event as deferred.
The state machine should be able to queue these events until a state has been entered which can handle the deferred event.
Substates should take precedence over super states. In orthogonal regions the consuming state takes precedence over the deferring state.

The state machine should only execute guard and action blocks when parameter target in method -registerEvent:target:action:guard: in class TBSMState is set to nil. The exit block should not be executed.

• each node knows its path inside the state machine hierarchy when it is added to the hierarchy
• find LCA from source state's path and destination state's
• switches to next sub state machine

• execution sequence of exit - action - enter is messed up
• state is entered by the wrong state machine in the hierarchy