ComponentObserverConsumer.h

Go to the documentation of this file.

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

#include <coil/Mutex.h>
#include <coil/Factory.h>
#include <coil/stringutil.h>
#include <rtm/SdoServiceConsumerBase.h>
#include <rtm/CorbaConsumer.h>
#include <rtm/ComponentActionListener.h>
#include <rtm/idl/SDOPackageStub.h>
#include "ComponentObserverStub.h"

namespace RTC
{

  class ComponentObserverConsumer
    : public SdoServiceConsumerBase
  {
  public:
    ComponentObserverConsumer();

    virtual ~ComponentObserverConsumer();

    virtual bool init(RTObject_impl& rtobj,
                      const SDOPackage::ServiceProfile& profile);

    virtual bool reinit(const SDOPackage::ServiceProfile& profile);

    virtual const SDOPackage::ServiceProfile& getProfile() const;
    
    virtual void finalize();

  protected:
    inline void updateStatus(OpenRTM::StatusKind statuskind, const char* msg)
    {
      try
        {
          m_observer->update_status(statuskind, msg);
        }
      catch (...)
        {
          m_rtobj->removeSdoServiceConsumer(m_profile.id);
        }
    }

    inline const char* toString(OpenRTM::StatusKind kind)
    {
      static const char* kinds[] = 
        {
          "COMPONENT_PROFILE",
          "RTC_STATUS",
          "EC_STATUS",
          "PORT_PROFILE",
          "CONFIGURATION",
          "HEARTBEAT"
        };
      return (size_t)kind < sizeof(kind)/sizeof(char*) ? kinds[kind] : "";
    }

    void setListeners(coil::Properties& prop);

    void switchListeners(bool& next, bool& pre,
                         void (ComponentObserverConsumer::*setfunc)(), 
                         void (ComponentObserverConsumer::*unsetfunc)());

    //============================================================
    // Heartbeat related functions
    void heartbeat();

    void setHeartbeat(coil::Properties& prop);

    void unsetHeartbeat();

    //============================================================
    // Component status related functions
    void setComponentStatusListeners();

    void unsetComponentStatusListeners();

    //============================================================
    // Port profile related functions
    void setPortProfileListeners();

    void unsetPortProfileListeners();


    //============================================================
    // EC profile related functions
    void setExecutionContextListeners();

    void unsetExecutionContextListeners();


    //============================================================
    // ComponentProfile related functions
    void setComponentProfileListeners();

    void unsetComponentProfileListeners();

    //============================================================
    // Configuration related functions

    void setConfigurationListeners();

    void unsetConfigurationListeners();


  private:
    class CompStatMsg
    {
    public:
      CompStatMsg(ComponentObserverConsumer& coc)
        : activatedListener(NULL), deactivatedListener(NULL),
          resetListener(NULL), abortingListener(NULL),
          finalizeListener(NULL), m_coc(coc) {}
      void onGeneric(const char* msgprefix, UniqueId ec_id, ReturnCode_t ret)
      {
        if (ret == RTC::RTC_OK)
          {
            std::string msg(msgprefix);
            msg += coil::otos(ec_id);
            m_coc.updateStatus(OpenRTM::RTC_STATUS, msg.c_str());
          }
      }
      void onActivated(UniqueId ec_id, ReturnCode_t ret)
      {
        onGeneric("ACTIVE:", ec_id, ret);
      }
      void onDeactivated(UniqueId ec_id, ReturnCode_t ret)
      {
        onGeneric("INACTIVE:", ec_id, ret);
      }
      void onReset(UniqueId ec_id, ReturnCode_t ret)
      {
        onGeneric("INACTIVE:", ec_id, ret);
      }
      void onAborting(UniqueId ec_id, ReturnCode_t ret)
      {
        onGeneric("ERROR:", ec_id, ret);
      }
      void onFinalize(UniqueId ec_id, ReturnCode_t ret)
      {
        onGeneric("FINALIZE:", ec_id, ret);
      }

      PostComponentActionListener* activatedListener;
      PostComponentActionListener* deactivatedListener;
      PostComponentActionListener* resetListener;
      PostComponentActionListener* abortingListener;
      PostComponentActionListener* finalizeListener;
    private:
      ComponentObserverConsumer& m_coc;
    };

    class PortAction
    {
    public:
      PortAction(ComponentObserverConsumer& coc)
        : portAddListener(NULL), portRemoveListener(NULL),
          portConnectListener(NULL), portDisconnectListener(NULL),
          m_coc(coc) {}
      void onGeneric(const char* _msg, const char* portname)
      {
        std::string msg(_msg);
        msg += portname;
        m_coc.updateStatus(OpenRTM::PORT_PROFILE, msg.c_str());
      }
      void onAddPort(const ::RTC::PortProfile& pprof)
      {
        onGeneric("ADD:", static_cast<const char*>(pprof.name));
      }
      void onRemovePort(const ::RTC::PortProfile& pprof)
      {
        onGeneric("REMOVE:", static_cast<const char*>(pprof.name));
      }
      void onConnect(const char* portname,
                     ::RTC::ConnectorProfile& pprof, ReturnCode_t ret)
      {
        if (ret == RTC::RTC_OK)
          {
            onGeneric("CONNECT:", portname);
          }
      }
      void onDisconnect(const char* portname,
                        ::RTC::ConnectorProfile& pprof, ReturnCode_t ret)
      {
        if (ret == RTC::RTC_OK)
          {
            onGeneric("DISCONNECT:", portname);
          }
      }

      PortActionListener* portAddListener;
      PortActionListener* portRemoveListener;
      PortConnectRetListener* portConnectListener;
      PortConnectRetListener* portDisconnectListener;

    private:
      ComponentObserverConsumer& m_coc;
    };

    class ECAction
    {
    public:
      ECAction(ComponentObserverConsumer& coc)
        : ecAttached(NULL), ecDetached(NULL), ecRatechanged(NULL),
          ecStartup(NULL), ecShutdown(NULL),
          m_coc(coc) {}
      void onGeneric(const char* _msg, UniqueId ec_id)
      {
        std::string msg(_msg + coil::otos(ec_id));
        m_coc.updateStatus(OpenRTM::EC_STATUS, msg.c_str());
      }
      void onAttached(UniqueId ec_id)
      {
        onGeneric("ATTACHED:", ec_id);
      }
      void onDetached(UniqueId ec_id)
      {
        onGeneric("DETACHED:", ec_id);
      }
      void onRateChanged(UniqueId ec_id, ReturnCode_t ret)
      {
        if (ret == RTC::RTC_OK)
          {
            onGeneric("RATE_CHANGED:", ec_id);
          }
      }
      void onStartup(UniqueId ec_id, ReturnCode_t ret)
      {
        if (ret == RTC::RTC_OK)
          {
            onGeneric("STARTUP:", ec_id);
          }
      }
      void onShutdown(UniqueId ec_id, ReturnCode_t ret)
      {
        if (ret == RTC::RTC_OK)
          {
            onGeneric("SHUTDOWN:", ec_id);
          }
      }
      ExecutionContextActionListener* ecAttached;
      ExecutionContextActionListener* ecDetached;
      PostComponentActionListener* ecRatechanged;
      PostComponentActionListener* ecStartup;
      PostComponentActionListener* ecShutdown;
    private:
      ComponentObserverConsumer& m_coc;
    };

    class ConfigAction
    {
    public:
      ConfigAction(ComponentObserverConsumer& coc)
        : updateConfigParamListener(NULL), setConfigSetListener(NULL),
          addConfigSetListener(NULL), updateConfigSetListener(NULL),
          removeConfigSetListener(NULL), activateConfigSetListener(NULL),
          m_coc(coc) {}
      void updateConfigParam(const char* configsetname,
                             const char* configparamname)
      {
        std::string msg("UPDATE_CONFIG_PARAM: ");
        msg += configsetname;
        msg += ".";
        msg += configparamname;
        m_coc.updateStatus(OpenRTM::CONFIGURATION, msg.c_str());
      }
      void setConfigSet(const coil::Properties& config_set)
      {
        std::string msg("SET_CONFIG_SET: ");
        msg += config_set.getName();
        m_coc.updateStatus(OpenRTM::CONFIGURATION, msg.c_str());
      }
      void addConfigSet(const coil::Properties& config_set)
      {
        std::string msg("ADD_CONFIG_SET: ");
        msg += config_set.getName();
        m_coc.updateStatus(OpenRTM::CONFIGURATION, msg.c_str());
      }
      void updateConfigSet(const char* config_set_name)
      {
        std::string msg("UPDATE_CONFIG_SET: ");
        msg += config_set_name;
        m_coc.updateStatus(OpenRTM::CONFIGURATION, msg.c_str());
      }
      void removeConfigSet(const char* config_set_name)
      {
        std::string msg("REMOVE_CONFIG_SET: ");
        msg += config_set_name;
        m_coc.updateStatus(OpenRTM::CONFIGURATION, msg.c_str());
      }
      void activateConfigSet(const char* config_set_name)
      {
        std::string msg("ACTIVATE_CONFIG_SET: ");
        msg += config_set_name;
        m_coc.updateStatus(OpenRTM::CONFIGURATION, msg.c_str());
      }
      // Listener object's pointer holder
      ConfigurationParamListener*   updateConfigParamListener;
      ConfigurationSetListener*     setConfigSetListener;
      ConfigurationSetListener*     addConfigSetListener;
      ConfigurationSetNameListener* updateConfigSetListener;
      ConfigurationSetNameListener* removeConfigSetListener;
      ConfigurationSetNameListener* activateConfigSetListener;

    private:
      ComponentObserverConsumer& m_coc;
    };



    RTC::RTObject_impl* m_rtobj;
    SDOPackage::ServiceProfile m_profile;
    CorbaConsumer<OpenRTM::ComponentObserver> m_observer;

    bool m_observed[OpenRTM::STATUS_KIND_NUM];

    CompStatMsg m_compstat;
    PortAction m_portaction;
    ECAction m_ecaction;
    ConfigAction m_configMsg;

    coil::TimeValue m_interval;
    bool m_heartbeat;
    ListenerId m_hblistenerid;

    // ¤³¤Î¥¿¥¤¥Þ¡¼¤Ï¤¤¤º¤ì¥°¥í¡¼¥Ð¥ë¤Ê¥¿¥¤¥Þ¤Ë¤ª¤­¤«¤¨¤ë
    coil::Timer m_timer;

  };

}; // namespace RTC

extern "C"
{
  DLL_EXPORT void ComponentObserverConsumerInit();
};

#endif // RTC_COMPONENTOBSERVERCONSUMER_H