TAO/tao/Object_Reference_Sequence_Element_T.h

   1 #ifndef guard_object_reference_sequence_element_hpp
   2 #define guard_object_reference_sequence_element_hpp
   3 /**
   4  * @file
   5  *
   6  * @brief Implement the type returned by operator[] in object_reference
   7  * sequences.
   8  *
   9  * @author Carlos O'Ryan
  10  */
  11 #include "tao/Basic_Types.h"
  12
  13 #include <algorithm>
  14
  15 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  16
  17 namespace TAO
  18 {
  19 namespace details
  20 {
  21 template<typename obj_ref_traits>
  22 class object_reference_sequence_element
  23 {
  24 public:
  25   typedef typename obj_ref_traits::object_type object_reference_type;
  26   typedef object_reference_type * value_type;
  27   typedef object_reference_type const * const_value_type;
  28   typedef typename obj_ref_traits::object_type_var object_reference_var;
  29
  30 private:
  31   inline object_reference_sequence_element<obj_ref_traits> & pseudo_copy_swap(
  32       object_reference_var & rhs)
  33   {
  34     if (release())
  35     {
  36       obj_ref_traits::release(*element_);
  37     }
  38     *element_ = rhs._retn();
  39     return *this;
  40   }
  41
  42 public:
  43   object_reference_sequence_element(
  44       value_type & e, CORBA::Boolean release)
  45     : element_(&e)
  46     , release_(release)
  47   {
  48   }
  49
  50   object_reference_sequence_element(
  51       object_reference_sequence_element const & rhs)
  52     : element_(rhs.element_)
  53     , release_(rhs.release_)
  54   {
  55   }
  56
  57   ~object_reference_sequence_element()
  58   {
  59   }
  60
  61   object_reference_sequence_element & operator=(
  62       object_reference_var const & rhs)
  63   {
  64     object_reference_var tmp(rhs);
  65     return pseudo_copy_swap(tmp);
  66   }
  67
  68   object_reference_sequence_element & operator=(
  69       object_reference_sequence_element const & rhs)
  70   {
  71     object_reference_var tmp(obj_ref_traits::duplicate(*rhs.element_));
  72     return pseudo_copy_swap(tmp);
  73   }
  74
  75   object_reference_sequence_element & operator=(value_type rhs)
  76   {
  77     object_reference_var tmp(rhs);
  78     return pseudo_copy_swap(tmp);
  79   }
  80
  81   inline operator value_type()
  82   {
  83     return *this->element_;
  84   }
  85
  86   inline operator const_value_type() const
  87   {
  88     return *this->element_;
  89   }
  90
  91   inline object_reference_type *in () const {
  92     return *this->element_;
  93   }
  94
  95   inline object_reference_type *&inout () const {
  96     return *this->element_;
  97   }
  98
  99   inline value_type operator->()
 100   {
 101     return *this->element_;
 102   }
 103
 104   inline value_type operator->() const
 105   {
 106     return *this->element_;
 107   }
 108
 109   void swap(object_reference_sequence_element & rhs)
 110   {
 111     std::swap(this->element_, rhs.element_);
 112     std::swap(this->release_, rhs.release_);
 113   }
 114
 115   inline CORBA::Boolean release() const
 116   {
 117     return this->release_;
 118   }
 119
 120 private:
 121   // This function is not implemented
 122   object_reference_sequence_element();
 123
 124 private:
 125   value_type * element_;
 126   CORBA::Boolean release_;
 127 };
 128 } // namespace details
 129 } // namespace CORBA
 130
 131 TAO_END_VERSIONED_NAMESPACE_DECL
 132
 133 #endif // guard_object_reference_sequence_element_hpp