PeriodicECSharedComposite.h

Go to the documentation of this file.

// -*- 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>

#ifdef WIN32
#pragma warning( disable : 4290 )
#endif

namespace SDOPackage
{
  class PeriodicECOrganization
    : public Organization_impl
  {
    typedef std::vector<std::string> PortList;

  public:
    PeriodicECOrganization(::RTC::RTObject_impl* rtobj);
    virtual ~PeriodicECOrganization(void);

    virtual ::CORBA::Boolean add_members(const SDOList& sdo_list)
      throw (::CORBA::SystemException,
             InvalidParameter, NotAvailable, InternalError);

    virtual ::CORBA::Boolean set_members(const SDOList& sdos)
      throw (::CORBA::SystemException,
             InvalidParameter, NotAvailable, InternalError);

    virtual ::CORBA::Boolean remove_member(const char* id)
      throw (::CORBA::SystemException,
             InvalidParameter, NotAvailable, InternalError);

    void removeAllMembers(void);
    void updateDelegatedPorts(void);

  protected:
    class Member;
    bool sdoToDFC(const SDO_ptr sdo, ::OpenRTM::DataFlowComponent_ptr& dfc);

    void stopOwnedEC(Member& member);

    void startOwnedEC(Member& member);

    void addOrganizationToTarget(Member& member);

    void removeOrganizationFromTarget(Member& member);

    void addParticipantToEC(Member& member);

    void removeParticipantFromEC(Member& member);

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

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

    void updateExportedPortsList(void);

  protected:
    RTC::Logger rtclog;

    ::RTC::RTObject_impl* m_rtobj;

    ::RTC::ExecutionContext_var m_ec;

    class Member
    {
    public:
      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(void)
      {
        /*
        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)
      {
//        std::cout << "####################op=" << std::endl;
        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;
    typedef std::vector<Member>::iterator MemIt;

    PortList m_expPorts;
    
    void print(PortList p)
    {
      for (int i(0), len(p.size()); i < len; ++i)
        {
          std::cout << p[i] << std::endl;
        }
    }
  };
};


namespace RTC
{
  class Manager;

  class PeriodicECSharedComposite
    : public RTObject_impl
  {
  public:
    PeriodicECSharedComposite(Manager* manager);
    
    virtual ~PeriodicECSharedComposite(void);
    
    virtual ReturnCode_t onInitialize(void);
    virtual ReturnCode_t onActivated(RTC::UniqueId exec_handle);
    virtual ReturnCode_t onDeactivated(RTC::UniqueId exec_handle);

    virtual ReturnCode_t onReset(RTC::UniqueId exec_handle);
    virtual ReturnCode_t onFinalize(void);
    
  protected:
    std::vector<std::string> m_members;

    OpenRTM::DataFlowComponent_var m_ref;
//    PeriodicExecutionContext* m_pec;
//    ExecutionContextService_var m_ecref;
    SDOPackage::PeriodicECOrganization* m_org;
  };  // class PeriodicECOrganization
}; // namespace RTC

#ifdef WIN32
#pragma warning( default : 4290 )
#endif


extern "C"
{
  DLL_EXPORT void PeriodicECSharedCompositeInit(RTC::Manager* manager);
};

#endif // RTC_PERIODICECSHAREDCOMPOSITE_H