ComponentActionListener.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_COMPONENTACTIONLISTENER_H
#define RTC_COMPONENTACTIONLISTENER_H

#include <vector>
#include <utility>
#include <coil/Mutex.h>
#include <coil/Guard.h>
#include <rtm/RTC.h>
#include <rtm/idl/RTCSkel.h>
#include <rtm/ConnectorBase.h>

namespace RTC
{
  typedef ExecutionContextHandle_t UniqueId;
  //============================================================
  enum PreComponentActionListenerType
    {
      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)
    {
      static const char* 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"
        };
      if (type < PRE_COMPONENT_ACTION_LISTENER_NUM) { return typeString[type]; }
      return "";
    }

    virtual ~PreComponentActionListener();

    virtual void operator()(UniqueId ec_id) = 0;
  };


  //============================================================
  enum PostComponentActionListenerType
    {
      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)
    {
      static const char* 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"
        };
      if (type < POST_COMPONENT_ACTION_LISTENER_NUM)
        {
          return typeString[type];
        }
      return "";
    }

    virtual ~PostComponentActionListener();

    virtual void operator()(UniqueId ec_id,
                            ReturnCode_t ret) = 0;
  };

  //============================================================
  enum PortActionListenerType
    {
      ADD_PORT,
      REMOVE_PORT,
      PORT_ACTION_LISTENER_NUM
    };

  class PortActionListener
  {
  public:
    static const char* toString(PortActionListenerType type)
    {
      static const char* typeString[] =
        {
          "ADD_PORT",
          "REMOVE_PORT",
          "PORT_ACTION_LISTENER_NUM"
        };
      if (type < PORT_ACTION_LISTENER_NUM) { return typeString[type]; }
      return "";
    }

    virtual ~PortActionListener();

    virtual void operator()(const ::RTC::PortProfile& pprof) = 0;
  };


  //============================================================
  enum ExecutionContextActionListenerType
    {
      EC_ATTACHED,
      EC_DETACHED,
      EC_ACTION_LISTENER_NUM
    };

  class ExecutionContextActionListener
  {
  public:
    static const char* toString(ExecutionContextActionListenerType type)
    {
      static const char* typeString[] =
        {
          "ATTACH_EC",
          "DETACH_ECT",
          "EC_ACTION_LISTENER_NUM"
        };
      if (type < EC_ACTION_LISTENER_NUM) { return typeString[type]; }
      return "";
    }

    virtual ~ExecutionContextActionListener();

    virtual void operator()(UniqueId ec_id) = 0;
  };



  //============================================================
  class PreComponentActionListenerHolder
  {
    typedef std::pair<PreComponentActionListener*, bool> Entry;
    typedef coil::Guard<coil::Mutex> Guard;
  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;
    coil::Mutex m_mutex;
  };


  class PostComponentActionListenerHolder
  {
    typedef std::pair<PostComponentActionListener*, bool> Entry;
    typedef coil::Guard<coil::Mutex> Guard;
  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;
    coil::Mutex m_mutex;
  };


  //============================================================
  class PortActionListenerHolder
  {
    typedef std::pair<PortActionListener*, bool> Entry;
    typedef coil::Guard<coil::Mutex> Guard;
  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;
    coil::Mutex m_mutex;
  };

  class ExecutionContextActionListenerHolder
  {
    typedef std::pair<ExecutionContextActionListener*, bool> Entry;
    typedef coil::Guard<coil::Mutex> Guard;
  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;
    coil::Mutex m_mutex;
  };


  class ComponentActionListeners
  {
  public:
    PreComponentActionListenerHolder 
    preaction_[PRE_COMPONENT_ACTION_LISTENER_NUM];
    PostComponentActionListenerHolder 
    postaction_[POST_COMPONENT_ACTION_LISTENER_NUM];
    PortActionListenerHolder
    portaction_[PORT_ACTION_LISTENER_NUM];
   ExecutionContextActionListenerHolder
    ecaction_[EC_ACTION_LISTENER_NUM];
  };


}; // namespace RTC

#endif // RTC_COMPONENTACTIONLISTENER_H