simgear/structure/SGWeakPtr.hxx

   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 template<typename T>
  24 class SGWeakPtr {
  25 public:
  26   typedef T element_type;
  27
  28   SGWeakPtr(void)
  29   { }
  30   SGWeakPtr(const SGWeakPtr& p) : mWeakData(p.mWeakData)
  31   { }
  32   SGWeakPtr(T* ptr)
  33   { assign(ptr); }
  34   template<typename U>
  35   SGWeakPtr(const SGSharedPtr<U>& p)
  36   { assign(p.get()); }
  37   template<typename U>
  38   SGWeakPtr(const SGWeakPtr<U>& p)
  39   { SGSharedPtr<T> sharedPtr = p.lock(); assign(sharedPtr.get()); }
  40   ~SGWeakPtr(void)
  41   { }
  42
  43   template<typename U>
  44   SGWeakPtr& operator=(const SGSharedPtr<U>& p)
  45   { assign(p.get()); return *this; }
  46   template<typename U>
  47   SGWeakPtr& operator=(const SGWeakPtr<U>& p)
  48   { SGSharedPtr<T> sharedPtr = p.lock(); assign(sharedPtr.get()); return *this; }
  49   SGWeakPtr& operator=(const SGWeakPtr& p)
  50   { mWeakData = p.mWeakData; return *this; }
  51
  52   template<typename U>
  53   bool operator==(const SGWeakPtr<U>& rhs) const
  54   { return mWeakData == rhs.mWeakData; }
  55   template<typename U>
  56   bool operator!=(const SGWeakPtr<U>& rhs) const
  57   { return mWeakData != rhs.mWeakData; }
  58   template<typename U>
  59   bool operator<(const SGWeakPtr<U>& rhs) const
  60   { return mWeakData < rhs.mWeakData; }
  61
  62   SGSharedPtr<T> lock(void) const
  63   {
  64     if (!mWeakData)
  65       return SGSharedPtr<T>();
  66     SGSharedPtr<T> sharedPtr;
  67     sharedPtr.assignNonRef(mWeakData->getPointer<T>());
  68     return sharedPtr;
  69   }
  70
  71   bool expired() const
  72   { return !mWeakData || mWeakData->mRefcount == 0; }
  73
  74   void reset()
  75   { mWeakData.reset(); }
  76   void clear()
  77   { mWeakData.reset(); }
  78   void swap(SGWeakPtr& weakPtr)
  79   { mWeakData.swap(weakPtr.mWeakData); }
  80
  81 private:
  82   void assign(T* p)
  83   {
  84     if (p)
  85       mWeakData = p->mWeakData;
  86     else
  87       mWeakData = 0;
  88   }
  89
  90   // The indirect reference itself.
  91   SGSharedPtr<SGWeakReferenced::WeakData> mWeakData;
  92 };
  93
  94 #endif