1 // Copyright (C) 2004-2009 Mathias Froehlich - Mathias.Froehlich@web.de 2 // 3 // This library is free software; you can redistribute it and/or 4 // modify it under the terms of the GNU Library General Public 5 // License as published by the Free Software Foundation; either 6 // version 2 of the License, or (at your option) any later version. 7 // 8 // This library is distributed in the hope that it will be useful, 9 // but WITHOUT ANY WARRANTY; without even the implied warranty of 10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 // Library General Public License for more details. 12 // 13 // You should have received a copy of the GNU General Public License 14 // along with this program; if not, write to the Free Software 15 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 16 // 17 18 #ifndef SGWeakPtr_HXX 19 #define SGWeakPtr_HXX 20 21 #include "SGWeakReferenced.hxx" 22 23 /** 24 * Class for handling weak references to classes derived from SGWeakReferenced 25 * or SGVirtualWeakReferenced. 26 */ 27 template<typename T> 28 class SGWeakPtr { 29 public: 30 typedef T element_type; 31 SGWeakPtr(void)32 SGWeakPtr(void) 33 { } SGWeakPtr(const SGWeakPtr & p)34 SGWeakPtr(const SGWeakPtr& p) : mWeakData(p.mWeakData) 35 { } SGWeakPtr(T * ptr)36 SGWeakPtr(T* ptr) 37 { assign(ptr); } 38 template<typename U> SGWeakPtr(const SGSharedPtr<U> & p)39 SGWeakPtr(const SGSharedPtr<U>& p) 40 { assign(p.get()); } 41 template<typename U> SGWeakPtr(const SGWeakPtr<U> & p)42 SGWeakPtr(const SGWeakPtr<U>& p) 43 { SGSharedPtr<T> sharedPtr = p.lock(); assign(sharedPtr.get()); } ~SGWeakPtr(void)44 ~SGWeakPtr(void) 45 { } 46 47 template<typename U> operator =(const SGSharedPtr<U> & p)48 SGWeakPtr& operator=(const SGSharedPtr<U>& p) 49 { assign(p.get()); return *this; } 50 template<typename U> operator =(const SGWeakPtr<U> & p)51 SGWeakPtr& operator=(const SGWeakPtr<U>& p) 52 { SGSharedPtr<T> sharedPtr = p.lock(); assign(sharedPtr.get()); return *this; } operator =(const SGWeakPtr & p)53 SGWeakPtr& operator=(const SGWeakPtr& p) 54 { mWeakData = p.mWeakData; return *this; } 55 56 template<typename U> operator ==(const SGWeakPtr<U> & rhs) const57 bool operator==(const SGWeakPtr<U>& rhs) const 58 { return mWeakData == rhs.mWeakData; } 59 template<typename U> operator !=(const SGWeakPtr<U> & rhs) const60 bool operator!=(const SGWeakPtr<U>& rhs) const 61 { return mWeakData != rhs.mWeakData; } 62 template<typename U> operator <(const SGWeakPtr<U> & rhs) const63 bool operator<(const SGWeakPtr<U>& rhs) const 64 { return mWeakData < rhs.mWeakData; } 65 lock(void) const66 SGSharedPtr<T> lock(void) const 67 { 68 if (!mWeakData) 69 return SGSharedPtr<T>(); 70 SGSharedPtr<T> sharedPtr; 71 sharedPtr.assignNonRef(mWeakData->getPointer<T>()); 72 return sharedPtr; 73 } 74 expired() const75 bool expired() const 76 { return !mWeakData || mWeakData->mRefcount == 0; } 77 reset()78 void reset() 79 { mWeakData.reset(); } clear()80 void clear() 81 { mWeakData.reset(); } swap(SGWeakPtr & weakPtr)82 void swap(SGWeakPtr& weakPtr) 83 { mWeakData.swap(weakPtr.mWeakData); } 84 85 private: assign(T * p)86 void assign(T* p) 87 { 88 if (p) 89 mWeakData = p->mWeakData; 90 else 91 mWeakData = 0; 92 } 93 94 // The indirect reference itself. 95 SGSharedPtr<SGWeakReferenced::WeakData> mWeakData; 96 }; 97 98 #endif 99