// unique_ptr implementation -*- C++ -*-
-// Copyright (C) 2008-2012 Free Software Foundation, Inc.
+// Copyright (C) 2008-2015 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
template<typename> class auto_ptr;
#endif
- /// Primary template, default_delete.
+ /// Primary template of default_delete, used by unique_ptr
template<typename _Tp>
struct default_delete
{
+ /// Default constructor
constexpr default_delete() noexcept = default;
+ /** @brief Converting constructor.
+ *
+ * Allows conversion from a deleter for arrays of another type, @p _Up,
+ * only if @p _Up* is convertible to @p _Tp*.
+ */
template<typename _Up, typename = typename
- std::enable_if<std::is_convertible<_Up*, _Tp*>::value>::type>
+ enable_if<is_convertible<_Up*, _Tp*>::value>::type>
default_delete(const default_delete<_Up>&) noexcept { }
+ /// Calls @c delete @p __ptr
void
operator()(_Tp* __ptr) const
{
+ static_assert(!is_void<_Tp>::value,
+ "can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete __ptr;
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
- /// Specialization, default_delete.
+ /// Specialization for arrays, default_delete.
template<typename _Tp>
struct default_delete<_Tp[]>
{
+ private:
+ template<typename _Up>
+ using __remove_cv = typename remove_cv<_Up>::type;
+
+ // Like is_base_of<_Tp, _Up> but false if unqualified types are the same
+ template<typename _Up>
+ using __is_derived_Tp
+ = __and_< is_base_of<_Tp, _Up>,
+ __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
+
+ public:
+ /// Default constructor
constexpr default_delete() noexcept = default;
+ /** @brief Converting constructor.
+ *
+ * Allows conversion from a deleter for arrays of another type, such as
+ * a const-qualified version of @p _Tp.
+ *
+ * Conversions from types derived from @c _Tp are not allowed because
+ * it is unsafe to @c delete[] an array of derived types through a
+ * pointer to the base type.
+ */
+ template<typename _Up, typename = typename
+ enable_if<!__is_derived_Tp<_Up>::value>::type>
+ default_delete(const default_delete<_Up[]>&) noexcept { }
+
+ /// Calls @c delete[] @p __ptr
void
operator()(_Tp* __ptr) const
{
delete [] __ptr;
}
- template<typename _Up> void operator()(_Up*) const = delete;
+ template<typename _Up>
+ typename enable_if<__is_derived_Tp<_Up>::value>::type
+ operator()(_Up*) const = delete;
};
/// 20.7.1.2 unique_ptr for single objects.
typedef typename remove_reference<_Dp>::type _Del;
public:
- typedef decltype( __test<_Del>(0)) type;
+ typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
typedef _Dp deleter_type;
// Constructors.
+
+ /// Default constructor, creates a unique_ptr that owns nothing.
constexpr unique_ptr() noexcept
: _M_t()
- { static_assert(!std::is_pointer<deleter_type>::value,
+ { static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
+ /** Takes ownership of a pointer.
+ *
+ * @param __p A pointer to an object of @c element_type
+ *
+ * The deleter will be value-initialized.
+ */
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
- { static_assert(!std::is_pointer<deleter_type>::value,
+ { static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
+ /** Takes ownership of a pointer.
+ *
+ * @param __p A pointer to an object of @c element_type
+ * @param __d A reference to a deleter.
+ *
+ * The deleter will be initialized with @p __d
+ */
unique_ptr(pointer __p,
- typename std::conditional<std::is_reference<deleter_type>::value,
+ typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
+ /** Takes ownership of a pointer.
+ *
+ * @param __p A pointer to an object of @c element_type
+ * @param __d An rvalue reference to a deleter.
+ *
+ * The deleter will be initialized with @p std::move(__d)
+ */
unique_ptr(pointer __p,
- typename std::remove_reference<deleter_type>::type&& __d) noexcept
+ typename remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ static_assert(!std::is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
- constexpr unique_ptr(nullptr_t) noexcept
- : _M_t()
- { static_assert(!std::is_pointer<deleter_type>::value,
- "constructed with null function pointer deleter"); }
+ /// Creates a unique_ptr that owns nothing.
+ constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
// Move constructors.
+
+ /// Move constructor.
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
- template<typename _Up, typename _Ep, typename = typename
- std::enable_if
- <std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
- pointer>::value
- && !std::is_array<_Up>::value
- && ((std::is_reference<_Dp>::value
- && std::is_same<_Ep, _Dp>::value)
- || (!std::is_reference<_Dp>::value
- && std::is_convertible<_Ep, _Dp>::value))>
- ::type>
+ /** @brief Converting constructor from another type
+ *
+ * Requires that the pointer owned by @p __u is convertible to the
+ * type of pointer owned by this object, @p __u does not own an array,
+ * and @p __u has a compatible deleter type.
+ */
+ template<typename _Up, typename _Ep, typename = _Require<
+ is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
+ __not_<is_array<_Up>>,
+ typename conditional<is_reference<_Dp>::value,
+ is_same<_Ep, _Dp>,
+ is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
#if _GLIBCXX_USE_DEPRECATED
- template<typename _Up, typename = typename
- std::enable_if<std::is_convertible<_Up*, _Tp*>::value
- && std::is_same<_Dp,
- default_delete<_Tp>>::value>::type>
+ /// Converting constructor from @c auto_ptr
+ template<typename _Up, typename = _Require<
+ is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
#endif
- // Destructor.
+ /// Destructor, invokes the deleter if the stored pointer is not null.
~unique_ptr() noexcept
{
auto& __ptr = std::get<0>(_M_t);
}
// Assignment.
+
+ /** @brief Move assignment operator.
+ *
+ * @param __u The object to transfer ownership from.
+ *
+ * Invokes the deleter first if this object owns a pointer.
+ */
unique_ptr&
operator=(unique_ptr&& __u) noexcept
{
return *this;
}
- template<typename _Up, typename _Ep, typename = typename
- std::enable_if
- <std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
- pointer>::value
- && !std::is_array<_Up>::value>::type>
- unique_ptr&
+ /** @brief Assignment from another type.
+ *
+ * @param __u The object to transfer ownership from, which owns a
+ * convertible pointer to a non-array object.
+ *
+ * Invokes the deleter first if this object owns a pointer.
+ */
+ template<typename _Up, typename _Ep>
+ typename enable_if< __and_<
+ is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
+ __not_<is_array<_Up>>
+ >::value,
+ unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
return *this;
}
+ /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
unique_ptr&
operator=(nullptr_t) noexcept
{
}
// Observers.
- typename std::add_lvalue_reference<element_type>::type
+
+ /// Dereference the stored pointer.
+ typename add_lvalue_reference<element_type>::type
operator*() const
{
_GLIBCXX_DEBUG_ASSERT(get() != pointer());
return *get();
}
+ /// Return the stored pointer.
pointer
operator->() const noexcept
{
return get();
}
+ /// Return the stored pointer.
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
+ /// Return a reference to the stored deleter.
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
+ /// Return a reference to the stored deleter.
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
+ /// Return @c true if the stored pointer is not null.
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
// Modifiers.
+
+ /// Release ownership of any stored pointer.
pointer
release() noexcept
{
return __p;
}
+ /** @brief Replace the stored pointer.
+ *
+ * @param __p The new pointer to store.
+ *
+ * The deleter will be invoked if a pointer is already owned.
+ */
void
reset(pointer __p = pointer()) noexcept
{
get_deleter()(__p);
}
+ /// Exchange the pointer and deleter with another object.
void
swap(unique_ptr& __u) noexcept
{
template<typename _Tp, typename _Dp>
class unique_ptr<_Tp[], _Dp>
{
- typedef std::tuple<_Tp*, _Dp> __tuple_type;
- __tuple_type _M_t;
+ // use SFINAE to determine whether _Del::pointer exists
+ class _Pointer
+ {
+ template<typename _Up>
+ static typename _Up::pointer __test(typename _Up::pointer*);
+
+ template<typename _Up>
+ static _Tp* __test(...);
+
+ typedef typename remove_reference<_Dp>::type _Del;
+
+ public:
+ typedef decltype(__test<_Del>(0)) type;
+ };
+
+ typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
+ __tuple_type _M_t;
+
+ template<typename _Up>
+ using __remove_cv = typename remove_cv<_Up>::type;
+
+ // like is_base_of<_Tp, _Up> but false if unqualified types are the same
+ template<typename _Up>
+ using __is_derived_Tp
+ = __and_< is_base_of<_Tp, _Up>,
+ __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
+
+ template<typename _Up, typename _Ep,
+ typename _Tp_pointer = typename _Pointer::type,
+ typename _Up_pointer = typename unique_ptr<_Up, _Ep>::pointer>
+ using __safe_conversion = __and_<
+ is_convertible<_Up_pointer, _Tp_pointer>,
+ is_array<_Up>,
+ __or_<__not_<is_pointer<_Up_pointer>>,
+ __not_<is_pointer<_Tp_pointer>>,
+ __not_<__is_derived_Tp<typename remove_extent<_Up>::type>>
+ >
+ >;
public:
- typedef _Tp* pointer;
+ typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
// Constructors.
+
+ /// Default constructor, creates a unique_ptr that owns nothing.
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
- "constructed with null function pointer deleter"); }
-
+ "constructed with null function pointer deleter"); }
+
+ /** Takes ownership of a pointer.
+ *
+ * @param __p A pointer to an array of @c element_type
+ *
+ * The deleter will be value-initialized.
+ */
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
- { static_assert(!std::is_pointer<deleter_type>::value,
- "constructed with null function pointer deleter"); }
+ { static_assert(!is_pointer<deleter_type>::value,
+ "constructed with null function pointer deleter"); }
+ // Disable construction from convertible pointer types.
+ template<typename _Up, typename = _Require<is_pointer<pointer>,
+ is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+ explicit
+ unique_ptr(_Up* __p) = delete;
+
+ /** Takes ownership of a pointer.
+ *
+ * @param __p A pointer to an array of @c element_type
+ * @param __d A reference to a deleter.
+ *
+ * The deleter will be initialized with @p __d
+ */
unique_ptr(pointer __p,
- typename std::conditional<std::is_reference<deleter_type>::value,
+ typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
+ /** Takes ownership of a pointer.
+ *
+ * @param __p A pointer to an array of @c element_type
+ * @param __d A reference to a deleter.
+ *
+ * The deleter will be initialized with @p std::move(__d)
+ */
unique_ptr(pointer __p, typename
- std::remove_reference<deleter_type>::type && __d) noexcept
+ remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
- { static_assert(!std::is_reference<deleter_type>::value,
+ { static_assert(!is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
- constexpr unique_ptr(nullptr_t) noexcept
- : _M_t()
- { static_assert(!std::is_pointer<deleter_type>::value,
- "constructed with null function pointer deleter"); }
-
- // Move constructors.
+ /// Move constructor.
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
- template<typename _Up, typename _Ep>
+ /// Creates a unique_ptr that owns nothing.
+ constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
+
+ template<typename _Up, typename _Ep,
+ typename = _Require<__safe_conversion<_Up, _Ep>,
+ typename conditional<is_reference<_Dp>::value,
+ is_same<_Ep, _Dp>,
+ is_convertible<_Ep, _Dp>>::type
+ >>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
- // Destructor.
+ /// Destructor, invokes the deleter if the stored pointer is not null.
~unique_ptr()
{
auto& __ptr = std::get<0>(_M_t);
}
// Assignment.
+
+ /** @brief Move assignment operator.
+ *
+ * @param __u The object to transfer ownership from.
+ *
+ * Invokes the deleter first if this object owns a pointer.
+ */
unique_ptr&
operator=(unique_ptr&& __u) noexcept
{
return *this;
}
+ /** @brief Assignment from another type.
+ *
+ * @param __u The object to transfer ownership from, which owns a
+ * convertible pointer to an array object.
+ *
+ * Invokes the deleter first if this object owns a pointer.
+ */
template<typename _Up, typename _Ep>
- unique_ptr&
+ typename
+ enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
return *this;
}
+ /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
unique_ptr&
operator=(nullptr_t) noexcept
{
}
// Observers.
+
+ /// Access an element of owned array.
typename std::add_lvalue_reference<element_type>::type
operator[](size_t __i) const
{
return get()[__i];
}
+ /// Return the stored pointer.
pointer
get() const noexcept
{ return std::get<0>(_M_t); }
+ /// Return a reference to the stored deleter.
deleter_type&
get_deleter() noexcept
{ return std::get<1>(_M_t); }
+ /// Return a reference to the stored deleter.
const deleter_type&
get_deleter() const noexcept
{ return std::get<1>(_M_t); }
+ /// Return @c true if the stored pointer is not null.
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
// Modifiers.
+
+ /// Release ownership of any stored pointer.
pointer
release() noexcept
{
return __p;
}
+ /** @brief Replace the stored pointer.
+ *
+ * @param __p The new pointer to store.
+ *
+ * The deleter will be invoked if a pointer is already owned.
+ */
void
reset(pointer __p = pointer()) noexcept
{
get_deleter()(__p);
}
- void
- reset(nullptr_t) noexcept
- {
- pointer __p = get();
- std::get<0>(_M_t) = pointer();
- if (__p != nullptr)
- get_deleter()(__p);
- }
-
- // DR 821.
- template<typename _Up>
- void reset(_Up) = delete;
+ // Disable resetting from convertible pointer types.
+ template<typename _Up, typename = _Require<is_pointer<pointer>,
+ is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+ void reset(_Up*) = delete;
+ /// Exchange the pointer and deleter with another object.
void
swap(unique_ptr& __u) noexcept
{
unique_ptr& operator=(const unique_ptr&) = delete;
// Disable construction from convertible pointer types.
- // (N2315 - 20.7.1.3.1)
- template<typename _Up>
+ template<typename _Up, typename = _Require<is_pointer<pointer>,
+ is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
unique_ptr(_Up*, typename
- std::conditional<std::is_reference<deleter_type>::value,
- deleter_type, const deleter_type&>::type,
- typename std::enable_if<std::is_convertible<_Up*,
- pointer>::value>::type* = 0) = delete;
-
- template<typename _Up>
- unique_ptr(_Up*, typename std::remove_reference<deleter_type>::type&&,
- typename std::enable_if<std::is_convertible<_Up*,
- pointer>::value>::type* = 0) = delete;
+ conditional<is_reference<deleter_type>::value,
+ deleter_type, const deleter_type&>::type) = delete;
- template<typename _Up>
- explicit
- unique_ptr(_Up*, typename std::enable_if<std::is_convertible<_Up*,
- pointer>::value>::type* = 0) = delete;
+ // Disable construction from convertible pointer types.
+ template<typename _Up, typename = _Require<is_pointer<pointer>,
+ is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+ unique_ptr(_Up*, typename
+ remove_reference<deleter_type>::type&&) = delete;
};
template<typename _Tp, typename _Dp>
}
};
+#if __cplusplus > 201103L
+
+#define __cpp_lib_make_unique 201304
+
+ template<typename _Tp>
+ struct _MakeUniq
+ { typedef unique_ptr<_Tp> __single_object; };
+
+ template<typename _Tp>
+ struct _MakeUniq<_Tp[]>
+ { typedef unique_ptr<_Tp[]> __array; };
+
+ template<typename _Tp, size_t _Bound>
+ struct _MakeUniq<_Tp[_Bound]>
+ { struct __invalid_type { }; };
+
+ /// std::make_unique for single objects
+ template<typename _Tp, typename... _Args>
+ inline typename _MakeUniq<_Tp>::__single_object
+ make_unique(_Args&&... __args)
+ { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
+
+ /// std::make_unique for arrays of unknown bound
+ template<typename _Tp>
+ inline typename _MakeUniq<_Tp>::__array
+ make_unique(size_t __num)
+ { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
+
+ /// Disable std::make_unique for arrays of known bound
+ template<typename _Tp, typename... _Args>
+ inline typename _MakeUniq<_Tp>::__invalid_type
+ make_unique(_Args&&...) = delete;
+#endif
+
// @} group pointer_abstractions
_GLIBCXX_END_NAMESPACE_VERSION
projects / gcc.git / blobdiff