PeriodicECSharedComposite.h

[詳解]

// -*- C++ -*-
 
#ifndef RTC_PERIODICECSHAREDCOMPOSITE_H
#define RTC_PERIODICECSHAREDCOMPOSITE_H
 
#include <rtm/idl/RTCSkel.h>
#include <rtm/idl/OpenRTMSkel.h>
#include <rtm/RTObject.h>
#include <rtm/PeriodicExecutionContext.h>
#include <rtm/SdoOrganization.h>
#include <coil/stringutil.h>
 
#include <string>
#include <utility>
#include <vector>

 
namespace SDOPackage
{
  class PeriodicECOrganization
    : public Organization_impl
  {
    using PortList = std::vector<std::string>;
 
  public:
    explicit PeriodicECOrganization(::RTC::RTObject_impl* rtobj, SDOSystemElement_ptr sdo);
    ~PeriodicECOrganization() override;

    ::CORBA::Boolean add_members(const SDOList& sdo_list) override;

    ::CORBA::Boolean set_members(const SDOList& sdo_list) override;

    ::CORBA::Boolean remove_member(const char* id) override;

    void removeAllMembers();
    void updateDelegatedPorts();
 
  protected:
    class Member;
    static bool sdoToDFC(SDO_ptr sdo, ::OpenRTM::DataFlowComponent_ptr& dfc);

    static void stopOwnedEC(Member& member);

    static void startOwnedEC(Member& member);

    void addOrganizationToTarget(Member& member);

    void removeOrganizationFromTarget(Member& member);
    void addRTCToEC(RTC::RTObject_ptr rtobj);

    void addParticipantToEC(Member& member);

    void removeParticipantFromEC(Member& member);

    void addPort(Member& member, PortList& portlist);

    void removePort(Member& member, PortList& portlist);

    void updateExportedPortsList();
 
  protected:
    RTC::Logger rtclog;

    ::RTC::RTObject_impl* m_rtobj;

    ::RTC::ExecutionContext_var m_ec;
 
    class Member
    {
    public:
      explicit Member(RTC::RTObject_ptr rtobj)
      //        : rtobj_(rtobj),
      //          profile_(rtobj->get_component_profile()),
      //          eclist_(rtobj->get_owned_contexts()),
      //          config_(rtobj->get_configuration())
      {
        rtobj_   = RTC::RTObject::_duplicate(rtobj);
        profile_ = rtobj->get_component_profile();
        eclist_  = rtobj->get_owned_contexts();
        config_  = rtobj->get_configuration();
      }
 
      virtual ~Member()
      {
        /*
        rtobj_.out();
        profile_.out();
        eclist_.out();
        config_.out();
        */
      }
 
      Member(const Member& x)
      //        : rtobj_(x.rtobj_),
      //          profile_(x.profile_),
      //          eclist_(x.eclist_),
      //          config_(x.config_)
      {
        rtobj_   = x.rtobj_;
        profile_ = x.profile_;
        eclist_  = x.eclist_;
        config_  = x.config_;
      }
 
      Member& operator=(const Member& x)
      {
        Member tmp(x);
        tmp.swap(*this);
        return *this;
      }
//
      void swap(Member& x)
      {
        RTC::RTObject_var rtobj(x.rtobj_);
        RTC::ComponentProfile_var profile(x.profile_);
        RTC::ExecutionContextList_var eclist(x.eclist_);
        SDOPackage::Configuration_var config(x.config_);
 
        x.rtobj_ = this->rtobj_;
        x.profile_ = this->profile_;
        x.eclist_ = this->eclist_;
        x.config_ = this->config_;
 
        this->rtobj_ = rtobj;
        this->profile_ = profile;
        this->eclist_ = eclist;
        this->config_ = config;
      }
 
      RTC::RTObject_var rtobj_;
      RTC::ComponentProfile_var profile_;
      RTC::ExecutionContextList_var eclist_;
      SDOPackage::Configuration_var config_;
    };

    std::vector<Member> m_rtcMembers;
    using MemIt = std::vector<Member>::iterator;

    PortList m_expPorts;

    static void print(const PortList& p)
    {
      for (auto & i : p)
        {
          std::cout << i << std::endl;
        }
    }
  };
} // namespace SDOPackage
 

namespace RTC
{
  class Manager;

  class PeriodicECSharedComposite
    : public RTObject_impl
  {
  public:
    explicit PeriodicECSharedComposite(Manager* manager);

    ~PeriodicECSharedComposite() override;

    ReturnCode_t onInitialize() override;
    ReturnCode_t onActivated(RTC::UniqueId exec_handle) override;
    void activateChildComp(const RTC::RTObject_ptr rtobj);
    ReturnCode_t onDeactivated(RTC::UniqueId exec_handle) override;
    void deactivateChildComp(const RTC::RTObject_ptr rtobj);

    ReturnCode_t onReset(RTC::UniqueId exec_handle) override;
    void resetChildComp(const RTC::RTObject_ptr rtobj);
    ReturnCode_t onFinalize() override;
 
    ReturnCode_t exit() override;
 
  protected:
    std::vector<std::string> m_members;

    OpenRTM::DataFlowComponent_var m_ref;
    SDOPackage::PeriodicECOrganization* m_org;
  };  // class PeriodicECOrganization
} // namespace RTC
 
 
extern "C"
{
  void PeriodicECSharedCompositeInit(RTC::Manager* manager);
}
 
#endif  // RTC_PERIODICECSHAREDCOMPOSITE_H