// unique_ptr implementation -*- C++ -*-
-// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2008-2014 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
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
-/** @file unique_ptr.h
+/** @file bits/unique_ptr.h
* This is an internal header file, included by other library headers.
- * You should not attempt to use it directly.
+ * Do not attempt to use it directly. @headername{memory}
*/
#ifndef _UNIQUE_PTR_H
#include <utility>
#include <tuple>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup pointer_abstractions
* @{
*/
- /// Primary template, default_delete.
- template<typename _Tp>
- struct default_delete
- {
- default_delete() { }
+#if _GLIBCXX_USE_DEPRECATED
+ template<typename> class auto_ptr;
+#endif
- template<typename _Up, typename = typename
- std::enable_if<std::is_convertible<_Up*, _Tp*>::value>::type>
- default_delete(const default_delete<_Up>&) { }
+ /// 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
+ enable_if<is_convertible<_Up*, _Tp*>::value>::type>
+ default_delete(const default_delete<_Up>&) noexcept { }
- void
- operator()(_Tp* __ptr) const
- {
- static_assert(sizeof(_Tp)>0,
- "can't delete pointer to incomplete type");
- delete __ptr;
- }
+ /// 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.
- template<typename _Tp>
+ /// 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
{
"can't delete pointer to incomplete type");
delete [] __ptr;
}
+
+ template<typename _Up>
+ typename enable_if<__is_derived_Tp<_Up>::value>::type
+ operator()(_Up*) const = delete;
};
- /// 20.7.12.2 unique_ptr for single objects.
- template <typename _Tp, typename _Dp = default_delete<_Tp> >
+ /// 20.7.1.2 unique_ptr for single objects.
+ template <typename _Tp, typename _Dp = default_delete<_Tp> >
class unique_ptr
{
- typedef std::tuple<_Tp*, _Dp> __tuple_type;
-
// use SFINAE to determine whether _Del::pointer exists
class _Pointer
{
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;
+ __tuple_type _M_t;
+
public:
- typedef typename _Pointer::type pointer;
+ typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
// Constructors.
- unique_ptr()
- : _M_t(pointer(), deleter_type())
- { static_assert(!std::is_pointer<deleter_type>::value,
- "constructed with null function pointer deleter"); }
+ /// Default constructor, creates a unique_ptr that owns nothing.
+ constexpr unique_ptr() noexcept
+ : _M_t()
+ { 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)
+ 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,
- deleter_type, const deleter_type&>::type __d)
+ 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)
+ typename 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(!std::is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
- unique_ptr(nullptr_t)
- : _M_t(pointer(), deleter_type())
- { }
+ /// Creates a unique_ptr that owns nothing.
+ constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
// Move constructors.
- unique_ptr(unique_ptr&& __u)
+
+ /// 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>
- unique_ptr(unique_ptr<_Up, _Ep>&& __u)
- : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter()))
+ /** @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_DEPRECATED
- template<typename _Up, typename = typename
- std::enable_if<std::is_convertible<_Up*, _Tp*>::value
- && std::is_same<_Dp,
- default_delete<_Tp>>::value>::type>
- unique_ptr(auto_ptr<_Up>&& __u)
- : _M_t(__u.release(), deleter_type()) { }
+#if _GLIBCXX_USE_DEPRECATED
+ /// 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.
- ~unique_ptr() { reset(); }
+ /// Destructor, invokes the deleter if the stored pointer is not null.
+ ~unique_ptr() noexcept
+ {
+ auto& __ptr = std::get<0>(_M_t);
+ if (__ptr != nullptr)
+ get_deleter()(__ptr);
+ __ptr = pointer();
+ }
// 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)
- {
- reset(__u.release());
- get_deleter() = std::move(__u.get_deleter());
- return *this;
+ operator=(unique_ptr&& __u) noexcept
+ {
+ reset(__u.release());
+ get_deleter() = std::forward<deleter_type>(__u.get_deleter());
+ 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&
- operator=(unique_ptr<_Up, _Ep>&& __u)
+ /** @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());
- get_deleter() = std::move(__u.get_deleter());
- return *this;
- }
+ reset(__u.release());
+ get_deleter() = std::forward<_Ep>(__u.get_deleter());
+ return *this;
+ }
+ /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
unique_ptr&
- operator=(nullptr_t)
+ operator=(nullptr_t) noexcept
{
reset();
return *this;
}
// 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
+ operator->() const noexcept
{
_GLIBCXX_DEBUG_ASSERT(get() != pointer());
return get();
}
+ /// Return the stored pointer.
pointer
- get() const
+ get() const noexcept
{ return std::get<0>(_M_t); }
+ /// Return a reference to the stored deleter.
deleter_type&
- get_deleter()
+ get_deleter() noexcept
{ return std::get<1>(_M_t); }
+ /// Return a reference to the stored deleter.
const deleter_type&
- get_deleter() const
+ get_deleter() const noexcept
{ return std::get<1>(_M_t); }
- explicit operator bool() const
+ /// 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()
+ release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
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())
+ reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
get_deleter()(__p);
}
+ /// Exchange the pointer and deleter with another object.
void
- swap(unique_ptr& __u)
+ swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
// Disable copy from lvalue.
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
-
- private:
- __tuple_type _M_t;
};
-
- /// 20.7.12.3 unique_ptr for array objects with a runtime length
+
+ /// 20.7.1.3 unique_ptr for array objects with a runtime length
// [unique.ptr.runtime]
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
template<typename _Tp, typename _Dp>
class unique_ptr<_Tp[], _Dp>
{
- typedef std::tuple<_Tp*, _Dp> __tuple_type;
+ // 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 _Tp element_type;
- typedef _Dp deleter_type;
+ typedef typename _Pointer::type pointer;
+ typedef _Tp element_type;
+ typedef _Dp deleter_type;
// Constructors.
- unique_ptr()
- : _M_t(pointer(), deleter_type())
+
+ /// 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"); }
+ /** 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)
+ 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"); }
+ // 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,
- deleter_type, const deleter_type&>::type __d)
+ typename conditional<is_reference<deleter_type>::value,
+ deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
- unique_ptr(pointer __p,
- typename std::remove_reference<deleter_type>::type && __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
+ 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"); }
- /* TODO: use delegating constructor */
- unique_ptr(nullptr_t)
- : _M_t(pointer(), deleter_type())
- { }
-
- // Move constructors.
- unique_ptr(unique_ptr&& __u)
+ /// Move constructor.
+ unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
- template<typename _Up, typename _Ep>
- unique_ptr(unique_ptr<_Up, _Ep>&& __u)
- : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter()))
+ /// 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.
- ~unique_ptr() { reset(); }
+ /// Destructor, invokes the deleter if the stored pointer is not null.
+ ~unique_ptr()
+ {
+ auto& __ptr = std::get<0>(_M_t);
+ if (__ptr != nullptr)
+ get_deleter()(__ptr);
+ __ptr = pointer();
+ }
// 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)
+ operator=(unique_ptr&& __u) noexcept
{
reset(__u.release());
- get_deleter() = std::move(__u.get_deleter());
- return *this;
+ get_deleter() = std::forward<deleter_type>(__u.get_deleter());
+ return *this;
}
- template<typename _Up, typename _Ep>
- unique_ptr&
- operator=(unique_ptr<_Up, _Ep>&& __u)
+ /** @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>
+ typename
+ enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr&>::type
+ operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
- reset(__u.release());
- get_deleter() = std::move(__u.get_deleter());
- return *this;
- }
+ reset(__u.release());
+ get_deleter() = std::forward<_Ep>(__u.get_deleter());
+ return *this;
+ }
+ /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
unique_ptr&
- operator=(nullptr_t)
+ operator=(nullptr_t) noexcept
{
reset();
return *this;
}
// Observers.
- typename std::add_lvalue_reference<element_type>::type
- operator[](size_t __i) const
+
+ /// Access an element of owned array.
+ typename std::add_lvalue_reference<element_type>::type
+ operator[](size_t __i) const
{
_GLIBCXX_DEBUG_ASSERT(get() != pointer());
return get()[__i];
}
+ /// Return the stored pointer.
pointer
- get() const
+ get() const noexcept
{ return std::get<0>(_M_t); }
- deleter_type&
- get_deleter()
+ /// 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
- { return std::get<1>(_M_t); }
+ get_deleter() const noexcept
+ { return std::get<1>(_M_t); }
- explicit operator bool() const
+ /// 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()
+ release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
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())
+ reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
get_deleter()(__p);
}
- void
- reset(nullptr_t)
- {
- 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)
+ swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
unique_ptr& operator=(const unique_ptr&) = delete;
// Disable construction from convertible pointer types.
- // (N2315 - 20.6.5.3.1)
- template<typename _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;
+ template<typename _Up, typename = _Require<is_pointer<pointer>,
+ is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
+ unique_ptr(_Up*, typename
+ 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;
+ };
- private:
- __tuple_type _M_t;
- };
-
- template<typename _Tp, typename _Dp>
+ template<typename _Tp, typename _Dp>
inline void
swap(unique_ptr<_Tp, _Dp>& __x,
- unique_ptr<_Tp, _Dp>& __y)
+ unique_ptr<_Tp, _Dp>& __y) noexcept
{ __x.swap(__y); }
template<typename _Tp, typename _Dp,
template<typename _Tp, typename _Dp>
inline bool
- operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
- { return __x.get() == nullptr; }
+ operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
+ { return !__x; }
template<typename _Tp, typename _Dp>
inline bool
- operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __y)
- { return nullptr == __y.get(); }
+ operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
+ { return !__x; }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
- { return !(__x.get() == __y.get()); }
+ { return __x.get() != __y.get(); }
template<typename _Tp, typename _Dp>
inline bool
- operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
- { return __x.get() != nullptr; }
+ operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
+ { return (bool)__x; }
template<typename _Tp, typename _Dp>
inline bool
- operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __y)
- { return nullptr != __y.get(); }
+ operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
+ { return (bool)__x; }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator<(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
- { return __x.get() < __y.get(); }
+ {
+ typedef typename
+ std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
+ typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
+ return std::less<_CT>()(__x.get(), __y.get());
+ }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+ { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
+ nullptr); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+ { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
+ __x.get()); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
- { return !(__y.get() < __x.get()); }
+ { return !(__y < __x); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+ { return !(nullptr < __x); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+ { return !(__x < nullptr); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator>(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
- { return __y.get() < __x.get(); }
+ { return (__y < __x); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+ { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
+ __x.get()); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+ { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
+ nullptr); }
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
- { return !(__x.get() < __y.get()); }
+ { return !(__x < __y); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+ { return !(__x < nullptr); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+ { return !(nullptr < __x); }
/// std::hash specialization for unique_ptr.
template<typename _Tp, typename _Dp>
struct hash<unique_ptr<_Tp, _Dp>>
- : public std::unary_function<unique_ptr<_Tp, _Dp>, size_t>
+ : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>
{
size_t
- operator()(const unique_ptr<_Tp, _Dp>& __u) const
+ operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
{
typedef unique_ptr<_Tp, _Dp> _UP;
return std::hash<typename _UP::pointer>()(__u.get());
}
};
+#if __cplusplus > 201103L
+ 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 typename remove_extent<_Tp>::type[__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
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _UNIQUE_PTR_H */
projects / thirdparty / gcc.git / blobdiff