ConnectorListener.h

Go to the documentation of this file.

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

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

class cdrMemoryStream;

namespace RTC
{
  class ConnectorInfo;
  class ConnectorListenerStatus
  {
  public:
    enum Enum
      {
        NO_CHANGE    = 0,
        INFO_CHANGED = 1 << 0,
        DATA_CHANGED = 1 << 1,
        BOTH_CHANGED = INFO_CHANGED | DATA_CHANGED
      };
  };
  ConnectorListenerStatus::Enum operator|(ConnectorListenerStatus::Enum L,
                                          ConnectorListenerStatus::Enum R);
  ConnectorListenerStatus::Enum operator&(ConnectorListenerStatus::Enum L,
                                          ConnectorListenerStatus::Enum R);

#define USE_CONNLISTENER_STATUS                             \
  typedef ::RTC::ConnectorListenerStatus::Enum ReturnCode;  \
  using ::RTC::ConnectorListenerStatus::NO_CHANGE;          \
  using ::RTC::ConnectorListenerStatus::INFO_CHANGED;       \
  using ::RTC::ConnectorListenerStatus::DATA_CHANGED;       \
  using ::RTC::ConnectorListenerStatus::BOTH_CHANGED;

  enum ConnectorDataListenerType
    {
      ON_BUFFER_WRITE = 0,
      ON_BUFFER_FULL,
      ON_BUFFER_WRITE_TIMEOUT,
      ON_BUFFER_OVERWRITE,
      ON_BUFFER_READ,
      ON_SEND,
      ON_RECEIVED,
      ON_RECEIVER_FULL,
      ON_RECEIVER_TIMEOUT,
      ON_RECEIVER_ERROR,
      CONNECTOR_DATA_LISTENER_NUM
    };

  class ConnectorDataListener
    : public ConnectorListenerStatus
  {
  public:
    USE_CONNLISTENER_STATUS;
    static const char* toString(ConnectorDataListenerType type)
    {
      static const char* typeString[] =
        {
          "ON_BUFFER_WRITE",
          "ON_BUFFER_FULL",
          "ON_BUFFER_WRITE_TIMEOUT",
          "ON_BUFFER_OVERWRITE",
          "ON_BUFFER_READ", 
          "ON_SEND", 
          "ON_RECEIVED",
          "ON_RECEIVER_FULL", 
          "ON_RECEIVER_TIMEOUT", 
          "ON_RECEIVER_ERROR",
          "CONNECTOR_DATA_LISTENER_NUM"
        };
      if (type < CONNECTOR_DATA_LISTENER_NUM) { return typeString[type]; }
      return "";
    }

    virtual ~ConnectorDataListener();

    virtual ReturnCode operator()(ConnectorInfo& info,
                            cdrMemoryStream& data) = 0;
  };

  template <class DataType>
  class ConnectorDataListenerT
    : public ConnectorDataListener
  {
  public:
    virtual ~ConnectorDataListenerT(){}

    virtual ReturnCode operator()(ConnectorInfo& info,
                                  cdrMemoryStream& cdrdata)
    {
      DataType data;
      cdrMemoryStream cdr(cdrdata.bufPtr(), cdrdata.bufSize());

      // endian type check
      std::string endian_type;
      endian_type = info.properties.getProperty("serializer.cdr.endian",
                                                "little");
      coil::normalize(endian_type);
      std::vector<std::string> endian(coil::split(endian_type, ","));
      if (endian[0] == "little")
        {
          cdr.setByteSwapFlag(true);
        }
      else if (endian[0] == "big")
        {
          cdr.setByteSwapFlag(false);
        }
      data <<= cdr;
      ReturnCode ret = this->operator()(info, data);
      if (ret == DATA_CHANGED || ret == BOTH_CHANGED)
        {
          cdrdata.rewindPtrs();
          data >>= cdrdata;
        }
      return ret;
    }

    virtual ReturnCode operator()(ConnectorInfo& info,
                                  DataType& data) = 0;
  };


  enum ConnectorListenerType
    {
      ON_BUFFER_EMPTY = 0,
      ON_BUFFER_READ_TIMEOUT,
      ON_SENDER_EMPTY,
      ON_SENDER_TIMEOUT,
      ON_SENDER_ERROR,
      ON_CONNECT,
      ON_DISCONNECT,
      CONNECTOR_LISTENER_NUM
    };

  class ConnectorListener
    : public ConnectorListenerStatus
  {
  public:
    USE_CONNLISTENER_STATUS;
    static const char* toString(ConnectorListenerType type)
    { 
      static const char* typeStr[] =
        {
          "ON_BUFFER_EMPTY",
          "ON_BUFFER_READ_TIMEOUT",
          "ON_SENDER_EMPTY", 
          "ON_SENDER_TIMEOUT", 
          "ON_SENDER_ERROR", 
          "ON_CONNECT",
          "ON_DISCONNECT",
          "CONNECTOR_LISTENER_NUM"
        };
      if (type < CONNECTOR_LISTENER_NUM) { return typeStr[type]; }
      return "";
    }

    virtual ~ConnectorListener();

    virtual ReturnCode operator()(ConnectorInfo& info) = 0;
  };


  class ConnectorDataListenerHolder
    : public ConnectorListenerStatus
  {
    typedef std::pair<ConnectorDataListener*, bool> Entry;
    typedef coil::Guard<coil::Mutex> Guard;
  public:
    USE_CONNLISTENER_STATUS;
    ConnectorDataListenerHolder();
    virtual ~ConnectorDataListenerHolder();
    
    void addListener(ConnectorDataListener* listener, bool autoclean);
    
    void removeListener(ConnectorDataListener* listener);
    
    size_t size();

    ReturnCode notify(ConnectorInfo& info,
                      cdrMemoryStream& cdrdata);

    template <class DataType>
    ReturnCode notify(ConnectorInfo& info, DataType& typeddata)
    {
      Guard guard(m_mutex);
      ReturnCode ret(NO_CHANGE);
      for (size_t i(0), len(m_listeners.size()); i < len; ++i)
        {
          ConnectorDataListenerT<DataType>* listener(0);
          listener =
          dynamic_cast<ConnectorDataListenerT<DataType>*>(m_listeners[i].first);
          if (listener != 0)
            {
              ret = ret | listener->operator()(info, typeddata);
            }
          else
            {
              cdrMemoryStream cdr;
              typeddata >>= cdr;
              ret = ret | m_listeners[i].first->operator()(info, cdr);
            }
        }
      return ret;
    }

  private:
    std::vector<Entry> m_listeners;
    coil::Mutex m_mutex;
  };


  class ConnectorListenerHolder
    : public ConnectorListenerStatus
  {
    typedef std::pair<ConnectorListener*, bool> Entry;
    typedef coil::Guard<coil::Mutex> Guard;
  public:
    USE_CONNLISTENER_STATUS;
    ConnectorListenerHolder();
    
    virtual ~ConnectorListenerHolder();
    
    void addListener(ConnectorListener* listener, bool autoclean);
    
    void removeListener(ConnectorListener* listener);

    size_t size();

    ReturnCode notify(ConnectorInfo& info);
      
  private:
    std::vector<Entry> m_listeners;
    coil::Mutex m_mutex;
  };
  
  class ConnectorListeners
  {
  public:
    ConnectorDataListenerHolder connectorData_[CONNECTOR_DATA_LISTENER_NUM];
    ConnectorListenerHolder connector_[CONNECTOR_LISTENER_NUM];
  };
};

#endif // RTC_CONNECTORLISTENER_H