GoF - State Örüntüsü (Durum Makinesi)

Not : GoF Tasarım Örüntüleri yazısına bakabilirsiniz.

Örnek
IActivityHandler, state'e IActivityEvent gelince çalışacak kodu belirtir. State değişmez. Şöyle yaparız

public interface IActivityHandler<T extends IActivityEvent>{

  void perform (T event, IEventQueue queue);
}

IStateChangeHandler, state'in ITransitionEvent gelince state girişinde ve çıkışında çalışacak kodu belirtir. Şöyle yaparız

public interface IStateChangeHandler{

  void onEnter (State fromState, State totate, IEvent event, IEventQueue queue);

  void onExit (State fromState, State toState, IEvent event, IEventQueue queue);

}

ITransitionAction transition çalışınca çalışacak kodu belirtir. Şöyle yaparız

public interface ITransitionAction{

  void perform (Transition source, IEvent event);
}

Kuyruk için şöyle yaparız

public class FSMEventQueue : IEventQueue {

  private Queue<IEvent> queue = new LinkedList<>();

  private FSM fsm;


  @Override
  public void postEvent(IEvent event){
    eventQueue.offer(event);
    processEvents();
  }


  protected void processEvents(){
    while(!eventQueue.isEmpty()){
      IEvent event = eventQueue.poll();
      fsm.handleEvent(event);
    }
  }
}

FSM için şöyle yaparız

public class FSM{

  private IEventQueue queue = new FSMEventQueue();

  private Map<String, State> states = new LinkedHashMap();

  private State currentState;


  public void addState(State state){
    states.put(state.getIdentifier(),state);
  }


  //Bu kod aslında başka bir yardımcı sınıfta da olabilirdi
  public addTransition (State fromState, State toState, Object eventType,
    ITransitionAction action){
    Transition transition = new Transition (fromState,toState,eventType,action))
    fromState.addTransiton(transition);
  }


  public void handleEvent(IEvent event){

    if (event instanceof IActivityEvent){
      ActivityEvent activityEvent = (ActivityEvent)event;
      currentState.handleActivityEvent(activityEvent,queue);

    } else if (event instanceof ITransitionEvent){

      ITransitionEvent transitionEvent = ITransitionEvent)event;
      Object eventType = transitionEvent.getEventType();
      Transition transition = currentState.getTransition(eventType);
      currentState = transition.performTransition(transitionEvent,queue);

    }
  }
}

State için şöyle yaparız. eventType olarak Object kullanılıyor. Mesela eğer istersek hep String geçebiliriz.

public class State{

  private HashMap<Object,Transition> transition = new HashMap<>();

  private IActivityHandler activityHandler;

  private IStateChangeHandler stateChangeHandler;

  public void addTransition(Transition transition, Object eventType){
    transitions.put(eventType,transition);
  }


  public Transiton getTransition(Object eventType){
    return transitions.get(eventType);
  }


  public handleActivityEvent(IActivityEvent event, IEventQueue queue){
    activityHandler.handleActivity(event,queue);
  }

  public void onEnter(State fromState, IEvent event,IEventQueue queue){
    stateChangeHandler.onEnter(fromState,this,event,queue);
  }


  public void onExit(State toState, IEvent event,IEventQueue queue){
    stateChangeHandler.onEnter(this,toState,event,queue);
  }
}

Transition için şöyle yaparız

public class Transition{

  State fromState;

  State toState;

  Object eventType;

  ITransitionAction transitionAction;

  public State performTransition(ITransitionEvent event, IEventQueue queue){
    fromState.onExit(toState,event,queue);
    transitionAction.perform(event);
    toState.onEnter(fromState,event,queue);
    return toState;
  }
}

State - Davranışsal Örüntü

Tasarım örüntülerinde gösterilen state machine aslında Moore Machine, çünkü he bir state'in ismi var. State örüntüsünü kullanmadan önce aşağıdaki örnekte görüldüğü gibi bir modemi kontrol etmek için switch/case'ler kullanılabilir. Ancak bir miktar global değişken kullanmak gerekebilir.

switch(stage){
   case Power:
      powerOn();                 // Turn the modem on
      nextstage = ResetCmd;      // Go perform a reset
      attemptsLeft = 5;          // Send the reset command up to five times
      break;
   case ResetCmd;
      modem.write("ATZ\n");      // ATZ - reset
      attemptsLeft--;            // Use one of our attempts
      nextstage = ResetReply;    // Next wait for a response (should be OK)
      timeout = millis() + 5000; // Wait for up to 5 seconds each attempt
      break;
   case ResetReply;
      if(receivedResponse() == OK)     // Success
      {
         nextStage = NetworkAttachCmd; // Attach to the cellular network
      } elseif(receivedResponse() == ERROR || timeout < millis())
      {  // If we get an error or timeout, reattempt if we can, power on if we can't
         if(attemptsLeft > 0)
         {
            nextStage = ResetCmd;
         } else {
            nextStage = Power;
         }
      } 
      break;
   case NetworkAttachCmd:
   ...
}
stage = nextstage;        

Kod karmaşıklaştıkça global değişkenlerden kurtulmak ve daha anlaşılır hale getirmek için bu örüntüye ihtiyaç duyuluyor.

Current State
State örüntüsünde içinde bulunan state kutusuna "current state" ismi verilir.

State Metodları
Bir state OnEnter (), Process (), OnExit gibi metodlarsa sahip olabilir. Bu metodlar state'in hangi transition yolunu kullanarak değiştiğine bakmaksızın çalışır. Yani A'dan B'ye geçiş veya A'dan C'ye geçiş farketmez.

interface IState {
  void OnEnter
  void Process
  StateEnum OnExit
}

StateManager::Initialize (){
  stateList.Add (new InitialState (), INITIAL_STATE);
  stateList.Add (new AwaitingState (), AWAITING_STATE);
  ...
  currentState = stateList [ INITIAL_STATE ];

}

StateManager::Run () {
  currentState -> OnEnter (); // Do something
  currentState -> Process ();  //Do actual work
  SetNextState (currentState -> OnExit ()); // Decide which state is next
}

StateManager::SetNextState (StateEnum value) {
  currentState = stateList [ value ];
}

Bir State'ten Diğerine Geçmek - Transition
Bir state'ten diğerine geçmek için harici (external) veya dahili (internal) bir olayın (event) olması gerekir.

Bazı daha karmaşık State örüntüsünden bir state'ten birden fazla state'e geçiş olabiliyor. Bu durumda state kendi içinde bir Transition listesi tutar. Transition sınıfı şöyledir

class Transition {
  State FromState;
  State ToState;
}

StateManager şöyle yapar.

StateManager::Run (IEvent event) {
  Transition transition = currentState->GetTransition (event);
  currentState = transition.transit (event)
}

Transition çıktığı state'in OnExit(), girdiği state'in OnEnter() metodunu çağırır. Ayrıca Transition perform() metoduna da sahip olabilir. Böylece sadece belli bir yolu izlerken bazı işler yapılabilir. Yani sadece A'dan B'ye geçiş durumnda bir kod çalıştırabiliriz. A'dan C'ye geçişte ise çalıştırmayız.

StateEventQueue

Bazen state geçişleri olan event'lerin başka bir thread'den gelmesi ve asenkron olarak işlenmesi gerekir. Bu durumda event'ler bir kuyruğa konulur ve bu kuyruğu bir thread boşaltıp StateManager'ı çağırır.

Harici Olay

Harici olay dışarıdan gelen bir girdidir. Harici olay current state'e StateManager tarafından iletilir. Harici olayın bir event hiyerarşisinden türemesi iyi bir tasarımdır. Böylece her olay için state arayüzü değişmez. Current State olayı işledikten sonra bir sonraki state'i StateManager'a döndürür. Buraya kadar olan kısım kolay.

Dahili Olay
Dahili geçiş ise genelde bir timer aracılığıyla olur. State bir işlem başlatır ve beklemeye başlar. Bekleme süresi sonunda istenilen netice elde edilmemişse, bir başka state'e geçmek gerekir. İşte bu durumda State kendisini içeren StateManager veya StateContext isimli sınıfa çağrı yapar ve bir sonraki geçilmesi gereken state'i bildirir.

Genel Transition Kararları
Gelen girdiye göre içinde bulunulan state bir sonraki state'e karar verir. Bazen aksiyon state'lerinden önce READY state'leri koymak faydalı olabilir. Böylece gerekli mantık kontrollerin yapıldığından emin olunur.


STOPPED -> READY_TO_WASH -> WASHING

Non-deterministic State Machine
Eğer bir state'ten aynı girdi ile birden fazla state'e geçilebiliyorsa, bu örüntüye non-deterministic state machine adı verilir.

Karnaugh Map
Karnaugh Map yani K-Map state geçişlerinde belki işe yarayabilir.