1 //== llvm/ADT/IntrusiveRefCntPtr.h - Smart Refcounting Pointer ---*- C++ -*-==//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
16 // IntrusiveRefCntPtr is similar to Boost's intrusive_ptr with added
17 // LLVM-style casting.
19 //===----------------------------------------------------------------------===//
21 #ifndef LLVM_ADT_INTRUSIVE_REF_CNT_PTR
22 #define LLVM_ADT_INTRUSIVE_REF_CNT_PTR
24 #include "llvm/Support/Casting.h"
25 #include "llvm/Support/Compiler.h"
31 class IntrusiveRefCntPtr
;
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
;
48 RefCountedBase() : ref_cnt(0) {}
49 RefCountedBase(const RefCountedBase
&) : ref_cnt(0) {}
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);
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();
71 RefCountedBaseVPTR() : ref_cnt(0) {}
72 RefCountedBaseVPTR(const RefCountedBaseVPTR
&) : ref_cnt(0) {}
74 virtual ~RefCountedBaseVPTR() {}
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;
83 friend struct IntrusiveRefCntPtrInfo
;
87 template <typename T
> struct IntrusiveRefCntPtrInfo
{
88 static void retain(T
*obj
) { obj
->Retain(); }
89 static void release(T
*obj
) { obj
->Release(); }
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.
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
108 //===----------------------------------------------------------------------===//
109 template <typename T
>
110 class IntrusiveRefCntPtr
{
112 typedef IntrusiveRefCntPtr this_type
;
114 typedef T element_type
;
116 explicit IntrusiveRefCntPtr() : Obj(0) {}
118 IntrusiveRefCntPtr(T
* obj
) : Obj(obj
) {
122 IntrusiveRefCntPtr(const IntrusiveRefCntPtr
& S
) : Obj(S
.Obj
) {
126 #if LLVM_USE_RVALUE_REFERENCES
127 IntrusiveRefCntPtr(IntrusiveRefCntPtr
&& S
) : Obj(S
.Obj
) {
132 IntrusiveRefCntPtr(IntrusiveRefCntPtr
<X
>&& S
) : Obj(S
.getPtr()) {
138 IntrusiveRefCntPtr(const IntrusiveRefCntPtr
<X
>& S
)
143 IntrusiveRefCntPtr
& operator=(IntrusiveRefCntPtr S
) {
148 ~IntrusiveRefCntPtr() { release(); }
150 T
& operator*() const { return *Obj
; }
152 T
* operator->() const { return Obj
; }
154 T
* getPtr() const { return Obj
; }
156 typedef T
* (IntrusiveRefCntPtr::*unspecified_bool_type
) () const;
157 operator unspecified_bool_type() const {
158 return Obj
== 0 ? 0 : &IntrusiveRefCntPtr::getPtr
;
161 void swap(IntrusiveRefCntPtr
& other
) {
172 void resetWithoutRelease() {
177 void retain() { if (Obj
) IntrusiveRefCntPtrInfo
<T
>::retain(Obj
); }
178 void release() { if (Obj
) IntrusiveRefCntPtrInfo
<T
>::release(Obj
); }
181 template<class T
, class U
>
182 inline bool operator==(const IntrusiveRefCntPtr
<T
>& A
,
183 const IntrusiveRefCntPtr
<U
>& B
)
185 return A
.getPtr() == B
.getPtr();
188 template<class T
, class U
>
189 inline bool operator!=(const IntrusiveRefCntPtr
<T
>& A
,
190 const IntrusiveRefCntPtr
<U
>& B
)
192 return A
.getPtr() != B
.getPtr();
195 template<class T
, class U
>
196 inline bool operator==(const IntrusiveRefCntPtr
<T
>& A
,
199 return A
.getPtr() == B
;
202 template<class T
, class U
>
203 inline bool operator!=(const IntrusiveRefCntPtr
<T
>& A
,
206 return A
.getPtr() != B
;
209 template<class T
, class U
>
210 inline bool operator==(T
* A
,
211 const IntrusiveRefCntPtr
<U
>& B
)
213 return A
== B
.getPtr();
216 template<class T
, class U
>
217 inline bool operator!=(T
* A
,
218 const IntrusiveRefCntPtr
<U
>& B
)
220 return A
!= B
.getPtr();
223 //===----------------------------------------------------------------------===//
224 // LLVM-style downcasting support for IntrusiveRefCntPtr objects
225 //===----------------------------------------------------------------------===//
227 template<class T
> struct simplify_type
<IntrusiveRefCntPtr
<T
> > {
228 typedef T
* SimpleType
;
229 static SimpleType
getSimplifiedValue(const IntrusiveRefCntPtr
<T
>& Val
) {
234 template<class T
> struct simplify_type
<const IntrusiveRefCntPtr
<T
> > {
235 typedef T
* SimpleType
;
236 static SimpleType
getSimplifiedValue(const IntrusiveRefCntPtr
<T
>& Val
) {
241 } // end namespace llvm
243 #endif // LLVM_ADT_INTRUSIVE_REF_CNT_PTR