[python] Replace print operator with print() function for python3 compatibility
[WebKit-https.git] / PerformanceTests / StitchMarker / wtf / RefPtr.h
1 /*
2  *  Copyright (C) 2005-2017 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 // RefPtr is documented at http://webkit.org/coding/RefPtr.html
22
23 #ifndef WTF_RefPtr_h
24 #define WTF_RefPtr_h
25
26 #include <algorithm>
27 #include <utility>
28 #include <wtf/FastMalloc.h>
29 #include <wtf/Ref.h>
30
31 namespace WTF {
32
33 template<typename T> class RefPtr;
34 template<typename T> RefPtr<T> adoptRef(T*);
35
36 template<typename T> ALWAYS_INLINE void refIfNotNull(T* ptr)
37 {
38     if (LIKELY(ptr != nullptr))
39         ptr->ref();
40 }
41
42 template<typename T> ALWAYS_INLINE void derefIfNotNull(T* ptr)
43 {
44     if (LIKELY(ptr != nullptr))
45         ptr->deref();
46 }
47
48 template<typename T> class RefPtr {
49     WTF_MAKE_FAST_ALLOCATED;
50 public:
51     typedef T ValueType;
52     typedef ValueType* PtrType;
53
54     static constexpr bool isRefPtr = true;
55
56     ALWAYS_INLINE constexpr RefPtr() : m_ptr(nullptr) { }
57     ALWAYS_INLINE RefPtr(T* ptr) : m_ptr(ptr) { refIfNotNull(ptr); }
58     ALWAYS_INLINE RefPtr(const RefPtr& o) : m_ptr(o.m_ptr) { refIfNotNull(m_ptr); }
59     template<typename U> RefPtr(const RefPtr<U>& o) : m_ptr(o.get()) { refIfNotNull(m_ptr); }
60
61     ALWAYS_INLINE RefPtr(RefPtr&& o) : m_ptr(o.leakRef()) { }
62     template<typename U> RefPtr(RefPtr<U>&& o) : m_ptr(o.leakRef()) { }
63     template<typename U> RefPtr(Ref<U>&&);
64
65     // Hash table deleted values, which are only constructed and never copied or destroyed.
66     RefPtr(HashTableDeletedValueType) : m_ptr(hashTableDeletedValue()) { }
67     bool isHashTableDeletedValue() const { return m_ptr == hashTableDeletedValue(); }
68
69     ALWAYS_INLINE ~RefPtr() { derefIfNotNull(std::exchange(m_ptr, nullptr)); }
70
71     T* get() const { return m_ptr; }
72
73     Ref<T> releaseNonNull() { ASSERT(m_ptr); Ref<T> tmp(adoptRef(*m_ptr)); m_ptr = nullptr; return tmp; }
74     Ref<const T> releaseConstNonNull() { ASSERT(m_ptr); Ref<const T> tmp(adoptRef(*m_ptr)); m_ptr = nullptr; return tmp; }
75
76     T* leakRef() WARN_UNUSED_RETURN;
77
78     T& operator*() const { ASSERT(m_ptr); return *m_ptr; }
79     ALWAYS_INLINE T* operator->() const { return m_ptr; }
80
81     bool operator!() const { return !m_ptr; }
82
83     // This conversion operator allows implicit conversion to bool but not to other integer types.
84     typedef T* (RefPtr::*UnspecifiedBoolType);
85     operator UnspecifiedBoolType() const { return m_ptr ? &RefPtr::m_ptr : nullptr; }
86     
87     RefPtr& operator=(const RefPtr&);
88     RefPtr& operator=(T*);
89     RefPtr& operator=(std::nullptr_t);
90     template<typename U> RefPtr& operator=(const RefPtr<U>&);
91     RefPtr& operator=(RefPtr&&);
92     template<typename U> RefPtr& operator=(RefPtr<U>&&);
93     template<typename U> RefPtr& operator=(Ref<U>&&);
94
95     void swap(RefPtr&);
96
97     static T* hashTableDeletedValue() { return reinterpret_cast<T*>(-1); }
98
99 #if COMPILER_SUPPORTS(CXX_REFERENCE_QUALIFIED_FUNCTIONS)
100     RefPtr copyRef() && = delete;
101     RefPtr copyRef() const & WARN_UNUSED_RETURN { return RefPtr(m_ptr); }
102 #else
103     RefPtr copyRef() const WARN_UNUSED_RETURN { return RefPtr(m_ptr); }
104 #endif
105
106 private:
107     friend RefPtr adoptRef<T>(T*);
108
109     enum AdoptTag { Adopt };
110     RefPtr(T* ptr, AdoptTag) : m_ptr(ptr) { }
111
112     T* m_ptr;
113 };
114
115 template<typename T> template<typename U> inline RefPtr<T>::RefPtr(Ref<U>&& reference)
116     : m_ptr(&reference.leakRef())
117 {
118 }
119
120 template<typename T>
121 inline T* RefPtr<T>::leakRef()
122 {
123     return std::exchange(m_ptr, nullptr);
124 }
125
126 template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(const RefPtr& o)
127 {
128     RefPtr ptr = o;
129     swap(ptr);
130     return *this;
131 }
132
133 template<typename T> template<typename U> inline RefPtr<T>& RefPtr<T>::operator=(const RefPtr<U>& o)
134 {
135     RefPtr ptr = o;
136     swap(ptr);
137     return *this;
138 }
139
140 template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(T* optr)
141 {
142     RefPtr ptr = optr;
143     swap(ptr);
144     return *this;
145 }
146
147 template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(std::nullptr_t)
148 {
149     derefIfNotNull(std::exchange(m_ptr, nullptr));
150     return *this;
151 }
152
153 template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(RefPtr&& o)
154 {
155     RefPtr ptr = WTFMove(o);
156     swap(ptr);
157     return *this;
158 }
159
160 template<typename T> template<typename U> inline RefPtr<T>& RefPtr<T>::operator=(RefPtr<U>&& o)
161 {
162     RefPtr ptr = WTFMove(o);
163     swap(ptr);
164     return *this;
165 }
166
167 template<typename T> template<typename U> inline RefPtr<T>& RefPtr<T>::operator=(Ref<U>&& reference)
168 {
169     RefPtr ptr = WTFMove(reference);
170     swap(ptr);
171     return *this;
172 }
173
174 template<class T> inline void RefPtr<T>::swap(RefPtr& o)
175 {
176     std::swap(m_ptr, o.m_ptr);
177 }
178
179 template<class T> inline void swap(RefPtr<T>& a, RefPtr<T>& b)
180 {
181     a.swap(b);
182 }
183
184 template<typename T, typename U> inline bool operator==(const RefPtr<T>& a, const RefPtr<U>& b)
185
186     return a.get() == b.get(); 
187 }
188
189 template<typename T, typename U> inline bool operator==(const RefPtr<T>& a, U* b)
190
191     return a.get() == b; 
192 }
193
194 template<typename T, typename U> inline bool operator==(T* a, const RefPtr<U>& b) 
195 {
196     return a == b.get(); 
197 }
198
199 template<typename T, typename U> inline bool operator!=(const RefPtr<T>& a, const RefPtr<U>& b)
200
201     return a.get() != b.get(); 
202 }
203
204 template<typename T, typename U> inline bool operator!=(const RefPtr<T>& a, U* b)
205 {
206     return a.get() != b; 
207 }
208
209 template<typename T, typename U> inline bool operator!=(T* a, const RefPtr<U>& b)
210
211     return a != b.get(); 
212 }
213
214 template<typename T, typename U> inline RefPtr<T> static_pointer_cast(const RefPtr<U>& p)
215
216     return RefPtr<T>(static_cast<T*>(p.get())); 
217 }
218
219 template <typename T> struct IsSmartPtr<RefPtr<T>> {
220     static const bool value = true;
221 };
222
223 template<typename T> inline RefPtr<T> adoptRef(T* p)
224 {
225     adopted(p);
226     return RefPtr<T>(p, RefPtr<T>::Adopt);
227 }
228
229 template<typename T> inline RefPtr<T> makeRefPtr(T* pointer)
230 {
231     return pointer;
232 }
233
234 template<typename T> inline RefPtr<T> makeRefPtr(T& reference)
235 {
236     return &reference;
237 }
238
239 } // namespace WTF
240
241 using WTF::RefPtr;
242 using WTF::adoptRef;
243 using WTF::makeRefPtr;
244 using WTF::static_pointer_cast;
245
246 #endif // WTF_RefPtr_h