ManagerActionListener.h

Go to the documentation of this file.

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

#include <vector>
#include <utility>
#include <coil/Mutex.h>
#include <coil/Guard.h>
#include <coil/Properties.h>
#include <coil/stringutil.h>
#include <rtm/ListenerHolder.h>

// forward decl
namespace RTC
{
  class RTObject_impl;
};

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:
    virtual ~ManagerActionListenerHolder();

    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:
    virtual ~ModuleActionListenerHolder();
    
    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(void) = 0;
    
    virtual void postInitialize(void) = 0;
  };
  
  
  class RtcLifecycleActionListenerHolder
    : public RTM::util::ListenerHolder<RtcLifecycleActionListener>
  {
  public:
    virtual ~RtcLifecycleActionListenerHolder();
    
    
    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(void);
    
    virtual void postInitialize(void);
  };
  
  
  //============================================================
  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:
    virtual ~NamingActionListenerHolder();
    
    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:
    virtual ~LocalServiceActionListenerHolder();
    
    // 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:
    ManagerActionListenerHolder manager_;
    ModuleActionListenerHolder module_;
    RtcLifecycleActionListenerHolder rtclifecycle_;
    NamingActionListenerHolder naming_;
    LocalServiceActionListenerHolder localservice_;
  };
}; // namespace RTM

#endif // RTC_MANAGERACTIONLISTENER_H