Clean up CPDF_AnnotList.
[pdfium.git] / third_party / base / nonstd_unique_ptr.h
1 // Copyright 2013 Google Inc. All Rights Reserved.
2 //
3 // Redistribution and use in source and binary forms, with or without
4 // modification, are permitted provided that the following conditions are
5 // met:
6 //
7 //     * Redistributions of source code must retain the above copyright
8 // notice, this list of conditions and the following disclaimer.
9 //     * Redistributions in binary form must reproduce the above
10 // copyright notice, this list of conditions and the following disclaimer
11 // in the documentation and/or other materials provided with the
12 // distribution.
13 //     * Neither the name of Google Inc. nor the names of its
14 // contributors may be used to endorse or promote products derived from
15 // this software without specific prior written permission.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29 // This is a copy of breakpad's standalone scoped_ptr, which has been
30 // renamed to nonstd::unique_ptr, and from which more complicated classes
31 // have been removed. The reset() method has also been tweaked to more
32 // closely match c++11, and an implicit conversion to bool has been added.
33
34 // Scopers help you manage ownership of a pointer, helping you easily manage the
35 // a pointer within a scope, and automatically destroying the pointer at the
36 // end of a scope.
37 //
38 // A unique_ptr<T> is like a T*, except that the destructor of unique_ptr<T>
39 // automatically deletes the pointer it holds (if any).
40 // That is, unique_ptr<T> owns the T object that it points to.
41 // Like a T*, a unique_ptr<T> may hold either NULL or a pointer to a T object.
42 // Also like T*, unique_ptr<T> is thread-compatible, and once you
43 // dereference it, you get the thread safety guarantees of T.
44 //
45 // Example usage (unique_ptr):
46 //   {
47 //     unique_ptr<Foo> foo(new Foo("wee"));
48 //   }  // foo goes out of scope, releasing the pointer with it.
49 //
50 //   {
51 //     unique_ptr<Foo> foo;          // No pointer managed.
52 //     foo.reset(new Foo("wee"));    // Now a pointer is managed.
53 //     foo.reset(new Foo("wee2"));   // Foo("wee") was destroyed.
54 //     foo.reset(new Foo("wee3"));   // Foo("wee2") was destroyed.
55 //     foo->Method();                // Foo::Method() called.
56 //     foo.get()->Method();          // Foo::Method() called.
57 //     SomeFunc(foo.release());      // SomeFunc takes ownership, foo no longer
58 //                                   // manages a pointer.
59 //     foo.reset(new Foo("wee4"));   // foo manages a pointer again.
60 //     foo.reset();                  // Foo("wee4") destroyed, foo no longer
61 //                                   // manages a pointer.
62 //   }  // foo wasn't managing a pointer, so nothing was destroyed.
63 //
64 // The size of a unique_ptr is small: sizeof(unique_ptr<C>) == sizeof(C*)
65
66 #ifndef NONSTD_UNIQUE_PTR_H_
67 #define NONSTD_UNIQUE_PTR_H_
68
69 // This is an implementation designed to match the anticipated future C++11
70 // implementation of the unique_ptr class.
71
72 #include <assert.h>
73 #include <stddef.h>
74 #include <stdlib.h>
75
76 #include <ostream>
77
78 #include "template_util.h"
79
80 namespace nonstd {
81
82 // Replacement for move, but doesn't allow things that are already
83 // rvalue references.
84 template <class T>
85 T&& move(T& t) {
86   return static_cast<T&&>(t);
87 }
88
89 // Function object which deletes its parameter, which must be a pointer.
90 // If C is an array type, invokes 'delete[]' on the parameter; otherwise,
91 // invokes 'delete'. The default deleter for unique_ptr<T>.
92 template <class T>
93 struct DefaultDeleter {
94   DefaultDeleter() {}
95   template <typename U>
96   DefaultDeleter(const DefaultDeleter<U>& other) {
97     // IMPLEMENTATION NOTE: C++11 20.7.1.1.2p2 only provides this constructor
98     // if U* is implicitly convertible to T* and U is not an array type.
99     //
100     // Correct implementation should use SFINAE to disable this
101     // constructor. However, since there are no other 1-argument constructors,
102     // using a static_assert() based on is_convertible<> and requiring
103     // complete types is simpler and will cause compile failures for equivalent
104     // misuses.
105     //
106     // Note, the is_convertible<U*, T*> check also ensures that U is not an
107     // array. T is guaranteed to be a non-array, so any U* where U is an array
108     // cannot convert to T*.
109     enum { T_must_be_complete = sizeof(T) };
110     enum { U_must_be_complete = sizeof(U) };
111     static_assert((pdfium::base::is_convertible<U*, T*>::value),
112                   "U_ptr_must_implicitly_convert_to_T_ptr");
113   }
114   inline void operator()(T* ptr) const {
115     enum { type_must_be_complete = sizeof(T) };
116     delete ptr;
117   }
118 };
119
120 // Specialization of DefaultDeleter for array types.
121 template <class T>
122 struct DefaultDeleter<T[]> {
123   inline void operator()(T* ptr) const {
124     enum { type_must_be_complete = sizeof(T) };
125     delete[] ptr;
126   }
127
128  private:
129   // Disable this operator for any U != T because it is undefined to execute
130   // an array delete when the static type of the array mismatches the dynamic
131   // type.
132   //
133   // References:
134   //   C++98 [expr.delete]p3
135   //   http://cplusplus.github.com/LWG/lwg-defects.html#938
136   template <typename U>
137   void operator()(U* array) const;
138 };
139
140 template <class T, int n>
141 struct DefaultDeleter<T[n]> {
142   // Never allow someone to declare something like unique_ptr<int[10]>.
143   static_assert(sizeof(T) == -1, "do_not_use_array_with_size_as_type");
144 };
145
146 namespace internal {
147
148 // Common implementation for both pointers to elements and pointers to
149 // arrays. These are differentiated below based on the need to invoke
150 // delete vs. delete[] as appropriate.
151 template <class C, class D>
152 class unique_ptr_base {
153  public:
154   // The element type
155   typedef C element_type;
156
157   explicit unique_ptr_base(C* p) : data_(p) {}
158
159   // Initializer for deleters that have data parameters.
160   unique_ptr_base(C* p, const D& d) : data_(p, d) {}
161
162   // Move constructor.
163   unique_ptr_base(unique_ptr_base<C, D>&& that)
164       : data_(that.release(), that.get_deleter()) {}
165
166   ~unique_ptr_base() {
167     enum { type_must_be_complete = sizeof(C) };
168     if (data_.ptr != nullptr) {
169       // Not using get_deleter() saves one function call in non-optimized
170       // builds.
171       static_cast<D&>(data_)(data_.ptr);
172     }
173   }
174
175   void reset(C* p = nullptr) {
176     C* old = data_.ptr;
177     data_.ptr = p;
178     if (old != nullptr)
179       static_cast<D&>(data_)(old);
180   }
181
182   C* get() const { return data_.ptr; }
183   D& get_deleter() { return data_; }
184   const D& get_deleter() const { return data_; }
185
186   // Comparison operators.
187   // These return whether two unique_ptr refer to the same object, not just to
188   // two different but equal objects.
189   bool operator==(C* p) const { return data_.ptr == p; }
190   bool operator!=(C* p) const { return data_.ptr != p; }
191
192   // Swap two unique pointers.
193   void swap(unique_ptr_base& p2) {
194     Data tmp = data_;
195     data_ = p2.data_;
196     p2.data_ = tmp;
197   }
198
199   // Release a pointer.
200   // The return value is the current pointer held by this object.
201   // If this object holds a NULL pointer, the return value is NULL.
202   // After this operation, this object will hold a NULL pointer,
203   // and will not own the object any more.
204   C* release() {
205     C* ptr = data_.ptr;
206     data_.ptr = nullptr;
207     return ptr;
208   }
209
210   // Allow promotion to bool for conditional statements.
211   explicit operator bool() const { return data_.ptr != nullptr; }
212
213  protected:
214   // Use the empty base class optimization to allow us to have a D
215   // member, while avoiding any space overhead for it when D is an
216   // empty class.  See e.g. http://www.cantrip.org/emptyopt.html for a good
217   // discussion of this technique.
218   struct Data : public D {
219     explicit Data(C* ptr_in) : ptr(ptr_in) {}
220     Data(C* ptr_in, const D& other) : D(other), ptr(ptr_in) {}
221     C* ptr;
222   };
223
224   Data data_;
225 };
226
227 }  // namespace internal
228
229 // Implementation for ordinary pointers using delete.
230 template <class C, class D = DefaultDeleter<C>>
231 class unique_ptr : public internal::unique_ptr_base<C, D> {
232  public:
233   // Constructor.  Defaults to initializing with nullptr.
234   unique_ptr() : internal::unique_ptr_base<C, D>(nullptr) {}
235
236   // Constructor.  Takes ownership of p.
237   explicit unique_ptr(C* p) : internal::unique_ptr_base<C, D>(p) {}
238
239   // Constructor.  Allows initialization of a stateful deleter.
240   unique_ptr(C* p, const D& d) : internal::unique_ptr_base<C, D>(p, d) {}
241
242   // Constructor.  Allows construction from a nullptr.
243   unique_ptr(decltype(nullptr)) : internal::unique_ptr_base<C, D>(nullptr) {}
244
245   // Move constructor.
246   unique_ptr(unique_ptr&& that)
247       : internal::unique_ptr_base<C, D>(nonstd::move(that)) {}
248
249   // operator=.  Allows assignment from a nullptr. Deletes the currently owned
250   // object, if any.
251   unique_ptr& operator=(decltype(nullptr)) {
252     this->reset();
253     return *this;
254   }
255
256   // Move assignment.
257   unique_ptr<C>& operator=(unique_ptr<C>&& that) {
258     this->reset(that.release());
259     return *this;
260   }
261
262   // Accessors to get the owned object.
263   // operator* and operator-> will assert() if there is no current object.
264   C& operator*() const {
265     assert(this->data_.ptr != nullptr);
266     return *this->data_.ptr;
267   }
268   C* operator->() const {
269     assert(this->data_.ptr != nullptr);
270     return this->data_.ptr;
271   }
272
273   // Comparison operators.
274   // These return whether two unique_ptr refer to the same object, not just to
275   // two different but equal objects.
276   bool operator==(const C* p) const { return this->get() == p; }
277   bool operator!=(const C* p) const { return this->get() != p; }
278
279  private:
280   // Disallow evil constructors. It doesn't make sense to make a copy of
281   // something that's allegedly unique.
282   unique_ptr(const unique_ptr&) = delete;
283   void operator=(const unique_ptr&) = delete;
284
285   // Forbid comparison of unique_ptr types.  If U != C, it totally
286   // doesn't make sense, and if U == C, it still doesn't make sense
287   // because you should never have the same object owned by two different
288   // unique_ptrs.
289   template <class U>
290   bool operator==(unique_ptr<U> const& p2) const;
291   template <class U>
292   bool operator!=(unique_ptr<U> const& p2) const;
293 };
294
295 // Specialization for arrays using delete[].
296 template <class C, class D>
297 class unique_ptr<C[], D> : public internal::unique_ptr_base<C, D> {
298  public:
299   // Constructor.  Defaults to initializing with nullptr.
300   unique_ptr() : internal::unique_ptr_base<C, D>(nullptr) {}
301
302   // Constructor. Stores the given array. Note that the argument's type
303   // must exactly match T*. In particular:
304   // - it cannot be a pointer to a type derived from T, because it is
305   //   inherently unsafe in the general case to access an array through a
306   //   pointer whose dynamic type does not match its static type (eg., if
307   //   T and the derived types had different sizes access would be
308   //   incorrectly calculated). Deletion is also always undefined
309   //   (C++98 [expr.delete]p3). If you're doing this, fix your code.
310   // - it cannot be const-qualified differently from T per unique_ptr spec
311   //   (http://cplusplus.github.com/LWG/lwg-active.html#2118). Users wanting
312   //   to work around this may use const_cast<const T*>().
313   explicit unique_ptr(C* p) : internal::unique_ptr_base<C, D>(p) {}
314
315   // Constructor.  Allows construction from a nullptr.
316   unique_ptr(decltype(nullptr)) : internal::unique_ptr_base<C, D>(nullptr) {}
317
318   // Move constructor.
319   unique_ptr(unique_ptr&& that)
320       : internal::unique_ptr_base<C, D>(nonstd::move(that)) {}
321
322   // operator=.  Allows assignment from a nullptr. Deletes the currently owned
323   // array, if any.
324   unique_ptr& operator=(decltype(nullptr)) {
325     this->reset();
326     return *this;
327   }
328
329   // Move assignment.
330   unique_ptr<C>& operator=(unique_ptr<C>&& that) {
331     this->reset(that.release());
332     return *this;
333   }
334
335   // Reset.  Deletes the currently owned array, if any.
336   // Then takes ownership of a new object, if given.
337   void reset(C* array = nullptr) {
338     static_cast<internal::unique_ptr_base<C, D>*>(this)->reset(array);
339   }
340
341   // Support indexing since it is holding array.
342   C& operator[](size_t i) { return this->data_.ptr[i]; }
343
344   // Comparison operators.
345   // These return whether two unique_ptr refer to the same object, not just to
346   // two different but equal objects.
347   bool operator==(C* array) const { return this->get() == array; }
348   bool operator!=(C* array) const { return this->get() != array; }
349
350  private:
351   // Disable initialization from any type other than element_type*, by
352   // providing a constructor that matches such an initialization, but is
353   // private and has no definition. This is disabled because it is not safe to
354   // call delete[] on an array whose static type does not match its dynamic
355   // type.
356   template <typename U>
357   explicit unique_ptr(U* array);
358   explicit unique_ptr(int disallow_construction_from_null);
359
360   // Disable reset() from any type other than element_type*, for the same
361   // reasons as the constructor above.
362   template <typename U>
363   void reset(U* array);
364   void reset(int disallow_reset_from_null);
365
366   // Disallow evil constructors.  It doesn't make sense to make a copy of
367   // something that's allegedly unique.
368   unique_ptr(const unique_ptr&) = delete;
369   void operator=(const unique_ptr&) = delete;
370
371   // Forbid comparison of unique_ptr types.  If U != C, it totally
372   // doesn't make sense, and if U == C, it still doesn't make sense
373   // because you should never have the same object owned by two different
374   // unique_ptrs.
375   template <class U>
376   bool operator==(unique_ptr<U> const& p2) const;
377   template <class U>
378   bool operator!=(unique_ptr<U> const& p2) const;
379 };
380
381 // Free functions
382 template <class C>
383 void swap(unique_ptr<C>& p1, unique_ptr<C>& p2) {
384   p1.swap(p2);
385 }
386
387 template <class C>
388 bool operator==(C* p1, const unique_ptr<C>& p2) {
389   return p1 == p2.get();
390 }
391
392 template <class C>
393 bool operator!=(C* p1, const unique_ptr<C>& p2) {
394   return p1 != p2.get();
395 }
396
397 template <typename T>
398 std::ostream& operator<<(std::ostream& out, const unique_ptr<T>& p) {
399   return out << p.get();
400 }
401
402 }  // namespace nonstd
403
404 #endif  // NONSTD_UNIQUE_PTR_H_