00001 // -*- c++ -*- 00002 // = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 00003 00004 // O S C L _ E X C L U S I V E _ P T R 00005 00006 // = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 00007 00023 #ifndef OSCL_EXCLUSIVE_PTR_H_INCLUDED 00024 #define OSCL_EXCLUSIVE_PTR_H_INCLUDED 00025 00026 #ifndef OSCL_DEFALLOC_H_INCLUDED 00027 #include "oscl_defalloc.h" 00028 #endif 00029 00030 #ifndef OSCL_BASE_H_INCLUDED 00031 #include "oscl_base.h" 00032 #endif 00033 00051 template<class T> class OsclExclusivePtr 00052 { 00053 protected: 00054 T* _Ptr; 00055 00056 public: 00057 00062 explicit OsclExclusivePtr(T* inPtr = 0) : _Ptr(inPtr) {}; 00063 00071 OsclExclusivePtr(OsclExclusivePtr<T>& _Y): _Ptr(_Y.release()) {}; 00072 00073 00087 OsclExclusivePtr<T>& operator=(OsclExclusivePtr<T>& _Y) 00088 { 00089 if (this != &_Y) 00090 { 00091 if (_Ptr != _Y.get()) 00092 { 00093 delete _Ptr; 00094 } 00095 _Ptr = _Y.release(); 00096 } 00097 return (*this); 00098 } 00099 00105 virtual ~OsclExclusivePtr() 00106 { 00107 if (_Ptr) 00108 delete _Ptr; 00109 } 00110 00118 T& operator*() const 00119 { 00120 return (*get()); 00121 } 00122 00130 T *operator->() const 00131 { 00132 return (get()); 00133 } 00134 00139 T *get() const 00140 { 00141 return (_Ptr); 00142 } 00143 00149 T *release() 00150 { 00151 T *tmp = _Ptr; 00152 _Ptr = NULL; 00153 return (tmp); 00154 } 00155 00162 bool set(T* ptr) 00163 { 00164 if ((_Ptr == NULL)) 00165 { 00166 _Ptr = ptr; 00167 return true; 00168 } 00169 return false; 00170 } 00171 00172 }; 00173 00190 template<class T> class OsclExclusiveArrayPtr 00191 { 00192 protected: 00193 T* _Ptr; 00194 00195 public: 00196 00201 explicit OsclExclusiveArrayPtr(T* inPtr = 0) : _Ptr(inPtr) {}; 00202 00210 OsclExclusiveArrayPtr(OsclExclusiveArrayPtr<T>& _Y): _Ptr(_Y.release()) {}; 00211 00212 00226 OsclExclusiveArrayPtr<T>& operator=(OsclExclusiveArrayPtr<T>& _Y) 00227 { 00228 if (this != &_Y) 00229 { 00230 if (_Ptr != _Y.get()) 00231 { 00232 delete [] _Ptr; 00233 } 00234 _Ptr = _Y.release(); 00235 } 00236 return (*this); 00237 } 00238 00244 virtual ~OsclExclusiveArrayPtr() 00245 { 00246 if (_Ptr) 00247 delete [] _Ptr; 00248 } 00249 00257 T& operator*() const 00258 { 00259 return (*get()); 00260 } 00261 00269 T *operator->() const 00270 { 00271 return (get()); 00272 } 00273 00278 T *get() const 00279 { 00280 return (_Ptr); 00281 } 00282 00288 T *release() 00289 { 00290 T *tmp = _Ptr; 00291 _Ptr = NULL; 00292 return (tmp); 00293 } 00294 00301 bool set(T* ptr) 00302 { 00303 if ((_Ptr == NULL)) 00304 { 00305 _Ptr = ptr; 00306 return true; 00307 } 00308 return false; 00309 } 00310 00311 }; 00312 00313 00330 template<class T, class Alloc> class OsclExclusivePtrA 00331 { 00332 protected: 00333 T* _Ptr; 00334 00335 public: 00336 00341 explicit OsclExclusivePtrA(T* inPtr = 0) : _Ptr(inPtr) {}; 00342 00350 OsclExclusivePtrA(OsclExclusivePtrA<T, Alloc>& _Y): _Ptr(_Y.release()) {}; 00351 00352 00366 OsclExclusivePtrA<T, Alloc>& operator=(OsclExclusivePtrA<T, Alloc>& _Y) 00367 { 00368 if (this != &_Y) 00369 { 00370 if (_Ptr != _Y.get()) 00371 { 00372 defAlloc.deallocate(_Ptr); 00373 } 00374 _Ptr = _Y.release(); 00375 } 00376 return (*this); 00377 } 00378 00384 virtual ~OsclExclusivePtrA() 00385 { 00386 defAlloc.deallocate(_Ptr); 00387 } 00388 00396 T& operator*() const 00397 { 00398 return (*get()); 00399 } 00400 00408 T *operator->() const 00409 { 00410 return (get()); 00411 } 00412 00417 T *get() const 00418 { 00419 return (_Ptr); 00420 } 00421 00427 T *release() 00428 { 00429 T *tmp = _Ptr; 00430 _Ptr = NULL; 00431 return (tmp); 00432 } 00433 00440 bool set(T* ptr) 00441 { 00442 if ((_Ptr == NULL)) 00443 { 00444 _Ptr = ptr; 00445 return true; 00446 } 00447 return false; 00448 } 00449 00450 private: 00451 Oscl_TAlloc<T, Alloc> defAlloc; 00452 }; 00453 00457 #endif //OSCL_EXCLUSIVE_PTR_H_INCLUDED 00458