it_cal/auto_ptr.h

00001 #ifndef _IT_CAL_AUTO_PTR_H_
00002 #define _IT_CAL_AUTO_PTR_H_
00003 
00004 // ******************************************************************
00005 //
00006 //
00007 //        Copyright (c) 1993-2004 IONA Technologies PLC.
00008 //                       All Rights Reserved.
00009 //
00010 //
00011 // ******************************************************************
00012 
00013 
00014 
00015 //
00016 // REVISIT: all this should probably move to dsa/auto_ptr
00017 //
00018 
00019 #include <it_cal/cal.h>
00020 
00021 // for ptrdiff_t
00022 //
00023 #include <stddef.h>
00024 
00025 
00026 #if IT_HAS_STANDARD_HEADERS && IT_HAS_AUTO_PTR
00027 
00028 #include <memory>
00029 
00030 #if IT_HAS_NAMESPACE_STD
00031 
00032 #define IT_AutoPtr std::auto_ptr
00033 
00034 #else  
00035 
00036 #define IT_AutoPtr auto_ptr
00037 
00038 #endif 
00039 
00040 #else  
00041 
00048 template<class T>
00049 class IT_AutoPtr
00050 {
00051   public:
00052 
00058     IT_EXPLICIT
00059     IT_AutoPtr(
00060         T* ptr = 0
00061     ) IT_THROW_DECL(()) :
00062         m_ptr(ptr)
00063     {}
00064     
00070     IT_AutoPtr(
00071         const IT_AutoPtr<T>& other
00072     )  IT_THROW_DECL(()) :
00073         m_ptr(
00074             (IT_CONST_CAST(IT_AutoPtr<T>&, other)).release()
00075         )
00076     {}
00077 
00081     ~IT_AutoPtr() IT_THROW_DECL(())
00082     {
00083         delete m_ptr;
00084     }
00085     
00092     IT_AutoPtr<T>&
00093     operator=(
00094         const IT_AutoPtr<T>& rhs
00095     )  IT_THROW_DECL(())
00096     {
00097         reset((IT_CONST_CAST(IT_AutoPtr<T>&, rhs)).release());
00098         return *this;
00099     }
00100     
00106     T&
00107     operator*() const IT_THROW_DECL(())
00108     {
00109         return *m_ptr;
00110     }
00111     
00117     T*
00118     operator->() const IT_THROW_DECL(())
00119     {
00120         return m_ptr;
00121     }
00122 
00128     T*
00129     get() const IT_THROW_DECL(())
00130     {
00131         return m_ptr;
00132     }
00133 
00141     T*
00142     release() IT_THROW_DECL(())
00143     {
00144         T* tmp = m_ptr;
00145         m_ptr = 0;
00146         return tmp;
00147     }
00148 
00155     void
00156     reset(
00157         T* ptr = 0
00158     )  IT_THROW_DECL(())
00159     {
00160         delete m_ptr;
00161         m_ptr = ptr;
00162     }
00163  
00164   private:
00165     
00166     T* m_ptr;
00167 };
00168 
00169 
00170 #endif 
00171 
00172 
00173 
00174 template<class T>
00175 class IT_AutoArrayPtr
00176 {
00177   public:
00178 
00179     IT_EXPLICIT
00180     IT_AutoArrayPtr(
00181         T* ptr = 0
00182     ) IT_THROW_DECL(()) :
00183         m_ptr(ptr)
00184     {}
00185     
00186     IT_AutoArrayPtr(
00187         const IT_AutoArrayPtr<T>& other
00188     )  IT_THROW_DECL(()) :
00189         m_ptr(
00190             (IT_CONST_CAST(IT_AutoArrayPtr<T>&, other)).release()
00191         )
00192     {}
00193 
00194     ~IT_AutoArrayPtr() IT_THROW_DECL(())
00195     {
00196         delete [] m_ptr;
00197     }
00198     
00199     IT_AutoArrayPtr<T>&
00200     operator=(
00201         const IT_AutoArrayPtr<T>& rhs
00202     )  IT_THROW_DECL(())
00203     {
00204         reset((IT_CONST_CAST(IT_AutoArrayPtr<T>&, rhs)).release());
00205         return *this;
00206     }
00207 
00208     T&
00209     operator[](
00210         ptrdiff_t i
00211     ) const IT_THROW_DECL(())
00212     {
00213         return m_ptr[i];
00214     }
00215     
00216     T&
00217     operator*() const IT_THROW_DECL(())
00218     {
00219         return *m_ptr;
00220     }
00221 
00222     T*
00223     get() const IT_THROW_DECL(())
00224     {
00225         return m_ptr;
00226     }
00227 
00228     T*
00229     release() IT_THROW_DECL(())
00230     {
00231         T* tmp = m_ptr;
00232         m_ptr = 0;
00233         return tmp;
00234     }
00235 
00236     void
00237     reset(
00238         T* ptr = 0
00239     )  IT_THROW_DECL(())
00240     {
00241         delete[] m_ptr;
00242         m_ptr = ptr;
00243     }
00244  
00245   private:
00246     
00247     T* m_ptr;
00248 };
00249 
00250 
00251 template<class T, class R>
00252 class IT_ExtendedAutoPtr
00253 {
00254     typedef ::IT_ExtendedAutoPtr<T,R>& _ref_type;
00255   public:
00256 
00257     IT_EXPLICIT
00258     IT_ExtendedAutoPtr(
00259         T* ptr = 0
00260     ) IT_THROW_DECL(()) :
00261         m_ptr(ptr)
00262     {}
00263     
00264     IT_ExtendedAutoPtr(
00265         const IT_ExtendedAutoPtr<T,R>& other
00266     )  IT_THROW_DECL(()) :
00267         m_ptr(
00268             (IT_CONST_CAST(_ref_type, other)).release()
00269         )
00270     {}
00271 
00272     ~IT_ExtendedAutoPtr() IT_THROW_DECL(())
00273     {
00274         R::release(m_ptr);
00275     }
00276     
00277     IT_ExtendedAutoPtr<T,R>&
00278     operator=(
00279         const IT_ExtendedAutoPtr<T,R>& rhs
00280     )  IT_THROW_DECL(())
00281     {
00282         reset((IT_CONST_CAST(_ref_type, rhs)).release());
00283         return *this;
00284     }
00285     
00286     T&
00287     operator*() const IT_THROW_DECL(())
00288     {
00289         return *m_ptr;
00290     }
00291     
00292     T*
00293     get() const IT_THROW_DECL(())
00294     {
00295         return m_ptr;
00296     }
00297 
00298     T*
00299     release() IT_THROW_DECL(())
00300     {
00301         T* tmp = m_ptr;
00302         m_ptr = 0;
00303         return tmp;
00304     }
00305 
00306     void
00307     reset(
00308         T* ptr = 0
00309     )  IT_THROW_DECL(())
00310     {
00311         R::release(m_ptr);
00312         m_ptr = ptr;
00313     }
00314  
00315   private:
00316     
00317     T* m_ptr;
00318 };
00319 
00320 
00321 
00322 #endif  
00323 
00324 

Generated on Thu Sep 7 11:39:38 2006 for Artix by  doxygen 1.4.7