1 | /* |
2 | * Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved. |
3 | * |
4 | * This library is free software; you can redistribute it and/or |
5 | * modify it under the terms of the GNU Library General Public |
6 | * License as published by the Free Software Foundation; either |
7 | * version 2 of the License, or (at your option) any later version. |
8 | * |
9 | * This library is distributed in the hope that it will be useful, |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
12 | * Library General Public License for more details. |
13 | * |
14 | * You should have received a copy of the GNU Library General Public License |
15 | * along with this library; see the file COPYING.LIB. If not, write to |
16 | * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
17 | * Boston, MA 02110-1301, USA. |
18 | * |
19 | */ |
20 | |
21 | #ifndef WTF_PassRefPtr_h |
22 | #define WTF_PassRefPtr_h |
23 | |
24 | #include "AlwaysInline.h" |
25 | |
26 | namespace WTF { |
27 | |
28 | template<typename T> class RefPtr; |
29 | template<typename T> class PassRefPtr; |
30 | template <typename T> PassRefPtr<T> adoptRef(T*); |
31 | |
32 | // Remove inline for winscw compiler to prevent the compiler agressively resolving |
33 | // T::deref(), which will fail compiling when PassRefPtr<T> is used as class member |
34 | // or function arguments before T is defined. |
35 | template<typename T> |
36 | #if !COMPILER(WINSCW) |
37 | inline |
38 | #endif |
39 | void derefIfNotNull(T* ptr) |
40 | { |
41 | if (UNLIKELY(ptr != 0)) |
42 | ptr->deref(); |
43 | } |
44 | |
45 | template<typename T> class PassRefPtr { |
46 | public: |
47 | PassRefPtr() : m_ptr(0) {} |
48 | PassRefPtr(T* ptr) : m_ptr(ptr) { if (ptr) ptr->ref(); } |
49 | // It somewhat breaks the type system to allow transfer of ownership out of |
50 | // a const PassRefPtr. However, it makes it much easier to work with PassRefPtr |
51 | // temporaries, and we don't really have a need to use real const PassRefPtrs |
52 | // anyway. |
53 | PassRefPtr(const PassRefPtr& o) : m_ptr(o.releaseRef()) {} |
54 | template <typename U> PassRefPtr(const PassRefPtr<U>& o) : m_ptr(o.releaseRef()) { } |
55 | |
56 | ALWAYS_INLINE ~PassRefPtr() { derefIfNotNull<T>(m_ptr); } |
57 | |
58 | template <class U> |
59 | PassRefPtr(const RefPtr<U>& o) : m_ptr(o.get()) { if (T* ptr = m_ptr) ptr->ref(); } |
60 | |
61 | T* get() const { return m_ptr; } |
62 | |
63 | void clear() { if (T* ptr = m_ptr) ptr->deref(); m_ptr = 0; } |
64 | T* releaseRef() const { T* tmp = m_ptr; m_ptr = 0; return tmp; } |
65 | |
66 | T& operator*() const { return *m_ptr; } |
67 | T* operator->() const { return m_ptr; } |
68 | |
69 | bool operator!() const { return !m_ptr; } |
70 | |
71 | // This conversion operator allows implicit conversion to bool but not to other integer types. |
72 | typedef T* (PassRefPtr::*UnspecifiedBoolType); |
73 | operator UnspecifiedBoolType() const { return m_ptr ? &PassRefPtr::m_ptr : 0; } |
74 | |
75 | PassRefPtr& operator=(T*); |
76 | PassRefPtr& operator=(const PassRefPtr&); |
77 | template <typename U> PassRefPtr& operator=(const PassRefPtr<U>&); |
78 | template <typename U> PassRefPtr& operator=(const RefPtr<U>&); |
79 | |
80 | friend PassRefPtr adoptRef<T>(T*); |
81 | private: |
82 | // adopting constructor |
83 | PassRefPtr(T* ptr, bool) : m_ptr(ptr) {} |
84 | mutable T* m_ptr; |
85 | }; |
86 | |
87 | // NonNullPassRefPtr: Optimized for passing non-null pointers. A NonNullPassRefPtr |
88 | // begins life non-null, and can only become null through a call to releaseRef() |
89 | // or clear(). |
90 | |
91 | // FIXME: NonNullPassRefPtr could just inherit from PassRefPtr. However, |
92 | // if we use inheritance, GCC's optimizer fails to realize that destruction |
93 | // of a released NonNullPassRefPtr is a no-op. So, for now, just copy the |
94 | // most important code from PassRefPtr. |
95 | template <typename T> class NonNullPassRefPtr { |
96 | public: |
97 | NonNullPassRefPtr(T* ptr) |
98 | : m_ptr(ptr) |
99 | { |
100 | ASSERT(m_ptr); |
101 | m_ptr->ref(); |
102 | } |
103 | |
104 | template <class U> NonNullPassRefPtr(const RefPtr<U>& o) |
105 | : m_ptr(o.get()) |
106 | { |
107 | ASSERT(m_ptr); |
108 | m_ptr->ref(); |
109 | } |
110 | |
111 | NonNullPassRefPtr(const NonNullPassRefPtr& o) |
112 | : m_ptr(o.releaseRef()) |
113 | { |
114 | ASSERT(m_ptr); |
115 | } |
116 | |
117 | template <class U> NonNullPassRefPtr(const NonNullPassRefPtr<U>& o) |
118 | : m_ptr(o.releaseRef()) |
119 | { |
120 | ASSERT(m_ptr); |
121 | } |
122 | |
123 | template <class U> NonNullPassRefPtr(const PassRefPtr<U>& o) |
124 | : m_ptr(o.releaseRef()) |
125 | { |
126 | ASSERT(m_ptr); |
127 | } |
128 | |
129 | ALWAYS_INLINE ~NonNullPassRefPtr() { derefIfNotNull(m_ptr); } |
130 | |
131 | T* get() const { return m_ptr; } |
132 | |
133 | void clear() { derefIfNotNull(m_ptr); m_ptr = 0; } |
134 | T* releaseRef() const { T* tmp = m_ptr; m_ptr = 0; return tmp; } |
135 | |
136 | T& operator*() const { return *m_ptr; } |
137 | T* operator->() const { return m_ptr; } |
138 | |
139 | private: |
140 | mutable T* m_ptr; |
141 | }; |
142 | |
143 | template <typename T> template <typename U> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const RefPtr<U>& o) |
144 | { |
145 | T* optr = o.get(); |
146 | if (optr) |
147 | optr->ref(); |
148 | T* ptr = m_ptr; |
149 | m_ptr = optr; |
150 | if (ptr) |
151 | ptr->deref(); |
152 | return *this; |
153 | } |
154 | |
155 | template <typename T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(T* optr) |
156 | { |
157 | if (optr) |
158 | optr->ref(); |
159 | T* ptr = m_ptr; |
160 | m_ptr = optr; |
161 | if (ptr) |
162 | ptr->deref(); |
163 | return *this; |
164 | } |
165 | |
166 | template <typename T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const PassRefPtr<T>& ref) |
167 | { |
168 | T* ptr = m_ptr; |
169 | m_ptr = ref.releaseRef(); |
170 | if (ptr) |
171 | ptr->deref(); |
172 | return *this; |
173 | } |
174 | |
175 | template <typename T> template <typename U> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const PassRefPtr<U>& ref) |
176 | { |
177 | T* ptr = m_ptr; |
178 | m_ptr = ref.releaseRef(); |
179 | if (ptr) |
180 | ptr->deref(); |
181 | return *this; |
182 | } |
183 | |
184 | template <typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, const PassRefPtr<U>& b) |
185 | { |
186 | return a.get() == b.get(); |
187 | } |
188 | |
189 | template <typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, const RefPtr<U>& b) |
190 | { |
191 | return a.get() == b.get(); |
192 | } |
193 | |
194 | template <typename T, typename U> inline bool operator==(const RefPtr<T>& a, const PassRefPtr<U>& b) |
195 | { |
196 | return a.get() == b.get(); |
197 | } |
198 | |
199 | template <typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, U* b) |
200 | { |
201 | return a.get() == b; |
202 | } |
203 | |
204 | template <typename T, typename U> inline bool operator==(T* a, const PassRefPtr<U>& b) |
205 | { |
206 | return a == b.get(); |
207 | } |
208 | |
209 | template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, const PassRefPtr<U>& b) |
210 | { |
211 | return a.get() != b.get(); |
212 | } |
213 | |
214 | template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, const RefPtr<U>& b) |
215 | { |
216 | return a.get() != b.get(); |
217 | } |
218 | |
219 | template <typename T, typename U> inline bool operator!=(const RefPtr<T>& a, const PassRefPtr<U>& b) |
220 | { |
221 | return a.get() != b.get(); |
222 | } |
223 | |
224 | template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, U* b) |
225 | { |
226 | return a.get() != b; |
227 | } |
228 | |
229 | template <typename T, typename U> inline bool operator!=(T* a, const PassRefPtr<U>& b) |
230 | { |
231 | return a != b.get(); |
232 | } |
233 | |
234 | template <typename T> inline PassRefPtr<T> adoptRef(T* p) |
235 | { |
236 | return PassRefPtr<T>(p, true); |
237 | } |
238 | |
239 | template <typename T, typename U> inline PassRefPtr<T> static_pointer_cast(const PassRefPtr<U>& p) |
240 | { |
241 | return adoptRef(static_cast<T*>(p.releaseRef())); |
242 | } |
243 | |
244 | template <typename T, typename U> inline PassRefPtr<T> const_pointer_cast(const PassRefPtr<U>& p) |
245 | { |
246 | return adoptRef(const_cast<T*>(p.releaseRef())); |
247 | } |
248 | |
249 | template <typename T> inline T* getPtr(const PassRefPtr<T>& p) |
250 | { |
251 | return p.get(); |
252 | } |
253 | |
254 | } // namespace WTF |
255 | |
256 | using WTF::PassRefPtr; |
257 | using WTF::NonNullPassRefPtr; |
258 | using WTF::adoptRef; |
259 | using WTF::static_pointer_cast; |
260 | using WTF::const_pointer_cast; |
261 | |
262 | #endif // WTF_PassRefPtr_h |
263 | |