AsyncStateMachine.h

Go to the documentation of this file.

 
#ifndef ASYNC_STATE_MACHINE_INCLUDED
#define ASYNC_STATE_MACHINE_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <typeinfo>
#include <cassert>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncTimer.h>
#include <AsyncAtTimer.h>
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
template <class ContextT, class TopStateT> class StateTopBase;
 
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
template <class ContextT, class StateTopT>
class StateMachine
{
  public:
    using StateTopBaseT = StateTopBase<ContextT,StateTopT>;
 
    StateMachine(ContextT* ctx) : m_ctx(ctx)
    {
      m_timer.expired.connect(
          [&](Timer*)
          {
            assert(m_state != nullptr);
            clearTimeout();
            static_cast<StateTopBaseT*>(m_state)->timeoutEvent();
          });
      m_at_timer.expired.connect(
          [&](AtTimer*)
          {
            assert(m_state != nullptr);
            clearTimeoutAt();
            static_cast<StateTopBaseT*>(m_state)->timeoutAtEvent();
          });
    }
 
    StateMachine(const StateMachine&) = delete;
 
    StateMachine& operator=(const StateMachine&) = delete;
 
    ~StateMachine(void)
    {
      delete m_state;
      m_state = nullptr;
    }
 
    void start(void)
    {
      setState<StateTopT>();
    }
 
    ContextT& ctx(void)
    {
      return *m_ctx;
    }
 
    template <class NewStateT>
    void setState(NewStateT* state=new NewStateT)
    {
      state->setMachine(this);
      StateTopT* old_state = m_state;
      if ((old_state != nullptr) && (typeid(NewStateT) == old_state->typeId()))
      {
        delete state;
        return;
      }
      static_cast<StateTopBaseT*>(state)->initHandler();
      if (old_state != m_state)
      {
        delete state;
        return;
      }
#ifdef ASYNC_STATE_MACHINE_DEBUG
      std::cout << "### StateMachine: ";
      std::cout << (old_state != nullptr ? old_state->name() : "NULL");
      std::cout << " -> " << state->name() << std::endl;
#endif
      if (old_state != nullptr)
      {
        static_cast<StateTopBaseT*>(old_state)->exitHandler(state);
      }
      m_state = state;
      static_cast<StateTopBaseT*>(m_state)->entryHandler(old_state);
      delete old_state;
    }
 
    template <class T>
    bool isActive(void) const
    {
      return typeid(T) == m_state->typeId();
    }
 
    StateTopT& state(void) { return *m_state; }
 
    void setTimeout(int timeout_ms)
    {
#ifdef ASYNC_STATE_MACHINE_DEBUG
      std::cout << "### StateMachine: setTimeout(" << timeout_ms << ")"
                << std::endl;
#endif
      m_timer.setTimeout(timeout_ms);
      m_timer.setEnable(true);
    }
 
    void setTimeoutAt(struct tm& tm, int expire_offset=0)
    {
      m_at_timer.setTimeout(tm);
      m_at_timer.setExpireOffset(expire_offset);
      m_at_timer.start();
    }
 
    void clearTimeout(void)
    {
#ifdef ASYNC_STATE_MACHINE_DEBUG
      std::cout << "### StateMachine: clearTimeout()" << std::endl;
#endif
      m_timer.setEnable(false);
    }
 
    void clearTimeoutAt(void)
    {
      m_at_timer.stop();
    }
 
  private:
    StateTopT*  m_state     = nullptr;
    ContextT*   m_ctx       = nullptr;
    Timer       m_timer     = -1;
    AtTimer     m_at_timer;
}; /* StateMachine */
 
 
template <class ParentT, class T>
class StateBase : public ParentT
{
  public:
    virtual const std::type_info& typeId(void) const override
    {
      return typeid(T);
    }
 
    virtual const char* name(void) const { return T::NAME; }
 
  protected:
    virtual void initHandler(void) override
    {
      dynamic_cast<T*>(this)->init();
    }
 
    virtual void entryHandler(typename ParentT::StateT* from) override
    {
      if (dynamic_cast<T*>(from) == nullptr)
      {
        ParentT::entryHandler(from);
        dynamic_cast<T*>(this)->entry();
      }
    }
 
    virtual void exitHandler(typename ParentT::StateT* to) override
    {
      if (dynamic_cast<T*>(to) == nullptr)
      {
        dynamic_cast<T*>(this)->exit();
        ParentT::exitHandler(to);
      }
    }
 
    void init(void) {}
 
    void entry(void) {}
 
    void exit(void) {}
 
    virtual void timeoutEvent(void) override
    {
      assert(!"Async::StateBase: Unhandled timeoutEvent");
    }
 
    virtual void timeoutAtEvent(void) override
    {
      assert(!"Async::StateBase: Unhandled timeoutAtEvent");
    }
 
}; /* StateBase */
 
 
template <class ContextT, class TopStateT>
class StateTopBase
{
  public:
    using Type = StateBase<StateTopBase<ContextT, TopStateT>, TopStateT>;
 
    using StateT = TopStateT;
 
    using StateMachineT = StateMachine<ContextT, StateT>;
 
    virtual ~StateTopBase(void) {}
 
    ContextT& ctx(void) { return m_sm->ctx(); }
 
  protected:
    template <class NewStateT>
    void setState(void) { m_sm->setState(new NewStateT); }
 
    void setTimeout(int timeout_ms) { m_sm->setTimeout(timeout_ms); }
 
    void setTimeoutAt(struct tm& tm, int expire_offset=0)
    {
      m_sm->setTimeoutAt(tm, expire_offset);
    }
 
    void clearTimeout(void) { m_sm->clearTimeout(); }
 
    void clearTimeoutAt(void) { m_sm->clearTimeoutAt(); }
 
    virtual const std::type_info& typeId(void) const = 0;
 
    virtual void initHandler(void) = 0;
 
    virtual void entryHandler(StateT* from) {}
 
    virtual void exitHandler(StateT* to) {}
 
    virtual void timeoutEvent(void) = 0;
 
    virtual void timeoutAtEvent(void) = 0;
 
  private:
    StateMachineT* m_sm;
 
    void setMachine(StateMachineT* sm) { m_sm = sm; }
 
    friend StateMachineT;
}; /* StateTopBase */
 
 
 
} /* namespace Async */
 
#endif /* ASYNC_STATE_MACHINE_INCLUDED */
 
/*
 * This file has not been truncated
 */