vsmartptr.h
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #ifndef __BARRY_VSMARTPTR_H__
00023 #define __BARRY_VSMARTPTR_H__
00024
00025 namespace Barry {
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035 template <class T, class FT, void (*FreeFunc)(FT *pt)>
00036 class vSmartPtr
00037 {
00038 mutable T *m_pt;
00039
00040 public:
00041 vSmartPtr() : m_pt(0) {}
00042 vSmartPtr(T *pt) : m_pt(pt) {}
00043 vSmartPtr(const vSmartPtr &sp) : m_pt(sp.m_pt)
00044 {
00045 sp.m_pt = 0;
00046 }
00047 ~vSmartPtr()
00048 {
00049 reset();
00050 }
00051
00052 vSmartPtr& operator=(T *pt)
00053 {
00054 reset(pt);
00055 return *this;
00056 }
00057
00058 vSmartPtr& operator=(const vSmartPtr &sp)
00059 {
00060 reset(sp.release());
00061 return *this;
00062 }
00063
00064
00065 T* Extract()
00066 {
00067 return this->release();
00068 }
00069
00070 T* Get()
00071 {
00072 return this->get();
00073 }
00074
00075
00076 T* get()
00077 {
00078 return m_pt;
00079 }
00080
00081 T* release()
00082 {
00083 T *rp = m_pt;
00084 m_pt = 0;
00085 return rp;
00086 }
00087
00088 void reset(T *new_obj = 0)
00089 {
00090 if( m_pt )
00091 FreeFunc(m_pt);
00092 m_pt = new_obj;
00093 }
00094 };
00095
00096
00097
00098
00099
00100
00101
00102
00103 template <class T, class FreeFuncPtrT>
00104 class vLateSmartPtr
00105 {
00106 mutable T *m_pt;
00107 FreeFuncPtrT m_FreeFuncPtr;
00108
00109 public:
00110 explicit vLateSmartPtr(FreeFuncPtrT freefunc = 0)
00111 : m_pt(0)
00112 , m_FreeFuncPtr(freefunc)
00113 {
00114 }
00115
00116 vLateSmartPtr(T *pt, FreeFuncPtrT freefunc = 0)
00117 : m_pt(pt)
00118 , m_FreeFuncPtr(freefunc)
00119 {
00120 }
00121
00122 vLateSmartPtr(const vLateSmartPtr &sp)
00123 : m_pt(sp.m_pt)
00124 , m_FreeFuncPtr(sp.m_FreeFuncPtr)
00125 {
00126 sp.m_pt = 0;
00127 }
00128
00129 ~vLateSmartPtr()
00130 {
00131 reset();
00132 }
00133
00134 void SetFreeFunc(FreeFuncPtrT freefunc)
00135 {
00136 m_FreeFuncPtr = freefunc;
00137 }
00138
00139 vLateSmartPtr& operator=(T *pt)
00140 {
00141 reset(pt);
00142 return *this;
00143 }
00144
00145 vLateSmartPtr& operator=(const vLateSmartPtr &sp)
00146 {
00147 reset(sp.release());
00148 m_FreeFuncPtr = sp.m_FreeFuncPtr;
00149 return *this;
00150 }
00151
00152
00153 T* Extract()
00154 {
00155 return this->release();
00156 }
00157
00158 T* Get()
00159 {
00160 return this->get();
00161 }
00162
00163
00164 T* get()
00165 {
00166 return m_pt;
00167 }
00168
00169 T* release()
00170 {
00171 T *rp = m_pt;
00172 m_pt = 0;
00173 return rp;
00174 }
00175
00176 void reset(T *new_obj = 0)
00177 {
00178
00179
00180 if( m_pt )
00181 (*m_FreeFuncPtr)(m_pt);
00182 m_pt = new_obj;
00183 }
00184 };
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196 }
00197
00198 #endif
00199