UCommon
/usr/src/RPM/BUILD/ucommon-6.3.3/inc/commoncpp/pointer.h
Go to the documentation of this file.
00001 // Copyright (C) 2001-2005 Open Source Telecom Corporation.
00002 // Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
00003 // Copyright (C) 2015 Cherokees of Idaho.
00004 //
00005 // This program is free software; you can redistribute it and/or modify
00006 // it under the terms of the GNU General Public License as published by
00007 // the Free Software Foundation; either version 2 of the License, or
00008 // (at your option) any later version.
00009 //
00010 // This program is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 // GNU General Public License for more details.
00014 //
00015 // You should have received a copy of the GNU Lesser General Public License
00016 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
00017 //
00018 // As a special exception to the GNU General Public License, permission is
00019 // granted for additional uses of the text contained in its release
00020 // of Common C++.
00021 //
00022 // The exception is that, if you link the Common C++ library with other
00023 // files to produce an executable, this does not by itself cause the
00024 // resulting executable to be covered by the GNU General Public License.
00025 // Your use of that executable is in no way restricted on account of
00026 // linking the Common C++ library code into it.
00027 //
00028 // This exception does not however invalidate any other reasons why
00029 // the executable file might be covered by the GNU General Public License.
00030 //
00031 // This exception applies only to the code released under the
00032 // name Common C++.  If you copy code from other releases into a copy of
00033 // Common C++, as the General Public License permits, the exception does
00034 // not apply to the code that you add in this way.  To avoid misleading
00035 // anyone as to the status of such modified files, you must delete
00036 // this exception notice from them.
00037 //
00038 // If you write modifications of your own for Common C++, it is your choice
00039 // whether to permit this exception to apply to your modifications.
00040 // If you do not wish that, delete this exception notice.
00041 
00047 #ifndef COMMONCPP_POINTER_H_
00048 #define COMMONCPP_POINTER_H_
00049 
00050 #ifndef COMMONCPP_CONFIG_H_
00051 #include <commoncpp/config.h>
00052 #endif
00053 
00054 namespace ost {
00055 
00062 template <class T>
00063 class Pointer
00064 {
00065 protected:
00066     unsigned *ptrCount;
00067     T *ptrObject;
00068 
00069     inline void ptrDetach(void) {
00070         if(ptrCount && --(*ptrCount)==0) {
00071             delete ptrObject;
00072             delete ptrCount;
00073         }
00074         ptrObject = NULL;
00075         ptrCount = NULL;
00076     }
00077 
00078 public:
00079     inline explicit Pointer(T* ptr = NULL) : ptrObject(ptr) {
00080         ptrCount = new unsigned;
00081         *ptrCount = 1;
00082     }
00083 
00084     inline Pointer(const Pointer<T> &ref) {
00085         ptrObject = ref.ptrObject;
00086         ptrCount = ref.ptrCount;
00087         ++(*ptrCount);
00088     }
00089 
00090     inline virtual ~Pointer()
00091         {ptrDetach();}
00092 
00093 
00094     inline Pointer& operator=(const Pointer<T> &ref) {
00095         if(this != &ref) {
00096             ptrDetach();
00097             ptrObject = ref.ptrObject;
00098             ptrCount = ref.ptrCount;
00099             ++(*ptrCount);
00100         }
00101         return *this;
00102     }
00103 
00104     inline T& operator*() const
00105         {return *ptrObject;}
00106 
00107     inline T* getObject() const
00108         {return ptrObject;}
00109 
00110     inline T* operator->() const
00111         {return ptrObject;}
00112 
00113     inline bool operator!() const
00114         {return (*ptrCount == 1);}
00115 
00116     inline int operator++() const
00117         {return ++(*ptrCount);}
00118 
00119     inline int operator--() const {
00120         if(*ptrCount == 1) {
00121             delete this;
00122             return 0;
00123         }
00124         return --(*ptrCount);
00125     }
00126 };
00127 
00128 } // namespace ost
00129 
00130 #endif