CORBA_RTCUtil.h

[詳解]

// -*- C++ -*-
#ifndef CORBA_RTCUTIL_H
#define CORBA_RTCUTIL_H
 
#include <rtm/RTC.h>
#include <rtm/NVUtil.h>
#include <rtm/CORBA_SeqUtil.h>
#include <rtm/RTObject.h>
 
#include <utility>
 
 
namespace CORBA_RTCUtil
{
  coil::Properties get_component_profile(const RTC::RTObject_ptr rtc);
  bool is_existing(const RTC::RTObject_ptr rtc);
  bool is_alive_in_default_ec(const RTC::RTObject_ptr rtc);
 
 
  RTC::ExecutionContext_ptr get_actual_ec(const RTC::RTObject_ptr rtc,
                                          const RTC::UniqueId ec_id = 0);
 
  RTC::UniqueId get_ec_id(const RTC::RTObject_ptr rtc,
                          const RTC::ExecutionContext_ptr ec);
 
  RTC::ReturnCode_t activate(const RTC::RTObject_ptr rtc, const RTC::UniqueId ec_id = 0);
 
  RTC::ReturnCode_t deactivate(const RTC::RTObject_ptr rtc, const RTC::UniqueId ec_id = 0);
 
  RTC::ReturnCode_t reset(const RTC::RTObject_ptr rtc, const RTC::UniqueId ec_id = 0);
 
 
 
  bool get_state(RTC::LifeCycleState  &state, const RTC::RTObject_ptr rtc, const RTC::UniqueId ec_id = 0);
 
 
  bool is_in_inactive(const RTC::RTObject_ptr rtc, const RTC::UniqueId ec_id = 0);
 
 
  bool is_in_active(const RTC::RTObject_ptr rtc, const RTC::UniqueId ec_id = 0);
 
 
  bool is_in_error(const RTC::RTObject_ptr rtc, const RTC::UniqueId ec_id = 0);
 
 
 
  CORBA::Double get_default_rate(const RTC::RTObject_ptr rtc);
 
 
  RTC::ReturnCode_t set_default_rate(const RTC::RTObject_ptr rtc,
                                     CORBA::Double rate);
 
 
  CORBA::Double get_current_rate(const RTC::RTObject_ptr rtc,
                                 const RTC::UniqueId ec_id);
 
  RTC::ReturnCode_t set_current_rate(const RTC::RTObject_ptr rtc,
                                     const RTC::UniqueId ec_id,
                                     const CORBA::Double rate);
 
 
  RTC::ReturnCode_t add_rtc_to_default_ec(const RTC::RTObject_ptr localcomp,
                                          const RTC::RTObject_ptr othercomp);
 
 
  RTC::ReturnCode_t remove_rtc_to_default_ec(const RTC::RTObject_ptr localcomp,
                                             const RTC::RTObject_ptr othercomp);
 
 
  RTC::RTCList get_participants_rtc(const RTC::RTObject_ptr rtc);
 
 
 
  coil::vstring get_port_names(const RTC::RTObject_ptr rtc);
 
 
  coil::vstring get_inport_names(const RTC::RTObject_ptr rtc);
 
 
  coil::vstring get_outport_names(const RTC::RTObject_ptr rtc);
 
 
  coil::vstring get_svcport_names(const RTC::RTObject_ptr rtc);
 
 
  coil::vstring get_connector_names(const RTC::PortService_ptr port);
 
 
  coil::vstring get_connector_names(const RTC::RTObject_ptr rtc,
                                    const std::string& port_name);
 
  coil::vstring get_connector_ids(const RTC::PortService_ptr port);
 
 
  coil::vstring get_connector_ids(const RTC::RTObject_ptr rtc,
                                  const std::string& port_name);
 
 
  RTC::ConnectorProfile* create_connector(const std::string& name,
                                             const coil::Properties& prop_arg,
                                             const RTC::PortService_ptr port0,
                                             const RTC::PortService_ptr port1);
 
  bool already_connected(const RTC::PortService_ptr localport,
                         const RTC::PortService_ptr otherport);
 
  RTC::ReturnCode_t connect(const std::string& name,
                            const coil::Properties& prop,
                            const RTC::PortService_ptr port0,
                            const RTC::PortService_ptr port1);
 
 
  RTC::ReturnCode_t disconnect(const RTC::ConnectorProfile connector_prof);
 
 
  RTC::ReturnCode_t disconnect_connector_name(const RTC::PortService_ptr port_ref, const std::string& conn_name);
 
 
 
  RTC::ReturnCode_t disconnect_connector_name(const std::string& port_name,
                                              const std::string& conn_name);
 
 
  RTC::ReturnCode_t
  disconnect_connector_id(const RTC::PortService_ptr port_ref,
                          const std::string& conn_id);
 
 
  RTC::ReturnCode_t disconnect_connector_id(const std::string& port_name,
                                            const std::string& conn_id);
 
  RTC::ReturnCode_t disconnect_all(const RTC::PortService_ptr port_ref);
 
 
  RTC::ReturnCode_t disconnect_all(const std::string& port_name);
 
  RTC::PortService_ptr get_port_by_url(const std::string& port_name);
 
  RTC::ReturnCode_t disconnect_name(const RTC::PortService_ptr localport,
                                    const std::string& othername);
  RTC::ReturnCode_t connect_multi(const std::string& name,
    const coil::Properties& prop,
    const RTC::PortService_ptr port,
    RTC::PortServiceList& target_ports);
  struct find_port
  {
    const std::string m_name;
    find_port(std::string  name) : m_name(std::move(name)) {}
  bool operator()(const RTC::PortService_ptr p);
  };
 
  RTC::PortService_ptr get_port_by_name(const RTC::RTObject_ptr rtc,
                                        const std::string& name);
 
  RTC::ReturnCode_t connect_by_name(const std::string& name, const coil::Properties& prop,
                                    const RTC::RTObject_ptr rtc0,
                                    const std::string& portName0,
                                    const RTC::RTObject_ptr rtc1,
                                    const std::string& portName1);
 
  coil::Properties get_configuration(const RTC::RTObject_ptr rtc, const std::string& conf_name);
 
 
  std::string get_parameter_by_key(const RTC::RTObject_ptr rtc,
                                   const std::string& confset_name,
                                   const std::string& value_name);
 
  std::string get_active_configuration_name(const RTC::RTObject_ptr rtc);
 
 
 
  coil::Properties get_active_configuration(const RTC::RTObject_ptr rtc);
 
 
  bool set_configuration(const RTC::RTObject_ptr rtc, const std::string& confset_name, const std::string& value_name, const std::string& value);
 
 
 
  bool set_active_configuration(const RTC::RTObject_ptr rtc, const std::string& value_name, const std::string& value);
 
 
  bool set_configuration_parameter(SDOPackage::Configuration_ptr conf,
                                   SDOPackage::ConfigurationSet& confset,
                                   const std::string& value_name,
                                   const std::string& value);
  class CorbaURI
  {
  public:
    CorbaURI(std::string uri, const std::string &objkey="");
    ~CorbaURI();
    std::string toString() const;
    std::string getProtocol() const;
    std::string getHost() const;
    unsigned short getPort() const;
    bool isAddressOnly() const;
  private:
    std::string m_protocol;
    std::string m_host;
    unsigned short m_port;
    std::string m_path;
    std::string m_fragment;
    std::string m_uri;
    bool m_addressonly;
  };
 
  class RTCURIObject
  {
  public:
    RTCURIObject(const std::string& uri, bool isrtcname=false, bool isrtcloc=false);
    ~RTCURIObject();
    std::string getRTCName() const;
    std::string getAddress() const;
    bool isRTCNameURI() const;
    bool isRTCLocURI() const;
  private:
    std::string m_rtcpath;
    std::string m_address;
    bool m_is_rtcname;
    bool m_is_rtcloc;
  };
 
 
} // namespace CORBA_RTCUtil
#endif // CORBA_SEQUTIL_H