mfbt/WeakPtr.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /* Weak pointer functionality, implemented as a mixin for use with any class. */
   8
   9 /**
  10  * SupportsWeakPtr lets you have a pointer to an object 'Foo' without affecting
  11  * its lifetime. It works by creating a single shared reference counted object
  12  * (WeakReference) that each WeakPtr will access 'Foo' through. This lets 'Foo'
  13  * clear the pointer in the WeakReference without having to know about all of
  14  * the WeakPtrs to it and allows the WeakReference to live beyond the lifetime
  15  * of 'Foo'.
  16  *
  17  * The overhead of WeakPtr is that accesses to 'Foo' becomes an additional
  18  * dereference, and an additional heap allocated pointer sized object shared
  19  * between all of the WeakPtrs.
  20  *
  21  * Example of usage:
  22  *
  23  *   // To have a class C support weak pointers, inherit from SupportsWeakPtr<C>.
  24  *   class C : public SupportsWeakPtr<C>
  25  *   {
  26  *    public:
  27  *      int num;
  28  *      void act();
  29  *   };
  30  *
  31  *   C* ptr =  new C();
  32  *
  33  *   // Get weak pointers to ptr. The first time asWeakPtr is called
  34  *   // a reference counted WeakReference object is created that
  35  *   // can live beyond the lifetime of 'ptr'. The WeakReference
  36  *   // object will be notified of 'ptr's destruction.
  37  *   WeakPtr<C> weak = ptr->asWeakPtr();
  38  *   WeakPtr<C> other = ptr->asWeakPtr();
  39  *
  40  *   // Test a weak pointer for validity before using it.
  41  *   if (weak) {
  42  *     weak->num = 17;
  43  *     weak->act();
  44  *   }
  45  *
  46  *   // Destroying the underlying object clears weak pointers to it.
  47  *   delete ptr;
  48  *
  49  *   MOZ_ASSERT(!weak, "Deleting |ptr| clears weak pointers to it.");
  50  *   MOZ_ASSERT(!other, "Deleting |ptr| clears all weak pointers to it.");
  51  *
  52  * WeakPtr is typesafe and may be used with any class. It is not required that
  53  * the class be reference-counted or allocated in any particular way.
  54  *
  55  * The API was loosely inspired by Chromium's weak_ptr.h:
  56  * http://src.chromium.org/svn/trunk/src/base/memory/weak_ptr.h
  57  */
  58
  59 #ifndef mozilla_WeakPtr_h
  60 #define mozilla_WeakPtr_h
  61
  62 #include "mozilla/Assertions.h"
  63 #include "mozilla/NullPtr.h"
  64 #include "mozilla/RefPtr.h"
  65 #include "mozilla/TypeTraits.h"
  66
  67 namespace mozilla {
  68
  69 template <typename T, class WeakReference> class WeakPtrBase;
  70 template <typename T, class WeakReference> class SupportsWeakPtrBase;
  71
  72 namespace detail {
  73
  74 // This can live beyond the lifetime of the class derived from SupportsWeakPtrBase.
  75 template<class T>
  76 class WeakReference : public ::mozilla::RefCounted<WeakReference<T> >
  77 {
  78   public:
  79     explicit WeakReference(T* p) : ptr(p) {}
  80     T* get() const {
  81       return ptr;
  82     }
  83
  84   private:
  85     friend class WeakPtrBase<T, WeakReference<T> >;
  86     friend class SupportsWeakPtrBase<T, WeakReference<T> >;
  87     void detach() {
  88       ptr = nullptr;
  89     }
  90     T* ptr;
  91 };
  92
  93 } // namespace detail
  94
  95 template <typename T, class WeakReference>
  96 class SupportsWeakPtrBase
  97 {
  98   public:
  99     WeakPtrBase<T, WeakReference> asWeakPtr() {
 100       if (!weakRef)
 101         weakRef = new WeakReference(static_cast<T*>(this));
 102       return WeakPtrBase<T, WeakReference>(weakRef);
 103     }
 104
 105   protected:
 106     ~SupportsWeakPtrBase() {
 107       static_assert(IsBaseOf<SupportsWeakPtrBase<T, WeakReference>, T>::value,
 108                     "T must derive from SupportsWeakPtrBase<T, WeakReference>");
 109       if (weakRef)
 110         weakRef->detach();
 111     }
 112
 113   private:
 114     friend class WeakPtrBase<T, WeakReference>;
 115
 116     RefPtr<WeakReference> weakRef;
 117 };
 118
 119 template <typename T>
 120 class SupportsWeakPtr : public SupportsWeakPtrBase<T, detail::WeakReference<T> >
 121 {
 122 };
 123
 124 template <typename T, class WeakReference>
 125 class WeakPtrBase
 126 {
 127   public:
 128     WeakPtrBase(const WeakPtrBase<T, WeakReference>& o) : ref(o.ref) {}
 129     // Ensure that ref is dereferenceable in the uninitialized state
 130     WeakPtrBase() : ref(new WeakReference(nullptr)) {}
 131
 132     operator T*() const {
 133       return ref->get();
 134     }
 135     T& operator*() const {
 136       return *ref->get();
 137     }
 138
 139     T* operator->() const {
 140       return ref->get();
 141     }
 142
 143     T* get() const {
 144       return ref->get();
 145     }
 146
 147   private:
 148     friend class SupportsWeakPtrBase<T, WeakReference>;
 149
 150     explicit WeakPtrBase(const RefPtr<WeakReference> &o) : ref(o) {}
 151
 152     RefPtr<WeakReference> ref;
 153 };
 154
 155 template <typename T>
 156 class WeakPtr : public WeakPtrBase<T, detail::WeakReference<T> >
 157 {
 158     typedef WeakPtrBase<T, detail::WeakReference<T> > Base;
 159   public:
 160     WeakPtr(const WeakPtr<T>& o) : Base(o) {}
 161     WeakPtr(const Base& o) : Base(o) {}
 162     WeakPtr() {}
 163 };
 164
 165 } // namespace mozilla
 166
 167 #endif /* mozilla_WeakPtr_h */