00001
00018 #ifndef RTC_RTOBJECT_H
00019 #define RTC_RTOBJECT_H
00020
00021
00022 #include <coil/Properties.h>
00023
00024 #include <rtm/RTC.h>
00025 #include <rtm/idl/RTCSkel.h>
00026 #include <rtm/idl/OpenRTMSkel.h>
00027 #include <rtm/PortBase.h>
00028 #include <rtm/PortAdmin.h>
00029 #include <rtm/InPortBase.h>
00030 #include <rtm/OutPortBase.h>
00031 #include <rtm/CorbaPort.h>
00032 #include <rtm/ConfigAdmin.h>
00033 #include <rtm/SystemLogger.h>
00034 #include <rtm/ComponentActionListener.h>
00035 #include <rtm/SdoServiceAdmin.h>
00036 #include <rtm/PortConnectListener.h>
00037
00038 #define ECOTHER_OFFSET 1000
00039
00040 namespace SDOPackage
00041 {
00042 class Configuration_impl;
00043 };
00044
00045 #ifdef WIN32
00046 #pragma warning( disable : 4290 )
00047 #endif
00048
00049 namespace RTC
00050 {
00051 class Manager;
00052 class ExecutionContextBase;
00053 typedef ExecutionContextHandle_t UniqueId;
00054
00089 class RTObject_impl
00090 : public virtual POA_OpenRTM::DataFlowComponent,
00091 public virtual PortableServer::RefCountServantBase
00092 {
00093 public:
00112 RTObject_impl(Manager* manager);
00113
00134 RTObject_impl(CORBA::ORB_ptr orb, PortableServer::POA_ptr poa);
00135
00147 virtual ~RTObject_impl(void);
00148
00149 protected:
00150
00151
00152
00180
00181
00182 virtual ReturnCode_t onInitialize();
00183
00211
00212
00213 virtual ReturnCode_t onFinalize();
00214
00246
00247
00248 virtual ReturnCode_t onStartup(RTC::UniqueId exec_handle);
00249
00281
00282
00283 virtual ReturnCode_t onShutdown(RTC::UniqueId exec_handle);
00284
00316
00317
00318 virtual ReturnCode_t onActivated(RTC::UniqueId exec_handle);
00319
00351
00352
00353 virtual ReturnCode_t onDeactivated(RTC::UniqueId exec_handle);
00354
00391
00392
00393 virtual ReturnCode_t onExecute(RTC::UniqueId exec_handle);
00394
00426
00427
00428 virtual ReturnCode_t onAborting(RTC::UniqueId exec_handle);
00429
00460
00461
00462 virtual ReturnCode_t onError(RTC::UniqueId exec_handle);
00463
00494
00495
00496 virtual ReturnCode_t onReset(RTC::UniqueId exec_handle);
00497
00534
00535
00536 virtual ReturnCode_t onStateUpdate(RTC::UniqueId exec_handle);
00537
00573
00574
00575 virtual ReturnCode_t onRateChanged(RTC::UniqueId exec_handle);
00576
00577 public:
00578
00579
00580
00616 virtual ReturnCode_t initialize()
00617 throw (CORBA::SystemException);
00618
00664 virtual ReturnCode_t finalize()
00665 throw (CORBA::SystemException);
00666
00710 virtual ReturnCode_t exit()
00711 throw (CORBA::SystemException);
00712
00746 virtual CORBA::Boolean is_alive(ExecutionContext_ptr exec_context)
00747 throw (CORBA::SystemException);
00748
00776 virtual ExecutionContext_ptr get_context(UniqueId exec_handle)
00777 throw (CORBA::SystemException);
00778
00797 virtual ExecutionContextList* get_owned_contexts()
00798 throw (CORBA::SystemException);
00799
00818 virtual ExecutionContextList* get_participating_contexts()
00819 throw (CORBA::SystemException);
00820
00835 virtual ExecutionContextHandle_t
00836 get_context_handle(ExecutionContext_ptr cxt)
00837 throw (CORBA::SystemException);
00838
00869 UniqueId attach_context(ExecutionContext_ptr exec_context)
00870 throw (CORBA::SystemException);
00871
00872 UniqueId bindContext(ExecutionContext_ptr exec_context);
00873
00915 ReturnCode_t detach_context(UniqueId exec_handle)
00916 throw (CORBA::SystemException);
00917
00918
00919
00920
00940 virtual ComponentProfile* get_component_profile()
00941 throw (CORBA::SystemException);
00942
00962 virtual PortServiceList* get_ports()
00963 throw (CORBA::SystemException);
00964
00986
00987
00988
00989
00990
00991
01017 virtual ReturnCode_t on_initialize()
01018 throw (CORBA::SystemException);
01019
01044 virtual ReturnCode_t on_finalize()
01045 throw (CORBA::SystemException);
01046
01075 virtual ReturnCode_t on_startup(UniqueId exec_handle)
01076 throw (CORBA::SystemException);
01077
01106 virtual ReturnCode_t on_shutdown(UniqueId exec_handle)
01107 throw (CORBA::SystemException);
01108
01135 virtual ReturnCode_t on_activated(UniqueId exec_handle)
01136 throw (CORBA::SystemException);
01137
01165 virtual ReturnCode_t on_deactivated(UniqueId exec_handle)
01166 throw (CORBA::SystemException);
01167
01200 virtual ReturnCode_t on_aborting(UniqueId exec_handle)
01201 throw (CORBA::SystemException);
01202
01246 virtual ReturnCode_t on_error(UniqueId exec_handle)
01247 throw (CORBA::SystemException);
01248
01283 virtual ReturnCode_t on_reset(UniqueId exec_handle)
01284 throw (CORBA::SystemException);
01285
01286
01287
01288
01331 virtual ReturnCode_t on_execute(UniqueId exec_handle)
01332 throw (CORBA::SystemException);
01333
01377 virtual ReturnCode_t on_state_update(UniqueId exec_handle)
01378 throw (CORBA::SystemException);
01379
01416 virtual ReturnCode_t on_rate_changed(UniqueId exec_handle)
01417 throw (CORBA::SystemException);
01418
01419
01420
01421
01459 virtual SDOPackage::OrganizationList* get_owned_organizations()
01460 throw (CORBA::SystemException,
01461 SDOPackage::NotAvailable, SDOPackage::InternalError);
01462
01463
01464
01465
01499 virtual char* get_sdo_id()
01500 throw (CORBA::SystemException,
01501 SDOPackage::NotAvailable, SDOPackage::InternalError);
01502
01536 virtual char* get_sdo_type()
01537 throw (CORBA::SystemException,
01538 SDOPackage::NotAvailable, SDOPackage::InternalError);
01539
01576 virtual SDOPackage::DeviceProfile* get_device_profile()
01577 throw (CORBA::SystemException,
01578 SDOPackage::NotAvailable, SDOPackage::InternalError);
01579
01616 virtual SDOPackage::ServiceProfileList* get_service_profiles()
01617 throw (CORBA::SystemException,
01618 SDOPackage::NotAvailable, SDOPackage::InternalError);
01619
01661 virtual SDOPackage::ServiceProfile* get_service_profile(const char* id)
01662 throw (CORBA::SystemException,
01663 SDOPackage::InvalidParameter, SDOPackage::NotAvailable,
01664 SDOPackage::InternalError);
01665
01713 virtual SDOPackage::SDOService_ptr get_sdo_service(const char* id)
01714 throw (CORBA::SystemException,
01715 SDOPackage::InvalidParameter, SDOPackage::NotAvailable,
01716 SDOPackage::InternalError);
01717
01762 virtual SDOPackage::Configuration_ptr get_configuration()
01763 throw (CORBA::SystemException,
01764 SDOPackage::InterfaceNotImplemented, SDOPackage::NotAvailable,
01765 SDOPackage::InternalError);
01766
01810 virtual SDOPackage::Monitoring_ptr get_monitoring()
01811 throw (CORBA::SystemException,
01812 SDOPackage::InterfaceNotImplemented, SDOPackage::NotAvailable,
01813 SDOPackage::InternalError);
01814
01850 virtual SDOPackage::OrganizationList* get_organizations()
01851 throw (CORBA::SystemException,
01852 SDOPackage::NotAvailable, SDOPackage::InternalError);
01853
01885 virtual SDOPackage::NVList* get_status_list()
01886 throw (CORBA::SystemException,
01887 SDOPackage::NotAvailable, SDOPackage::InternalError);
01888
01925 virtual CORBA::Any* get_status(const char* name)
01926 throw (CORBA::SystemException,
01927 SDOPackage::InvalidParameter, SDOPackage::NotAvailable,
01928 SDOPackage::InternalError);
01929
01930
01931
01932
01952 const char* getInstanceName()
01953 {
01954 RTC_TRACE(("getInstanceName()"));
01955 return m_profile.instance_name;
01956 }
01957
01977 void setInstanceName(const char* instance_name);
01978
01998 const char* getTypeName()
01999 {
02000 RTC_TRACE(("getTypeName()"));
02001 return m_profile.type_name;
02002 }
02003
02023 const char* getDescription()
02024 {
02025 RTC_TRACE(("getDescription()"));
02026 return m_profile.description;
02027 }
02028
02049 const char* getVersion()
02050 {
02051 RTC_TRACE(("getVersion()"));
02052 return m_profile.version;
02053 }
02054
02074 const char* getVendor()
02075 {
02076 RTC_TRACE(("getVendor()"));
02077 return m_profile.vendor;
02078 }
02079
02099 const char* getCategory()
02100 {
02101 RTC_TRACE(("getCategory()"));
02102 return m_profile.category;
02103 }
02104
02124 std::vector<std::string> getNamingNames();
02125
02145 void setObjRef(const RTObject_ptr rtobj);
02146
02166 RTObject_ptr getObjRef() const;
02167
02193 void setProperties(const coil::Properties& prop);
02194
02216 coil::Properties& getProperties();
02217
02250 template <typename VarType>
02251 bool bindParameter(const char* param_name, VarType& var,
02252 const char* def_val,
02253 bool (*trans)(VarType&, const char*) = coil::stringTo)
02254 {
02255 RTC_TRACE(("bindParameter(%s (default: %s))", param_name, def_val));
02256 m_configsets.bindParameter(param_name, var, def_val, trans);
02257 return true;
02258 }
02259
02281 void updateParameters(const char* config_set);
02282
02316 bool addPort(PortBase& port);
02350 bool addPort(PortService_ptr port);
02384 bool addPort(CorbaPort& port);
02416 void registerPort(PortBase& port);
02448 void registerPort(PortService_ptr port);
02480 void registerPort(CorbaPort& port);
02481
02510 bool addInPort(const char* name, InPortBase& inport);
02537 void registerInPort(const char* name, InPortBase& inport);
02538
02567 bool addOutPort(const char* name, OutPortBase& outport);
02594 void registerOutPort(const char* name, OutPortBase& outport);
02595
02617 bool removeInPort(InPortBase& port);
02618
02640 bool removeOutPort(OutPortBase& port);
02641
02663 bool removePort(PortBase& port);
02685 bool removePort(PortService_ptr port);
02707 bool removePort(CorbaPort& port);
02727 void deletePort(PortBase& port);
02747 void deletePort(PortService_ptr port);
02767 void deletePort(CorbaPort& port);
02768
02788 void deletePortByName(const char* port_name);
02789
02840 ExecutionContext_ptr getExecutionContext(RTC::UniqueId ec_id);
02841
02894 double getExecutionRate(RTC::UniqueId ec_id);
02895
02949 ReturnCode_t setExecutionRate(RTC::UniqueId ec_id, double rate);
02950
03003 bool isOwnExecutionContext(RTC::UniqueId ec_id);
03004
03043 ReturnCode_t deactivate(RTC::UniqueId ec_id);
03044
03081 ReturnCode_t activate(RTC::UniqueId ec_id);
03082
03117 ReturnCode_t reset(RTC::UniqueId ec_id);
03118
03126 bool addSdoServiceProvider(const SDOPackage::ServiceProfile& prof,
03127 SdoServiceProviderBase* provider);
03128
03136 bool removeSdoServiceProvider(const char* id);
03137
03145 bool addSdoServiceConsumer(const SDOPackage::ServiceProfile& prof);
03146
03154 bool removeSdoServiceConsumer(const char* id);
03155
03176 bool readAll();
03177
03198 bool writeAll();
03199
03234 void setReadAll(bool read=true, bool completion=false);
03235
03270 void setWriteAll(bool write=true, bool completion=false);
03271
03272
03289 void finalizePorts();
03290
03291
03303 void finalizeContexts();
03304
03305
03378 typedef PreComponentActionListener PreCompActionListener;
03379 typedef PreComponentActionListenerType PreCompActionListenerType;
03380 void
03381 addPreComponentActionListener(PreComponentActionListenerType listener_type,
03382 PreComponentActionListener* listener,
03383 bool autoclean = true);
03384
03385
03386 template <class Listener>
03387 PreComponentActionListener*
03388 addPreComponentActionListener(PreCompActionListenerType listener_type,
03389 Listener& obj,
03390 void (Listener::*memfunc)(UniqueId ec_id))
03391 {
03392 class Noname
03393 : public PreComponentActionListener
03394 {
03395 public:
03396 Noname(Listener& obj, void (Listener::*memfunc)(UniqueId))
03397 : m_obj(obj), m_memfunc(memfunc)
03398 {
03399 }
03400 void operator()(UniqueId ec_id)
03401 {
03402 (m_obj.*m_memfunc)(ec_id);
03403 }
03404 private:
03405 Listener& m_obj;
03406 typedef void (Listener::*Memfunc)(UniqueId ec_id);
03407 Memfunc m_memfunc;
03408 };
03409 Noname* listener(new Noname(obj, memfunc));
03410 addPreComponentActionListener(listener_type, listener, true);
03411 return listener;
03412 }
03413
03433 void
03434 removePreComponentActionListener(
03435 PreComponentActionListenerType listener_type,
03436 PreComponentActionListener* listener);
03437
03438
03511 typedef PostComponentActionListener PostCompActionListener;
03512 typedef PostComponentActionListenerType PostCompActionListenerType;
03513 void
03514 addPostComponentActionListener(
03515 PostComponentActionListenerType listener_type,
03516 PostComponentActionListener* listener,
03517 bool autoclean = true);
03518
03519 template <class Listener>
03520 PostComponentActionListener*
03521 addPostComponentActionListener(PostCompActionListenerType listener_type,
03522 Listener& obj,
03523 void (Listener::*memfunc)(UniqueId ec_id,
03524 ReturnCode_t ret))
03525 {
03526 class Noname
03527 : public PostComponentActionListener
03528 {
03529 public:
03530 Noname(Listener& obj, void (Listener::*memfunc)(UniqueId, ReturnCode_t))
03531 : m_obj(obj), m_memfunc(memfunc)
03532 {
03533 }
03534 void operator()(UniqueId ec_id, ReturnCode_t ret)
03535 {
03536 (m_obj.*m_memfunc)(ec_id, ret);
03537 }
03538 private:
03539 Listener& m_obj;
03540 typedef void (Listener::*Memfunc)(UniqueId ec_id, ReturnCode_t ret);
03541 Memfunc m_memfunc;
03542 };
03543 Noname* listener(new Noname(obj, memfunc));
03544 addPostComponentActionListener(listener_type, listener, true);
03545 return listener;
03546 }
03547
03567 void
03568 removePostComponentActionListener(
03569 PostComponentActionListenerType listener_type,
03570 PostComponentActionListener* listener);
03571
03572
03573
03627 void
03628 addPortActionListener(PortActionListenerType listener_type,
03629 PortActionListener* listener,
03630 bool autoclean = true);
03631
03632 template <class Listener>
03633 PortActionListener*
03634 addPortActionListener(PortActionListenerType listener_type,
03635 Listener& obj,
03636 void (Listener::*memfunc)(const RTC::PortProfile&))
03637 {
03638 class Noname
03639 : public PortActionListener
03640 {
03641 public:
03642 Noname(Listener& obj,
03643 void (Listener::*memfunc)(const RTC::PortProfile&))
03644 : m_obj(obj), m_memfunc(memfunc)
03645 {
03646 }
03647 void operator()(const RTC::PortProfile& pprofile)
03648 {
03649 (m_obj.*m_memfunc)(pprofile);
03650 }
03651 private:
03652 Listener& m_obj;
03653 typedef void (Listener::*Memfunc)(const RTC::PortProfile&);
03654 Memfunc m_memfunc;
03655 };
03656 Noname* listener(new Noname(obj, memfunc));
03657 addPortActionListener(listener_type, listener, true);
03658 return listener;
03659 }
03660
03680 void
03681 removePortActionListener(PortActionListenerType listener_type,
03682 PortActionListener* listener);
03683
03684
03685
03739 typedef ExecutionContextActionListenerType ECActionListenerType;
03740 typedef ExecutionContextActionListener ECActionListener;
03741 void addExecutionContextActionListener(ECActionListenerType listener_type,
03742 ECActionListener* listener,
03743 bool autoclean = true);
03744
03745 template <class Listener>
03746 ECActionListener*
03747 addExecutionContextActionListener(ECActionListenerType listener_type,
03748 Listener& obj,
03749 void (Listener::*memfunc)(UniqueId))
03750 {
03751 class Noname
03752 : public ECActionListener
03753 {
03754 public:
03755 Noname(Listener& obj, void (Listener::*memfunc)(UniqueId))
03756 : m_obj(obj), m_memfunc(memfunc)
03757 {
03758 }
03759 void operator()(UniqueId ec_id)
03760 {
03761 (m_obj.*m_memfunc)(ec_id);
03762 }
03763 private:
03764 Listener& m_obj;
03765 typedef void (Listener::*Memfunc)(UniqueId);
03766 Memfunc m_memfunc;
03767 };
03768 Noname* listener(new Noname(obj, memfunc));
03769 addExecutionContextActionListener(listener_type, listener, true);
03770 return listener;
03771 }
03772
03773
03793 void
03794 removeExecutionContextActionListener(ECActionListenerType listener_type,
03795 ECActionListener* listener);
03796
03797
03852 void addPortConnectListener(PortConnectListenerType listener_type,
03853 PortConnectListener* listener,
03854 bool autoclean = true);
03855
03856 template <class Listener>
03857 PortConnectListener*
03858 addPortConnectListener(PortConnectListenerType listener_type,
03859 Listener& obj,
03860 void (Listener::*memfunc)(const char*,
03861 ConnectorProfile&))
03862 {
03863 class Noname
03864 : public PortConnectListener
03865 {
03866 public:
03867 Noname(Listener& obj,
03868 void (Listener::*memfunc)(const char*, ConnectorProfile&))
03869 : m_obj(obj), m_memfunc(memfunc)
03870 {
03871 }
03872 void operator()(const char* portname, ConnectorProfile& cprofile)
03873 {
03874 (m_obj.*m_memfunc)(portname, cprofile);
03875 }
03876 private:
03877 Listener& m_obj;
03878 typedef void (Listener::*Memfunc)(const char*, ConnectorProfile&);
03879 Memfunc m_memfunc;
03880 };
03881 Noname* listener(new Noname(obj, memfunc));
03882 addPortConnectListener(listener_type, listener, true);
03883 return listener;
03884 }
03885
03886
03906 void
03907 removePortConnectListener(PortConnectListenerType listener_type,
03908 PortConnectListener* listener);
03909
03968 void addPortConnectRetListener(PortConnectRetListenerType listener_type,
03969 PortConnectRetListener* listener,
03970 bool autoclean = true);
03971
03972 template <class Listener>
03973 PortConnectRetListener*
03974 addPortConnectRetListener(PortConnectRetListenerType listener_type,
03975 Listener& obj,
03976 void (Listener::*memfunc)(const char*,
03977 ConnectorProfile&,
03978 ReturnCode_t))
03979 {
03980 class Noname
03981 : public PortConnectRetListener
03982 {
03983 public:
03984 Noname(Listener& obj,
03985 void (Listener::*memfunc)(const char*,
03986 ConnectorProfile&,
03987 ReturnCode_t))
03988 : m_obj(obj), m_memfunc(memfunc)
03989 {
03990 }
03991 void operator()(const char* portname,
03992 ConnectorProfile& cprofile,
03993 ReturnCode_t ret)
03994 {
03995 (m_obj.*m_memfunc)(portname, cprofile, ret);
03996 }
03997 private:
03998 Listener& m_obj;
03999 typedef void (Listener::*Memfunc)(const char* portname,
04000 ConnectorProfile& cprofile,
04001 ReturnCode_t ret);
04002 Memfunc m_memfunc;
04003 };
04004 Noname* listener(new Noname(obj, memfunc));
04005 addPortConnectRetListener(listener_type, listener, true);
04006 return listener;
04007 }
04008
04009
04029 void
04030 removePortConnectRetListener(PortConnectRetListenerType listener_type,
04031 PortConnectRetListener* listener);
04032
04033
04066 void addConfigurationParamListener(ConfigurationParamListenerType type,
04067 ConfigurationParamListener* listener,
04068 bool autoclean = true);
04069
04070 template <class Listener>
04071 ConfigurationParamListener*
04072 addConfigurationParamListener(ConfigurationParamListenerType listener_type,
04073 Listener& obj,
04074 void (Listener::*memfunc)(const char*,
04075 const char*))
04076 {
04077 class Noname
04078 : public ConfigurationParamListener
04079 {
04080 public:
04081 Noname(Listener& obj,
04082 void (Listener::*memfunc)(const char*, const char*))
04083 : m_obj(obj), m_memfunc(memfunc)
04084 {
04085 }
04086 void operator()(const char* config_set_name,
04087 const char* config_param_name)
04088 {
04089 (m_obj.*m_memfunc)(config_set_name, config_param_name);
04090 }
04091 private:
04092 Listener& m_obj;
04093 typedef void (Listener::*Memfunc)(const char*, const char*);
04094 Memfunc m_memfunc;
04095 };
04096 Noname* listener(new Noname(obj, memfunc));
04097 addConfigurationParamListener(listener_type, listener, true);
04098 return listener;
04099 }
04100
04125 void removeConfigurationParamListener(ConfigurationParamListenerType type,
04126 ConfigurationParamListener* listener);
04127
04159 void addConfigurationSetListener(ConfigurationSetListenerType type,
04160 ConfigurationSetListener* listener,
04161 bool autoclean = true);
04162
04163 template <class Listener>
04164 ConfigurationSetListener*
04165 addConfigurationSetListener(ConfigurationSetListenerType listener_type,
04166 Listener& obj,
04167 void (Listener::*memfunc)
04168 (const coil::Properties& config_set))
04169 {
04170 class Noname
04171 : public ConfigurationSetListener
04172 {
04173 public:
04174 Noname(Listener& obj,
04175 void (Listener::*memfunc)(const coil::Properties& config_set))
04176 : m_obj(obj), m_memfunc(memfunc)
04177 {
04178 }
04179 virtual void operator()(const coil::Properties& config_set)
04180 {
04181 (m_obj.*m_memfunc)(config_set);
04182 }
04183 private:
04184 Listener& m_obj;
04185 typedef void (Listener::*Memfunc)(const coil::Properties& config_set);
04186 Memfunc m_memfunc;
04187 };
04188 Noname* listener(new Noname(obj, memfunc));
04189 addConfigurationSetListener(listener_type, listener, true);
04190 return listener;
04191 }
04192
04215 void removeConfigurationSetListener(ConfigurationSetListenerType type,
04216 ConfigurationSetListener* listener);
04217
04252 void
04253 addConfigurationSetNameListener(ConfigurationSetNameListenerType type,
04254 ConfigurationSetNameListener* listener,
04255 bool autoclean = true);
04256
04257 template <class Listener>
04258 ConfigurationSetNameListener*
04259 addConfigurationSetNameListener(ConfigurationSetNameListenerType type,
04260 Listener& obj,
04261 void (Listener::*memfunc)(const char*))
04262 {
04263 class Noname
04264 : public ConfigurationSetNameListener
04265 {
04266 public:
04267 Noname(Listener& obj, void (Listener::*memfunc)(const char*))
04268 : m_obj(obj), m_memfunc(memfunc)
04269 {
04270 }
04271 virtual void operator()(const char* config_set_name)
04272 {
04273 (m_obj.*m_memfunc)(config_set_name);
04274 }
04275 private:
04276 Listener& m_obj;
04277 typedef void (Listener::*Memfunc)(const char*);
04278 Memfunc m_memfunc;
04279 };
04280 Noname* listener(new Noname(obj, memfunc));
04281 addConfigurationSetNameListener(type, listener, true);
04282 return listener;
04283 }
04284
04311 void
04312 removeConfigurationSetNameListener(ConfigurationSetNameListenerType type,
04313 ConfigurationSetNameListener* listener);
04314
04315 protected:
04335 void shutdown();
04336
04337 inline void preOnInitialize(UniqueId ec_id)
04338 {
04339 m_actionListeners.preaction_[PRE_ON_INITIALIZE].notify(ec_id);
04340 }
04341
04342 inline void preOnFinalize(UniqueId ec_id)
04343 {
04344 m_actionListeners.preaction_[PRE_ON_FINALIZE].notify(ec_id);
04345 }
04346
04347 inline void preOnStartup(UniqueId ec_id)
04348 {
04349 m_actionListeners.preaction_[PRE_ON_STARTUP].notify(ec_id);
04350 }
04351
04352 inline void preOnShutdown(UniqueId ec_id)
04353 {
04354 m_actionListeners.preaction_[PRE_ON_SHUTDOWN].notify(ec_id);
04355 }
04356
04357 inline void preOnActivated(UniqueId ec_id)
04358 {
04359 m_actionListeners.preaction_[PRE_ON_ACTIVATED].notify(ec_id);
04360 }
04361
04362 inline void preOnDeactivated(UniqueId ec_id)
04363 {
04364 m_actionListeners.preaction_[PRE_ON_DEACTIVATED].notify(ec_id);
04365 }
04366
04367 inline void preOnAborting(UniqueId ec_id)
04368 {
04369 m_actionListeners.preaction_[PRE_ON_ABORTING].notify(ec_id);
04370 }
04371
04372 inline void preOnError(UniqueId ec_id)
04373 {
04374 m_actionListeners.preaction_[PRE_ON_ERROR].notify(ec_id);
04375 }
04376
04377 inline void preOnReset(UniqueId ec_id)
04378 {
04379 m_actionListeners.preaction_[PRE_ON_RESET].notify(ec_id);
04380 }
04381
04382 inline void preOnExecute(UniqueId ec_id)
04383 {
04384 m_actionListeners.preaction_[PRE_ON_EXECUTE].notify(ec_id);
04385 }
04386
04387 inline void preOnStateUpdate(UniqueId ec_id)
04388 {
04389 m_actionListeners.preaction_[PRE_ON_STATE_UPDATE].notify(ec_id);
04390 }
04391
04392 inline void preOnRateChanged(UniqueId ec_id)
04393 {
04394 m_actionListeners.preaction_[PRE_ON_RATE_CHANGED].notify(ec_id);
04395 }
04396
04397 inline void postOnInitialize(UniqueId ec_id, ReturnCode_t ret)
04398 {
04399 m_actionListeners.postaction_[POST_ON_INITIALIZE].notify(ec_id, ret);
04400 }
04401
04402 inline void postOnFinalize(UniqueId ec_id, ReturnCode_t ret)
04403 {
04404 m_actionListeners.postaction_[POST_ON_FINALIZE].notify(ec_id, ret);
04405 }
04406
04407 inline void postOnStartup(UniqueId ec_id, ReturnCode_t ret)
04408 {
04409 m_actionListeners.postaction_[POST_ON_STARTUP].notify(ec_id, ret);
04410 }
04411
04412 inline void postOnShutdown(UniqueId ec_id, ReturnCode_t ret)
04413 {
04414 m_actionListeners.postaction_[POST_ON_SHUTDOWN].notify(ec_id, ret);
04415 }
04416
04417 inline void postOnActivated(UniqueId ec_id, ReturnCode_t ret)
04418 {
04419 m_actionListeners.postaction_[POST_ON_ACTIVATED].notify(ec_id, ret);
04420 }
04421
04422 inline void postOnDeactivated(UniqueId ec_id, ReturnCode_t ret)
04423 {
04424 m_actionListeners.postaction_[POST_ON_DEACTIVATED].notify(ec_id, ret);
04425 }
04426
04427 inline void postOnAborting(UniqueId ec_id, ReturnCode_t ret)
04428 {
04429 m_actionListeners.postaction_[POST_ON_ABORTING].notify(ec_id, ret);
04430 }
04431
04432 inline void postOnError(UniqueId ec_id, ReturnCode_t ret)
04433 {
04434 m_actionListeners.postaction_[POST_ON_ERROR].notify(ec_id, ret);
04435 }
04436
04437 inline void postOnReset(UniqueId ec_id, ReturnCode_t ret)
04438 {
04439 m_actionListeners.postaction_[POST_ON_RESET].notify(ec_id, ret);
04440 }
04441
04442 inline void postOnExecute(UniqueId ec_id, ReturnCode_t ret)
04443 {
04444 m_actionListeners.postaction_[POST_ON_EXECUTE].notify(ec_id, ret);
04445 }
04446
04447 inline void postOnStateUpdate(UniqueId ec_id, ReturnCode_t ret)
04448 {
04449 m_actionListeners.postaction_[POST_ON_STATE_UPDATE].notify(ec_id, ret);
04450 }
04451
04452 inline void postOnRateChanged(UniqueId ec_id, ReturnCode_t ret)
04453 {
04454 m_actionListeners.postaction_[POST_ON_RATE_CHANGED].notify(ec_id, ret);
04455 }
04456
04457 inline void onAddPort(const PortProfile& pprof)
04458 {
04459 m_actionListeners.portaction_[ADD_PORT].notify(pprof);
04460 }
04461
04462 inline void onRemovePort(const PortProfile& pprof)
04463 {
04464 m_actionListeners.portaction_[REMOVE_PORT].notify(pprof);
04465 }
04466
04467 inline void onAttachExecutionContext(UniqueId ec_id)
04468 {
04469 m_actionListeners.ecaction_[EC_ATTACHED].notify(ec_id);
04470 }
04471
04472 inline void onDetachExecutionContext(UniqueId ec_id)
04473 {
04474 m_actionListeners.ecaction_[EC_DETACHED].notify(ec_id);
04475 }
04476
04477 protected:
04485 mutable Logger rtclog;
04493 Manager* m_pManager;
04494
04502 CORBA::ORB_var m_pORB;
04503
04511 PortableServer::POA_var m_pPOA;
04512
04513
04514
04515
04523 SDOPackage::OrganizationList m_sdoOwnedOrganizations;
04524
04532 struct svc_name
04533 {
04534 svc_name (const char* id) : m_id(id) {};
04535 bool operator()(const SDOPackage::ServiceProfile& prof)
04536 {
04537 return m_id == std::string(prof.id);
04538 }
04539 std::string m_id;
04540 };
04541
04549 SDOPackage::Configuration_impl* m_pSdoConfigImpl;
04550
04558 SDOPackage::Configuration_var m_pSdoConfig;
04559
04567 SDOPackage::OrganizationList m_sdoOrganizations;
04568
04576 SDOPackage::NVList m_sdoStatus;
04577
04578
04579
04580
04588 ComponentProfile m_profile;
04589
04597 RTObject_var m_objref;
04598
04606 PortAdmin m_portAdmin;
04607
04615 std::vector<InPortBase*> m_inports;
04616
04624 std::vector<OutPortBase*> m_outports;
04625
04633 ExecutionContextServiceList m_ecMine;
04634
04642 std::vector<ExecutionContextBase*> m_eclist;
04643
04651 ExecutionContextServiceList m_ecOther;
04652
04660 bool m_created;
04661
04669 bool m_exiting;
04670
04678
04679
04687 coil::Properties m_properties;
04688
04696 ConfigAdmin m_configsets;
04697
04705 SdoServiceAdmin m_sdoservice;
04706
04714 bool m_readAll;
04715
04723 bool m_writeAll;
04724
04741 bool m_readAllCompletion;
04742
04759 bool m_writeAllCompletion;
04760
04774 ComponentActionListeners m_actionListeners;
04775
04789 PortConnectListeners m_portconnListeners;
04790
04791
04792
04793
04801 struct nv_name
04802 {
04803 nv_name(const char* name) : m_name(name) {};
04804 bool operator()(const SDOPackage::NameValue& nv)
04805 {
04806 return m_name == std::string(nv.name);
04807 }
04808 std::string m_name;
04809 };
04810
04818 struct ec_copy
04819 {
04820 ec_copy(ExecutionContextList& eclist)
04821 : m_eclist(eclist)
04822 {
04823 }
04824 void operator()(ExecutionContextService_ptr ecs)
04825 {
04826 if (!::CORBA::is_nil(ecs))
04827 {
04828 CORBA_SeqUtil::push_back(m_eclist,
04829 ExecutionContext::_duplicate(ecs));
04830 }
04831 }
04832 ExecutionContextList& m_eclist;
04833 };
04841 struct ec_find
04842 {
04843 ec_find(ExecutionContext_ptr& ec)
04844 : m_ec(ExecutionContext::_duplicate(ec))
04845 {
04846 }
04847 bool operator()(ExecutionContextService_ptr ecs)
04848 {
04849 try
04850 {
04851 if (!::CORBA::is_nil(ecs))
04852 {
04853 ExecutionContext_var ec;
04854 ec = ExecutionContext::_narrow(ecs);
04855 return m_ec->_is_equivalent(ec);
04856 }
04857 }
04858 catch (...)
04859 {
04860 return false;
04861 }
04862 return false;
04863 }
04864 ExecutionContext_var m_ec;
04865
04866 };
04867
04868
04876 struct deactivate_comps
04877 {
04878 deactivate_comps(LightweightRTObject_ptr comp)
04879 : m_comp(RTC::LightweightRTObject::_duplicate(comp))
04880 {
04881 }
04882 void operator()(ExecutionContextService_ptr ec)
04883 {
04884 if (!::CORBA::is_nil(ec) && !ec->_non_existent())
04885 {
04886
04887 ec->deactivate_component(RTC::LightweightRTObject::_duplicate(m_comp));
04888 ec->stop();
04889 }
04890 }
04891 LightweightRTObject_var m_comp;
04892 };
04893 };
04894 };
04895
04896 #ifdef WIN32
04897 #pragma warning( default : 4290 )
04898 #endif
04899
04900 #endif // RTC_RTOBJECT