FsmActionListener.h

[詳解]

// -*- C++ -*-
#ifndef RTC_FSMACTIONLISTENER_H
#define RTC_FSMACTIONLISTENER_H
 
#include <vector>
#include <utility>
#include <mutex>
#include <array>
#include <rtm/RTC.h>
#include <rtm/idl/RTCSkel.h>
#include <rtm/ConnectorBase.h>
#include <rtm/idl/ExtendedFsmServiceStub.h>
 
namespace RTC
{
  //============================================================
  enum class PreFsmActionListenerType : uint8_t
    {
      PRE_ON_INIT,
      PRE_ON_ENTRY,
      PRE_ON_DO,
      PRE_ON_EXIT,
      PRE_ON_STATE_CHANGE,
      PRE_FSM_ACTION_LISTENER_NUM
    };
 
  class PreFsmActionListener
  {
  public:
    static const char* toString(PreFsmActionListenerType type)
    {
      static const char* const typeString[] =
        {
          "PRE_ON_INIT",
          "PRE_ON_ENTRY",
          "PRE_ON_DO",
          "PRE_ON_EXIT",
          "PRE_ON_STATE_CHANGE",
          "PRE_FSM_ACTION_LISTENER_NUM"
        };
      if (type < PreFsmActionListenerType::PRE_FSM_ACTION_LISTENER_NUM)
        {
          return typeString[static_cast<uint8_t>(type)];
        }
      return "";
    }
 
    virtual ~PreFsmActionListener();
 
    virtual void operator()(const char*) = 0;
  };
 
 
  //============================================================
  enum class PostFsmActionListenerType : uint8_t
    {
      POST_ON_INIT,
      POST_ON_ENTRY,
      POST_ON_DO,
      POST_ON_EXIT,
      POST_ON_STATE_CHANGE,
      POST_FSM_ACTION_LISTENER_NUM
    };
 
  class PostFsmActionListener
  {
  public:
    static const char* toString(PostFsmActionListenerType type)
    {
      static const char* const typeString[] =
        {
          "POST_ON_INIT",
          "POST_ON_ENTRY",
          "POST_ON_DO",
          "POST_ON_EXIT",
          "POST_ON_STATE_CHANGE",
          "POST_FSM_ACTION_LISTENER_NUM"
        };
      if (type < PostFsmActionListenerType::POST_FSM_ACTION_LISTENER_NUM)
        {
          return typeString[static_cast<uint8_t>(type)];
        }
      return "";
    }
 
    virtual ~PostFsmActionListener();
 
    virtual void operator()(const char* state,
                            ReturnCode_t ret) = 0;
  };
 
  //============================================================
  enum class FsmProfileListenerType : uint8_t
    {
      SET_FSM_PROFILE,
      GET_FSM_PROFILE,
      ADD_FSM_STATE,
      REMOVE_FSM_STATE,
      ADD_FSM_TRANSITION,
      REMOVE_FSM_TRANSITION,
      BIND_FSM_EVENT,
      UNBIND_FSM_EVENT,
      FSM_PROFILE_LISTENER_NUM
    };
 
  class FsmProfileListener
  {
  public:
    static const char* toString(FsmProfileListenerType type)
    {
      static const char* const typeString[] =
        {
          "SET_FSM_PROFILE",
          "GET_FSM_PROFILE",
          "ADD_FSM_STATE",
          "REMOVE_FSM_STATE",
          "ADD_FSM_TRANSITION",
          "REMOVE_FSM_TRANSITION",
          "BIND_FSM_EVENT",
          "UNBIND_FSM_EVENT",
          "FSM_PROFILE_LISTENER_NUM"
        };
      if (type < FsmProfileListenerType::FSM_PROFILE_LISTENER_NUM)
        {
          return typeString[static_cast<uint8_t>(type)];
        }
      return "";
    }
 
    virtual ~FsmProfileListener();
 
    virtual void operator()(const ::RTC::FsmProfile& fsmprof) = 0;
  };
 
 
  //============================================================
  enum class FsmStructureListenerType : uint8_t
    {
      SET_FSM_STRUCTURE,
      GET_FSM_STRUCTURE,
      FSM_STRUCTURE_LISTENER_NUM
    };
 
  class FsmStructureListener
  {
  public:
    static const char* toString(FsmStructureListenerType type)
    {
      static const char* const typeString[] =
        {
          "SET_FSM_STRUCTURE",
          "GET_FSM_STRUCTURE",
          "FSM_STRUCTURE_LISTENER_NUM"
        };
      if (type < FsmStructureListenerType::FSM_STRUCTURE_LISTENER_NUM)
       {
         return typeString[static_cast<uint8_t>(type)];
       }
      return "";
    }
 
    virtual ~FsmStructureListener();
 
    virtual void operator()(::RTC::FsmStructure& pprof) = 0;
  };
 
  //============================================================
  // Holder classes
  //============================================================
  class PreFsmActionListenerHolder
  {
     using Entry = std::pair<PreFsmActionListener*, bool>;
  public:
    PreFsmActionListenerHolder();
    
    virtual ~PreFsmActionListenerHolder();
    
    void addListener(PreFsmActionListener* listener, bool autoclean);
    
    void removeListener(PreFsmActionListener* listener);
 
    void notify(const char* state);
      
  private:
    std::vector<Entry> m_listeners;
    std::mutex m_mutex;
  };
 
 
  class PostFsmActionListenerHolder
  {
    using Entry = std::pair<PostFsmActionListener*, bool>;
  public:
    PostFsmActionListenerHolder();
    virtual ~PostFsmActionListenerHolder();
    
    void addListener(PostFsmActionListener* listener, bool autoclean);
    
    void removeListener(PostFsmActionListener* listener);
    
    void notify(const char* state, ReturnCode_t ret);
    
  private:
    std::vector<Entry> m_listeners;
    std::mutex m_mutex;
  };
 
 
  //============================================================
  class FsmProfileListenerHolder
  {
    using Entry = std::pair<FsmProfileListener*, bool>;
  public:
    FsmProfileListenerHolder();
    virtual ~FsmProfileListenerHolder();
 
    void addListener(FsmProfileListener* listener, bool autoclean);
 
    void removeListener(FsmProfileListener* listener);
 
    void notify(RTC::FsmProfile& profile);
 
  private:
    std::vector<Entry> m_listeners;
    std::mutex m_mutex;
  };
 
  class FsmStructureListenerHolder
  {
    using Entry = std::pair<FsmStructureListener*, bool>;
  public:
    FsmStructureListenerHolder();
    virtual ~FsmStructureListenerHolder();
 
    void addListener(FsmStructureListener* listener, bool autoclean);
 
    void removeListener(FsmStructureListener* listener);
 
    void notify(RTC::FsmStructure& structure);
 
  private:
    std::vector<Entry> m_listeners;
    std::mutex m_mutex;
  };
 
  //============================================================
  class FsmActionListeners
  {
  public:
    FsmActionListeners();
    ~FsmActionListeners();
    bool addListener(PreFsmActionListenerType type, PreFsmActionListener* listener, bool autoclean=true);
    bool removeListener(PreFsmActionListenerType type, PreFsmActionListener* listener);
    bool addListener(PostFsmActionListenerType type, PostFsmActionListener* listener, bool autoclean=true);
    bool removeListener(PostFsmActionListenerType type, PostFsmActionListener* listener);
    bool addListener(FsmProfileListenerType type, FsmProfileListener* listener, bool autoclean=true);
    bool removeListener(FsmProfileListenerType type, FsmProfileListener* listener);
    bool addListener(FsmStructureListenerType type, FsmStructureListener* listener, bool autoclean=true);
    bool removeListener(FsmStructureListenerType type, FsmStructureListener* listener);
    inline bool notify(PreFsmActionListenerType type, const char* state)
    {
        if (static_cast<uint8_t>(type) < preaction_.size())
        {
            preaction_[static_cast<uint8_t>(type)].notify(state);
            return true;
        }
        return false;
    }
    inline bool notify(PostFsmActionListenerType type, const char* state, ReturnCode_t ret)
    {
        if (static_cast<uint8_t>(type) < postaction_.size())
        {
            postaction_[static_cast<uint8_t>(type)].notify(state, ret);
            return true;
        }
        return false;
    }
    inline bool notify(FsmProfileListenerType type, RTC::FsmProfile& profile)
    {
        if (static_cast<uint8_t>(type) < profile_.size())
        {
            profile_[static_cast<uint8_t>(type)].notify(profile);
            return true;
        }
        return false;
    }
    inline bool notify(FsmStructureListenerType type, RTC::FsmStructure& structure)
    {
        if (static_cast<uint8_t>(type) < structure_.size())
        {
            structure_[static_cast<uint8_t>(type)].notify(structure);
            return true;
        }
        return false;
    }
  private:
    std::array<PreFsmActionListenerHolder, static_cast<uint8_t>(PreFsmActionListenerType::PRE_FSM_ACTION_LISTENER_NUM)> preaction_;
    std::array<PostFsmActionListenerHolder, static_cast<uint8_t>(PostFsmActionListenerType::POST_FSM_ACTION_LISTENER_NUM)> postaction_;
    std::array<FsmProfileListenerHolder, static_cast<uint8_t>(FsmProfileListenerType::FSM_PROFILE_LISTENER_NUM)> profile_;
    std::array<FsmStructureListenerHolder, static_cast<uint8_t>(FsmStructureListenerType::FSM_STRUCTURE_LISTENER_NUM)> structure_;
  };
 
} // namespace RTC
 
#endif // RTC_FSMACTIONLISTENER_H