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 <coil/Task.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>
#include <rtm/FsmActionListener.h>
 
#include <string>
#include <vector>
 
#define ECOTHER_OFFSET 1000
 
namespace SDOPackage
{
  class Configuration_impl;
} // namespace SDOPackage
 
namespace RTC
{
  class Manager;
  class ExecutionContextBase;
  using UniqueId = ExecutionContextHandle_t;
 
  class RTObject_impl
    : public virtual POA_OpenRTM::DataFlowComponent,
      public virtual PortableServer::RefCountServantBase
  {
  public:
    explicit RTObject_impl(Manager* manager);
 
    RTObject_impl(CORBA::ORB_ptr orb, PortableServer::POA_ptr poa);
 
    ~RTObject_impl() override;
 
  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 ec_id);
 
    // The shutdown action when ExecutionContext stop
    // former rtc_stopping_entry()
    virtual ReturnCode_t onShutdown(RTC::UniqueId ec_id);
 
    // The activated action (Active state entry action)
    // former rtc_active_entry()
    virtual ReturnCode_t onActivated(RTC::UniqueId ec_id);
 
    // The deactivated action (Active state exit action)
    // former rtc_active_exit()
    virtual ReturnCode_t onDeactivated(RTC::UniqueId ec_id);
 
    // The execution action that is invoked periodically
    // former rtc_active_do()
    virtual ReturnCode_t onExecute(RTC::UniqueId ec_id);
 
    // The aborting action when main logic error occurred.
    // former rtc_aborting_entry()
    virtual ReturnCode_t onAborting(RTC::UniqueId ec_id);
 
    // The error action in ERROR state
    // former rtc_error_do()
    virtual ReturnCode_t onError(RTC::UniqueId ec_id);
 
    // The reset action that is invoked resetting
    // This is same but different the former rtc_init_entry()
    virtual ReturnCode_t onReset(RTC::UniqueId ec_id);
 
    // 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 ec_id);
 
    // 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 ec_id);
 
  public:
    //============================================================
    // RTC::LightweightRTObject
    //============================================================
    ReturnCode_t initialize() override;
 
    ReturnCode_t finalize() override;
 
    ReturnCode_t exit() override;
 
    CORBA::Boolean is_alive(ExecutionContext_ptr exec_context) override;
 
    ExecutionContext_ptr get_context(UniqueId ec_id) override;
 
    ExecutionContextList* get_owned_contexts() override;
 
    ExecutionContextList* get_participating_contexts() override;
 
    ExecutionContextHandle_t
    get_context_handle(ExecutionContext_ptr cxt) override;
 
    UniqueId attach_context(ExecutionContext_ptr exec_context) override;
 
    UniqueId bindContext(ExecutionContext_ptr exec_context);
 
    ReturnCode_t detach_context(UniqueId ec_id) override;
 
    //============================================================
    // RTC::RTObject
    //============================================================
    ComponentProfile* get_component_profile() override;
 
    PortServiceList* get_ports() override;
 
    //============================================================
    // RTC::ComponentAction
    //============================================================
    ReturnCode_t on_initialize() override;
 
    ReturnCode_t on_finalize() override;
 
    ReturnCode_t on_startup(UniqueId ec_id) override;
 
    ReturnCode_t on_shutdown(UniqueId ec_id) override;
 
    ReturnCode_t on_activated(UniqueId ec_id) override;
 
    ReturnCode_t on_deactivated(UniqueId ec_id) override;
 
    ReturnCode_t on_aborting(UniqueId ec_id) override;
 
    ReturnCode_t on_error(UniqueId ec_id) override;
 
    ReturnCode_t on_reset(UniqueId ec_id) override;
 
    //============================================================
    // RTC::DataFlowComponentAction
    //============================================================
    ReturnCode_t on_execute(UniqueId ec_id) override;
 
    ReturnCode_t on_state_update(UniqueId ec_id) override;
 
    ReturnCode_t on_rate_changed(UniqueId ec_id) override;
 
    //============================================================
    // SDOPackage::SdoSystemElement
    //============================================================
    SDOPackage::OrganizationList* get_owned_organizations() override;
 
    //============================================================
    // SDOPackage::SDO
    //============================================================
    char* get_sdo_id() override;
 
    char* get_sdo_type() override;
 
    SDOPackage::DeviceProfile* get_device_profile() override;
 
    SDOPackage::ServiceProfileList* get_service_profiles() override;
 
    SDOPackage::ServiceProfile* get_service_profile(const char* id) override;
 
    SDOPackage::SDOService_ptr get_sdo_service(const char* id) override;
 
    SDOPackage::Configuration_ptr get_configuration() override;
 
    SDOPackage::Monitoring_ptr get_monitoring() override;
 
    SDOPackage::OrganizationList* get_organizations() override;
 
    SDOPackage::NVList* get_status_list() override;
 
    CORBA::Any* get_status(const char* name) override;
 
    //============================================================
    // 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(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;
    }
 
    ConfigAdmin& getConfigService() { return m_configsets; }
 
    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);
    const std::vector<InPortBase*>& getInPorts() const { return m_inports; }
    const std::vector<OutPortBase*>& getOutPorts() const { return m_outports; }
    void registerInPort(const char* name, InPortBase& inport);
 
    bool addOutPort(const char* name, OutPortBase& outport);
    void registerOutPort(const char* name, OutPortBase& outport);
 
    bool removeInPort(InPortBase& inport);
 
    bool removeOutPort(OutPortBase& outport);
 
    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);
 
    static 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);
 
    void removeSdoServiceConsumerStartThread(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();
 
    void setINSObjRef(RTC::LightweightRTObject_ptr obj);
 
    using PreCompActionListener = PreComponentActionListener;
    using PreCompActionListenerType = PreComponentActionListenerType;
    void
    addPreComponentActionListener(PreCompActionListenerType listener_type,
                                  PreCompActionListener* 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) override
        {
          (m_obj.*m_memfunc)(ec_id);
        }
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(UniqueId);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addPreComponentActionListener(listener_type, listener, true);
      return listener;
    }
 
    void
    removePreComponentActionListener(
        PreComponentActionListenerType listener_type,
        PreComponentActionListener* listener);
 
    using PostCompActionListener = PostComponentActionListener;
    using PostCompActionListenerType = PostComponentActionListenerType;
    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) override
        {
          (m_obj.*m_memfunc)(ec_id, ret);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(UniqueId, ReturnCode_t);
        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) override
        {
          (m_obj.*m_memfunc)(pprofile);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(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);
 
    using ECActionListenerType = ExecutionContextActionListenerType;
    using ECActionListener = ExecutionContextActionListener;
    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) override
        {
          (m_obj.*m_memfunc)(ec_id);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(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) override
        {
          (m_obj.*m_memfunc)(portname, cprofile);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(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) override
        {
          (m_obj.*m_memfunc)(portname, cprofile, ret);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(const char*, ConnectorProfile&, ReturnCode_t);
        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) override
        {
          (m_obj.*m_memfunc)(config_set_name, config_param_name);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(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)
        {
        }
        void operator()(const coil::Properties& config_set) override
        {
          (m_obj.*m_memfunc)(config_set);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(const coil::Properties&);
        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)
        {
        }
        void operator()(const char* config_set_name) override
        {
          (m_obj.*m_memfunc)(config_set_name);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(const char*);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addConfigurationSetNameListener(type, listener, true);
      return listener;
    }
 
    void
    removeConfigurationSetNameListener(ConfigurationSetNameListenerType type,
                                       ConfigurationSetNameListener* listener);
 
    //============================================================
    // FSM Listener
    void
    addPreFsmActionListener(PreFsmActionListenerType listener_type,
                            PreFsmActionListener* listener,
                            bool autoclean = true);
 
    template <class Listener>
    PreFsmActionListener*
    addPreFsmActionListener(PreFsmActionListenerType listener_type,
                            Listener& obj,
                            void (Listener::*memfunc)(const char* state))
    {
      class Noname
        : public PreFsmActionListener
      {
      public:
        Noname(Listener& obj, void (Listener::*memfunc)(const char*))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        void operator()(const char* state) override
        {
          (m_obj.*m_memfunc)(state);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(const char*);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addPreFsmActionListener(listener_type, listener, true);
      return listener;
    }
 
    void
    removePreFsmActionListener(PreFsmActionListenerType listener_type,
                               PreFsmActionListener* listener);
 
    void
    addPostFsmActionListener(PostFsmActionListenerType listener_type,
                             PostFsmActionListener* listener,
                             bool autoclean = true);
 
    template <class Listener>
    PostFsmActionListener*
    addPostFsmActionListener(PostFsmActionListenerType listener_type,
                             Listener& obj,
                             void (Listener::*memfunc)(const char* state,
                                                       ReturnCode_t ret))
    {
      class Noname
        : public PostFsmActionListener
      {
      public:
        Noname(Listener& obj,
               void (Listener::*memfunc)(const char*, ReturnCode_t))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        void operator()(const char* state, ReturnCode_t ret) override
        {
          (m_obj.*m_memfunc)(state, ret);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(const char*, ReturnCode_t);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addPostFsmActionListener(listener_type, listener, true);
      return listener;
    }
 
    void
    removePostFsmActionListener(PostFsmActionListenerType listener_type,
                                PostFsmActionListener* listener);
 
    void
    addFsmProfileListener(FsmProfileListenerType listener_type,
                          FsmProfileListener* listener,
                          bool autoclean = true);
 
    template <class Listener>
    FsmProfileListener*
    addFsmProfileListener(FsmProfileListenerType listener_type,
                          Listener& obj,
                          void (Listener::*memfunc)(const RTC::PortProfile&))
    {
      class Noname
        : public FsmProfileListener
      {
      public:
        Noname(Listener& obj,
               void (Listener::*memfunc)(const RTC::FsmProfile&))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        void operator()(const RTC::PortProfile& pprofile)
        {
          (m_obj.*m_memfunc)(pprofile);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(const RTC::FsmProfile&);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addFsmProfileListener(listener_type, listener, true);
      return listener;
    }
 
    void
    removeFsmProfileListener(FsmProfileListenerType listener_type,
                             FsmProfileListener* listener);
 
    void
    addFsmStructureListener(FsmStructureListenerType listener_type,
                            FsmStructureListener* listener,
                            bool autoclean = true);
 
    template <class Listener>
    FsmStructureListener*
    addFsmStructureListener(FsmStructureListenerType listener_type,
                            Listener& obj,
                            void (Listener::*memfunc)(const RTC::PortProfile&))
    {
      class Noname
        : public FsmStructureListener
      {
      public:
        Noname(Listener& obj,
               void (Listener::*memfunc)(const RTC::FsmStructure&))
          : m_obj(obj), m_memfunc(memfunc)
        {
        }
        void operator()(const RTC::PortProfile& pprofile)
        {
          (m_obj.*m_memfunc)(pprofile);
        }
 
      private:
        Listener& m_obj;
        using Memfunc = void (Listener::*)(const RTC::FsmStructure&);
        Memfunc m_memfunc;
      };
      Noname* listener(new Noname(obj, memfunc));
      addFsmStructureListener(listener_type, listener, true);
      return listener;
    }
 
    void
    removeFsmStructureListener(FsmStructureListenerType listener_type,
                               FsmStructureListener* listener);
 
    inline void preOnInitialize(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_INITIALIZE, ec_id);
    }
 
    inline void preOnFinalize(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_FINALIZE, ec_id);
    }
 
    inline void preOnStartup(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_STARTUP, ec_id);
    }
 
    inline void preOnShutdown(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_SHUTDOWN, ec_id);
    }
 
    inline void preOnActivated(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_ACTIVATED, ec_id);
    }
 
    inline void preOnDeactivated(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_DEACTIVATED, ec_id);
    }
 
    inline void preOnAborting(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_ABORTING, ec_id);
    }
 
    inline void preOnError(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_ERROR, ec_id);
    }
 
    inline void preOnReset(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_RESET, ec_id);
    }
 
    inline void preOnExecute(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_EXECUTE, ec_id);
    }
 
    inline void preOnStateUpdate(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_STATE_UPDATE, ec_id);
    }
 
    inline void preOnRateChanged(UniqueId ec_id)
    {
      m_actionListeners.notify(PreComponentActionListenerType::PRE_ON_RATE_CHANGED, ec_id);
    }
 
    inline void postOnInitialize(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_INITIALIZE, ec_id, ret);
    }
 
    inline void postOnFinalize(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_FINALIZE, ec_id, ret);
    }
 
    inline void postOnStartup(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_STARTUP, ec_id, ret);
    }
 
    inline void postOnShutdown(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_SHUTDOWN, ec_id, ret);
    }
 
    inline void postOnActivated(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_ACTIVATED, ec_id, ret);
    }
 
    inline void postOnDeactivated(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_DEACTIVATED, ec_id, ret);
    }
 
    inline void postOnAborting(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_ABORTING, ec_id, ret);
    }
 
    inline void postOnError(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_ERROR, ec_id, ret);
    }
 
    inline void postOnReset(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_RESET, ec_id, ret);
    }
 
    inline void postOnExecute(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_EXECUTE, ec_id, ret);
    }
 
    inline void postOnStateUpdate(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_STATE_UPDATE, ec_id, ret);
    }
 
    inline void postOnRateChanged(UniqueId ec_id, ReturnCode_t ret)
    {
      m_actionListeners.notify(PostComponentActionListenerType::POST_ON_RATE_CHANGED, ec_id, ret);
    }
 
    inline void onAddPort(const PortProfile& pprof)
    {
      m_actionListeners.notify(PortActionListenerType::ADD_PORT, pprof);
    }
 
    inline void onRemovePort(const PortProfile& pprof)
    {
      m_actionListeners.notify(PortActionListenerType::REMOVE_PORT, pprof);
    }
 
    inline void onAttachExecutionContext(UniqueId ec_id)
    {
      m_actionListeners.
          notify(ExecutionContextActionListenerType::EC_ATTACHED, ec_id);
    }
 
    inline void onDetachExecutionContext(UniqueId ec_id)
    {
      m_actionListeners.
          notify(ExecutionContextActionListenerType::EC_DETACHED, ec_id);
    }
 
    inline void preOnFsmInit(const char* state)
    {
      m_fsmActionListeners.notify(PreFsmActionListenerType::PRE_ON_INIT, state);
    }
    inline void preOnFsmEntry(const char* state)
    {
      m_fsmActionListeners.notify(PreFsmActionListenerType::PRE_ON_ENTRY, state);
    }
    inline void preOnFsmDo(const char* state)
    {
      m_fsmActionListeners.notify(PreFsmActionListenerType::PRE_ON_DO, state);
    }
    inline void preOnFsmExit(const char* state)
    {
      m_fsmActionListeners.notify(PreFsmActionListenerType::PRE_ON_EXIT, state);
    }
    inline void preOnFsmStateChange(const char* state)
    {
      m_fsmActionListeners.notify(PreFsmActionListenerType::PRE_ON_STATE_CHANGE, state);
    }
    inline void postOnFsmInit(const char* state, ReturnCode_t ret)
    {
      m_fsmActionListeners.notify(PostFsmActionListenerType::POST_ON_INIT, state, ret);
    }
    inline void postOnFsmEntry(const char* state, ReturnCode_t ret)
    {
      m_fsmActionListeners.notify(PostFsmActionListenerType::POST_ON_ENTRY, state, ret);
    }
    inline void postOnFsmDo(const char* state, ReturnCode_t ret)
    {
      m_fsmActionListeners.notify(PostFsmActionListenerType::POST_ON_DO, state, ret);
    }
    inline void postOnFsmExit(const char* state, ReturnCode_t ret)
    {
      m_fsmActionListeners.notify(PostFsmActionListenerType::POST_ON_EXIT, state, ret);
    }
    inline void postOnFsmStateChange(const char* state, ReturnCode_t ret)
    {
      m_fsmActionListeners.notify(PostFsmActionListenerType::POST_ON_STATE_CHANGE, state, ret);
    }
 
  protected:
    void shutdown();
 
    ReturnCode_t initMineEC();
    void startMineEC();
    void finalizeMineEC();
    void finalizeOtherEC();
 
    ReturnCode_t getInheritedECOptions(coil::Properties& default_opts);
 
    ReturnCode_t
    getPrivateContextOptions(std::vector<coil::Properties>& ec_args);
 
    ReturnCode_t
    getGlobalContextOptions(coil::Properties& global_ec_props);
 
    ReturnCode_t
    getContextOptions(std::vector<coil::Properties>& ec_args);
 
    static ReturnCode_t findExistingEC(coil::Properties& ec_arg,
                                       RTC::ExecutionContextBase*& ec);
    ReturnCode_t createContexts(std::vector<coil::Properties>& ec_args);
 
    void initSdoService();
 
  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
    {
      explicit 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;
 
    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;
 
    FsmActionListeners m_fsmActionListeners;
 
    RTC::LightweightRTObject_var m_insref;
 
    class SdoServiceConsumerTerminator
      : public coil::Task
    {
    public:
      SdoServiceConsumerTerminator();
      void setSdoServiceConsumer(SdoServiceAdmin * sdoservice, const char* id);
      int svc() override;
 
    private:
      SdoServiceAdmin *m_sdoservice;
      std::string m_id;
    };
    SdoServiceConsumerTerminator *m_sdoconterm;
 
    //------------------------------------------------------------
    // Functor
    //------------------------------------------------------------
    struct nv_name
    {
      explicit 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
    {
      explicit 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
    {
      explicit ec_find(ExecutionContext_ptr& ec)
        : m_ec(ExecutionContext::_duplicate(ec))
      {
      }
#ifdef ORB_IS_ORBEXPRESS
      bool operator()(ExecutionContextService_var ecs)
      {
        try
          {
            if (!::CORBA::is_nil(ecs.in()))
              {
                ExecutionContext_var ec;
                ec = ExecutionContext::_narrow(ecs.in());
                return m_ec->_is_equivalent(ec);
              }
          }
#else
      bool operator()(ExecutionContextService_ptr ecs)
      {
        try
          {
            if (!::CORBA::is_nil(ecs))
              {
                ExecutionContext_var ec;
                ec = ExecutionContext::_narrow(ecs);
                return m_ec->_is_equivalent(ec);
              }
            }
#endif
        catch (...)
          {
            return false;
          }
        return false;
      }
      ExecutionContext_var m_ec;
    }; // struct ec_find
 
    struct deactivate_comps
    {
      explicit deactivate_comps(LightweightRTObject_ptr comp)
        : m_comp(RTC::LightweightRTObject::_duplicate(comp))
      {
      }
      void operator()(ExecutionContextService_ptr ec)
      {
        if (!::CORBA::is_nil(ec) && !ec->_non_existent())
          {
            RTC::LifeCycleState state = ec->get_component_state(m_comp);
            if (state == RTC::ACTIVE_STATE)
              {
                ec->deactivate_component(
                    RTC::LightweightRTObject::_duplicate(m_comp));
              }
            else if (state == RTC::ERROR_STATE)
              {
                ec->reset_component(
                    RTC::LightweightRTObject::_duplicate(m_comp));
              }
          }
      }
      LightweightRTObject_var m_comp;
    }; // struct deactivate_comps
  };   // class RTObject_impl
} // namespace RTC
 
#endif // RTC_RTOBJECT