RTObject.h

Go to the documentation of this file.

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

// CORBA header include
#include <coil/Properties.h>

#include <rtm/RTC.h>
#include <rtm/idl/RTCSkel.h>
#include <rtm/idl/OpenRTMSkel.h>
#include <rtm/PortBase.h>
#include <rtm/PortAdmin.h>
#include <rtm/InPortBase.h>
#include <rtm/OutPortBase.h>
#include <rtm/CorbaPort.h>
#include <rtm/ConfigAdmin.h>
#include <rtm/SystemLogger.h>
#include <rtm/ComponentActionListener.h>
#include <rtm/SdoServiceAdmin.h>
#include <rtm/PortConnectListener.h>

#define ECOTHER_OFFSET 1000

namespace SDOPackage
{
  class Configuration_impl;
};

#ifdef WIN32
#pragma warning( disable : 4290 )
#endif

namespace RTC
{
  class Manager;
  class ExecutionContextBase;
  typedef ExecutionContextHandle_t UniqueId;

  class RTObject_impl
    : public virtual POA_OpenRTM::DataFlowComponent, 
      public virtual PortableServer::RefCountServantBase
  {
  public:
    RTObject_impl(Manager* manager);
    
    RTObject_impl(CORBA::ORB_ptr orb, PortableServer::POA_ptr poa);
    
    virtual ~RTObject_impl(void);
    
  protected:
    //============================================================
    // Overridden functions
    //============================================================
    // The initialize action (on CREATED->ALIVE transition)
    // formaer rtc_init_entry() 
    virtual ReturnCode_t onInitialize();
    
    // The finalize action (on ALIVE->END transition)
    // formaer rtc_exiting_entry()
    virtual ReturnCode_t onFinalize();
    
    // The startup action when ExecutionContext startup
    // former rtc_starting_entry()
    virtual ReturnCode_t onStartup(RTC::UniqueId exec_handle);
    
    // The shutdown action when ExecutionContext stop
    // former rtc_stopping_entry()
    virtual ReturnCode_t onShutdown(RTC::UniqueId exec_handle);
    
    // The activated action (Active state entry action)
    // former rtc_active_entry()
    virtual ReturnCode_t onActivated(RTC::UniqueId exec_handle);
    
    // The deactivated action (Active state exit action)
    // former rtc_active_exit()
    virtual ReturnCode_t onDeactivated(RTC::UniqueId exec_handle);
    
    // The execution action that is invoked periodically
    // former rtc_active_do()
    virtual ReturnCode_t onExecute(RTC::UniqueId exec_handle);
    
    // The aborting action when main logic error occurred.
    // former rtc_aborting_entry()
    virtual ReturnCode_t onAborting(RTC::UniqueId exec_handle);
    
    // The error action in ERROR state
    // former rtc_error_do()
    virtual ReturnCode_t onError(RTC::UniqueId exec_handle);
    
    // The reset action that is invoked resetting
    // This is same but different the former rtc_init_entry()
    virtual ReturnCode_t onReset(RTC::UniqueId exec_handle);
    
    // The state update action that is invoked after onExecute() action
    // no corresponding operation exists in OpenRTm-aist-0.2.0
    virtual ReturnCode_t onStateUpdate(RTC::UniqueId exec_handle);
    
    // The action that is invoked when execution context's rate is changed
    // no corresponding operation exists in OpenRTm-aist-0.2.0
    virtual ReturnCode_t onRateChanged(RTC::UniqueId exec_handle);
    
  public:
    //============================================================
    // RTC::LightweightRTObject
    //============================================================
    virtual ReturnCode_t initialize()
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t finalize()
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t exit()
      throw (CORBA::SystemException); 
    
    virtual CORBA::Boolean is_alive(ExecutionContext_ptr exec_context)
      throw (CORBA::SystemException);
    
    virtual ExecutionContext_ptr get_context(UniqueId exec_handle)
      throw (CORBA::SystemException);

    virtual ExecutionContextList* get_owned_contexts()
      throw (CORBA::SystemException);

    virtual ExecutionContextList* get_participating_contexts()
      throw (CORBA::SystemException);

    virtual ExecutionContextHandle_t
    get_context_handle(ExecutionContext_ptr cxt)
      throw (CORBA::SystemException);

    UniqueId attach_context(ExecutionContext_ptr exec_context)
      throw (CORBA::SystemException);

    UniqueId bindContext(ExecutionContext_ptr exec_context);
    
    ReturnCode_t detach_context(UniqueId exec_handle)
      throw (CORBA::SystemException);
    
    //============================================================
    // RTC::RTObject
    //============================================================
    virtual ComponentProfile* get_component_profile()
      throw (CORBA::SystemException);
    
    virtual PortServiceList* get_ports()
      throw (CORBA::SystemException);
    
    //    virtual ExecutionContextServiceList* get_execution_context_services()
    //      throw (CORBA::SystemException);
    
    //============================================================
    // RTC::ComponentAction
    //============================================================
    virtual ReturnCode_t on_initialize()
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t on_finalize()
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t on_startup(UniqueId exec_handle)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t on_shutdown(UniqueId exec_handle)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t on_activated(UniqueId exec_handle)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t on_deactivated(UniqueId exec_handle)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t on_aborting(UniqueId exec_handle)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t on_error(UniqueId exec_handle)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t on_reset(UniqueId exec_handle)
      throw (CORBA::SystemException);
    
    //============================================================
    // RTC::DataFlowComponentAction
    //============================================================
    virtual ReturnCode_t on_execute(UniqueId exec_handle)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t on_state_update(UniqueId exec_handle)
      throw (CORBA::SystemException);
    
    virtual ReturnCode_t on_rate_changed(UniqueId exec_handle)
      throw (CORBA::SystemException);
    
    //============================================================
    // SDOPackage::SdoSystemElement
    //============================================================
    virtual SDOPackage::OrganizationList* get_owned_organizations()
      throw (CORBA::SystemException,
             SDOPackage::NotAvailable, SDOPackage::InternalError);
    
    //============================================================
    // SDOPackage::SDO
    //============================================================
    virtual char* get_sdo_id()
      throw (CORBA::SystemException,
             SDOPackage::NotAvailable, SDOPackage::InternalError);
    
    virtual char* get_sdo_type()
      throw (CORBA::SystemException, 
             SDOPackage::NotAvailable, SDOPackage::InternalError);
    
    virtual SDOPackage::DeviceProfile* get_device_profile()
      throw (CORBA::SystemException, 
             SDOPackage::NotAvailable, SDOPackage::InternalError);
    
    virtual SDOPackage::ServiceProfileList* get_service_profiles()
      throw (CORBA::SystemException, 
             SDOPackage::NotAvailable, SDOPackage::InternalError);
    
    virtual SDOPackage::ServiceProfile* get_service_profile(const char* id)
      throw (CORBA::SystemException, 
             SDOPackage::InvalidParameter, SDOPackage::NotAvailable,
             SDOPackage::InternalError);
    
    virtual SDOPackage::SDOService_ptr get_sdo_service(const char* id)
      throw (CORBA::SystemException, 
             SDOPackage::InvalidParameter, SDOPackage::NotAvailable,
             SDOPackage::InternalError);
    
    virtual SDOPackage::Configuration_ptr get_configuration()
      throw (CORBA::SystemException, 
             SDOPackage::InterfaceNotImplemented, SDOPackage::NotAvailable,
             SDOPackage::InternalError);
    
    virtual SDOPackage::Monitoring_ptr get_monitoring()
      throw (CORBA::SystemException, 
             SDOPackage::InterfaceNotImplemented, SDOPackage::NotAvailable,
             SDOPackage::InternalError);
    
    virtual SDOPackage::OrganizationList* get_organizations()
      throw (CORBA::SystemException, 
             SDOPackage::NotAvailable, SDOPackage::InternalError);
    
    virtual SDOPackage::NVList* get_status_list()
      throw (CORBA::SystemException, 
             SDOPackage::NotAvailable, SDOPackage::InternalError);
    
    virtual CORBA::Any* get_status(const char* name)
      throw (CORBA::SystemException, 
             SDOPackage::InvalidParameter, SDOPackage::NotAvailable,
             SDOPackage::InternalError);
    
    //============================================================
    // Local interfaces
    //============================================================
    const char* getInstanceName()
    {
      RTC_TRACE(("getInstanceName()"));
      return m_profile.instance_name;
    }
    
    void setInstanceName(const char* instance_name);
    
    const char* getTypeName()
    {
      RTC_TRACE(("getTypeName()"));
      return m_profile.type_name;
    }
    
    const char* getDescription()
    {
      RTC_TRACE(("getDescription()"));
      return m_profile.description;
    }
    
    const char* getVersion()
    {
      RTC_TRACE(("getVersion()"));
      return m_profile.version;
    }
    
    const char* getVendor()
    {
      RTC_TRACE(("getVendor()"));
      return m_profile.vendor;
    }
    
    const char* getCategory()
    {
      RTC_TRACE(("getCategory()"));
      return m_profile.category;
    }
    
    std::vector<std::string> getNamingNames();
    
    void setObjRef(const RTObject_ptr rtobj);
    
    RTObject_ptr getObjRef() const;
    
    void setProperties(const coil::Properties& prop);
    
    coil::Properties& getProperties();
    
    template <typename VarType>
    bool bindParameter(const char* param_name, VarType& var,
                       const char* def_val,
                       bool (*trans)(VarType&, const char*) = coil::stringTo)
    {
      RTC_TRACE(("bindParameter(%s (default: %s))", param_name, def_val));
      m_configsets.bindParameter(param_name, var, def_val, trans);
      return true;
    }
    
    void updateParameters(const char* config_set);
    
    bool addPort(PortBase& port);
    bool addPort(PortService_ptr port);
    bool addPort(CorbaPort& port);
    void registerPort(PortBase& port);
    void registerPort(PortService_ptr port);
    void registerPort(CorbaPort& port);

    bool addInPort(const char* name, InPortBase& inport);
    void registerInPort(const char* name, InPortBase& inport);
    
    bool addOutPort(const char* name, OutPortBase& outport);
    void registerOutPort(const char* name, OutPortBase& outport);
    
    bool removeInPort(InPortBase& port);

    bool removeOutPort(OutPortBase& port);

    bool removePort(PortBase& port);
    bool removePort(PortService_ptr port);
    bool removePort(CorbaPort& port);
    void deletePort(PortBase& port);
    void deletePort(PortService_ptr port);
    void deletePort(CorbaPort& port);
    
    void deletePortByName(const char* port_name);
    
    ExecutionContext_ptr getExecutionContext(RTC::UniqueId ec_id);

    double getExecutionRate(RTC::UniqueId ec_id);

    ReturnCode_t setExecutionRate(RTC::UniqueId ec_id, double rate);

    bool isOwnExecutionContext(RTC::UniqueId ec_id);

    ReturnCode_t deactivate(RTC::UniqueId ec_id);

    ReturnCode_t activate(RTC::UniqueId ec_id);

    ReturnCode_t reset(RTC::UniqueId ec_id);

    bool addSdoServiceProvider(const SDOPackage::ServiceProfile& prof,
                               SdoServiceProviderBase* provider);

    bool removeSdoServiceProvider(const char* id);

    bool addSdoServiceConsumer(const SDOPackage::ServiceProfile& prof);

    bool removeSdoServiceConsumer(const char* id);

    bool readAll();

    bool writeAll();

    void setReadAll(bool read=true, bool completion=false);

    void setWriteAll(bool write=true, bool completion=false);


    void finalizePorts();


    void finalizeContexts();


    typedef PreComponentActionListener PreCompActionListener;
    typedef PreComponentActionListenerType PreCompActionListenerType;
    void 
    addPreComponentActionListener(PreComponentActionListenerType listener_type,
                                  PreComponentActionListener* listener,
                                  bool autoclean = true);


    template <class Listener>
    PreComponentActionListener*
    addPreComponentActionListener(PreCompActionListenerType listener_type,
                                   Listener& obj,
                                   void (Listener::*memfunc)(UniqueId ec_id))
    {
      class Noname
        : public PreComponentActionListener
      {
      public:
        Noname(Listener& obj, void (Listener::*memfunc)(UniqueId))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        void operator()(UniqueId ec_id)
        {
          (m_obj.*m_memfunc)(ec_id);
        }
      private:
        Listener& m_obj;
        typedef void (Listener::*Memfunc)(UniqueId ec_id);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addPreComponentActionListener(listener_type, listener, true);
      return listener;
    }

    void 
    removePreComponentActionListener(
                                 PreComponentActionListenerType listener_type,
                                 PreComponentActionListener* listener);


    typedef PostComponentActionListener PostCompActionListener;
    typedef PostComponentActionListenerType PostCompActionListenerType;
    void 
    addPostComponentActionListener(
                               PostComponentActionListenerType listener_type,
                               PostComponentActionListener* listener,
                               bool autoclean = true);

    template <class Listener>
    PostComponentActionListener*
    addPostComponentActionListener(PostCompActionListenerType listener_type,
                                   Listener& obj,
                                   void (Listener::*memfunc)(UniqueId ec_id,
                                                             ReturnCode_t ret))
    {
      class Noname
        : public PostComponentActionListener
      {
      public:
        Noname(Listener& obj, void (Listener::*memfunc)(UniqueId, ReturnCode_t))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        void operator()(UniqueId ec_id, ReturnCode_t ret)
        {
          (m_obj.*m_memfunc)(ec_id, ret);
        }
      private:
        Listener& m_obj;
        typedef void (Listener::*Memfunc)(UniqueId ec_id, ReturnCode_t ret);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addPostComponentActionListener(listener_type, listener, true);
      return listener;
    }

    void 
    removePostComponentActionListener(
                                  PostComponentActionListenerType listener_type,
                                  PostComponentActionListener* listener);



    void 
    addPortActionListener(PortActionListenerType listener_type,
                          PortActionListener* listener,
                          bool autoclean = true);
    
    template <class Listener>
    PortActionListener*
    addPortActionListener(PortActionListenerType listener_type,
                          Listener& obj,
                          void (Listener::*memfunc)(const RTC::PortProfile&))
    {
      class Noname
        : public PortActionListener
      {
      public:
        Noname(Listener& obj,
               void (Listener::*memfunc)(const RTC::PortProfile&))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        void operator()(const RTC::PortProfile& pprofile)
        {
          (m_obj.*m_memfunc)(pprofile);
        }
      private:
        Listener& m_obj;
        typedef void (Listener::*Memfunc)(const RTC::PortProfile&);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addPortActionListener(listener_type, listener, true);
      return listener;
    }

    void 
    removePortActionListener(PortActionListenerType listener_type,
                             PortActionListener* listener);



    typedef ExecutionContextActionListenerType ECActionListenerType;
    typedef ExecutionContextActionListener ECActionListener;
    void addExecutionContextActionListener(ECActionListenerType listener_type,
                                           ECActionListener* listener,
                                           bool autoclean = true);

    template <class Listener>
    ECActionListener*
    addExecutionContextActionListener(ECActionListenerType listener_type,
                                      Listener& obj,
                                      void (Listener::*memfunc)(UniqueId))
    {
      class Noname
        : public ECActionListener
      {
      public:
        Noname(Listener& obj, void (Listener::*memfunc)(UniqueId))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        void operator()(UniqueId ec_id)
        {
          (m_obj.*m_memfunc)(ec_id);
        }
      private:
        Listener& m_obj;
        typedef void (Listener::*Memfunc)(UniqueId);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addExecutionContextActionListener(listener_type, listener, true);
      return listener;
    }
    

    void 
    removeExecutionContextActionListener(ECActionListenerType listener_type,
                                         ECActionListener* listener);


    void addPortConnectListener(PortConnectListenerType listener_type,
                                           PortConnectListener* listener,
                                           bool autoclean = true);

    template <class Listener>
    PortConnectListener*
    addPortConnectListener(PortConnectListenerType listener_type,
                           Listener& obj,
                           void (Listener::*memfunc)(const char*,
                                                     ConnectorProfile&))
    {
      class Noname
        : public PortConnectListener
      {
      public:
        Noname(Listener& obj,
               void (Listener::*memfunc)(const char*, ConnectorProfile&))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        void operator()(const char* portname, ConnectorProfile& cprofile)
        {
          (m_obj.*m_memfunc)(portname, cprofile);
        }
      private:
        Listener& m_obj;
        typedef void (Listener::*Memfunc)(const char*, ConnectorProfile&);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addPortConnectListener(listener_type, listener, true);
      return listener;
    }
    

    void 
    removePortConnectListener(PortConnectListenerType listener_type,
                              PortConnectListener* listener);

    void addPortConnectRetListener(PortConnectRetListenerType listener_type,
                                           PortConnectRetListener* listener,
                                           bool autoclean = true);

    template <class Listener>
    PortConnectRetListener*
    addPortConnectRetListener(PortConnectRetListenerType listener_type,
                              Listener& obj,
                              void (Listener::*memfunc)(const char*,
                                                        ConnectorProfile&,
                                                        ReturnCode_t))
    {
      class Noname
        : public PortConnectRetListener
      {
      public:
        Noname(Listener& obj,
               void (Listener::*memfunc)(const char*,
                                         ConnectorProfile&,
                                         ReturnCode_t))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        void operator()(const char* portname,
                        ConnectorProfile& cprofile,
                        ReturnCode_t ret)
        {
          (m_obj.*m_memfunc)(portname, cprofile, ret);
        }
      private:
        Listener& m_obj;
        typedef void (Listener::*Memfunc)(const char* portname,
                                          ConnectorProfile& cprofile,
                                          ReturnCode_t ret);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addPortConnectRetListener(listener_type, listener, true);
      return listener;
    }
    

    void 
    removePortConnectRetListener(PortConnectRetListenerType listener_type,
                                 PortConnectRetListener* listener);


    void addConfigurationParamListener(ConfigurationParamListenerType type,
                                       ConfigurationParamListener* listener,
                                       bool autoclean = true);

    template <class Listener>
    ConfigurationParamListener*
    addConfigurationParamListener(ConfigurationParamListenerType listener_type,
                                  Listener& obj,
                                  void (Listener::*memfunc)(const char*,
                                                            const char*))
    {
      class Noname
        : public ConfigurationParamListener
      {
      public:
        Noname(Listener& obj,
               void (Listener::*memfunc)(const char*, const char*))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        void operator()(const char* config_set_name,
                        const char* config_param_name)
        {
          (m_obj.*m_memfunc)(config_set_name, config_param_name);
        }
      private:
        Listener& m_obj;
        typedef void (Listener::*Memfunc)(const char*, const char*);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addConfigurationParamListener(listener_type, listener, true);
      return listener;
    }

    void removeConfigurationParamListener(ConfigurationParamListenerType type,
                                          ConfigurationParamListener* listener);
    
    void addConfigurationSetListener(ConfigurationSetListenerType type,
                                     ConfigurationSetListener* listener,
                                     bool autoclean = true);

    template <class Listener>
    ConfigurationSetListener*
    addConfigurationSetListener(ConfigurationSetListenerType listener_type,
                                Listener& obj,
                                void (Listener::*memfunc)
                                (const coil::Properties& config_set))
    {
      class Noname
        : public ConfigurationSetListener
      {
      public:
        Noname(Listener& obj,
               void (Listener::*memfunc)(const coil::Properties& config_set))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        virtual void operator()(const coil::Properties& config_set)
        {
          (m_obj.*m_memfunc)(config_set);
        }
      private:
        Listener& m_obj;
        typedef void (Listener::*Memfunc)(const coil::Properties& config_set);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addConfigurationSetListener(listener_type, listener, true);
      return listener;
    }

    void removeConfigurationSetListener(ConfigurationSetListenerType type,
                                        ConfigurationSetListener* listener);
    
    void 
    addConfigurationSetNameListener(ConfigurationSetNameListenerType type,
                                    ConfigurationSetNameListener* listener,
                                    bool autoclean = true);

    template <class Listener>
    ConfigurationSetNameListener*
    addConfigurationSetNameListener(ConfigurationSetNameListenerType type,
                                    Listener& obj,
                                    void (Listener::*memfunc)(const char*))
    {
      class Noname
        : public ConfigurationSetNameListener
      {
      public:
        Noname(Listener& obj, void (Listener::*memfunc)(const char*))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        virtual void operator()(const char* config_set_name)
        {
          (m_obj.*m_memfunc)(config_set_name);
        }
      private:
        Listener& m_obj;
        typedef void (Listener::*Memfunc)(const char*);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addConfigurationSetNameListener(type, listener, true);
      return listener;
    }

    void
    removeConfigurationSetNameListener(ConfigurationSetNameListenerType type,
                                       ConfigurationSetNameListener* listener);
    
  protected:
    void shutdown();

    inline void preOnInitialize(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_INITIALIZE].notify(ec_id);
    }

    inline void preOnFinalize(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_FINALIZE].notify(ec_id);
    }

    inline void preOnStartup(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_STARTUP].notify(ec_id);
    }

    inline void preOnShutdown(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_SHUTDOWN].notify(ec_id);
    }

    inline void preOnActivated(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_ACTIVATED].notify(ec_id);
    }

    inline void preOnDeactivated(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_DEACTIVATED].notify(ec_id);
    }

    inline void preOnAborting(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_ABORTING].notify(ec_id);
    }

    inline void preOnError(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_ERROR].notify(ec_id);
    }

    inline void preOnReset(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_RESET].notify(ec_id);
    }

    inline void preOnExecute(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_EXECUTE].notify(ec_id);
    }

    inline void preOnStateUpdate(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_STATE_UPDATE].notify(ec_id);
    }

    inline void preOnRateChanged(UniqueId ec_id)
    {
      m_actionListeners.preaction_[PRE_ON_RATE_CHANGED].notify(ec_id);
    }

    inline void postOnInitialize(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_INITIALIZE].notify(ec_id, ret);
    }

    inline void postOnFinalize(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_FINALIZE].notify(ec_id, ret);
    }

    inline void postOnStartup(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_STARTUP].notify(ec_id, ret);
    }

    inline void postOnShutdown(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_SHUTDOWN].notify(ec_id, ret);
    }

    inline void postOnActivated(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_ACTIVATED].notify(ec_id, ret);
    }

    inline void postOnDeactivated(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_DEACTIVATED].notify(ec_id, ret);
    }

    inline void postOnAborting(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_ABORTING].notify(ec_id, ret);
    }

    inline void postOnError(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_ERROR].notify(ec_id, ret);
    }

    inline void postOnReset(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_RESET].notify(ec_id, ret);
    }

    inline void postOnExecute(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_EXECUTE].notify(ec_id, ret);
    }

    inline void postOnStateUpdate(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_STATE_UPDATE].notify(ec_id, ret);
    }

    inline void postOnRateChanged(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.postaction_[POST_ON_RATE_CHANGED].notify(ec_id, ret);
    }

    inline void onAddPort(const PortProfile& pprof)
    {
      m_actionListeners.portaction_[ADD_PORT].notify(pprof);
    }
    
    inline void onRemovePort(const PortProfile& pprof)
    {
      m_actionListeners.portaction_[REMOVE_PORT].notify(pprof);
    }
    
    inline void onAttachExecutionContext(UniqueId ec_id)
    {
      m_actionListeners.ecaction_[EC_ATTACHED].notify(ec_id);
    }
    
    inline void onDetachExecutionContext(UniqueId ec_id)
    {
      m_actionListeners.ecaction_[EC_DETACHED].notify(ec_id);
    }
    
  protected:
    mutable Logger rtclog;
    Manager* m_pManager;
    
    CORBA::ORB_var m_pORB;
    
    PortableServer::POA_var m_pPOA;
    
    //============================================================
    // SDO ´Ø·¸¤ÎÊÑ¿ô
    //============================================================
    SDOPackage::OrganizationList m_sdoOwnedOrganizations;
    
    struct svc_name
    {
      svc_name (const char* id) : m_id(id) {};
      bool operator()(const SDOPackage::ServiceProfile& prof)
      {
        return m_id == std::string(prof.id);
      }
      std::string m_id;
    };  // struct svc_name
    
    SDOPackage::Configuration_impl* m_pSdoConfigImpl;
    
    SDOPackage::Configuration_var  m_pSdoConfig;
    
    SDOPackage::OrganizationList m_sdoOrganizations;
    
    SDOPackage::NVList m_sdoStatus;
    
    //============================================================
    // RTC ´Ø·¸¤ÎÊÑ¿ô
    //============================================================
    ComponentProfile m_profile;
    
    RTObject_var m_objref;
    
    PortAdmin m_portAdmin;

    std::vector<InPortBase*> m_inports;

    std::vector<OutPortBase*> m_outports;
    
    ExecutionContextServiceList m_ecMine;
    
    std::vector<ExecutionContextBase*> m_eclist;
    
    ExecutionContextServiceList m_ecOther;
    
    bool m_created;
    
    bool m_exiting;
    
    //    bool m_alive;
    
    coil::Properties m_properties;
    
    ConfigAdmin m_configsets;
    
    SdoServiceAdmin m_sdoservice;

    bool m_readAll;

    bool m_writeAll;

    bool m_readAllCompletion;

    bool m_writeAllCompletion;

    ComponentActionListeners m_actionListeners;

    PortConnectListeners m_portconnListeners;

    //------------------------------------------------------------
    // Functor
    //------------------------------------------------------------
    struct nv_name
    {
      nv_name(const char* name) : m_name(name) {};
      bool operator()(const SDOPackage::NameValue& nv)
      {
        return m_name == std::string(nv.name);
      }
      std::string m_name;
    };  // struct nv_name
    
    struct ec_copy
    {
      ec_copy(ExecutionContextList& eclist)
        : m_eclist(eclist)
      {
      }
      void operator()(ExecutionContextService_ptr ecs)
      {
        if (!::CORBA::is_nil(ecs))
          {
            CORBA_SeqUtil::push_back(m_eclist,
                                     ExecutionContext::_duplicate(ecs));
          }
      }
      ExecutionContextList& m_eclist;
    };  // struct ec_copy
    struct ec_find
    {
      ec_find(ExecutionContext_ptr& ec)
        : m_ec(ExecutionContext::_duplicate(ec))
      {
      }
      bool operator()(ExecutionContextService_ptr ecs)
      {
        try
          {
            if (!::CORBA::is_nil(ecs))
              {
                ExecutionContext_var ec;
                ec = ExecutionContext::_narrow(ecs);
                return m_ec->_is_equivalent(ec);
              }
          }
        catch (...)
          {
            return false;
          }
        return false;
      }
      ExecutionContext_var m_ec;

    };  // struct ec_find
    //    ExecutionContextAdminList m_execContextList;
    
    struct deactivate_comps
    {
      deactivate_comps(LightweightRTObject_ptr comp)
        : m_comp(RTC::LightweightRTObject::_duplicate(comp))
      {
      }
      void operator()(ExecutionContextService_ptr ec)
      {
        if (!::CORBA::is_nil(ec) && !ec->_non_existent())
          {
            
            ec->deactivate_component(RTC::LightweightRTObject::_duplicate(m_comp));
            ec->stop();
          }
      }
      LightweightRTObject_var m_comp;
    };  // struct deactivate_comps
  };  // class RTObject_impl
};  // namespace RTC

#ifdef WIN32
#pragma warning( default : 4290 )
#endif

#endif // RTC_RTOBJECT