ManagerActionListener.h

[詳解]

// -*- C++ -*-
#ifndef RTM_MANAGERACTIONLISTENER_H
#define RTM_MANAGERACTIONLISTENER_H
 
#include <mutex>
#include <coil/Properties.h>
#include <coil/stringutil.h>
#include <rtm/ListenerHolder.h>
 
#include <string>
#include <vector>
#include <utility>
 
// forward decl
namespace RTC
{
  class RTObject_impl;
} // namespace RTC
 
namespace RTM
{
  // forward decl
  class LocalServiceBase;
 
  //============================================================
  class ManagerActionListener
  {
  public:
    virtual ~ManagerActionListener();
 
    virtual void preShutdown() = 0;
 
    virtual void postShutdown() = 0;
 
    virtual void preReinit() = 0;
 
    virtual void postReinit() = 0;
  };
 
 
  class ManagerActionListenerHolder
    : public ::RTM::util::ListenerHolder<ManagerActionListener>
  {
  public:
    ~ManagerActionListenerHolder() override;
 
    virtual void preShutdown();
 
    virtual void postShutdown();
 
    virtual void preReinit();
 
    virtual void postReinit();
  };
 
 
  //============================================================
  class ModuleActionListener
  {
  public:
    virtual ~ModuleActionListener();
 
    virtual void preLoad(std::string& modname,
                         std::string& funcname) = 0;
 
    virtual void postLoad(std::string& modname,
                          std::string& funcname) = 0;
 
    virtual void preUnload(std::string& modname) = 0;
 
    virtual void postUnload(std::string& modname) = 0;
  };
 
 
  class ModuleActionListenerHolder
    : public ::RTM::util::ListenerHolder<ModuleActionListener>
  {
  public:
    ~ModuleActionListenerHolder() override;
 
    virtual void preLoad(std::string& modname,
                         std::string& funcname);
 
    virtual void postLoad(std::string& modname,
                          std::string& funcname);
 
    virtual void preUnload(std::string& modname);
 
    virtual void postUnload(std::string& modname);
  };
 
 
 
  //============================================================
  class RtcLifecycleActionListener
  {
  public:
    virtual ~RtcLifecycleActionListener();
 
    virtual void preCreate(std::string& args) = 0;
 
    virtual void postCreate(RTC::RTObject_impl*) = 0;
 
    virtual void preConfigure(coil::Properties& prop) = 0;
 
    virtual void postConfigure(coil::Properties& prop) = 0;
 
    virtual void preInitialize() = 0;
 
    virtual void postInitialize() = 0;
  };
 
 
  class RtcLifecycleActionListenerHolder
    : public RTM::util::ListenerHolder<RtcLifecycleActionListener>
  {
  public:
    ~RtcLifecycleActionListenerHolder() override;
 
 
    virtual void preCreate(std::string& args);
 
    virtual void postCreate(RTC::RTObject_impl* rtobj);
 
    virtual void preConfigure(coil::Properties& prop);
 
    virtual void postConfigure(coil::Properties& prop);
 
    virtual void preInitialize();
 
    virtual void postInitialize();
  };
 
 
  //============================================================
  class NamingActionListener
  {
  public:
    virtual ~NamingActionListener();
 
    virtual void preBind(RTC::RTObject_impl* rtobj,
                         coil::vstring& name) = 0;
    virtual void postBind(RTC::RTObject_impl* rtobj,
                          coil::vstring& name) = 0;
 
    virtual void preUnbind(RTC::RTObject_impl* rtobj,
                           coil::vstring& name) = 0;
 
    virtual void postUnbind(RTC::RTObject_impl* rtobj,
                            coil::vstring& name) = 0;
  };
 
 
  class NamingActionListenerHolder
    : public RTM::util::ListenerHolder<NamingActionListener>
  {
  public:
    ~NamingActionListenerHolder() override;
 
    virtual void preBind(RTC::RTObject_impl* rtobj,
                         coil::vstring& name);
    virtual void postBind(RTC::RTObject_impl* rtobj,
                          coil::vstring& name);
 
    virtual void preUnbind(RTC::RTObject_impl* rtobj,
                           coil::vstring& name);
 
    virtual void postUnbind(RTC::RTObject_impl* rtobj,
                            coil::vstring& name);
  };
 
 
  //============================================================
  class LocalServiceActionListener
  {
  public:
    virtual ~LocalServiceActionListener();
 
    virtual void preServiceRegister(std::string service_name) = 0;
 
    virtual void postServiceRegister(std::string service_name,
                                     RTM::LocalServiceBase* service) = 0;
 
    virtual void preServiceInit(coil::Properties& prop,
                                RTM::LocalServiceBase* service) = 0;
 
    virtual void postServiceInit(coil::Properties& prop,
                                 RTM::LocalServiceBase* service) = 0;
 
    virtual void preServiceReinit(coil::Properties& prop,
                                  RTM::LocalServiceBase* service) = 0;
 
    virtual void postServiceReinit(coil::Properties& prop,
                                   RTM::LocalServiceBase* service) = 0;
 
    virtual void postServiceFinalize(std::string service_name,
                                     RTM::LocalServiceBase* service) = 0;
 
    virtual void preServiceFinalize(std::string service_name,
                                    RTM::LocalServiceBase* service) = 0;
  };
 
 
  class LocalServiceActionListenerHolder
    : public RTM::util::ListenerHolder<LocalServiceActionListener>
  {
  public:
    ~LocalServiceActionListenerHolder() override;
 
    // registration instance of service to svc admin
    virtual void preServiceRegister(std::string service_name);
 
    virtual void postServiceRegister(std::string service_name,
                                     RTM::LocalServiceBase* service);
 
    virtual void preServiceInit(coil::Properties& prop,
                                RTM::LocalServiceBase* service);
    virtual void postServiceInit(coil::Properties& prop,
                                 RTM::LocalServiceBase* service);
 
    virtual void preServiceReinit(coil::Properties& prop,
                                  RTM::LocalServiceBase* service);
    virtual void postServiceReinit(coil::Properties& prop,
                                   RTM::LocalServiceBase* service);
 
    virtual void postServiceFinalize(std::string service_name,
                                     RTM::LocalServiceBase* service);
    virtual void preServiceFinalize(std::string service_name,
                                    RTM::LocalServiceBase* service);
  };
 
 
 
  class ManagerActionListeners
  {
  public:
    ~ManagerActionListeners();
    ManagerActionListenerHolder manager_;
    ModuleActionListenerHolder module_;
    RtcLifecycleActionListenerHolder rtclifecycle_;
    NamingActionListenerHolder naming_;
    LocalServiceActionListenerHolder localservice_;
  };
} // namespace RTM
 
#endif  // RTC_MANAGERACTIONLISTENER_H