TAO/tao/String_Sequence_Element_T.h

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