Remove home-brewed nullptr
[WebKit-https.git] / Source / WTF / wtf / OwnArrayPtr.h
1 /*
2  *  Copyright (C) 2006, 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 #ifndef WTF_OwnArrayPtr_h
22 #define WTF_OwnArrayPtr_h
23
24 #include <wtf/Assertions.h>
25 #include <wtf/Noncopyable.h>
26 #include <algorithm>
27 #include <cstddef>
28
29 namespace WTF {
30
31 template<typename T> inline void deleteOwnedArrayPtr(T*);
32
33 template <typename T> class OwnArrayPtr {
34 public:
35     typedef T* PtrType;
36
37     OwnArrayPtr() : m_ptr(nullptr) { }
38     OwnArrayPtr(std::nullptr_t) : m_ptr(nullptr) { }
39     OwnArrayPtr(OwnArrayPtr&&);
40     template<typename U> OwnArrayPtr(OwnArrayPtr<U>&&);
41
42     ~OwnArrayPtr() { deleteOwnedArrayPtr(m_ptr); }
43
44     PtrType get() const { return m_ptr; }
45
46     void clear();
47     PtrType leakPtr() WARN_UNUSED_RETURN;
48
49     T& operator*() const { ASSERT(m_ptr); return *m_ptr; }
50     PtrType operator->() const { ASSERT(m_ptr); return m_ptr; }
51
52     T& operator[](std::ptrdiff_t i) const { ASSERT(m_ptr); ASSERT(i >= 0); return m_ptr[i]; }
53
54     bool operator!() const { return !m_ptr; }
55
56     // This conversion operator allows implicit conversion to bool but not to other integer types.
57     typedef T* OwnArrayPtr::*UnspecifiedBoolType;
58     operator UnspecifiedBoolType() const { return m_ptr ? &OwnArrayPtr::m_ptr : 0; }
59
60     OwnArrayPtr& operator=(std::nullptr_t) { clear(); return *this; }
61     OwnArrayPtr& operator=(OwnArrayPtr&&);
62     template<typename U> OwnArrayPtr& operator=(OwnArrayPtr<U>&&);
63
64     void swap(OwnArrayPtr& o) { std::swap(m_ptr, o.m_ptr); }
65
66 private:
67     template<typename U> friend OwnArrayPtr<U> adoptArrayPtr(U*);
68     explicit OwnArrayPtr(PtrType ptr) : m_ptr(ptr) { }
69
70     PtrType m_ptr;
71 };
72
73 template<typename T>
74 inline OwnArrayPtr<T>::OwnArrayPtr(OwnArrayPtr&& other)
75     : m_ptr(other.leakPtr())
76 {
77 }
78
79 template<typename T> template<typename U>
80 inline OwnArrayPtr<T>::OwnArrayPtr(OwnArrayPtr<U>&& other)
81     : m_ptr(other.leakPtr())
82 {
83 }
84
85 template<typename T>
86 inline void OwnArrayPtr<T>::clear()
87 {
88     PtrType ptr = m_ptr;
89     m_ptr = 0;
90     deleteOwnedArrayPtr(ptr);
91 }
92
93 template<typename T>
94 inline typename OwnArrayPtr<T>::PtrType OwnArrayPtr<T>::leakPtr()
95 {
96     PtrType ptr = m_ptr;
97     m_ptr = 0;
98     return ptr;
99 }
100
101 template<typename T>
102 inline OwnArrayPtr<T>& OwnArrayPtr<T>::operator=(OwnArrayPtr&& other)
103 {
104     auto ptr = std::move(other);
105     swap(ptr);
106     return *this;
107 }
108
109 template<typename T> template<typename U>
110 inline OwnArrayPtr<T>& OwnArrayPtr<T>::operator=(OwnArrayPtr<U>&& other)
111 {
112     auto ptr = std::move(other);
113     swap(ptr);
114     return *this;
115 }
116
117 template <typename T> inline void swap(OwnArrayPtr<T>& a, OwnArrayPtr<T>& b)
118 {
119     a.swap(b);
120 }
121
122 template<typename T, typename U> inline bool operator==(const OwnArrayPtr<T>& a, U* b)
123 {
124     return a.get() == b; 
125 }
126
127 template<typename T, typename U> inline bool operator==(T* a, const OwnArrayPtr<U>& b) 
128 {
129     return a == b.get(); 
130 }
131
132 template<typename T, typename U> inline bool operator!=(const OwnArrayPtr<T>& a, U* b)
133 {
134     return a.get() != b; 
135 }
136
137 template<typename T, typename U> inline bool operator!=(T* a, const OwnArrayPtr<U>& b)
138 {
139     return a != b.get(); 
140 }
141
142 template <typename T> inline T* getPtr(const OwnArrayPtr<T>& p)
143 {
144     return p.get();
145 }
146
147 template<typename T> inline OwnArrayPtr<T> adoptArrayPtr(T* ptr)
148 {
149     return OwnArrayPtr<T>(ptr);
150 }
151
152 template<typename T> inline void deleteOwnedArrayPtr(T* ptr)
153 {
154     static_assert(sizeof(T) > 0, "deleteOwnedArrayPtr can not delete incomplete types");
155
156     delete[] ptr;
157 }
158
159 } // namespace WTF
160
161 using WTF::OwnArrayPtr;
162 using WTF::adoptArrayPtr;
163
164 #endif // WTF_OwnArrayPtr_h