ComponentActionListener.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_COMPONENTACTIONLISTENER_H
#define RTC_COMPONENTACTIONLISTENER_H
 
#include <mutex>
 
#include <rtm/RTC.h>
#include <rtm/idl/RTCSkel.h>
#include <rtm/ConnectorBase.h>
 
#include <vector>
#include <utility>
#include <array>
 
namespace RTC
{
  using UniqueId = ExecutionContextHandle_t;
  //============================================================
  enum class PreComponentActionListenerType : uint8_t
    {
      PRE_ON_INITIALIZE,
      PRE_ON_FINALIZE,
      PRE_ON_STARTUP,
      PRE_ON_SHUTDOWN,
      PRE_ON_ACTIVATED,
      PRE_ON_DEACTIVATED,
      PRE_ON_ABORTING,
      PRE_ON_ERROR,
      PRE_ON_RESET,
      PRE_ON_EXECUTE,
      PRE_ON_STATE_UPDATE,
      PRE_ON_RATE_CHANGED,
      PRE_COMPONENT_ACTION_LISTENER_NUM
    };
 
  class PreComponentActionListener
  {
  public:
    static const char* toString(PreComponentActionListenerType type)
    {
      if (type <
      PreComponentActionListenerType::PRE_COMPONENT_ACTION_LISTENER_NUM)
        {
      static const char* const typeString[] =
        {
          "PRE_ON_INITIALIZE",
          "PRE_ON_FINALIZE",
          "PRE_ON_STARTUP",
          "PRE_ON_SHUTDOWN",
          "PRE_ON_ACTIVATED",
          "PRE_ON_DEACTIVATED",
          "PRE_ON_ABORTING",
          "PRE_ON_ERROR",
          "PRE_ON_RESET",
          "PRE_ON_EXECUTE",
          "PRE_ON_STATE_UPDATE",
          "PRE_ON_RATE_CHANGED",
          "PRE_COMPONENT_ACTION_LISTENER_NUM"
        };
                return typeString[static_cast<uint8_t>(type)];
        }
      return "";
    }
 
    virtual ~PreComponentActionListener();
 
    virtual void operator()(UniqueId ec_id) = 0;
  };
 
 
  //============================================================
  enum class PostComponentActionListenerType : uint8_t
    {
      POST_ON_INITIALIZE,
      POST_ON_FINALIZE,
      POST_ON_STARTUP,
      POST_ON_SHUTDOWN,
      POST_ON_ACTIVATED,
      POST_ON_DEACTIVATED,
      POST_ON_ABORTING,
      POST_ON_ERROR,
      POST_ON_RESET,
      POST_ON_EXECUTE,
      POST_ON_STATE_UPDATE,
      POST_ON_RATE_CHANGED,
      POST_COMPONENT_ACTION_LISTENER_NUM
    };
 
 
  class PostComponentActionListener
  {
  public:
    static const char* toString(PostComponentActionListenerType type)
    {
      if (type < 
      PostComponentActionListenerType::POST_COMPONENT_ACTION_LISTENER_NUM)
        {
      static const char* const typeString[] =
        {
          "POST_ON_INITIALIZE",
          "POST_ON_FINALIZE",
          "POST_ON_STARTUP",
          "POST_ON_SHUTDOWN",
          "POST_ON_ACTIVATED",
          "POST_ON_DEACTIVATED",
          "POST_ON_ABORTING",
          "POST_ON_ERROR",
          "POST_ON_RESET",
          "POST_ON_EXECUTE",
          "POST_ON_STATE_UPDATE",
          "POST_ON_RATE_CHANGED",
          "POST_COMPONENT_ACTION_LISTENER_NUM"
        };
          return typeString[static_cast<uint8_t>(type)];
        }
      return "";
    }
 
    virtual ~PostComponentActionListener();
 
    virtual void operator()(UniqueId ec_id,
                            ReturnCode_t ret) = 0;
  };
 
  //============================================================
  enum class PortActionListenerType : uint8_t
    {
      ADD_PORT,
      REMOVE_PORT,
      PORT_ACTION_LISTENER_NUM
    };
 
  class PortActionListener
  {
  public:
    static const char* toString(PortActionListenerType type)
    {
      if (type < PortActionListenerType::PORT_ACTION_LISTENER_NUM)
        {
      static const char* const typeString[] =
        {
          "ADD_PORT",
          "REMOVE_PORT",
          "PORT_ACTION_LISTENER_NUM"
        };
          return typeString[static_cast<uint8_t>(type)];
        }
      return "";
    }
 
    virtual ~PortActionListener();
 
    virtual void operator()(const ::RTC::PortProfile& pprof) = 0;
  };
 
 
  //============================================================
  enum class ExecutionContextActionListenerType : uint8_t
    {
      EC_ATTACHED,
      EC_DETACHED,
      EC_ACTION_LISTENER_NUM
    };
 
  class ExecutionContextActionListener
  {
  public:
    static const char* toString(ExecutionContextActionListenerType type)
    {
      if (type < ExecutionContextActionListenerType::EC_ACTION_LISTENER_NUM)
        {
      static const char* const typeString[] =
        {
          "ATTACH_EC",
          "DETACH_ECT",
          "EC_ACTION_LISTENER_NUM"
        };
          return typeString[static_cast<uint8_t>(type)];
        }
      return "";
    }
 
    virtual ~ExecutionContextActionListener();
 
    virtual void operator()(UniqueId ec_id) = 0;
  };
 
 
 
  //============================================================
  class PreComponentActionListenerHolder
  {
    using Entry = std::pair<PreComponentActionListener*, bool>;
  public:
    PreComponentActionListenerHolder();
 
    virtual ~PreComponentActionListenerHolder();
 
    void addListener(PreComponentActionListener* listener, bool autoclean);
 
    void removeListener(PreComponentActionListener* listener);
 
    void notify(UniqueId ec_id);
 
  private:
    std::vector<Entry> m_listeners;
    std::mutex m_mutex;
  };
 
 
  class PostComponentActionListenerHolder
  {
    using Entry = std::pair<PostComponentActionListener*, bool>;
  public:
    PostComponentActionListenerHolder();
    virtual ~PostComponentActionListenerHolder();
 
    void addListener(PostComponentActionListener* listener, bool autoclean);
 
    void removeListener(PostComponentActionListener* listener);
 
    void notify(UniqueId ec_id, ReturnCode_t ret);
 
  private:
    std::vector<Entry> m_listeners;
    std::mutex m_mutex;
  };
 
 
  //============================================================
  class PortActionListenerHolder
  {
    using Entry = std::pair<PortActionListener*, bool>;
  public:
    PortActionListenerHolder();
    virtual ~PortActionListenerHolder();
 
    void addListener(PortActionListener* listener, bool autoclean);
 
    void removeListener(PortActionListener* listener);
 
    void notify(const RTC::PortProfile& pprofile);
 
  private:
    std::vector<Entry> m_listeners;
    std::mutex m_mutex;
  };
 
  class ExecutionContextActionListenerHolder
  {
    using Entry = std::pair<ExecutionContextActionListener*, bool>;
  public:
    ExecutionContextActionListenerHolder();
    virtual ~ExecutionContextActionListenerHolder();
 
    void addListener(ExecutionContextActionListener* listener, bool autoclean);
 
    void removeListener(ExecutionContextActionListener* listener);
 
    void notify(UniqueId ec_id);
 
  private:
    std::vector<Entry> m_listeners;
    std::mutex m_mutex;
  };
 
 
  class ComponentActionListeners
  {
  public:
    ComponentActionListeners();
    ~ComponentActionListeners();
    bool addListener(PreComponentActionListenerType type, PreComponentActionListener* listener, bool autoclean);
    bool addListener(PostComponentActionListenerType type, PostComponentActionListener* listener, bool autoclean);
    bool addListener(PortActionListenerType type, PortActionListener* listener, bool autoclean);
    bool addListener(ExecutionContextActionListenerType type, ExecutionContextActionListener* listener, bool autoclean);
    bool removeListener(PreComponentActionListenerType type, PreComponentActionListener* listener);
    bool removeListener(PostComponentActionListenerType type, PostComponentActionListener* listener);
    bool removeListener(PortActionListenerType type, PortActionListener* listener);
    bool removeListener(ExecutionContextActionListenerType type, ExecutionContextActionListener* listener);
    inline bool notify(PreComponentActionListenerType type, UniqueId ec_id)
    {
        if (static_cast<uint8_t>(type) < preaction_.size())
        {
            preaction_[static_cast<uint8_t>(type)].notify(ec_id);
            return true;
        }
        return false;
    }
    inline bool notify(PostComponentActionListenerType type, UniqueId ec_id, ReturnCode_t ret)
    {
        if (static_cast<uint8_t>(type) < postaction_.size())
        {
            postaction_[static_cast<uint8_t>(type)].notify(ec_id, ret);
            return true;
        }
        return false;
    }
    inline bool notify(PortActionListenerType type, const RTC::PortProfile& pprofile)
    {
        if (static_cast<uint8_t>(type) < portaction_.size())
        {
            portaction_[static_cast<uint8_t>(type)].notify(pprofile);
            return true;
        }
        return false;
    }
    inline bool notify(ExecutionContextActionListenerType type, UniqueId ec_id)
    {
        if (static_cast<uint8_t>(type) < ecaction_.size())
        {
            ecaction_[static_cast<uint8_t>(type)].notify(ec_id);
            return true;
        }
        return false;
    }
  private:
    std::array<PreComponentActionListenerHolder, static_cast<uint8_t>(PreComponentActionListenerType::PRE_COMPONENT_ACTION_LISTENER_NUM)> preaction_;
    std::array<PostComponentActionListenerHolder, static_cast<uint8_t>(PostComponentActionListenerType::POST_COMPONENT_ACTION_LISTENER_NUM)> postaction_;
    std::array<PortActionListenerHolder, static_cast<uint8_t>(PortActionListenerType::PORT_ACTION_LISTENER_NUM)> portaction_;
    std::array<ExecutionContextActionListenerHolder, static_cast<uint8_t>(ExecutionContextActionListenerType::EC_ACTION_LISTENER_NUM)> ecaction_;
  };
 
 
} // namespace RTC
 
#endif  // RTC_COMPONENTACTIONLISTENER_H