// unique_ptr implementation -*- C++ -*-
-// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010, 2011 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>
+ template<typename _Tp>
struct default_delete
- {
- default_delete() { }
+ {
+ constexpr default_delete() noexcept = default;
- template<typename _Up, typename = typename
- std::enable_if<std::is_convertible<_Up*, _Tp*>::value>::type>
- default_delete(const default_delete<_Up>&) { }
+ template<typename _Up, typename = typename
+ std::enable_if<std::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;
- }
+ void
+ operator()(_Tp* __ptr) const
+ {
+ 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>
+ template<typename _Tp>
struct default_delete<_Tp[]>
{
+ constexpr default_delete() noexcept = default;
+
void
operator()(_Tp* __ptr) const
{
"can't delete pointer to incomplete type");
delete [] __ptr;
}
+
+ template<typename _Up> void operator()(_Up*) const = delete;
};
/// 20.7.12.2 unique_ptr for single objects.
- template <typename _Tp, typename _Tp_Deleter = default_delete<_Tp> >
+ template <typename _Tp, typename _Dp = default_delete<_Tp> >
class unique_ptr
{
- typedef std::tuple<_Tp*, _Tp_Deleter> __tuple_type;
-
// use SFINAE to determine whether _Del::pointer exists
class _Pointer
{
template<typename _Up>
static _Tp* __test(...);
- typedef typename remove_reference<_Tp_Deleter>::type _Del;
+ 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 _Tp_Deleter deleter_type;
+ typedef _Dp deleter_type;
// Constructors.
- unique_ptr()
- : _M_t(pointer(), deleter_type())
+ 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"); }
explicit
- unique_ptr(pointer __p)
+ unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
unique_ptr(pointer __p,
- typename std::conditional<std::is_reference<deleter_type>::value,
- deleter_type, const deleter_type&>::type __d)
+ typename std::conditional<std::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)
+ typename std::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())
- { }
+ constexpr unique_ptr(nullptr_t) noexcept
+ : _M_t()
+ { static_assert(!std::is_pointer<deleter_type>::value,
+ "constructed with null function pointer deleter"); }
// Move constructors.
- unique_ptr(unique_ptr&& __u)
+ unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
- template<typename _Up, typename _Up_Deleter, typename = typename
+ template<typename _Up, typename _Ep, typename = typename
std::enable_if
- <std::is_convertible<typename unique_ptr<_Up, _Up_Deleter>::pointer,
+ <std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
pointer>::value
&& !std::is_array<_Up>::value
- && ((std::is_reference<_Tp_Deleter>::value
- && std::is_same<_Up_Deleter, _Tp_Deleter>::value)
- || (!std::is_reference<_Tp_Deleter>::value
- && std::is_convertible<_Up_Deleter, _Tp_Deleter>::value))>
- ::type>
- unique_ptr(unique_ptr<_Up, _Up_Deleter>&& __u)
- : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter()))
+ && ((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) noexcept
+ : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
-#if _GLIBCXX_DEPRECATED
+#if _GLIBCXX_USE_DEPRECATED
template<typename _Up, typename = typename
std::enable_if<std::is_convertible<_Up*, _Tp*>::value
- && std::is_same<_Tp_Deleter,
+ && std::is_same<_Dp,
default_delete<_Tp>>::value>::type>
- unique_ptr(auto_ptr<_Up>&& __u)
+ unique_ptr(auto_ptr<_Up>&& __u) noexcept
: _M_t(__u.release(), deleter_type()) { }
#endif
// Destructor.
- ~unique_ptr() { reset(); }
+ ~unique_ptr() noexcept
+ {
+ auto& __ptr = std::get<0>(_M_t);
+ if (__ptr != nullptr)
+ get_deleter()(__ptr);
+ __ptr = pointer();
+ }
// Assignment.
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 _Up_Deleter, typename = typename
- std::enable_if
- <std::is_convertible<typename unique_ptr<_Up, _Up_Deleter>::pointer,
+ 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, _Up_Deleter>&& __u)
+ && !std::is_array<_Up>::value>::type>
+ unique_ptr&
+ 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;
+ }
unique_ptr&
- operator=(nullptr_t)
+ operator=(nullptr_t) noexcept
{
reset();
return *this;
}
pointer
- operator->() const
+ operator->() const noexcept
{
_GLIBCXX_DEBUG_ASSERT(get() != pointer());
return get();
}
pointer
- get() const
+ get() const noexcept
{ return std::get<0>(_M_t); }
deleter_type&
- get_deleter()
+ get_deleter() noexcept
{ return std::get<1>(_M_t); }
const deleter_type&
- get_deleter() const
+ get_deleter() const noexcept
{ return std::get<1>(_M_t); }
- explicit operator bool() const
+ explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
// Modifiers.
pointer
- release()
+ release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
}
void
- reset(pointer __p = pointer())
+ reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
}
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
// [unique.ptr.runtime]
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
- template<typename _Tp, typename _Tp_Deleter>
- class unique_ptr<_Tp[], _Tp_Deleter>
+ template<typename _Tp, typename _Dp>
+ class unique_ptr<_Tp[], _Dp>
{
- typedef std::tuple<_Tp*, _Tp_Deleter> __tuple_type;
+ typedef std::tuple<_Tp*, _Dp> __tuple_type;
+ __tuple_type _M_t;
public:
- typedef _Tp* pointer;
- typedef _Tp element_type;
- typedef _Tp_Deleter deleter_type;
+ typedef _Tp* pointer;
+ typedef _Tp element_type;
+ typedef _Dp deleter_type;
// Constructors.
- unique_ptr()
- : _M_t(pointer(), deleter_type())
+ 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"); }
explicit
- unique_ptr(pointer __p)
+ unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!std::is_pointer<deleter_type>::value,
- "constructed with null function pointer deleter"); }
+ "constructed with null function pointer deleter"); }
unique_ptr(pointer __p,
- typename std::conditional<std::is_reference<deleter_type>::value,
- deleter_type, const deleter_type&>::type __d)
+ typename std::conditional<std::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)
+ unique_ptr(pointer __p, typename
+ std::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"); }
- /* TODO: use delegating constructor */
- unique_ptr(nullptr_t)
- : _M_t(pointer(), deleter_type())
- { }
+ constexpr unique_ptr(nullptr_t) noexcept
+ : _M_t()
+ { static_assert(!std::is_pointer<deleter_type>::value,
+ "constructed with null function pointer deleter"); }
// Move constructors.
- unique_ptr(unique_ptr&& __u)
+ unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
- template<typename _Up, typename _Up_Deleter>
- unique_ptr(unique_ptr<_Up, _Up_Deleter>&& __u)
- : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter()))
+ template<typename _Up, typename _Ep>
+ unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
+ : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
// Destructor.
- ~unique_ptr() { reset(); }
+ ~unique_ptr()
+ {
+ auto& __ptr = std::get<0>(_M_t);
+ if (__ptr != nullptr)
+ get_deleter()(__ptr);
+ __ptr = pointer();
+ }
// Assignment.
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 _Up_Deleter>
- unique_ptr&
- operator=(unique_ptr<_Up, _Up_Deleter>&& __u)
+ template<typename _Up, typename _Ep>
+ unique_ptr&
+ 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;
+ }
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
+ typename std::add_lvalue_reference<element_type>::type
+ operator[](size_t __i) const
{
_GLIBCXX_DEBUG_ASSERT(get() != pointer());
return get()[__i];
}
pointer
- get() const
+ get() const noexcept
{ return std::get<0>(_M_t); }
- deleter_type&
- get_deleter()
+ deleter_type&
+ get_deleter() noexcept
{ return std::get<1>(_M_t); }
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
+ explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
-
+
// Modifiers.
pointer
- release()
+ release() noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
}
void
- reset(pointer __p = pointer())
+ reset(pointer __p = pointer()) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
}
void
- reset(nullptr_t)
+ reset(nullptr_t) noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
// DR 821.
template<typename _Up>
- void reset(_Up) = delete;
+ void reset(_Up) = delete;
void
- swap(unique_ptr& __u)
+ swap(unique_ptr& __u) noexcept
{
using std::swap;
swap(_M_t, __u._M_t);
// Disable construction from convertible pointer types.
// (N2315 - 20.6.5.3.1)
template<typename _Up>
- unique_ptr(_Up*, typename
+ 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*,
+ 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*,
+ 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>
- explicit
- unique_ptr(_Up*, typename std::enable_if<std::is_convertible<_Up*,
+ explicit
+ unique_ptr(_Up*, typename std::enable_if<std::is_convertible<_Up*,
pointer>::value>::type* = 0) = delete;
+ };
- private:
- __tuple_type _M_t;
- };
-
- template<typename _Tp, typename _Tp_Deleter>
+ template<typename _Tp, typename _Dp>
inline void
- swap(unique_ptr<_Tp, _Tp_Deleter>& __x,
- unique_ptr<_Tp, _Tp_Deleter>& __y)
+ swap(unique_ptr<_Tp, _Dp>& __x,
+ unique_ptr<_Tp, _Dp>& __y) noexcept
{ __x.swap(__y); }
- template<typename _Tp, typename _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp,
+ typename _Up, typename _Ep>
inline bool
- operator==(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
+ operator==(const unique_ptr<_Tp, _Dp>& __x,
+ const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() == __y.get(); }
- template<typename _Tp, typename _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp>
+ inline bool
+ 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>& __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(); }
+
+ template<typename _Tp, typename _Dp>
+ inline bool
+ 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>& __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)
+ {
+ 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 < __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 < __x); }
+
+ template<typename _Tp, typename _Dp>
inline bool
- operator!=(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
- { return !(__x.get() == __y.get()); }
+ 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 _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp>
inline bool
- operator<(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
- { return __x.get() < __y.get(); }
+ 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 _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp,
+ typename _Up, typename _Ep>
inline bool
- operator<=(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
- { return !(__y.get() < __x.get()); }
+ operator>=(const unique_ptr<_Tp, _Dp>& __x,
+ const unique_ptr<_Up, _Ep>& __y)
+ { return !(__x < __y); }
- template<typename _Tp, typename _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp>
inline bool
- operator>(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
- { return __y.get() < __x.get(); }
+ operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+ { return !(__x < nullptr); }
- template<typename _Tp, typename _Tp_Deleter,
- typename _Up, typename _Up_Deleter>
+ template<typename _Tp, typename _Dp>
inline bool
- operator>=(const unique_ptr<_Tp, _Tp_Deleter>& __x,
- const unique_ptr<_Up, _Up_Deleter>& __y)
- { return !(__x.get() < __y.get()); }
+ operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+ { return !(nullptr < __x); }
/// std::hash specialization for unique_ptr.
- template<typename _Tp, typename _Tp_Deleter>
- struct hash<unique_ptr<_Tp, _Tp_Deleter>>
- : public std::unary_function<unique_ptr<_Tp, _Tp_Deleter>, size_t>
+ template<typename _Tp, typename _Dp>
+ struct hash<unique_ptr<_Tp, _Dp>>
+ : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>
{
size_t
- operator()(const unique_ptr<_Tp, _Tp_Deleter>& __u) const
+ operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
{
- typedef unique_ptr<_Tp, _Tp_Deleter> _UP;
+ typedef unique_ptr<_Tp, _Dp> _UP;
return std::hash<typename _UP::pointer>()(__u.get());
}
};
// @} group pointer_abstractions
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _UNIQUE_PTR_H */
OSDN Git Service
