CorbaConsumer.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_CORBACONSUMER_H
#define RTC_CORBACONSUMER_H

#include <iostream>
#ifdef ORB_IS_MICO
#include <CORBA.h>
#endif
#ifdef ORB_IS_OMNIORB
#ifdef WIN32
#pragma warning( disable : 4267 )
#pragma warning( disable : 4290 )
#pragma warning( disable : 4311 )
#pragma warning( disable : 4312 )
#endif // WIN32
#include <omniORB4/CORBA.h>
#ifdef WIN32
#pragma warning( default : 4267 )
#pragma warning( default : 4290 )
#pragma warning( default : 4311 )
#pragma warning( default : 4312 )
#endif // WIN32
#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(){};
    
    CorbaConsumerBase(const CorbaConsumerBase& x)
      : m_objref(CORBA::Object::_duplicate(x.m_objref))
    {
    }
    
    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(void)
    {
      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)
      : m_var(ObjectType::_duplicate(x.m_var))
    {
    }
    
    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;
      
    }
    
    virtual ~CorbaConsumer(void)
    {
      releaseObject();
    };
    
    virtual bool setObject(CORBA::Object_ptr obj)
    {
      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();
    }
    
    virtual void releaseObject()
    {
      CorbaConsumerBase::releaseObject();
      m_var = ObjectType::_nil();
    }
    
  protected:
    ObjectTypeVar m_var;
  };
}; // namespace RTC
#endif // RTC_CORBACONSUMER_H