ManagerServant.h

[詳解]

// -*- C++ -*-
#ifndef RTM_MANAGERSERVANT_H
#define RTM_MANAGERSERVANT_H
 
#include <mutex>
#include <rtm/idl/ManagerSkel.h>
#include <rtm/Manager.h>
#include <rtm/SystemLogger.h>
 
#include <iostream>
 
namespace RTM
{
  class ManagerServant
    : public virtual POA_RTM::Manager,
      public virtual PortableServer::RefCountServantBase
  {
  public:
    // standard constructor
    ManagerServant();
 
    ~ManagerServant() override;
 
    RTC::ReturnCode_t load_module(const char* pathname, const char* initfunc) override;
 
    RTC::ReturnCode_t unload_module(const char* pathname) override;
 
    RTM::ModuleProfileList* get_loadable_modules() override;
 
    RTM::ModuleProfileList* get_loaded_modules() override;
 
    // component 関連
    RTM::ModuleProfileList* get_factory_profiles() override;
 
    RTC::RTObject_ptr create_component(const char* module_name) override;
 
    RTC::ReturnCode_t delete_component(const char* instance_name) override;
 
    RTC::RTCList* get_components() override;
 
    RTC::ComponentProfileList* get_component_profiles() override;
 
    // manager 基本
    RTM::ManagerProfile* get_profile() override;
 
    RTM::NVList* get_configuration() override;
 
    RTC::ReturnCode_t set_configuration(const char* name, const char* value) override;
 
    ::CORBA::Boolean is_master() override;
 
    RTM::ManagerList* get_master_managers() override;
 
    RTC::ReturnCode_t add_master_manager(RTM::Manager_ptr mgr) override;
 
    RTC::ReturnCode_t remove_master_manager(RTM::Manager_ptr mgr) override;
 
    RTM::ManagerList* get_slave_managers() override;
 
    RTC::ReturnCode_t add_slave_manager(RTM::Manager_ptr mgr) override;
 
    RTC::ReturnCode_t remove_slave_manager(RTM::Manager_ptr mgr) override;
 
    RTC::ReturnCode_t fork() override;
    RTC::ReturnCode_t shutdown() override;
    RTC::ReturnCode_t restart() override;
 
    RTC::RTCList* get_components_by_name(const char* name) override;
 
    CORBA::Object_ptr get_service(const char* name) override;
 
    RTM::Manager_ptr getObjRef() const;
 
    bool createINSManager();
 
    RTM::Manager_ptr findManager(const std::string& host_port);
 
    RTM::Manager_ptr findManagerByName(const std::string& mgr_name);
 
    RTM::Manager_ptr findManagerFromList(const std::string& name,
                                         RTM::ManagerList& mlist);
 
    RTC::RTObject_ptr
    createComponentByManagerName(std::string& create_arg, std::string& mgrstr);
 
    /*
     * @if jp
     * @brief 指定アドレスのマネージャでRTCを起動する
     *
     * comp&manager_address=localhost:2810 のようにRTC名
     * &manager_address=マネージャのホスト名、ポート番号を指定する
     *
     * @param module_name 起動するRTC、マネージャのホストアドレス
     * @return 生成されたRTCのオブジェクト参照
     *
     * @else
     * @brief Launch a RTC on the specified IP/Port address manager
     *
     * @param module_name Given parameter to create RTC
     * @return created RTObject object reference
     *
     * @endif
     */
    RTC::RTObject_ptr
    createComponentByAddress(std::string& create_arg, std::string& mgrstr);
 
    /*
     * @if jp
     * @brief マスターマネージャの有無を確認してリストを更新する
     *
     *
     *
     * @else
     * @brief 
     *
     *
     * @endif
     */
    void updateMasterManager();
    /*
     * @if jp
     * @brief create引数から指定されたキーの値を返す
     *
     * create引数から指定されたキーを値を返すとともに、そのキーと値を削除した引
     * 数を返す。
     * module_name: module_name?param1=value1&param2=value2&param3...
     * param_name:  param2
     * の場合
     * 返り値: value2
     * module_name: module_name?param1=value1&param3...
     * となる。
     *
     * @else @brief returns value of specified param_name from create arg
     *
     * This function returns the value of specified param_name from
     * create argument, and delete param_name=value from the create
     * arg string. If the arguments are
     * module_name: module_name?param1=value1&param2=value2&param3...
     * param_name:  param2
     * this function returns
     * ret value: value2
     * module_name: module_name?param1=value1&param3...
     *
     * @endif
     */
    std::string getParameterByModulename(const std::string& param_name, std::string &module_name);
    static bool isProcessIDManager(const std::string& mgrname);
 
  private:
    ::RTC::Logger rtclog{"ManagerServant"};
 
    ::RTC::Manager& m_mgr{::RTC::Manager::instance()};
 
    ::RTM::Manager_var m_objref{RTM::Manager::_nil()};
 
    ::RTM::ManagerList m_masters;
 
    ::std::mutex m_masterMutex;
 
    ::RTM::ManagerList m_slaves;
 
    ::std::mutex m_slaveMutex;
 
    CORBA::Boolean m_isMaster{false};
 
    class is_equiv
    {
      RTM::Manager_var m_mgr;
    public:
 
      is_equiv(RTM::Manager_ptr mgr)
        : m_mgr(RTM::Manager::_duplicate(mgr)) {}
#ifdef ORB_IS_ORBEXPRESS
      bool operator()(RTM::Manager_var mgr)
      {
        return m_mgr->_is_equivalent(mgr.in());
      }
#else
      bool operator()(RTM::Manager_ptr mgr)
      {
        return m_mgr->_is_equivalent(mgr);
      }
#endif
    };
 
 
  };
 
 
  class CompParam
  {
  public:
    CompParam(std::string module_name);
    ~CompParam();
    static const unsigned int prof_list_size = 6;
    static const char* prof_list[prof_list_size];
    std::string vendor();
    std::string category();
    std::string impl_id();
    std::string language();
    std::string version();
  private:
    std::string m_type;
    std::string m_vendor;
    std::string m_category;
    std::string m_impl_id;
    std::string m_language;
    std::string m_version;
  
  };
 
} // namespace RTM
#endif // RTM_MANAGERSERVANT_H