mitkStateMachine.h

Go to the documentation of this file.

/*=========================================================================

Program:   Medical Imaging & Interaction Toolkit
Language:  C++
Date:      $Date$
Version:   $Revision$

Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.

=========================================================================*/


#ifndef STATEMACHINE_H_HEADER_INCLUDED_C18896BD
#define STATEMACHINE_H_HEADER_INCLUDED_C18896BD

#include "mitkCommon.h"
#include <itkObject.h>
#include "mitkOperationActor.h"
#include <string>
#include "mitkState.h"
#include "mitkUndoModel.h"

namespace mitk {

  class Action;
  class StateEvent;
  class UndoController;

  // base class of statem machine functors
  class MITK_CORE_EXPORT TStateMachineFunctor
  {
    public:
      virtual bool DoAction(Action*, const StateEvent*)=0;        // call using function
      virtual ~TStateMachineFunctor() {}
  };

  // the template functor for arbitrary StateMachine derivations
  template <class T>
  class TSpecificStateMachineFunctor : public TStateMachineFunctor
  {
    public:

      // constructor - takes pointer to an object and pointer to a member and stores
      // them in two private variables
      TSpecificStateMachineFunctor(T* object, bool(T::*memberFunctionPointer)(Action*, const StateEvent*))
      :m_Object(object),
      m_MemberFunctionPointer(memberFunctionPointer)
      {
      }

      virtual ~TSpecificStateMachineFunctor() {} // virtual destructor

      // override function "Call"
      virtual bool DoAction(Action* action, const StateEvent* stateEvent)
      {
        return (*m_Object.*m_MemberFunctionPointer)(action, stateEvent);             // execute member function
      }

    private:
      T* m_Object;                  // pointer to object
      bool (T::*m_MemberFunctionPointer)(Action*, const StateEvent*);   // pointer to member function
  };

#define CONNECT_ACTION(a, f) \
  StateMachine::AddActionFunction(a, new TSpecificStateMachineFunctor<Self>(this, &Self::f));

#define STATEMACHINE_INFO MITK_INFO("StateMachine")
#define STATEMACHINE_WARN MITK_WARN("StateMachine")
#define STATEMACHINE_FATAL MITK_FATAL("StateMachine")
#define STATEMACHINE_ERROR MITK_ERROR("StateMachine")
#define STATEMACHINE_DEBUG MITK_DEBUG("StateMachine")

  class MITK_CORE_EXPORT StateMachine : public itk::Object, public mitk::OperationActor
  {

  public:
    mitkClassMacro(StateMachine,itk::Object);

    mitkNewMacro1Param(Self, const char*);


    typedef std::map<int, TStateMachineFunctor*> ActionFunctionsMapType;

    typedef std::vector<State::Pointer> StartStateVectorType;

    std::string GetType() const;

    virtual bool HandleEvent(StateEvent const* stateEvent);

    void EnableUndo(bool enable);

    friend class UndoModel;

    friend class GlobalInteraction;


  protected:
    StateMachine(const char * type);

    ~StateMachine();

    void AddActionFunction(int action, TStateMachineFunctor* functor);

    virtual bool ExecuteAction(Action* action, StateEvent const* stateEvent);

    const State* GetCurrentState(unsigned int timeStep = 0) const;

    bool m_UndoEnabled;

    void IncCurrGroupEventId();

    UndoController* m_UndoController;

    virtual void ExecuteOperation(Operation* operation);

    void ResetStatemachineToStartState(unsigned int timeStep = 0);

    void ExpandStartStateVector(unsigned int timeSteps);

    void InitializeStartStates(unsigned int timeSteps);

    virtual void UpdateTimeStep(unsigned int timeStep);

    unsigned int m_TimeStep;

  private:
    std::string m_Type;

    StartStateVectorType m_CurrentStateVector;

    ActionFunctionsMapType m_ActionFunctionsMap;

  };

} // namespace mitk



#endif /* STATEMACHINE_H_HEADER_INCLUDED_C18896BD */