Main Page   Modules   Class Hierarchy   Data Structures   File List   Data Fields   Globals   Related Pages  

oscl_exclusive_ptr.h

Go to the documentation of this file.
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 

OSCL API
Posting Version: CORE_8.000.1.1_RC4