CorbaConsumer.h

[詳解]

// -*- C++ -*-
 
#ifndef RTC_CORBACONSUMER_H
#define RTC_CORBACONSUMER_H
 
#include <utility>
#include <iostream>
#ifdef ORB_IS_MICO
#include <CORBA.h>
#endif
#ifdef ORB_IS_OMNIORB
#include <omniORB4/CORBA.h>
#endif
#ifdef ORB_IS_ORBACUS
#include <OB/CORBA.h>
#endif
#ifdef ORB_IS_ORBIT2
#include <orbitcpp/orb-cpp/orbitcpp.h>
#endif
#ifdef ORB_IS_ORBIX
#include <CORBA.h>
#endif
#ifdef ORB_IS_TAO
#include <tao/corba.h>
#endif

namespace RTC
{
  class CorbaConsumerBase
  {
  public:
    CorbaConsumerBase() = default;

    CorbaConsumerBase(const CorbaConsumerBase& x)
#ifdef ORB_IS_ORBEXPRESS
      : m_objref(CORBA::Object::_duplicate(x.m_objref.in()))
#else
      : m_objref(CORBA::Object::_duplicate(x.m_objref))
#endif
    {
    }

    CorbaConsumerBase& operator=(const CorbaConsumerBase& x)
    {
      CorbaConsumerBase tmp(x);
      tmp.swap(*this);
      return *this;
    }

    void swap(CorbaConsumerBase& x)
    {
      CORBA::Object_var tmpref = x.m_objref;
      x.m_objref = this->m_objref;
      this->m_objref = tmpref;
    }

    virtual ~CorbaConsumerBase()
    {
      releaseObject();
    }

 
    virtual bool setObject(CORBA::Object_ptr obj)
    {
      if (CORBA::is_nil(obj))
        {
          return false;
        }
      m_objref = CORBA::Object::_duplicate(obj);
      return true;
    }

    virtual CORBA::Object_ptr getObject()
    {
      return m_objref;
    }

    virtual void releaseObject()
    {
      m_objref = CORBA::Object::_nil();
    }
 
  protected:
    CORBA::Object_var m_objref;
  };

  template <class ObjectType,
            typename ObjectTypePtr = typename ObjectType::_ptr_type,
            typename ObjectTypeVar = typename ObjectType::_var_type>
  class CorbaConsumer
    : public CorbaConsumerBase
  {
  public:
    CorbaConsumer();

    CorbaConsumer(const CorbaConsumer& x)
      : CorbaConsumerBase()
#ifdef ORB_IS_ORBEXPRESS
      , m_var(ObjectType::_duplicate(x.m_var.in()))
#else
      , m_var(ObjectType::_duplicate(x.m_var))
#endif
    {
    }

    CorbaConsumer& operator=(const CorbaConsumer& x)
    {
      CorbaConsumer tmp(x);
      tmp.swap(*this);
      return *this;
    }
 
    void swap(CorbaConsumer& x)
    {
      CorbaConsumerBase::swap(x);
      ObjectTypeVar tmpref = x.m_var;
      x.m_var = this->m_var;
      this->m_var = tmpref;
 
    }

    ~CorbaConsumer() override
    {
      releaseObject();
    }

    bool setObject(CORBA::Object_ptr obj) override
    {
      if (!CorbaConsumerBase::setObject(obj))
        {
          releaseObject();
          return false;  // object is nil
        }
 
      ObjectTypeVar var = ObjectType::_narrow(m_objref);
 
      if (CORBA::is_nil(var))
        {
          releaseObject();
          return false;
        }
 
      m_var = var;
      return true;
    }

    inline ObjectTypePtr _ptr()
    {
      return m_var.inout();
    }

    inline ObjectTypePtr operator->()
    {
      return m_var.inout();
    }

    void releaseObject() override
    {
      CorbaConsumerBase::releaseObject();
      m_var = ObjectType::_nil();
    }
 
  protected:
    ObjectTypeVar m_var;
  };
 
  // No inline for gcc warning, too big
  template <class T, class U, class V>
  CorbaConsumer<T, U, V>::CorbaConsumer() = default;
} // namespace RTC
#endif  // RTC_CORBACONSUMER_H