Remove WTF smart pointers 'const_pointer_cast'
[WebKit-https.git] / Source / WTF / wtf / RefPtr.h
1 /*
2  *  Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2013 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 and PassRefPtr are 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/PassRefPtr.h>
30
31 namespace WTF {
32
33     template<typename T> class PassRefPtr;
34
35     enum HashTableDeletedValueType { HashTableDeletedValue };
36
37     template<typename T> class RefPtr {
38         WTF_MAKE_FAST_ALLOCATED;
39     public:
40         ALWAYS_INLINE RefPtr() : m_ptr(0) { }
41         ALWAYS_INLINE RefPtr(T* ptr) : m_ptr(ptr) { refIfNotNull(ptr); }
42         ALWAYS_INLINE RefPtr(const RefPtr& o) : m_ptr(o.m_ptr) { refIfNotNull(m_ptr); }
43         template<typename U> RefPtr(const RefPtr<U>& o) : m_ptr(o.get()) { refIfNotNull(m_ptr); }
44
45 #if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
46         ALWAYS_INLINE RefPtr(RefPtr&& o) : m_ptr(o.release().leakRef()) { }
47         template<typename U> RefPtr(RefPtr<U>&& o) : m_ptr(o.release().leakRef()) { }
48 #endif
49
50         // See comments in PassRefPtr.h for an explanation of why this takes a const reference.
51         template<typename U> RefPtr(const PassRefPtr<U>&);
52
53         // Hash table deleted values, which are only constructed and never copied or destroyed.
54         RefPtr(HashTableDeletedValueType) : m_ptr(hashTableDeletedValue()) { }
55         bool isHashTableDeletedValue() const { return m_ptr == hashTableDeletedValue(); }
56
57         ALWAYS_INLINE ~RefPtr() { derefIfNotNull(m_ptr); }
58
59         T* get() const { return m_ptr; }
60         
61         void clear();
62         PassRefPtr<T> release() { PassRefPtr<T> tmp = adoptRef(m_ptr); m_ptr = 0; return tmp; }
63
64         T& operator*() const { return *m_ptr; }
65         ALWAYS_INLINE T* operator->() const { return m_ptr; }
66         
67         bool operator!() const { return !m_ptr; }
68     
69         // This conversion operator allows implicit conversion to bool but not to other integer types.
70         typedef T* (RefPtr::*UnspecifiedBoolType);
71         operator UnspecifiedBoolType() const { return m_ptr ? &RefPtr::m_ptr : 0; }
72         
73         RefPtr& operator=(const RefPtr&);
74         RefPtr& operator=(T*);
75         RefPtr& operator=(const PassRefPtr<T>&);
76 #if !COMPILER_SUPPORTS(CXX_NULLPTR)
77         RefPtr& operator=(std::nullptr_t) { clear(); return *this; }
78 #endif
79         template<typename U> RefPtr& operator=(const RefPtr<U>&);
80         template<typename U> RefPtr& operator=(const PassRefPtr<U>&);
81 #if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
82         RefPtr& operator=(RefPtr&&);
83         template<typename U> RefPtr& operator=(RefPtr<U>&&);
84 #endif
85         void swap(RefPtr&);
86
87         static T* hashTableDeletedValue() { return reinterpret_cast<T*>(-1); }
88
89     private:
90         T* m_ptr;
91     };
92     
93     template<typename T> template<typename U> inline RefPtr<T>::RefPtr(const PassRefPtr<U>& o)
94         : m_ptr(o.leakRef())
95     {
96     }
97
98     template<typename T> inline void RefPtr<T>::clear()
99     {
100         T* ptr = m_ptr;
101         m_ptr = 0;
102         derefIfNotNull(ptr);
103     }
104
105     template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(const RefPtr& o)
106     {
107         RefPtr ptr = o;
108         swap(ptr);
109         return *this;
110     }
111     
112     template<typename T> template<typename U> inline RefPtr<T>& RefPtr<T>::operator=(const RefPtr<U>& o)
113     {
114         RefPtr ptr = o;
115         swap(ptr);
116         return *this;
117     }
118     
119     template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(T* optr)
120     {
121         RefPtr ptr = optr;
122         swap(ptr);
123         return *this;
124     }
125
126     template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(const PassRefPtr<T>& 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 PassRefPtr<U>& o)
134     {
135         RefPtr ptr = o;
136         swap(ptr);
137         return *this;
138     }
139
140 #if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
141
142     template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(RefPtr&& o)
143     {
144         RefPtr ptr = std::move(o);
145         swap(ptr);
146         return *this;
147     }
148
149     template<typename T> template<typename U> inline RefPtr<T>& RefPtr<T>::operator=(RefPtr<U>&& o)
150     {
151         RefPtr ptr = std::move(o);
152         swap(ptr);
153         return *this;
154     }
155
156 #endif
157
158     template<class T> inline void RefPtr<T>::swap(RefPtr& o)
159     {
160         std::swap(m_ptr, o.m_ptr);
161     }
162
163     template<class T> inline void swap(RefPtr<T>& a, RefPtr<T>& b)
164     {
165         a.swap(b);
166     }
167
168     template<typename T, typename U> inline bool operator==(const RefPtr<T>& a, const RefPtr<U>& b)
169     { 
170         return a.get() == b.get(); 
171     }
172
173     template<typename T, typename U> inline bool operator==(const RefPtr<T>& a, U* b)
174     { 
175         return a.get() == b; 
176     }
177     
178     template<typename T, typename U> inline bool operator==(T* a, const RefPtr<U>& b) 
179     {
180         return a == b.get(); 
181     }
182     
183     template<typename T, typename U> inline bool operator!=(const RefPtr<T>& a, const RefPtr<U>& b)
184     { 
185         return a.get() != b.get(); 
186     }
187
188     template<typename T, typename U> inline bool operator!=(const RefPtr<T>& a, U* b)
189     {
190         return a.get() != b; 
191     }
192
193     template<typename T, typename U> inline bool operator!=(T* a, const RefPtr<U>& b)
194     { 
195         return a != b.get(); 
196     }
197     
198     template<typename T, typename U> inline RefPtr<T> static_pointer_cast(const RefPtr<U>& p)
199     { 
200         return RefPtr<T>(static_cast<T*>(p.get())); 
201     }
202
203     template<typename T> inline T* getPtr(const RefPtr<T>& p)
204     {
205         return p.get();
206     }
207
208 } // namespace WTF
209
210 using WTF::RefPtr;
211 using WTF::static_pointer_cast;
212
213 #endif // WTF_RefPtr_h