Add nonstd::unique_ptr move assigment operator.
[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 namespace nonstd {
77
78 // Replacement for move, but doesn't allow things that are already
79 // rvalue references.
80 template <class T>
81 T&& move(T& t) {
82   return static_cast<T&&>(t);
83 }
84
85 // Common implementation for both pointers to elements and pointers to
86 // arrays. These are differentiated below based on the need to invoke
87 // delete vs. delete[] as appropriate.
88 template <class C>
89 class unique_ptr_base {
90  public:
91
92   // The element type
93   typedef C element_type;
94
95   explicit unique_ptr_base(C* p) : ptr_(p) { }
96
97   // Move constructor.
98   unique_ptr_base(unique_ptr_base<C>&& that) {
99     ptr_ = that.ptr_;
100     that.ptr_ = nullptr;
101   }
102
103   // Accessors to get the owned object.
104   // operator* and operator-> will assert() if there is no current object.
105   C& operator*() const {
106     assert(ptr_ != NULL);
107     return *ptr_;
108   }
109   C* operator->() const  {
110     assert(ptr_ != NULL);
111     return ptr_;
112   }
113   C* get() const { return ptr_; }
114
115   // Comparison operators.
116   // These return whether two unique_ptr refer to the same object, not just to
117   // two different but equal objects.
118   bool operator==(C* p) const { return ptr_ == p; }
119   bool operator!=(C* p) const { return ptr_ != p; }
120
121   // Swap two scoped pointers.
122   void swap(unique_ptr_base& p2) {
123     C* tmp = ptr_;
124     ptr_ = p2.ptr_;
125     p2.ptr_ = tmp;
126   }
127
128   // Release a pointer.
129   // The return value is the current pointer held by this object.
130   // If this object holds a NULL pointer, the return value is NULL.
131   // After this operation, this object will hold a NULL pointer,
132   // and will not own the object any more.
133   C* release() {
134     C* retVal = ptr_;
135     ptr_ = NULL;
136     return retVal;
137   }
138
139   // Allow promotion to bool for conditional statements.
140   explicit operator bool() const { return ptr_ != NULL; }
141
142  protected:
143   C* ptr_;
144 };
145
146 // Implementation for ordinary pointers using delete.
147 template <class C>
148 class unique_ptr : public unique_ptr_base<C> {
149  public:
150   using unique_ptr_base<C>::ptr_;
151
152   // Constructor. Defaults to initializing with NULL. There is no way
153   // to create an uninitialized unique_ptr. The input parameter must be
154   // allocated with new (not new[] - see below).
155   explicit unique_ptr(C* p = NULL) : unique_ptr_base<C>(p) { }
156
157   // Move constructor.
158   unique_ptr(unique_ptr<C>&& that) : unique_ptr_base<C>(nonstd::move(that)) {}
159
160   // Destructor.  If there is a C object, delete it.
161   // We don't need to test ptr_ == NULL because C++ does that for us.
162   ~unique_ptr() {
163     enum { type_must_be_complete = sizeof(C) };
164     delete ptr_;
165   }
166
167   // Reset.  Deletes the current owned object, if any.
168   // Then takes ownership of a new object, if given.
169   // this->reset(this->get()) works.
170   void reset(C* p = NULL) {
171     if (p != ptr_) {
172       enum { type_must_be_complete = sizeof(C) };
173       C* old_ptr = ptr_;
174       ptr_ = p;
175       delete old_ptr;
176     }
177   }
178
179   // Move assignment.
180   unique_ptr<C>& operator=(unique_ptr<C>&& that) {
181     if (that.ptr_ != ptr_)
182       reset(that.release());
183     return *this;
184   }
185
186 private:
187   // Forbid comparison of unique_ptr types.  If C2 != C, it totally doesn't
188   // make sense, and if C2 == C, it still doesn't make sense because you should
189   // never have the same object owned by two different unique_ptrs.
190   template <class C2> bool operator==(unique_ptr<C2> const& p2) const;
191   template <class C2> bool operator!=(unique_ptr<C2> const& p2) const;
192
193   // Disallow evil constructors. It doesn't make sense to make a copy of
194   // something that's allegedly unique.
195   unique_ptr(const unique_ptr&) = delete;
196   void operator=(const unique_ptr&) = delete;
197 };
198
199 // Specialization for arrays using delete[].
200 template <class C>
201 class unique_ptr<C[]> : public unique_ptr_base<C> {
202  public:
203   using unique_ptr_base<C>::ptr_;
204
205   // Constructor. Defaults to initializing with NULL. There is no way
206   // to create an uninitialized unique_ptr. The input parameter must be
207   // allocated with new[] (not new - see above).
208   explicit unique_ptr(C* p = NULL) : unique_ptr_base<C>(p) { }
209
210   // Move constructor.
211   unique_ptr(unique_ptr<C>&& that) : unique_ptr_base<C>(nonstd::move(that)) {}
212
213   // Destructor.  If there is a C object, delete it.
214   // We don't need to test ptr_ == NULL because C++ does that for us.
215   ~unique_ptr() {
216     enum { type_must_be_complete = sizeof(C) };
217     delete[] ptr_;
218   }
219
220   // Reset.  Deletes the current owned object, if any.
221   // Then takes ownership of a new object, if given.
222   // this->reset(this->get()) works.
223   void reset(C* p = NULL) {
224     if (p != ptr_) {
225       enum { type_must_be_complete = sizeof(C) };
226       C* old_ptr = ptr_;
227       ptr_ = p;
228       delete[] old_ptr;
229     }
230   }
231
232   // Move assignment.
233   unique_ptr<C>& operator=(unique_ptr<C>&& that) {
234     if (that.ptr_ != ptr_)
235       reset(that.release());
236     return *this;
237   }
238
239   // Support indexing since it is holding array.
240   C& operator[] (size_t i) { return ptr_[i]; }
241
242 private:
243   // Forbid comparison of unique_ptr types.  If C2 != C, it totally doesn't
244   // make sense, and if C2 == C, it still doesn't make sense because you should
245   // never have the same object owned by two different unique_ptrs.
246   template <class C2> bool operator==(unique_ptr<C2> const& p2) const;
247   template <class C2> bool operator!=(unique_ptr<C2> const& p2) const;
248
249   // Disallow evil constructors.  It doesn't make sense to make a copy of
250   // something that's allegedly unique.
251   unique_ptr(const unique_ptr&) = delete;
252   void operator=(const unique_ptr&) = delete;
253 };
254
255 // Free functions
256 template <class C>
257 void swap(unique_ptr<C>& p1, unique_ptr<C>& p2) {
258   p1.swap(p2);
259 }
260
261 template <class C>
262 bool operator==(C* p1, const unique_ptr<C>& p2) {
263   return p1 == p2.get();
264 }
265
266 template <class C>
267 bool operator!=(C* p1, const unique_ptr<C>& p2) {
268   return p1 != p2.get();
269 }
270
271 }  // namespace nonstd
272
273 #endif  // NONSTD_UNIQUE_PTR_H_