2013-12-30 19:34:15 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
|
|
|
/* Smart pointer managing sole ownership of a resource. */
|
|
|
|
|
|
|
|
#ifndef mozilla_UniquePtr_h
|
|
|
|
#define mozilla_UniquePtr_h
|
|
|
|
|
2020-03-28 13:57:16 +00:00
|
|
|
#include <type_traits>
|
Bug 1609996 - Reorder some includes affected by the previous patches. r=froydnj
This was done by:
This was done by applying:
```
diff --git a/python/mozbuild/mozbuild/code-analysis/mach_commands.py b/python/mozbuild/mozbuild/code-analysis/mach_commands.py
index 789affde7bbf..fe33c4c7d4d1 100644
--- a/python/mozbuild/mozbuild/code-analysis/mach_commands.py
+++ b/python/mozbuild/mozbuild/code-analysis/mach_commands.py
@@ -2007,7 +2007,7 @@ class StaticAnalysis(MachCommandBase):
from subprocess import Popen, PIPE, check_output, CalledProcessError
diff_process = Popen(self._get_clang_format_diff_command(commit), stdout=PIPE)
- args = [sys.executable, clang_format_diff, "-p1", "-binary=%s" % clang_format]
+ args = [sys.executable, clang_format_diff, "-p1", "-binary=%s" % clang_format, '-sort-includes']
if not output_file:
args.append("-i")
```
Then running `./mach clang-format -c <commit-hash>`
Then undoing that patch.
Then running check_spidermonkey_style.py --fixup
Then running `./mach clang-format`
I had to fix four things:
* I needed to move <utility> back down in GuardObjects.h because I was hitting
obscure problems with our system include wrappers like this:
0:03.94 /usr/include/stdlib.h:550:14: error: exception specification in declaration does not match previous declaration
0:03.94 extern void *realloc (void *__ptr, size_t __size)
0:03.94 ^
0:03.94 /home/emilio/src/moz/gecko-2/obj-debug/dist/include/malloc_decls.h:53:1: note: previous declaration is here
0:03.94 MALLOC_DECL(realloc, void*, void*, size_t)
0:03.94 ^
0:03.94 /home/emilio/src/moz/gecko-2/obj-debug/dist/include/mozilla/mozalloc.h:22:32: note: expanded from macro 'MALLOC_DECL'
0:03.94 MOZ_MEMORY_API return_type name##_impl(__VA_ARGS__);
0:03.94 ^
0:03.94 <scratch space>:178:1: note: expanded from here
0:03.94 realloc_impl
0:03.94 ^
0:03.94 /home/emilio/src/moz/gecko-2/obj-debug/dist/include/mozmemory_wrap.h:142:41: note: expanded from macro 'realloc_impl'
0:03.94 #define realloc_impl mozmem_malloc_impl(realloc)
Which I really didn't feel like digging into.
* I had to restore the order of TrustOverrideUtils.h and related files in nss
because the .inc files depend on TrustOverrideUtils.h being included earlier.
* I had to add a missing include to RollingNumber.h
* Also had to partially restore include order in JsepSessionImpl.cpp to avoid
some -WError issues due to some static inline functions being defined in a
header but not used in the rest of the compilation unit.
Differential Revision: https://phabricator.services.mozilla.com/D60327
--HG--
extra : moz-landing-system : lando
2020-01-20 16:19:48 +00:00
|
|
|
#include <utility>
|
|
|
|
|
2013-12-30 19:34:15 +00:00
|
|
|
#include "mozilla/Assertions.h"
|
|
|
|
#include "mozilla/Attributes.h"
|
2020-03-17 12:42:12 +00:00
|
|
|
#include "mozilla/CompactPair.h"
|
2013-12-30 19:34:15 +00:00
|
|
|
#include "mozilla/Compiler.h"
|
|
|
|
|
|
|
|
namespace mozilla {
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
class DefaultDelete;
|
|
|
|
template <typename T, class D = DefaultDelete<T>>
|
|
|
|
class UniquePtr;
|
|
|
|
|
|
|
|
} // namespace mozilla
|
|
|
|
|
|
|
|
namespace mozilla {
|
|
|
|
|
2016-03-11 19:48:58 +00:00
|
|
|
namespace detail {
|
|
|
|
|
|
|
|
struct HasPointerTypeHelper {
|
|
|
|
template <class U>
|
|
|
|
static double Test(...);
|
|
|
|
template <class U>
|
|
|
|
static char Test(typename U::pointer* = 0);
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
class HasPointerType
|
2020-03-28 13:57:19 +00:00
|
|
|
: public std::integral_constant<bool, sizeof(HasPointerTypeHelper::Test<T>(
|
|
|
|
0)) == 1> {};
|
2016-03-11 19:48:58 +00:00
|
|
|
|
|
|
|
template <class T, class D, bool = HasPointerType<D>::value>
|
|
|
|
struct PointerTypeImpl {
|
|
|
|
typedef typename D::pointer Type;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class T, class D>
|
|
|
|
struct PointerTypeImpl<T, D, false> {
|
|
|
|
typedef T* Type;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class T, class D>
|
|
|
|
struct PointerType {
|
2020-03-28 14:16:19 +00:00
|
|
|
typedef typename PointerTypeImpl<T, std::remove_reference_t<D>>::Type Type;
|
2016-03-11 19:48:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace detail
|
|
|
|
|
2013-12-30 19:34:15 +00:00
|
|
|
/**
|
|
|
|
* UniquePtr is a smart pointer that wholly owns a resource. Ownership may be
|
|
|
|
* transferred out of a UniquePtr through explicit action, but otherwise the
|
|
|
|
* resource is destroyed when the UniquePtr is destroyed.
|
|
|
|
*
|
|
|
|
* UniquePtr is similar to C++98's std::auto_ptr, but it improves upon auto_ptr
|
|
|
|
* in one crucial way: it's impossible to copy a UniquePtr. Copying an auto_ptr
|
|
|
|
* obviously *can't* copy ownership of its singly-owned resource. So what
|
|
|
|
* happens if you try to copy one? Bizarrely, ownership is implicitly
|
|
|
|
* *transferred*, preserving single ownership but breaking code that assumes a
|
|
|
|
* copy of an object is identical to the original. (This is why auto_ptr is
|
|
|
|
* prohibited in STL containers.)
|
|
|
|
*
|
|
|
|
* UniquePtr solves this problem by being *movable* rather than copyable.
|
|
|
|
* Instead of passing a |UniquePtr u| directly to the constructor or assignment
|
|
|
|
* operator, you pass |Move(u)|. In doing so you indicate that you're *moving*
|
|
|
|
* ownership out of |u|, into the target of the construction/assignment. After
|
|
|
|
* the transfer completes, |u| contains |nullptr| and may be safely destroyed.
|
|
|
|
* This preserves single ownership but also allows UniquePtr to be moved by
|
|
|
|
* algorithms that have been made move-safe. (Note: if |u| is instead a
|
|
|
|
* temporary expression, don't use |Move()|: just pass the expression, because
|
|
|
|
* it's already move-ready. For more information see Move.h.)
|
|
|
|
*
|
|
|
|
* UniquePtr is also better than std::auto_ptr in that the deletion operation is
|
|
|
|
* customizable. An optional second template parameter specifies a class that
|
|
|
|
* (through its operator()(T*)) implements the desired deletion policy. If no
|
|
|
|
* policy is specified, mozilla::DefaultDelete<T> is used -- which will either
|
|
|
|
* |delete| or |delete[]| the resource, depending whether the resource is an
|
|
|
|
* array. Custom deletion policies ideally should be empty classes (no member
|
|
|
|
* fields, no member fields in base classes, no virtual methods/inheritance),
|
|
|
|
* because then UniquePtr can be just as efficient as a raw pointer.
|
|
|
|
*
|
|
|
|
* Use of UniquePtr proceeds like so:
|
|
|
|
*
|
|
|
|
* UniquePtr<int> g1; // initializes to nullptr
|
|
|
|
* g1.reset(new int); // switch resources using reset()
|
|
|
|
* g1 = nullptr; // clears g1, deletes the int
|
|
|
|
*
|
|
|
|
* UniquePtr<int> g2(new int); // owns that int
|
|
|
|
* int* p = g2.release(); // g2 leaks its int -- still requires deletion
|
|
|
|
* delete p; // now freed
|
|
|
|
*
|
|
|
|
* struct S { int x; S(int x) : x(x) {} };
|
|
|
|
* UniquePtr<S> g3, g4(new S(5));
|
2018-05-30 19:15:35 +00:00
|
|
|
* g3 = std::move(g4); // g3 owns the S, g4 cleared
|
2013-12-30 19:34:15 +00:00
|
|
|
* S* p = g3.get(); // g3 still owns |p|
|
|
|
|
* assert(g3->x == 5); // operator-> works (if .get() != nullptr)
|
|
|
|
* assert((*g3).x == 5); // also operator* (again, if not cleared)
|
2020-01-20 16:17:06 +00:00
|
|
|
* std::swap(g3, g4); // g4 now owns the S, g3 cleared
|
2013-12-30 19:34:15 +00:00
|
|
|
* g3.swap(g4); // g3 now owns the S, g4 cleared
|
2018-05-30 19:15:35 +00:00
|
|
|
* UniquePtr<S> g5(std::move(g3)); // g5 owns the S, g3 cleared
|
2013-12-30 19:34:15 +00:00
|
|
|
* g5.reset(); // deletes the S, g5 cleared
|
|
|
|
*
|
|
|
|
* struct FreePolicy { void operator()(void* p) { free(p); } };
|
|
|
|
* UniquePtr<int, FreePolicy> g6(static_cast<int*>(malloc(sizeof(int))));
|
|
|
|
* int* ptr = g6.get();
|
|
|
|
* g6 = nullptr; // calls free(ptr)
|
|
|
|
*
|
|
|
|
* Now, carefully note a few things you *can't* do:
|
|
|
|
*
|
|
|
|
* UniquePtr<int> b1;
|
|
|
|
* b1 = new int; // BAD: can only assign another UniquePtr
|
|
|
|
* int* ptr = b1; // BAD: no auto-conversion to pointer, use get()
|
|
|
|
*
|
|
|
|
* UniquePtr<int> b2(b1); // BAD: can't copy a UniquePtr
|
|
|
|
* UniquePtr<int> b3 = b1; // BAD: can't copy-assign a UniquePtr
|
|
|
|
*
|
2014-07-18 16:24:47 +00:00
|
|
|
* (Note that changing a UniquePtr to store a direct |new| expression is
|
|
|
|
* permitted, but usually you should use MakeUnique, defined at the end of this
|
|
|
|
* header.)
|
|
|
|
*
|
2013-12-30 19:34:15 +00:00
|
|
|
* A few miscellaneous notes:
|
|
|
|
*
|
|
|
|
* UniquePtr, when not instantiated for an array type, can be move-constructed
|
|
|
|
* and move-assigned, not only from itself but from "derived" UniquePtr<U, E>
|
|
|
|
* instantiations where U converts to T and E converts to D. If you want to use
|
|
|
|
* this, you're going to have to specify a deletion policy for both UniquePtr
|
|
|
|
* instantations, and T pretty much has to have a virtual destructor. In other
|
|
|
|
* words, this doesn't work:
|
|
|
|
*
|
|
|
|
* struct Base { virtual ~Base() {} };
|
|
|
|
* struct Derived : Base {};
|
|
|
|
*
|
|
|
|
* UniquePtr<Base> b1;
|
|
|
|
* // BAD: DefaultDelete<Base> and DefaultDelete<Derived> don't interconvert
|
2018-05-30 19:15:35 +00:00
|
|
|
* UniquePtr<Derived> d1(std::move(b));
|
2013-12-30 19:34:15 +00:00
|
|
|
*
|
|
|
|
* UniquePtr<Base> b2;
|
2018-05-30 19:15:35 +00:00
|
|
|
* UniquePtr<Derived, DefaultDelete<Base>> d2(std::move(b2)); // okay
|
2013-12-30 19:34:15 +00:00
|
|
|
*
|
|
|
|
* UniquePtr is specialized for array types. Specializing with an array type
|
|
|
|
* creates a smart-pointer version of that array -- not a pointer to such an
|
|
|
|
* array.
|
|
|
|
*
|
|
|
|
* UniquePtr<int[]> arr(new int[5]);
|
|
|
|
* arr[0] = 4;
|
|
|
|
*
|
|
|
|
* What else is different? Deletion of course uses |delete[]|. An operator[]
|
|
|
|
* is provided. Functionality that doesn't make sense for arrays is removed.
|
|
|
|
* The constructors and mutating methods only accept array pointers (not T*, U*
|
|
|
|
* that converts to T*, or UniquePtr<U[]> or UniquePtr<U>) or |nullptr|.
|
|
|
|
*
|
2016-04-11 21:36:29 +00:00
|
|
|
* It's perfectly okay for a function to return a UniquePtr. This transfers
|
|
|
|
* the UniquePtr's sole ownership of the data, to the fresh UniquePtr created
|
|
|
|
* in the calling function, that will then solely own that data. Such functions
|
|
|
|
* can return a local variable UniquePtr, |nullptr|, |UniquePtr(ptr)| where
|
|
|
|
* |ptr| is a |T*|, or a UniquePtr |Move()|'d from elsewhere.
|
2013-12-30 19:34:15 +00:00
|
|
|
*
|
|
|
|
* UniquePtr will commonly be a member of a class, with lifetime equivalent to
|
|
|
|
* that of that class. If you want to expose the related resource, you could
|
|
|
|
* expose a raw pointer via |get()|, but ownership of a raw pointer is
|
|
|
|
* inherently unclear. So it's better to expose a |const UniquePtr&| instead.
|
|
|
|
* This prohibits mutation but still allows use of |get()| when needed (but
|
|
|
|
* operator-> is preferred). Of course, you can only use this smart pointer as
|
|
|
|
* long as the enclosing class instance remains live -- no different than if you
|
|
|
|
* exposed the |get()| raw pointer.
|
|
|
|
*
|
|
|
|
* To pass a UniquePtr-managed resource as a pointer, use a |const UniquePtr&|
|
|
|
|
* argument. To specify an inout parameter (where the method may or may not
|
|
|
|
* take ownership of the resource, or reset it), or to specify an out parameter
|
|
|
|
* (where simply returning a |UniquePtr| isn't possible), use a |UniquePtr&|
|
|
|
|
* argument. To unconditionally transfer ownership of a UniquePtr
|
|
|
|
* into a method, use a |UniquePtr| argument. To conditionally transfer
|
|
|
|
* ownership of a resource into a method, should the method want it, use a
|
|
|
|
* |UniquePtr&&| argument.
|
|
|
|
*/
|
|
|
|
template <typename T, class D>
|
|
|
|
class UniquePtr {
|
2014-08-01 03:34:17 +00:00
|
|
|
public:
|
|
|
|
typedef T ElementType;
|
|
|
|
typedef D DeleterType;
|
2016-03-11 19:48:58 +00:00
|
|
|
typedef typename detail::PointerType<T, DeleterType>::Type Pointer;
|
2014-08-01 03:34:17 +00:00
|
|
|
|
|
|
|
private:
|
2020-03-17 12:42:12 +00:00
|
|
|
mozilla::CompactPair<Pointer, DeleterType> mTuple;
|
2014-08-01 03:34:17 +00:00
|
|
|
|
|
|
|
Pointer& ptr() { return mTuple.first(); }
|
|
|
|
const Pointer& ptr() const { return mTuple.first(); }
|
|
|
|
|
|
|
|
DeleterType& del() { return mTuple.second(); }
|
|
|
|
const DeleterType& del() const { return mTuple.second(); }
|
|
|
|
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Construct a UniquePtr containing |nullptr|.
|
|
|
|
*/
|
|
|
|
constexpr UniquePtr() : mTuple(static_cast<Pointer>(nullptr), DeleterType()) {
|
2020-03-28 13:57:14 +00:00
|
|
|
static_assert(!std::is_pointer_v<D>, "must provide a deleter instance");
|
2020-01-10 10:40:34 +00:00
|
|
|
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
|
2014-08-01 03:34:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Construct a UniquePtr containing |aPtr|.
|
|
|
|
*/
|
|
|
|
explicit UniquePtr(Pointer aPtr) : mTuple(aPtr, DeleterType()) {
|
2020-03-28 13:57:14 +00:00
|
|
|
static_assert(!std::is_pointer_v<D>, "must provide a deleter instance");
|
2020-01-10 10:40:34 +00:00
|
|
|
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
|
2014-08-01 03:34:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
UniquePtr(Pointer aPtr,
|
2020-03-28 13:57:18 +00:00
|
|
|
std::conditional_t<std::is_reference_v<D>, D, const D&> aD1)
|
2014-08-01 03:34:17 +00:00
|
|
|
: mTuple(aPtr, aD1) {}
|
|
|
|
|
2020-03-28 14:16:19 +00:00
|
|
|
UniquePtr(Pointer aPtr, std::remove_reference_t<D>&& aD2)
|
2018-05-30 19:15:35 +00:00
|
|
|
: mTuple(aPtr, std::move(aD2)) {
|
2020-01-10 10:40:34 +00:00
|
|
|
static_assert(!std::is_reference_v<D>,
|
2014-08-01 03:34:17 +00:00
|
|
|
"rvalue deleter can't be stored by reference");
|
|
|
|
}
|
|
|
|
|
|
|
|
UniquePtr(UniquePtr&& aOther)
|
2018-06-01 16:30:30 +00:00
|
|
|
: mTuple(aOther.release(),
|
|
|
|
std::forward<DeleterType>(aOther.get_deleter())) {}
|
2014-08-01 03:34:17 +00:00
|
|
|
|
2015-01-14 17:09:11 +00:00
|
|
|
MOZ_IMPLICIT
|
|
|
|
UniquePtr(decltype(nullptr)) : mTuple(nullptr, DeleterType()) {
|
2020-03-28 13:57:14 +00:00
|
|
|
static_assert(!std::is_pointer_v<D>, "must provide a deleter instance");
|
2020-01-10 10:40:34 +00:00
|
|
|
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
|
2014-08-01 03:34:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename U, class E>
|
2015-07-28 01:12:06 +00:00
|
|
|
MOZ_IMPLICIT UniquePtr(
|
2014-08-01 03:34:17 +00:00
|
|
|
UniquePtr<U, E>&& aOther,
|
2020-03-28 13:35:31 +00:00
|
|
|
std::enable_if_t<
|
2020-03-28 13:57:17 +00:00
|
|
|
std::is_convertible_v<typename UniquePtr<U, E>::Pointer, Pointer> &&
|
2020-03-28 13:57:17 +00:00
|
|
|
!std::is_array_v<U> &&
|
2020-03-28 13:57:20 +00:00
|
|
|
(std::is_reference_v<D> ? std::is_same_v<D, E>
|
2020-03-28 13:57:17 +00:00
|
|
|
: std::is_convertible_v<E, D>),
|
2020-03-28 13:35:31 +00:00
|
|
|
int>
|
|
|
|
aDummy = 0)
|
2018-06-01 16:30:30 +00:00
|
|
|
: mTuple(aOther.release(), std::forward<E>(aOther.get_deleter())) {}
|
2014-08-01 03:34:17 +00:00
|
|
|
|
|
|
|
~UniquePtr() { reset(nullptr); }
|
|
|
|
|
|
|
|
UniquePtr& operator=(UniquePtr&& aOther) {
|
|
|
|
reset(aOther.release());
|
2018-06-01 16:30:30 +00:00
|
|
|
get_deleter() = std::forward<DeleterType>(aOther.get_deleter());
|
2014-08-01 03:34:17 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename U, typename E>
|
|
|
|
UniquePtr& operator=(UniquePtr<U, E>&& aOther) {
|
|
|
|
static_assert(
|
2020-03-28 13:57:17 +00:00
|
|
|
std::is_convertible_v<typename UniquePtr<U, E>::Pointer, Pointer>,
|
2014-08-01 03:34:17 +00:00
|
|
|
"incompatible UniquePtr pointees");
|
2020-03-28 13:57:17 +00:00
|
|
|
static_assert(!std::is_array_v<U>,
|
2014-08-01 03:34:17 +00:00
|
|
|
"can't assign from UniquePtr holding an array");
|
|
|
|
|
|
|
|
reset(aOther.release());
|
2018-06-01 16:30:30 +00:00
|
|
|
get_deleter() = std::forward<E>(aOther.get_deleter());
|
2014-08-01 03:34:17 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2015-01-14 17:09:11 +00:00
|
|
|
UniquePtr& operator=(decltype(nullptr)) {
|
2014-08-01 03:34:17 +00:00
|
|
|
reset(nullptr);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2020-11-16 20:11:24 +00:00
|
|
|
std::add_lvalue_reference_t<T> operator*() const {
|
|
|
|
MOZ_ASSERT(get(), "dereferencing a UniquePtr containing nullptr with *");
|
|
|
|
return *get();
|
|
|
|
}
|
2014-08-01 03:34:17 +00:00
|
|
|
Pointer operator->() const {
|
2020-11-16 20:11:24 +00:00
|
|
|
MOZ_ASSERT(get(), "dereferencing a UniquePtr containing nullptr with ->");
|
2014-08-01 03:34:17 +00:00
|
|
|
return get();
|
|
|
|
}
|
|
|
|
|
2015-02-03 16:52:36 +00:00
|
|
|
explicit operator bool() const { return get() != nullptr; }
|
|
|
|
|
2014-08-01 03:34:17 +00:00
|
|
|
Pointer get() const { return ptr(); }
|
|
|
|
|
2016-02-22 16:54:36 +00:00
|
|
|
DeleterType& get_deleter() { return del(); }
|
|
|
|
const DeleterType& get_deleter() const { return del(); }
|
2014-08-01 03:34:17 +00:00
|
|
|
|
2021-03-17 03:01:21 +00:00
|
|
|
[[nodiscard]] Pointer release() {
|
2014-08-01 03:34:17 +00:00
|
|
|
Pointer p = ptr();
|
|
|
|
ptr() = nullptr;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
void reset(Pointer aPtr = Pointer()) {
|
|
|
|
Pointer old = ptr();
|
|
|
|
ptr() = aPtr;
|
|
|
|
if (old != nullptr) {
|
2016-02-22 16:54:36 +00:00
|
|
|
get_deleter()(old);
|
2013-12-30 19:34:15 +00:00
|
|
|
}
|
2014-08-01 03:34:17 +00:00
|
|
|
}
|
2013-12-30 19:34:15 +00:00
|
|
|
|
2014-08-01 03:34:17 +00:00
|
|
|
void swap(UniquePtr& aOther) { mTuple.swap(aOther.mTuple); }
|
2013-12-30 19:34:15 +00:00
|
|
|
|
2018-05-30 19:15:35 +00:00
|
|
|
UniquePtr(const UniquePtr& aOther) = delete; // construct using std::move()!
|
|
|
|
void operator=(const UniquePtr& aOther) =
|
|
|
|
delete; // assign using std::move()!
|
2013-12-30 19:34:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// In case you didn't read the comment by the main definition (you should!): the
|
|
|
|
// UniquePtr<T[]> specialization exists to manage array pointers. It deletes
|
|
|
|
// such pointers using delete[], it will reject construction and modification
|
|
|
|
// attempts using U* or U[]. Otherwise it works like the normal UniquePtr.
|
|
|
|
template <typename T, class D>
|
|
|
|
class UniquePtr<T[], D> {
|
2014-08-01 03:34:17 +00:00
|
|
|
public:
|
|
|
|
typedef T* Pointer;
|
|
|
|
typedef T ElementType;
|
|
|
|
typedef D DeleterType;
|
|
|
|
|
|
|
|
private:
|
2020-03-17 12:42:12 +00:00
|
|
|
mozilla::CompactPair<Pointer, DeleterType> mTuple;
|
2014-08-01 03:34:17 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Construct a UniquePtr containing nullptr.
|
|
|
|
*/
|
|
|
|
constexpr UniquePtr() : mTuple(static_cast<Pointer>(nullptr), DeleterType()) {
|
2020-03-28 13:57:14 +00:00
|
|
|
static_assert(!std::is_pointer_v<D>, "must provide a deleter instance");
|
2020-01-10 10:40:34 +00:00
|
|
|
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
|
2014-08-01 03:34:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Construct a UniquePtr containing |aPtr|.
|
|
|
|
*/
|
|
|
|
explicit UniquePtr(Pointer aPtr) : mTuple(aPtr, DeleterType()) {
|
2020-03-28 13:57:14 +00:00
|
|
|
static_assert(!std::is_pointer_v<D>, "must provide a deleter instance");
|
2020-01-10 10:40:34 +00:00
|
|
|
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
|
2014-08-01 03:34:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// delete[] knows how to handle *only* an array of a single class type. For
|
|
|
|
// delete[] to work correctly, it must know the size of each element, the
|
|
|
|
// fields and base classes of each element requiring destruction, and so on.
|
|
|
|
// So forbid all overloads which would end up invoking delete[] on a pointer
|
|
|
|
// of the wrong type.
|
|
|
|
template <typename U>
|
2020-03-28 13:35:31 +00:00
|
|
|
UniquePtr(U&& aU,
|
|
|
|
std::enable_if_t<
|
|
|
|
std::is_pointer_v<U> && std::is_convertible_v<U, Pointer>, int>
|
|
|
|
aDummy = 0) = delete;
|
2014-08-01 03:34:17 +00:00
|
|
|
|
|
|
|
UniquePtr(Pointer aPtr,
|
2020-03-28 13:57:18 +00:00
|
|
|
std::conditional_t<std::is_reference_v<D>, D, const D&> aD1)
|
2014-08-01 03:34:17 +00:00
|
|
|
: mTuple(aPtr, aD1) {}
|
|
|
|
|
2020-03-28 14:16:19 +00:00
|
|
|
UniquePtr(Pointer aPtr, std::remove_reference_t<D>&& aD2)
|
2018-05-30 19:15:35 +00:00
|
|
|
: mTuple(aPtr, std::move(aD2)) {
|
2020-01-10 10:40:34 +00:00
|
|
|
static_assert(!std::is_reference_v<D>,
|
2014-08-01 03:34:17 +00:00
|
|
|
"rvalue deleter can't be stored by reference");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Forbidden for the same reasons as stated above.
|
|
|
|
template <typename U, typename V>
|
2020-03-28 13:57:14 +00:00
|
|
|
UniquePtr(U&& aU, V&& aV,
|
2020-03-28 13:35:31 +00:00
|
|
|
std::enable_if_t<
|
|
|
|
std::is_pointer_v<U> && std::is_convertible_v<U, Pointer>, int>
|
|
|
|
aDummy = 0) = delete;
|
2014-08-01 03:34:17 +00:00
|
|
|
|
|
|
|
UniquePtr(UniquePtr&& aOther)
|
2018-06-01 16:30:30 +00:00
|
|
|
: mTuple(aOther.release(),
|
|
|
|
std::forward<DeleterType>(aOther.get_deleter())) {}
|
2014-08-01 03:34:17 +00:00
|
|
|
|
2015-01-14 17:09:11 +00:00
|
|
|
MOZ_IMPLICIT
|
|
|
|
UniquePtr(decltype(nullptr)) : mTuple(nullptr, DeleterType()) {
|
2020-03-28 13:57:14 +00:00
|
|
|
static_assert(!std::is_pointer_v<D>, "must provide a deleter instance");
|
2020-01-10 10:40:34 +00:00
|
|
|
static_assert(!std::is_reference_v<D>, "must provide a deleter instance");
|
2014-08-01 03:34:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
~UniquePtr() { reset(nullptr); }
|
|
|
|
|
|
|
|
UniquePtr& operator=(UniquePtr&& aOther) {
|
|
|
|
reset(aOther.release());
|
2018-06-01 16:30:30 +00:00
|
|
|
get_deleter() = std::forward<DeleterType>(aOther.get_deleter());
|
2014-08-01 03:34:17 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2015-01-14 17:09:11 +00:00
|
|
|
UniquePtr& operator=(decltype(nullptr)) {
|
2014-08-01 03:34:17 +00:00
|
|
|
reset();
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2015-02-03 16:52:36 +00:00
|
|
|
explicit operator bool() const { return get() != nullptr; }
|
|
|
|
|
2014-08-01 03:34:17 +00:00
|
|
|
T& operator[](decltype(sizeof(int)) aIndex) const { return get()[aIndex]; }
|
|
|
|
Pointer get() const { return mTuple.first(); }
|
|
|
|
|
2016-02-22 16:54:36 +00:00
|
|
|
DeleterType& get_deleter() { return mTuple.second(); }
|
|
|
|
const DeleterType& get_deleter() const { return mTuple.second(); }
|
2014-08-01 03:34:17 +00:00
|
|
|
|
2021-03-17 03:01:21 +00:00
|
|
|
[[nodiscard]] Pointer release() {
|
2014-08-01 03:34:17 +00:00
|
|
|
Pointer p = mTuple.first();
|
|
|
|
mTuple.first() = nullptr;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
void reset(Pointer aPtr = Pointer()) {
|
|
|
|
Pointer old = mTuple.first();
|
|
|
|
mTuple.first() = aPtr;
|
|
|
|
if (old != nullptr) {
|
|
|
|
mTuple.second()(old);
|
2013-12-30 19:34:15 +00:00
|
|
|
}
|
2014-08-01 03:34:17 +00:00
|
|
|
}
|
|
|
|
|
2015-01-14 17:09:11 +00:00
|
|
|
void reset(decltype(nullptr)) {
|
|
|
|
Pointer old = mTuple.first();
|
|
|
|
mTuple.first() = nullptr;
|
|
|
|
if (old != nullptr) {
|
|
|
|
mTuple.second()(old);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-01 03:34:17 +00:00
|
|
|
template <typename U>
|
2015-01-14 17:09:11 +00:00
|
|
|
void reset(U) = delete;
|
2014-08-01 03:34:17 +00:00
|
|
|
|
|
|
|
void swap(UniquePtr& aOther) { mTuple.swap(aOther.mTuple); }
|
|
|
|
|
2018-05-30 19:15:35 +00:00
|
|
|
UniquePtr(const UniquePtr& aOther) = delete; // construct using std::move()!
|
|
|
|
void operator=(const UniquePtr& aOther) =
|
|
|
|
delete; // assign using std::move()!
|
2013-12-30 19:34:15 +00:00
|
|
|
};
|
|
|
|
|
2016-01-27 02:02:04 +00:00
|
|
|
/**
|
|
|
|
* A default deletion policy using plain old operator delete.
|
|
|
|
*
|
|
|
|
* Note that this type can be specialized, but authors should beware of the risk
|
|
|
|
* that the specialization may at some point cease to match (either because it
|
|
|
|
* gets moved to a different compilation unit or the signature changes). If the
|
|
|
|
* non-specialized (|delete|-based) version compiles for that type but does the
|
|
|
|
* wrong thing, bad things could happen.
|
|
|
|
*
|
|
|
|
* This is a non-issue for types which are always incomplete (i.e. opaque handle
|
|
|
|
* types), since |delete|-ing such a type will always trigger a compilation
|
|
|
|
* error.
|
|
|
|
*/
|
2013-12-30 19:34:15 +00:00
|
|
|
template <typename T>
|
|
|
|
class DefaultDelete {
|
2014-08-01 03:34:17 +00:00
|
|
|
public:
|
2020-02-13 11:20:27 +00:00
|
|
|
constexpr DefaultDelete() = default;
|
2014-08-01 03:34:17 +00:00
|
|
|
|
|
|
|
template <typename U>
|
2015-07-28 01:12:06 +00:00
|
|
|
MOZ_IMPLICIT DefaultDelete(
|
|
|
|
const DefaultDelete<U>& aOther,
|
2020-03-28 13:35:31 +00:00
|
|
|
std::enable_if_t<std::is_convertible_v<U*, T*>, int> aDummy = 0) {}
|
2014-08-01 03:34:17 +00:00
|
|
|
|
|
|
|
void operator()(T* aPtr) const {
|
|
|
|
static_assert(sizeof(T) > 0, "T must be complete");
|
|
|
|
delete aPtr;
|
|
|
|
}
|
2013-12-30 19:34:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/** A default deletion policy using operator delete[]. */
|
|
|
|
template <typename T>
|
|
|
|
class DefaultDelete<T[]> {
|
2014-08-01 03:34:17 +00:00
|
|
|
public:
|
2020-02-13 11:20:27 +00:00
|
|
|
constexpr DefaultDelete() = default;
|
2014-08-01 03:34:17 +00:00
|
|
|
|
|
|
|
void operator()(T* aPtr) const {
|
|
|
|
static_assert(sizeof(T) > 0, "T must be complete");
|
|
|
|
delete[] aPtr;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename U>
|
2015-01-06 23:35:02 +00:00
|
|
|
void operator()(U* aPtr) const = delete;
|
2013-12-30 19:34:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T, class D, typename U, class E>
|
2014-08-01 03:34:17 +00:00
|
|
|
bool operator==(const UniquePtr<T, D>& aX, const UniquePtr<U, E>& aY) {
|
|
|
|
return aX.get() == aY.get();
|
2013-12-30 19:34:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class D, typename U, class E>
|
2014-08-01 03:34:17 +00:00
|
|
|
bool operator!=(const UniquePtr<T, D>& aX, const UniquePtr<U, E>& aY) {
|
|
|
|
return aX.get() != aY.get();
|
2013-12-30 19:34:15 +00:00
|
|
|
}
|
|
|
|
|
2020-01-20 20:06:30 +00:00
|
|
|
template <typename T, class D>
|
|
|
|
bool operator==(const UniquePtr<T, D>& aX, const T* aY) {
|
|
|
|
return aX.get() == aY;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class D>
|
|
|
|
bool operator==(const T* aY, const UniquePtr<T, D>& aX) {
|
|
|
|
return aY == aX.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class D>
|
|
|
|
bool operator!=(const UniquePtr<T, D>& aX, const T* aY) {
|
|
|
|
return aX.get() != aY;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class D>
|
|
|
|
bool operator!=(const T* aY, const UniquePtr<T, D>& aX) {
|
|
|
|
return aY != aX.get();
|
|
|
|
}
|
|
|
|
|
2013-12-30 19:34:15 +00:00
|
|
|
template <typename T, class D>
|
2015-01-14 17:09:11 +00:00
|
|
|
bool operator==(const UniquePtr<T, D>& aX, decltype(nullptr)) {
|
2014-08-01 03:34:17 +00:00
|
|
|
return !aX;
|
2013-12-30 19:34:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class D>
|
2015-01-14 17:09:11 +00:00
|
|
|
bool operator==(decltype(nullptr), const UniquePtr<T, D>& aX) {
|
2014-08-01 03:34:17 +00:00
|
|
|
return !aX;
|
2013-12-30 19:34:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class D>
|
2015-01-14 17:09:11 +00:00
|
|
|
bool operator!=(const UniquePtr<T, D>& aX, decltype(nullptr)) {
|
2014-08-01 03:34:17 +00:00
|
|
|
return bool(aX);
|
2013-12-30 19:34:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T, class D>
|
2015-01-14 17:09:11 +00:00
|
|
|
bool operator!=(decltype(nullptr), const UniquePtr<T, D>& aX) {
|
2014-08-01 03:34:17 +00:00
|
|
|
return bool(aX);
|
2013-12-30 19:34:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// No operator<, operator>, operator<=, operator>= for now because simplicity.
|
|
|
|
|
2014-06-11 00:42:58 +00:00
|
|
|
namespace detail {
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
struct UniqueSelector {
|
2014-08-01 03:34:17 +00:00
|
|
|
typedef UniquePtr<T> SingleObject;
|
2014-06-11 00:42:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
struct UniqueSelector<T[]> {
|
2014-08-01 03:34:17 +00:00
|
|
|
typedef UniquePtr<T[]> UnknownBound;
|
2014-06-11 00:42:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename T, decltype(sizeof(int)) N>
|
|
|
|
struct UniqueSelector<T[N]> {
|
2014-08-01 03:34:17 +00:00
|
|
|
typedef UniquePtr<T[N]> KnownBound;
|
2014-06-11 00:42:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace detail
|
|
|
|
|
2014-07-18 16:24:47 +00:00
|
|
|
/**
|
|
|
|
* MakeUnique is a helper function for allocating new'd objects and arrays,
|
|
|
|
* returning a UniquePtr containing the resulting pointer. The semantics of
|
|
|
|
* MakeUnique<Type>(...) are as follows.
|
|
|
|
*
|
|
|
|
* If Type is an array T[n]:
|
|
|
|
* Disallowed, deleted, no overload for you!
|
|
|
|
* If Type is an array T[]:
|
|
|
|
* MakeUnique<T[]>(size_t) is the only valid overload. The pointer returned
|
|
|
|
* is as if by |new T[n]()|, which value-initializes each element. (If T
|
|
|
|
* isn't a class type, this will zero each element. If T is a class type,
|
|
|
|
* then roughly speaking, each element will be constructed using its default
|
|
|
|
* constructor. See C++11 [dcl.init]p7 for the full gory details.)
|
|
|
|
* If Type is non-array T:
|
|
|
|
* The arguments passed to MakeUnique<T>(...) are forwarded into a
|
|
|
|
* |new T(...)| call, initializing the T as would happen if executing
|
2015-01-14 17:09:11 +00:00
|
|
|
* |T(...)|.
|
2014-07-18 16:24:47 +00:00
|
|
|
*
|
|
|
|
* There are various benefits to using MakeUnique instead of |new| expressions.
|
|
|
|
*
|
|
|
|
* First, MakeUnique eliminates use of |new| from code entirely. If objects are
|
|
|
|
* only created through UniquePtr, then (assuming all explicit release() calls
|
|
|
|
* are safe, including transitively, and no type-safety casting funniness)
|
|
|
|
* correctly maintained ownership of the UniquePtr guarantees no leaks are
|
|
|
|
* possible. (This pays off best if a class is only ever created through a
|
|
|
|
* factory method on the class, using a private constructor.)
|
|
|
|
*
|
2014-12-19 22:51:10 +00:00
|
|
|
* Second, initializing a UniquePtr using a |new| expression requires repeating
|
|
|
|
* the name of the new'd type, whereas MakeUnique in concert with the |auto|
|
|
|
|
* keyword names it only once:
|
2014-07-18 16:24:47 +00:00
|
|
|
*
|
|
|
|
* UniquePtr<char> ptr1(new char()); // repetitive
|
|
|
|
* auto ptr2 = MakeUnique<char>(); // shorter
|
|
|
|
*
|
|
|
|
* Of course this assumes the reader understands the operation MakeUnique
|
|
|
|
* performs. In the long run this is probably a reasonable assumption. In the
|
|
|
|
* short run you'll have to use your judgment about what readers can be expected
|
|
|
|
* to know, or to quickly look up.
|
|
|
|
*
|
|
|
|
* Third, a call to MakeUnique can be assigned directly to a UniquePtr. In
|
|
|
|
* contrast you can't assign a pointer into a UniquePtr without using the
|
|
|
|
* cumbersome reset().
|
|
|
|
*
|
|
|
|
* UniquePtr<char> p;
|
|
|
|
* p = new char; // ERROR
|
|
|
|
* p.reset(new char); // works, but fugly
|
|
|
|
* p = MakeUnique<char>(); // preferred
|
|
|
|
*
|
|
|
|
* (And third, although not relevant to Mozilla: MakeUnique is exception-safe.
|
|
|
|
* An exception thrown after |new T| succeeds will leak that memory, unless the
|
|
|
|
* pointer is assigned to an object that will manage its ownership. UniquePtr
|
|
|
|
* ably serves this function.)
|
|
|
|
*/
|
|
|
|
|
2015-01-12 23:48:10 +00:00
|
|
|
template <typename T, typename... Args>
|
2014-08-16 00:38:06 +00:00
|
|
|
typename detail::UniqueSelector<T>::SingleObject MakeUnique(Args&&... aArgs) {
|
2018-06-01 16:30:30 +00:00
|
|
|
return UniquePtr<T>(new T(std::forward<Args>(aArgs)...));
|
2014-08-16 00:38:06 +00:00
|
|
|
}
|
|
|
|
|
2014-06-11 00:42:58 +00:00
|
|
|
template <typename T>
|
|
|
|
typename detail::UniqueSelector<T>::UnknownBound MakeUnique(
|
2014-08-01 03:34:17 +00:00
|
|
|
decltype(sizeof(int)) aN) {
|
2020-03-28 13:57:16 +00:00
|
|
|
using ArrayType = std::remove_extent_t<T>;
|
2014-08-01 03:34:17 +00:00
|
|
|
return UniquePtr<T>(new ArrayType[aN]());
|
2014-06-11 00:42:58 +00:00
|
|
|
}
|
|
|
|
|
2015-01-12 23:48:10 +00:00
|
|
|
template <typename T, typename... Args>
|
2014-08-16 00:38:06 +00:00
|
|
|
typename detail::UniqueSelector<T>::KnownBound MakeUnique(Args&&... aArgs) =
|
2015-01-12 23:48:10 +00:00
|
|
|
delete;
|
2014-08-16 00:38:06 +00:00
|
|
|
|
2018-09-13 13:29:13 +00:00
|
|
|
/**
|
|
|
|
* WrapUnique is a helper function to transfer ownership from a raw pointer
|
|
|
|
* into a UniquePtr<T>. It can only be used with a single non-array type.
|
|
|
|
*
|
|
|
|
* It is generally used this way:
|
|
|
|
*
|
|
|
|
* auto p = WrapUnique(new char);
|
|
|
|
*
|
|
|
|
* It can be used when MakeUnique is not usable, for example, when the
|
|
|
|
* constructor you are using is private, or you want to use aggregate
|
|
|
|
* initialization.
|
|
|
|
*/
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
typename detail::UniqueSelector<T>::SingleObject WrapUnique(T* aPtr) {
|
|
|
|
return UniquePtr<T>(aPtr);
|
|
|
|
}
|
|
|
|
|
2013-12-30 19:34:15 +00:00
|
|
|
} // namespace mozilla
|
|
|
|
|
2020-01-20 16:17:06 +00:00
|
|
|
namespace std {
|
|
|
|
|
|
|
|
template <typename T, class D>
|
|
|
|
void swap(mozilla::UniquePtr<T, D>& aX, mozilla::UniquePtr<T, D>& aY) {
|
|
|
|
aX.swap(aY);
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace std
|
|
|
|
|
2013-12-30 19:34:15 +00:00
|
|
|
#endif /* mozilla_UniquePtr_h */
|