1 //== llvm/ADT/IntrusiveRefCntPtr.h - Smart Refcounting Pointer ---*- C++ -*-==// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines IntrusiveRefCntPtr, a template class that 11 // implements a "smart" pointer for objects that maintain their own 12 // internal reference count, and RefCountedBase/RefCountedBaseVPTR, two 13 // generic base classes for objects that wish to have their lifetimes 14 // managed using reference counting. 15 // 16 // IntrusiveRefCntPtr is similar to Boost's intrusive_ptr with added 17 // LLVM-style casting. 18 // 19 //===----------------------------------------------------------------------===// 20 21 #ifndef LLVM_ADT_INTRUSIVEREFCNTPTR_H 22 #define LLVM_ADT_INTRUSIVEREFCNTPTR_H 23 24 #include "llvm/Support/Casting.h" 25 #include "llvm/Support/Compiler.h" 26 #include <memory> 27 28 namespace llvm { 29 30 template <class T> 31 class IntrusiveRefCntPtr; 32 33 //===----------------------------------------------------------------------===// 34 /// RefCountedBase - A generic base class for objects that wish to 35 /// have their lifetimes managed using reference counts. Classes 36 /// subclass RefCountedBase to obtain such functionality, and are 37 /// typically handled with IntrusiveRefCntPtr "smart pointers" (see below) 38 /// which automatically handle the management of reference counts. 39 /// Objects that subclass RefCountedBase should not be allocated on 40 /// the stack, as invoking "delete" (which is called when the 41 /// reference count hits 0) on such objects is an error. 42 //===----------------------------------------------------------------------===// 43 template <class Derived> 44 class RefCountedBase { 45 mutable unsigned ref_cnt; 46 47 public: 48 RefCountedBase() : ref_cnt(0) {} 49 RefCountedBase(const RefCountedBase &) : ref_cnt(0) {} 50 51 void Retain() const { ++ref_cnt; } 52 void Release() const { 53 assert (ref_cnt > 0 && "Reference count is already zero."); 54 if (--ref_cnt == 0) delete static_cast<const Derived*>(this); 55 } 56 }; 57 58 //===----------------------------------------------------------------------===// 59 /// RefCountedBaseVPTR - A class that has the same function as 60 /// RefCountedBase, but with a virtual destructor. Should be used 61 /// instead of RefCountedBase for classes that already have virtual 62 /// methods to enforce dynamic allocation via 'new'. Classes that 63 /// inherit from RefCountedBaseVPTR can't be allocated on stack - 64 /// attempting to do this will produce a compile error. 65 //===----------------------------------------------------------------------===// 66 class RefCountedBaseVPTR { 67 mutable unsigned ref_cnt; 68 virtual void anchor(); 69 70 protected: 71 RefCountedBaseVPTR() : ref_cnt(0) {} 72 RefCountedBaseVPTR(const RefCountedBaseVPTR &) : ref_cnt(0) {} 73 74 virtual ~RefCountedBaseVPTR() {} 75 76 void Retain() const { ++ref_cnt; } 77 void Release() const { 78 assert (ref_cnt > 0 && "Reference count is already zero."); 79 if (--ref_cnt == 0) delete this; 80 } 81 82 template <typename T> 83 friend struct IntrusiveRefCntPtrInfo; 84 }; 85 86 87 template <typename T> struct IntrusiveRefCntPtrInfo { 88 static void retain(T *obj) { obj->Retain(); } 89 static void release(T *obj) { obj->Release(); } 90 }; 91 92 //===----------------------------------------------------------------------===// 93 /// IntrusiveRefCntPtr - A template class that implements a "smart pointer" 94 /// that assumes the wrapped object has a reference count associated 95 /// with it that can be managed via calls to 96 /// IntrusivePtrAddRef/IntrusivePtrRelease. The smart pointers 97 /// manage reference counts via the RAII idiom: upon creation of 98 /// smart pointer the reference count of the wrapped object is 99 /// incremented and upon destruction of the smart pointer the 100 /// reference count is decremented. This class also safely handles 101 /// wrapping NULL pointers. 102 /// 103 /// Reference counting is implemented via calls to 104 /// Obj->Retain()/Obj->Release(). Release() is required to destroy 105 /// the object when the reference count reaches zero. Inheriting from 106 /// RefCountedBase/RefCountedBaseVPTR takes care of this 107 /// automatically. 108 //===----------------------------------------------------------------------===// 109 template <typename T> 110 class IntrusiveRefCntPtr { 111 T* Obj; 112 typedef IntrusiveRefCntPtr this_type; 113 public: 114 typedef T element_type; 115 116 explicit IntrusiveRefCntPtr() : Obj(0) {} 117 118 IntrusiveRefCntPtr(T* obj) : Obj(obj) { 119 retain(); 120 } 121 122 IntrusiveRefCntPtr(const IntrusiveRefCntPtr& S) : Obj(S.Obj) { 123 retain(); 124 } 125 126 #if LLVM_HAS_RVALUE_REFERENCES 127 IntrusiveRefCntPtr(IntrusiveRefCntPtr&& S) : Obj(S.Obj) { 128 S.Obj = 0; 129 } 130 131 template <class X> 132 IntrusiveRefCntPtr(IntrusiveRefCntPtr<X>&& S) : Obj(S.getPtr()) { 133 S.Obj = 0; 134 } 135 #endif 136 137 template <class X> 138 IntrusiveRefCntPtr(const IntrusiveRefCntPtr<X>& S) 139 : Obj(S.getPtr()) { 140 retain(); 141 } 142 143 IntrusiveRefCntPtr& operator=(IntrusiveRefCntPtr S) { 144 swap(S); 145 return *this; 146 } 147 148 ~IntrusiveRefCntPtr() { release(); } 149 150 T& operator*() const { return *Obj; } 151 152 T* operator->() const { return Obj; } 153 154 T* getPtr() const { return Obj; } 155 156 typedef T* (IntrusiveRefCntPtr::*unspecified_bool_type) () const; 157 operator unspecified_bool_type() const { 158 return Obj == 0 ? 0 : &IntrusiveRefCntPtr::getPtr; 159 } 160 161 void swap(IntrusiveRefCntPtr& other) { 162 T* tmp = other.Obj; 163 other.Obj = Obj; 164 Obj = tmp; 165 } 166 167 void reset() { 168 release(); 169 Obj = 0; 170 } 171 172 void resetWithoutRelease() { 173 Obj = 0; 174 } 175 176 private: 177 void retain() { if (Obj) IntrusiveRefCntPtrInfo<T>::retain(Obj); } 178 void release() { if (Obj) IntrusiveRefCntPtrInfo<T>::release(Obj); } 179 }; 180 181 template<class T, class U> 182 inline bool operator==(const IntrusiveRefCntPtr<T>& A, 183 const IntrusiveRefCntPtr<U>& B) 184 { 185 return A.getPtr() == B.getPtr(); 186 } 187 188 template<class T, class U> 189 inline bool operator!=(const IntrusiveRefCntPtr<T>& A, 190 const IntrusiveRefCntPtr<U>& B) 191 { 192 return A.getPtr() != B.getPtr(); 193 } 194 195 template<class T, class U> 196 inline bool operator==(const IntrusiveRefCntPtr<T>& A, 197 U* B) 198 { 199 return A.getPtr() == B; 200 } 201 202 template<class T, class U> 203 inline bool operator!=(const IntrusiveRefCntPtr<T>& A, 204 U* B) 205 { 206 return A.getPtr() != B; 207 } 208 209 template<class T, class U> 210 inline bool operator==(T* A, 211 const IntrusiveRefCntPtr<U>& B) 212 { 213 return A == B.getPtr(); 214 } 215 216 template<class T, class U> 217 inline bool operator!=(T* A, 218 const IntrusiveRefCntPtr<U>& B) 219 { 220 return A != B.getPtr(); 221 } 222 223 //===----------------------------------------------------------------------===// 224 // LLVM-style downcasting support for IntrusiveRefCntPtr objects 225 //===----------------------------------------------------------------------===// 226 227 template<class T> struct simplify_type<IntrusiveRefCntPtr<T> > { 228 typedef T* SimpleType; 229 static SimpleType getSimplifiedValue(IntrusiveRefCntPtr<T>& Val) { 230 return Val.getPtr(); 231 } 232 }; 233 234 template<class T> struct simplify_type<const IntrusiveRefCntPtr<T> > { 235 typedef /*const*/ T* SimpleType; 236 static SimpleType getSimplifiedValue(const IntrusiveRefCntPtr<T>& Val) { 237 return Val.getPtr(); 238 } 239 }; 240 241 } // end namespace llvm 242 243 #endif // LLVM_ADT_INTRUSIVEREFCNTPTR_H 244
