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 /**
  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
  32   SGWeakPtr(void)
  33   { }
  34   SGWeakPtr(const SGWeakPtr& p) : mWeakData(p.mWeakData)
  35   { }
  36   SGWeakPtr(T* ptr)
  37   { assign(ptr); }
  38   template<typename U>
  39   SGWeakPtr(const SGSharedPtr<U>& p)
  40   { assign(p.get()); }
  41   template<typename U>
  42   SGWeakPtr(const SGWeakPtr<U>& p)
  43   { SGSharedPtr<T> sharedPtr = p.lock(); assign(sharedPtr.get()); }
  44   ~SGWeakPtr(void)
  45   { }
  46
  47   template<typename U>
  48   SGWeakPtr& operator=(const SGSharedPtr<U>& p)
  49   { assign(p.get()); return *this; }
  50   template<typename U>
  51   SGWeakPtr& operator=(const SGWeakPtr<U>& p)
  52   { SGSharedPtr<T> sharedPtr = p.lock(); assign(sharedPtr.get()); return *this; }
  53   SGWeakPtr& operator=(const SGWeakPtr& p)
  54   { mWeakData = p.mWeakData; return *this; }
  55
  56   template<typename U>
  57   bool operator==(const SGWeakPtr<U>& rhs) const
  58   { return mWeakData == rhs.mWeakData; }
  59   template<typename U>
  60   bool operator!=(const SGWeakPtr<U>& rhs) const
  61   { return mWeakData != rhs.mWeakData; }
  62   template<typename U>
  63   bool operator<(const SGWeakPtr<U>& rhs) const
  64   { return mWeakData < rhs.mWeakData; }
  65
  66   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
  75   bool expired() const
  76   { return !mWeakData || mWeakData->mRefcount == 0; }
  77
  78   void reset()
  79   { mWeakData.reset(); }
  80   void clear()
  81   { mWeakData.reset(); }
  82   void swap(SGWeakPtr& weakPtr)
  83   { mWeakData.swap(weakPtr.mWeakData); }
  84
  85 private:
  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