TAO/tao/PortableServer/Servant_var.inl

   1 // -*- C++ -*-
   2 #include <algorithm>
   3
   4 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
   5
   6 template <class T>
   7 ACE_INLINE void
   8 PortableServer::Servant_var<T>::swap (Servant_var<T> & rhs) /* noexcept */
   9 {
  10   std::swap (this->ptr_, rhs.ptr_);
  11 }
  12
  13 template <class T>
  14 ACE_INLINE
  15 PortableServer::Servant_var<T>::Servant_var (T * p)
  16   : ptr_ (p)
  17 {
  18 }
  19
  20 // If _add_ref throws, this object will not be completely constructed
  21 // so the destructor will not be called.
  22 template <class T>
  23 ACE_INLINE
  24 PortableServer::Servant_var<T>::Servant_var (Servant_var<T> const & rhs)
  25   : ptr_ (Servant_var<T>::_duplicate(rhs.ptr_))
  26 {
  27 }
  28
  29 template <class T>
  30 ACE_INLINE PortableServer::Servant_var<T> &
  31 PortableServer::Servant_var<T>::operator= (Servant_var<T> const & rhs)
  32 {
  33   PortableServer::Servant_var<T> tmp (rhs);
  34   this->swap (tmp);
  35   return *this;
  36 }
  37
  38 template <class T>
  39 ACE_INLINE typename PortableServer::Servant_var<T> &
  40 PortableServer::Servant_var<T>::operator= (T * p)
  41 {
  42   if (this->ptr_ != p)
  43     {
  44       // This constructor doesn't increase the reference count, nor is
  45       // it a copy constructor, so we must check for self-assignment.
  46       // Otherwise the reference count would be prematurely
  47       // decremented upon exiting this scope.
  48       PortableServer::Servant_var<T> tmp (p);
  49       this->swap (tmp);
  50     }
  51
  52   return *this;
  53 }
  54
  55 template <class T>
  56 ACE_INLINE T *
  57 PortableServer::Servant_var<T>::operator->() const
  58 {
  59   return this->ptr_;
  60 }
  61
  62 template <class T>
  63 ACE_INLINE T const &
  64 PortableServer::Servant_var<T>::operator*() const
  65 {
  66   return *this->ptr_;
  67 }
  68
  69 template <class T>
  70 ACE_INLINE T &
  71 PortableServer::Servant_var<T>::operator*()
  72 {
  73   return *this->ptr_;
  74 }
  75
  76 template <class T>
  77 ACE_INLINE PortableServer::Servant_var<T>::operator void const * () const
  78 {
  79   return this->ptr_;
  80 }
  81
  82 template <class T>
  83 ACE_INLINE T *
  84 PortableServer::Servant_var<T>::in () const
  85 {
  86   return this->ptr_;
  87 }
  88
  89 template <class T>
  90 ACE_INLINE T *&
  91 PortableServer::Servant_var<T>::inout ()
  92 {
  93   return this->ptr_;
  94 }
  95
  96 template <class T>
  97 ACE_INLINE T *&
  98 PortableServer::Servant_var<T>::out ()
  99 {
 100   PortableServer::Servant_var<T> tmp;
 101   this->swap (tmp);
 102   return this->ptr_;
 103 }
 104
 105 template <class T>
 106 ACE_INLINE T *
 107 PortableServer::Servant_var<T>::_retn ()
 108 {
 109   T * const rval = ptr_;
 110   this->ptr_ = 0;
 111   return rval;
 112 }
 113
 114 template <class X, class Y>
 115 ACE_INLINE bool
 116 operator== (typename PortableServer::Servant_var<X> const & x,
 117             typename PortableServer::Servant_var<Y> const & y)
 118 {
 119   return x.in () == y.in ();
 120 }
 121
 122 template <class X, class Y>
 123 ACE_INLINE bool
 124 operator!= (typename PortableServer::Servant_var<X> const & x,
 125             typename PortableServer::Servant_var<Y> const & y)
 126 {
 127   return x.in () != y.in ();
 128 }
 129
 130 TAO_END_VERSIONED_NAMESPACE_DECL