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