00001 #ifndef guard_string_sequence_element_hpp 00002 #define guard_string_sequence_element_hpp 00003 /** 00004 * @file 00005 * 00006 * @brief Implement the type returned by operator[] in string 00007 * sequences. 00008 * 00009 * String_Sequence_Element_T.h,v 1.3 2006/06/20 06:04:32 jwillemsen Exp 00010 * 00011 * @author Carlos O'Ryan 00012 */ 00013 00014 #include "tao/Basic_Types.h" 00015 00016 TAO_BEGIN_VERSIONED_NAMESPACE_DECL 00017 00018 namespace TAO 00019 { 00020 namespace details 00021 { 00022 00023 template<typename traits> 00024 class string_sequence_element 00025 { 00026 public: 00027 typedef typename traits::char_type character_type; 00028 typedef character_type * value_type; 00029 typedef character_type const * const_value_type; 00030 typedef typename traits::string_var string_var; 00031 typedef typename traits::string_mgr string_mgr; 00032 00033 private: 00034 inline string_sequence_element<traits> & pseudo_copy_swap( 00035 string_var & rhs) 00036 { 00037 if (release()) 00038 { 00039 traits::release(*element_); 00040 } 00041 *element_ = rhs._retn(); 00042 return *this; 00043 } 00044 00045 public: 00046 string_sequence_element( 00047 value_type & e, CORBA::Boolean release) 00048 : element_(&e) 00049 , release_(release) 00050 { 00051 } 00052 00053 string_sequence_element( 00054 string_sequence_element const & rhs) 00055 : element_(rhs.element_) 00056 , release_(rhs.release_) 00057 { 00058 } 00059 00060 ~string_sequence_element() 00061 { 00062 } 00063 00064 string_sequence_element & operator=(const_value_type rhs) 00065 { 00066 string_var tmp(rhs); 00067 return pseudo_copy_swap(tmp); 00068 } 00069 00070 string_sequence_element & operator=(value_type rhs) 00071 { 00072 string_var tmp(rhs); 00073 return pseudo_copy_swap(tmp); 00074 } 00075 00076 string_sequence_element & operator=(string_sequence_element const & rhs) 00077 { 00078 string_var tmp(static_cast<const_value_type>(rhs)); 00079 return pseudo_copy_swap(tmp); 00080 } 00081 00082 string_sequence_element & operator=(string_var const & rhs) 00083 { 00084 string_var tmp(rhs); 00085 return pseudo_copy_swap(tmp); 00086 } 00087 00088 string_sequence_element & operator=(string_mgr const & rhs) 00089 { 00090 string_var tmp(rhs.in()); 00091 return pseudo_copy_swap(tmp); 00092 } 00093 00094 inline operator const_value_type() const 00095 { 00096 return *this->element_; 00097 } 00098 00099 inline const character_type *in (void) const { 00100 return *this->element_; 00101 } 00102 00103 void swap(string_sequence_element & rhs) 00104 { 00105 std::swap(element_, rhs.element_); 00106 std::swap(release_, rhs.release_); 00107 } 00108 00109 CORBA::Boolean release() const 00110 { 00111 return this->release_; 00112 } 00113 00114 private: 00115 // This function is not implemented 00116 string_sequence_element(); 00117 00118 private: 00119 value_type * element_; 00120 CORBA::Boolean release_; 00121 }; 00122 00123 } // namespace details 00124 } // namespace CORBA 00125 00126 TAO_END_VERSIONED_NAMESPACE_DECL 00127 00128 #endif // guard_string_sequence_element_hpp