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 * Object_Reference_Sequence_Element_T.h,v 1.3 2006/06/20 05:51:41 jwillemsen Exp 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 *element_; 00085 } 00086 00087 inline operator const_value_type() const 00088 { 00089 return *element_; 00090 } 00091 00092 inline object_reference_type *in (void) const { 00093 return *this->element_; 00094 } 00095 00096 inline value_type operator->() 00097 { 00098 return *this->element_; 00099 } 00100 00101 inline value_type operator->() const 00102 { 00103 return *this->element_; 00104 } 00105 00106 void swap(object_reference_sequence_element & rhs) 00107 { 00108 std::swap(this->element_, rhs.element_); 00109 std::swap(this->release_, rhs.release_); 00110 } 00111 00112 inline CORBA::Boolean release() const 00113 { 00114 return this->release_; 00115 } 00116 00117 private: 00118 // This function is not implemented 00119 object_reference_sequence_element(); 00120 00121 private: 00122 value_type * element_; 00123 CORBA::Boolean release_; 00124 }; 00125 00126 } // namespace details 00127 } // namespace CORBA 00128 00129 TAO_END_VERSIONED_NAMESPACE_DECL 00130 00131 #endif // guard_object_reference_sequence_element_hpp