diff options
Diffstat (limited to 'libstdc++-v3/include')
| -rw-r--r-- | libstdc++-v3/include/bits/move.h | 5 | ||||
| -rw-r--r-- | libstdc++-v3/include/bits/shared_ptr.h | 14 | ||||
| -rw-r--r-- | libstdc++-v3/include/bits/shared_ptr_base.h | 224 | ||||
| -rw-r--r-- | libstdc++-v3/include/experimental/bits/shared_ptr.h | 666 | ||||
| -rw-r--r-- | libstdc++-v3/include/experimental/memory_resource | 1 | ||||
| -rw-r--r-- | libstdc++-v3/include/std/future | 35 | ||||
| -rw-r--r-- | libstdc++-v3/include/std/string_view | 30 |
7 files changed, 279 insertions, 696 deletions
diff --git a/libstdc++-v3/include/bits/move.h b/libstdc++-v3/include/bits/move.h index a5002fca422..d0aefe76cf0 100644 --- a/libstdc++-v3/include/bits/move.h +++ b/libstdc++-v3/include/bits/move.h @@ -137,6 +137,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION addressof(_Tp& __r) noexcept { return std::__addressof(__r); } + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 2598. addressof works on temporaries + template<typename _Tp> + const _Tp* addressof(const _Tp&&) = delete; + // C++11 version of std::exchange for internal use. template <typename _Tp, typename _Up = _Tp> inline _Tp diff --git a/libstdc++-v3/include/bits/shared_ptr.h b/libstdc++-v3/include/bits/shared_ptr.h index 9f7a40c5e1e..cbe4144359e 100644 --- a/libstdc++-v3/include/bits/shared_ptr.h +++ b/libstdc++-v3/include/bits/shared_ptr.h @@ -277,6 +277,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION shared_ptr(unique_ptr<_Yp, _Del>&& __r) : __shared_ptr<_Tp>(std::move(__r)) { } +#if __cplusplus <= 201402L && _GLIBCXX_USE_DEPRECATED + // This non-standard constructor exists to support conversions that + // were possible in C++11 and C++14 but are ill-formed in C++17. + // If an exception is thrown this constructor has no effect. + template<typename _Yp, typename _Del, + _Constructible<unique_ptr<_Yp, _Del>, __sp_array_delete>* = 0> + shared_ptr(unique_ptr<_Yp, _Del>&& __r) + : __shared_ptr<_Tp>(std::move(__r), __sp_array_delete()) { } +#endif + /** * @brief Construct an empty %shared_ptr. * @post use_count() == 0 && get() == nullptr @@ -692,7 +702,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { size_t operator()(const shared_ptr<_Tp>& __s) const noexcept - { return std::hash<_Tp*>()(__s.get()); } + { + return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get()); + } }; // @} group pointer_abstractions diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h b/libstdc++-v3/include/bits/shared_ptr_base.h index 1a9e3e901e9..953aa87436e 100644 --- a/libstdc++-v3/include/bits/shared_ptr_base.h +++ b/libstdc++-v3/include/bits/shared_ptr_base.h @@ -559,6 +559,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Impl _M_impl; }; + // The default deleter for shared_ptr<T[]> and shared_ptr<T[N]>. + struct __sp_array_delete + { + template<typename _Yp> + void operator()(_Yp* __p) const { delete[] __p; } + }; template<_Lock_policy _Lp> class __shared_count @@ -582,6 +588,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } } + template<typename _Ptr> + __shared_count(_Ptr __p, /* is_array = */ false_type) + : __shared_count(__p) + { } + + template<typename _Ptr> + __shared_count(_Ptr __p, /* is_array = */ true_type) + : __shared_count(__p, __sp_array_delete{}, allocator<void>()) + { } + template<typename _Ptr, typename _Deleter> __shared_count(_Ptr __p, _Deleter __d) : __shared_count(__p, std::move(__d), allocator<void>()) @@ -848,8 +864,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_pi = nullptr; } - // Helper traits for shared_ptr +#define __cpp_lib_shared_ptr_arrays 201603 + + // Helper traits for shared_ptr of array: + // A pointer type Y* is said to be compatible with a pointer type T* when + // either Y* is convertible to T* or Y is U[N] and T is U cv []. template<typename _Yp_ptr, typename _Tp_ptr> struct __sp_compatible_with : false_type @@ -860,17 +880,161 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : is_convertible<_Yp*, _Tp*>::type { }; + template<typename _Up, size_t _Nm> + struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]> + : true_type + { }; + + template<typename _Up, size_t _Nm> + struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]> + : true_type + { }; + + template<typename _Up, size_t _Nm> + struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]> + : true_type + { }; + + template<typename _Up, size_t _Nm> + struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]> + : true_type + { }; + + // Test conversion from Y(*)[N] to U(*)[N] without forming invalid type Y[N]. + template<typename _Up, size_t _Nm, typename _Yp, typename = void> + struct __sp_is_constructible_arrN + : false_type + { }; + + template<typename _Up, size_t _Nm, typename _Yp> + struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>> + : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type + { }; + + // Test conversion from Y(*)[] to U(*)[] without forming invalid type Y[]. + template<typename _Up, typename _Yp, typename = void> + struct __sp_is_constructible_arr + : false_type + { }; + + template<typename _Up, typename _Yp> + struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>> + : is_convertible<_Yp(*)[], _Up(*)[]>::type + { }; + + // Trait to check if shared_ptr<T> can be constructed from Y*. + template<typename _Tp, typename _Yp> + struct __sp_is_constructible; + + // When T is U[N], Y(*)[N] shall be convertible to T*; + template<typename _Up, size_t _Nm, typename _Yp> + struct __sp_is_constructible<_Up[_Nm], _Yp> + : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type + { }; + + // when T is U[], Y(*)[] shall be convertible to T*; + template<typename _Up, typename _Yp> + struct __sp_is_constructible<_Up[], _Yp> + : __sp_is_constructible_arr<_Up, _Yp>::type + { }; + + // otherwise, Y* shall be convertible to T*. + template<typename _Tp, typename _Yp> + struct __sp_is_constructible + : is_convertible<_Yp*, _Tp*>::type + { }; + + + // Define operator* and operator-> for shared_ptr<T>. + template<typename _Tp, _Lock_policy _Lp, + bool = is_array<_Tp>::value, bool = is_void<_Tp>::value> + class __shared_ptr_access + { + public: + using element_type = _Tp; + + element_type& + operator*() const noexcept + { + __glibcxx_assert(_M_get() != nullptr); + return *_M_get(); + } + + element_type* + operator->() const noexcept + { + _GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr); + return _M_get(); + } + + private: + element_type* + _M_get() const noexcept + { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); } + }; + + // Define operator-> for shared_ptr<cv void>. template<typename _Tp, _Lock_policy _Lp> - class __shared_ptr + class __shared_ptr_access<_Tp, _Lp, false, true> { public: using element_type = _Tp; + element_type* + operator->() const noexcept + { + _GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr); + return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); + } + }; + + // Define operator[] for shared_ptr<T[]> and shared_ptr<T[N]>. + template<typename _Tp, _Lock_policy _Lp> + class __shared_ptr_access<_Tp, _Lp, true, false> + { + public: + using element_type = typename remove_extent<_Tp>::type; + +#if __cplusplus <= 201402L + [[__deprecated__("shared_ptr<T[]>::operator* is absent from C++17")]] + element_type& + operator*() const noexcept + { + __glibcxx_assert(_M_ptr != nullptr); + return *_M_get(); + } + + [[__deprecated__("shared_ptr<T[]>::operator-> is absent from C++17")]] + element_type* + operator->() const noexcept + { + _GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr); + return _M_get(); + } +#endif + + element_type& + operator[](ptrdiff_t __i) const + { + __glibcxx_assert(_M_get() != nullptr); + __glibcxx_assert(!extent<_Tp>::value || __i < extent<_Tp>::value); + return _M_get()[__i]; + } + private: - // Trait to check if shared_ptr<T> can be constructed from Y*. - template<typename _Tp1, typename _Yp> - using __sp_is_constructible = is_convertible<_Yp*, _Tp1*>; + element_type* + _M_get() const noexcept + { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); } + }; + + template<typename _Tp, _Lock_policy _Lp> + class __shared_ptr + : public __shared_ptr_access<_Tp, _Lp> + { + public: + using element_type = typename remove_extent<_Tp>::type; + private: // Constraint for taking ownership of a pointer of type _Yp*: template<typename _Yp> using _SafeConv @@ -888,9 +1052,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Constraint for construction from unique_ptr: template<typename _Yp, typename _Del, typename _Res = void, typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer> - using _UniqCompatible = typename enable_if< - is_convertible<_Ptr, element_type*>::value - , _Res>::type; + using _UniqCompatible = typename enable_if<__and_< + __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*> + >::value, _Res>::type; // Constraint for assignment from unique_ptr: template<typename _Yp, typename _Del> @@ -909,7 +1073,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Yp, typename = _SafeConv<_Yp>> explicit __shared_ptr(_Yp* __p) - : _M_ptr(__p), _M_refcount(__p) + : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type()) { static_assert( !is_void<_Yp>::value, "incomplete type" ); static_assert( sizeof(_Yp) > 0, "incomplete type" ); @@ -995,6 +1159,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_enable_shared_from_this_with(__raw); } +#if __cplusplus <= 201402L && _GLIBCXX_USE_DEPRECATED + protected: + // If an exception is thrown this constructor has no effect. + template<typename _Tp1, typename _Del, + typename enable_if<__and_< + __not_<is_array<_Tp>>, is_array<_Tp1>, + is_convertible<typename unique_ptr<_Tp1, _Del>::pointer, _Tp*> + >::value, bool>::type = true> + __shared_ptr(unique_ptr<_Tp1, _Del>&& __r, __sp_array_delete) + : _M_ptr(__r.get()), _M_refcount() + { + auto __raw = _S_raw_ptr(__r.get()); + _M_refcount = __shared_count<_Lp>(std::move(__r)); + _M_enable_shared_from_this_with(__raw); + } + public: +#endif + #if _GLIBCXX_USE_DEPRECATED // Postcondition: use_count() == 1 and __r.get() == 0 template<typename _Yp, typename = _Compatible<_Yp>> @@ -1068,21 +1250,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION reset(_Yp* __p, _Deleter __d, _Alloc __a) { __shared_ptr(__p, __d, std::move(__a)).swap(*this); } - // Allow class instantiation when _Tp is [cv-qual] void. - typename std::add_lvalue_reference<element_type>::type - operator*() const noexcept - { - __glibcxx_assert(_M_ptr != 0); - return *_M_ptr; - } - - element_type* - operator->() const noexcept - { - _GLIBCXX_DEBUG_PEDASSERT(_M_ptr != 0); - return _M_ptr; - } - element_type* get() const noexcept { return _M_ptr; } @@ -1193,7 +1360,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Yp> struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>> - : true_type { }; + : __not_<is_array<_Tp>> { }; // No enable shared_from_this for arrays template<typename _Yp> typename enable_if<__has_esft_base<_Yp>::value>::type @@ -1428,7 +1595,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using _Assignable = _Compatible<_Yp, __weak_ptr&>; public: - using element_type = _Tp; + using element_type = typename remove_extent<_Tp>::type; constexpr __weak_ptr() noexcept : _M_ptr(nullptr), _M_refcount() @@ -1681,7 +1848,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { size_t operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept - { return std::hash<_Tp*>()(__s.get()); } + { + return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()( + __s.get()); + } }; _GLIBCXX_END_NAMESPACE_VERSION diff --git a/libstdc++-v3/include/experimental/bits/shared_ptr.h b/libstdc++-v3/include/experimental/bits/shared_ptr.h index e8c533e158c..8a1fc52caf8 100644 --- a/libstdc++-v3/include/experimental/bits/shared_ptr.h +++ b/libstdc++-v3/include/experimental/bits/shared_ptr.h @@ -46,665 +46,20 @@ namespace experimental inline namespace fundamentals_v2 { _GLIBCXX_BEGIN_NAMESPACE_VERSION - template<typename _Tp> class enable_shared_from_this; -_GLIBCXX_END_NAMESPACE_VERSION -} // namespace fundamentals_v2 -} // namespace experimental - -#define __cpp_lib_experimental_shared_ptr_arrays 201406 - -_GLIBCXX_BEGIN_NAMESPACE_VERSION - - /* - * The specification of std::experimental::shared_ptr is slightly different - * to std::shared_ptr (specifically in terms of "compatible" pointers) so - * to implement std::experimental::shared_ptr without too much duplication - * we make it derive from a partial specialization of std::__shared_ptr - * using a special tag type, __libfund_v1. - * - * There are two partial specializations for the tag type, supporting the - * different interfaces of the array and non-array forms. - */ - - template <typename _Tp, bool = is_array<_Tp>::value> - struct __libfund_v1 { using type = _Tp; }; - - // Partial specialization for base class of experimental::shared_ptr<T> - // (i.e. the non-array form of experimental::shared_ptr) - template<typename _Tp, _Lock_policy _Lp> - class __shared_ptr<__libfund_v1<_Tp, false>, _Lp> - : private __shared_ptr<_Tp, _Lp> - { - // For non-arrays, Y* is compatible with T* if Y* is convertible to T*. - template<typename _Yp, typename _Res = void> - using _Compatible - = enable_if_t<experimental::is_convertible_v<_Yp*, _Tp*>, _Res>; - - template<typename _Yp, typename _Del, - typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer, - typename _Res = void> - using _UniqCompatible = enable_if_t< - experimental::is_convertible_v<_Yp*, _Tp*> - && experimental::is_convertible_v<_Ptr, _Tp*>, - _Res>; - - using _Base_type = __shared_ptr<_Tp>; - - _Base_type& _M_get_base() { return *this; } - const _Base_type& _M_get_base() const { return *this; } - - public: - using element_type = _Tp; - - constexpr __shared_ptr() noexcept = default; - - template<typename _Tp1, typename = _Compatible<_Tp1>> - explicit - __shared_ptr(_Tp1* __p) - : _Base_type(__p) - { } - - template<typename _Tp1, typename _Deleter, typename = _Compatible<_Tp1>> - __shared_ptr(_Tp1* __p, _Deleter __d) - : _Base_type(__p, __d) - { } - - template<typename _Tp1, typename _Deleter, typename _Alloc, - typename = _Compatible<_Tp1>> - __shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a) - : _Base_type(__p, __d, __a) - { } - - template<typename _Deleter> - __shared_ptr(nullptr_t __p, _Deleter __d) - : _Base_type(__p, __d) - { } - - template<typename _Deleter, typename _Alloc> - __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) - : _Base_type(__p, __d, __a) - { } - - template<typename _Tp1> - __shared_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r, - element_type* __p) noexcept - : _Base_type(__r._M_get_base(), __p) - { } - - __shared_ptr(const __shared_ptr&) noexcept = default; - __shared_ptr(__shared_ptr&&) noexcept = default; - __shared_ptr& operator=(const __shared_ptr&) noexcept = default; - __shared_ptr& operator=(__shared_ptr&&) noexcept = default; - ~__shared_ptr() = default; - - template<typename _Tp1, typename = _Compatible<_Tp1>> - __shared_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - : _Base_type(__r._M_get_base()) - { } - - template<typename _Tp1, typename = _Compatible<_Tp1>> - __shared_ptr(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept - : _Base_type(std::move((__r._M_get_base()))) - { } - - template<typename _Tp1, typename = _Compatible<_Tp1>> - explicit - __shared_ptr(const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r) - : _Base_type(__r._M_get_base()) - { } - - template<typename _Tp1, typename _Del, - typename = _UniqCompatible<_Tp1, _Del>> - __shared_ptr(unique_ptr<_Tp1, _Del>&& __r) - : _Base_type(std::move(__r)) - { } - -#if _GLIBCXX_USE_DEPRECATED - // Postcondition: use_count() == 1 and __r.get() == 0 - template<typename _Tp1, typename = _Compatible<_Tp1>> - __shared_ptr(std::auto_ptr<_Tp1>&& __r) - : _Base_type(std::move(__r)) - { } -#endif - - constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { } - - // reset - void - reset() noexcept - { __shared_ptr(nullptr).swap(*this); } - - template<typename _Tp1> - _Compatible<_Tp1> - reset(_Tp1* __p) - { - _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != get()); - __shared_ptr(__p).swap(*this); - } - - template<typename _Tp1, typename _Deleter> - _Compatible<_Tp1> - reset(_Tp1* __p, _Deleter __d) - { __shared_ptr(__p, __d).swap(*this); } - - template<typename _Tp1, typename _Deleter, typename _Alloc> - _Compatible<_Tp1> - reset(_Tp1* __p, _Deleter __d, _Alloc __a) - { __shared_ptr(__p, __d, std::move(__a)).swap(*this); } - - using _Base_type::operator*; - using _Base_type::operator->; - - template<typename _Tp1> - _Compatible<_Tp1, __shared_ptr&> - operator=(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - { - _Base_type::operator=(__r._M_get_base()); - return *this; - } - - template<class _Tp1> - _Compatible<_Tp1, __shared_ptr&> - operator=(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept - { - _Base_type::operator=(std::move(__r._M_get_base())); - return *this; - } - - template<typename _Tp1, typename _Del> - _UniqCompatible<_Tp1, _Del, __shared_ptr&> - operator=(unique_ptr<_Tp1, _Del>&& __r) - { - _Base_type::operator=(std::move(__r)); - return *this; - } - -#if _GLIBCXX_USE_DEPRECATED - template<typename _Tp1> - _Compatible<_Tp1, __shared_ptr&> - operator=(std::auto_ptr<_Tp1>&& __r) - { - _Base_type::operator=(std::move(__r)); - return *this; - } -#endif - - void - swap(__shared_ptr& __other) noexcept - { _Base_type::swap(__other); } - - template<typename _Tp1> - bool - owner_before(__shared_ptr<__libfund_v1<_Tp1>, _Lp> const& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - template<typename _Tp1> - bool - owner_before(__weak_ptr<__libfund_v1<_Tp1>, _Lp> const& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - using _Base_type::operator bool; - using _Base_type::get; - using _Base_type::unique; - using _Base_type::use_count; - - protected: - - // make_shared not yet support for shared_ptr_arrays - //template<typename _Alloc, typename... _Args> - // __shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a, - // _Args&&... __args) - // : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a, - // std::forward<_Args>(__args)...) - // { - // void* __p = _M_refcount._M_get_deleter(typeid(__tag)); - // _M_ptr = static_cast<_Tp*>(__p); - // } - - // __weak_ptr::lock() - __shared_ptr(const __weak_ptr<__libfund_v1<_Tp>, _Lp>& __r, - std::nothrow_t) - : _Base_type(__r._M_get_base(), std::nothrow) - { } - - private: - template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; - template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; - - // TODO - template<typename _Del, typename _Tp1, _Lock_policy _Lp1> - friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; - }; - - // Helper traits for shared_ptr of array: - // Trait that tests if Y* is compatible with T*, for shared_ptr purposes. - template<typename _Yp, typename _Tp> - struct __sp_compatible - : is_convertible<_Yp*, _Tp*>::type - { }; + // 8.2.1 - template<size_t _Nm, typename _Tp> - struct __sp_compatible<_Tp[_Nm], _Tp[]> - : true_type - { }; - - template<size_t _Nm, typename _Tp> - struct __sp_compatible<_Tp[_Nm], const _Tp[]> - : true_type - { }; + template<typename _Tp> class shared_ptr; + template<typename _Tp> class weak_ptr; + template<typename _Tp> class enable_shared_from_this; template<typename _Yp, typename _Tp> constexpr bool __sp_compatible_v - = __sp_compatible<_Yp, _Tp>::value; - - // Test conversion from Y(*)[N] to U(*)[N] without forming invalid type Y[N]. - template<typename _Up, size_t _Nm, typename _Yp, typename = void> - struct __sp_is_constructible_arrN - : false_type - { }; - - template<typename _Up, size_t _Nm, typename _Yp> - struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>> - : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type - { }; - - // Test conversion from Y(*)[] to U(*)[] without forming invalid type Y[]. - template<typename _Up, typename _Yp, typename = void> - struct __sp_is_constructible_arr - : false_type - { }; - - template<typename _Up, typename _Yp> - struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>> - : is_convertible<_Yp(*)[], _Up(*)[]>::type - { }; - - // Trait to check if shared_ptr<T> can be constructed from Y*. - template<typename _Tp, typename _Yp> - struct __sp_is_constructible; - - // When T is U[N], Y(*)[N] shall be convertible to T*; - template<typename _Up, size_t _Nm, typename _Yp> - struct __sp_is_constructible<_Up[_Nm], _Yp> - : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type - { }; - - // when T is U[], Y(*)[] shall be convertible to T*; - template<typename _Up, typename _Yp> - struct __sp_is_constructible<_Up[], _Yp> - : __sp_is_constructible_arr<_Up, _Yp>::type - { }; - - // otherwise, Y* shall be convertible to T*. - template<typename _Tp, typename _Yp> - struct __sp_is_constructible - : is_convertible<_Yp*, _Tp*>::type - { }; + = std::__sp_compatible_with<_Yp*, _Tp*>::value; template<typename _Tp, typename _Yp> constexpr bool __sp_is_constructible_v - = __sp_is_constructible<_Tp, _Yp>::value; - - - // Partial specialization for base class of experimental::shared_ptr<T[N]> - // and experimental::shared_ptr<T[]> (i.e. the array forms). - template<typename _Tp, _Lock_policy _Lp> - class __shared_ptr<__libfund_v1<_Tp, true>, _Lp> - : private __shared_ptr<remove_extent_t<_Tp>, _Lp> - { - public: - using element_type = remove_extent_t<_Tp>; - - private: - struct _Array_deleter - { - void - operator()(element_type const *__p) const - { delete [] __p; } - }; - - // Constraint for constructing/resetting with a pointer of type _Yp*: - template<typename _Yp> - using _SafeConv = enable_if_t<__sp_is_constructible_v<_Tp, _Yp>>; - - // Constraint for constructing/assigning from smart_pointer<_Tp1>: - template<typename _Tp1, typename _Res = void> - using _Compatible = enable_if_t<__sp_compatible_v<_Tp1, _Tp>, _Res>; - - // Constraint for constructing/assigning from unique_ptr<_Tp1, _Del>: - template<typename _Tp1, typename _Del, - typename _Ptr = typename unique_ptr<_Tp1, _Del>::pointer, - typename _Res = void> - using _UniqCompatible = enable_if_t< - __sp_compatible_v<_Tp1, _Tp> - && experimental::is_convertible_v<_Ptr, element_type*>, - _Res>; - - using _Base_type = __shared_ptr<element_type>; - - _Base_type& _M_get_base() { return *this; } - const _Base_type& _M_get_base() const { return *this; } - - public: - constexpr __shared_ptr() noexcept - : _Base_type() - { } - - template<typename _Tp1, typename = _SafeConv<_Tp1>> - explicit - __shared_ptr(_Tp1* __p) - : _Base_type(__p, _Array_deleter()) - { } - - template<typename _Tp1, typename _Deleter, typename = _SafeConv<_Tp1>> - __shared_ptr(_Tp1* __p, _Deleter __d) - : _Base_type(__p, __d) - { } - - template<typename _Tp1, typename _Deleter, typename _Alloc, - typename = _SafeConv<_Tp1>> - __shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a) - : _Base_type(__p, __d, __a) - { } - - template<typename _Deleter> - __shared_ptr(nullptr_t __p, _Deleter __d) - : _Base_type(__p, __d) - { } - - template<typename _Deleter, typename _Alloc> - __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) - : _Base_type(__p, __d, __a) - { } - - template<typename _Tp1> - __shared_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r, - element_type* __p) noexcept - : _Base_type(__r._M_get_base(), __p) - { } - - __shared_ptr(const __shared_ptr&) noexcept = default; - __shared_ptr(__shared_ptr&&) noexcept = default; - __shared_ptr& operator=(const __shared_ptr&) noexcept = default; - __shared_ptr& operator=(__shared_ptr&&) noexcept = default; - ~__shared_ptr() = default; - - template<typename _Tp1, typename = _Compatible<_Tp1>> - __shared_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - : _Base_type(__r._M_get_base()) - { } - - template<typename _Tp1, typename = _Compatible<_Tp1>> - __shared_ptr(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept - : _Base_type(std::move((__r._M_get_base()))) - { } - - template<typename _Tp1, typename = _Compatible<_Tp1>> - explicit - __shared_ptr(const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r) - : _Base_type(__r._M_get_base()) - { } - - template<typename _Tp1, typename _Del, - typename = _UniqCompatible<_Tp1, _Del>> - __shared_ptr(unique_ptr<_Tp1, _Del>&& __r) - : _Base_type(std::move(__r)) - { } - -#if _GLIBCXX_USE_DEPRECATED - // Postcondition: use_count() == 1 and __r.get() == 0 - template<typename _Tp1, typename = _Compatible<_Tp1>> - __shared_ptr(auto_ptr<_Tp1>&& __r) - : _Base_type(std::move(__r)) - { } -#endif - - constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { } - - // reset - void - reset() noexcept - { __shared_ptr(nullptr).swap(*this); } - - template<typename _Tp1> - _SafeConv<_Tp1> - reset(_Tp1* __p) - { - _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != get()); - __shared_ptr(__p, _Array_deleter()).swap(*this); - } - - template<typename _Tp1, typename _Deleter> - _SafeConv<_Tp1> - reset(_Tp1* __p, _Deleter __d) - { __shared_ptr(__p, __d).swap(*this); } - - template<typename _Tp1, typename _Deleter, typename _Alloc> - _SafeConv<_Tp1> - reset(_Tp1* __p, _Deleter __d, _Alloc __a) - { __shared_ptr(__p, __d, std::move(__a)).swap(*this); } - - element_type& - operator[](ptrdiff_t i) const noexcept - { - _GLIBCXX_DEBUG_ASSERT(get() != 0 && i >= 0); - return get()[i]; - } - - template<typename _Tp1> - _Compatible<_Tp1, __shared_ptr&> - operator=(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - { - _Base_type::operator=(__r._M_get_base()); - return *this; - } - - template<class _Tp1> - _Compatible<_Tp1, __shared_ptr&> - operator=(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept - { - _Base_type::operator=(std::move(__r._M_get_base())); - return *this; - } - - template<typename _Tp1, typename _Del> - _UniqCompatible<_Tp1, _Del, __shared_ptr&> - operator=(unique_ptr<_Tp1, _Del>&& __r) - { - _Base_type::operator=(std::move(__r)); - return *this; - } - -#if _GLIBCXX_USE_DEPRECATED - template<typename _Tp1> - _Compatible<_Tp1, __shared_ptr&> - operator=(auto_ptr<_Tp1>&& __r) - { - _Base_type::operator=(std::move(__r)); - return *this; - } -#endif - - void - swap(__shared_ptr& __other) noexcept - { _Base_type::swap(__other); } - - template<typename _Tp1> - bool - owner_before(__shared_ptr<__libfund_v1<_Tp1>, _Lp> const& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - template<typename _Tp1> - bool - owner_before(__weak_ptr<__libfund_v1<_Tp1>, _Lp> const& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - using _Base_type::operator bool; - using _Base_type::get; - using _Base_type::unique; - using _Base_type::use_count; - - protected: - - // make_shared not yet support for shared_ptr_arrays - //template<typename _Alloc, typename... _Args> - // __shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a, - // _Args&&... __args) - // : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a, - // std::forward<_Args>(__args)...) - // { - // void* __p = _M_refcount._M_get_deleter(typeid(__tag)); - // _M_ptr = static_cast<_Tp*>(__p); - // } - - // __weak_ptr::lock() - __shared_ptr(const __weak_ptr<__libfund_v1<_Tp>, _Lp>& __r, - std::nothrow_t) - : _Base_type(__r._M_get_base(), std::nothrow) - { } - - private: - template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; - template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; - - // TODO - template<typename _Del, typename _Tp1, _Lock_policy _Lp1> - friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; - }; - - // weak_ptr specialization for __shared_ptr array - template<typename _Tp, _Lock_policy _Lp> - class __weak_ptr<__libfund_v1<_Tp>, _Lp> - : __weak_ptr<remove_extent_t<_Tp>, _Lp> - { - template<typename _Tp1, typename _Res = void> - using _Compatible - = enable_if_t<__sp_compatible_v<_Tp1, _Tp>, _Res>; - - using _Base_type = __weak_ptr<remove_extent_t<_Tp>>; - - _Base_type& _M_get_base() { return *this; } - const _Base_type& _M_get_base() const { return *this; } - - public: - using element_type = remove_extent_t<_Tp>; - - constexpr __weak_ptr() noexcept - : _Base_type() - { } - - __weak_ptr(const __weak_ptr&) noexcept = default; - - ~__weak_ptr() = default; - - template<typename _Tp1, typename = _Compatible<_Tp1>> - __weak_ptr(const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - : _Base_type(__r._M_get_base()) - { } - - template<typename _Tp1, typename = _Compatible<_Tp1>> - __weak_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - : _Base_type(__r._M_get_base()) - { } - - __weak_ptr(__weak_ptr&& __r) noexcept - : _Base_type(std::move(__r)) - { } - - template<typename _Tp1, typename = _Compatible<_Tp1>> - __weak_ptr(__weak_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept - : _Base_type(std::move(__r._M_get_base())) - { } - - __weak_ptr& - operator=(const __weak_ptr& __r) noexcept = default; - - template<typename _Tp1> - _Compatible<_Tp1, __weak_ptr&> - operator=(const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept - { - this->_Base_type::operator=(__r._M_get_base()); - return *this; - } - - template<typename _Tp1> - _Compatible<_Tp1, __weak_ptr&> - operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept - { - this->_Base_type::operator=(__r._M_get_base()); - return *this; - } - - __weak_ptr& - operator=(__weak_ptr&& __r) noexcept - { - this->_Base_type::operator=(std::move(__r)); - return *this; - } - - template<typename _Tp1> - _Compatible<_Tp1, __weak_ptr&> - operator=(__weak_ptr<_Tp1, _Lp>&& __r) noexcept - { - this->_Base_type::operator=(std::move(__r._M_get_base())); - return *this; - } - - void - swap(__weak_ptr& __other) noexcept - { this->_Base_type::swap(__other); } - - template<typename _Tp1> - bool - owner_before(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - template<typename _Tp1> - bool - owner_before(const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __rhs) const - { return _Base_type::owner_before(__rhs._M_get_base()); } - - __shared_ptr<__libfund_v1<_Tp>, _Lp> - lock() const noexcept // should not be element_type - { return __shared_ptr<__libfund_v1<_Tp>, _Lp>(*this, std::nothrow); } - - using _Base_type::use_count; - using _Base_type::expired; - using _Base_type::reset; - - private: - // Used by __enable_shared_from_this. - void - _M_assign(element_type* __ptr, - const __shared_count<_Lp>& __refcount) noexcept - { this->_Base_type::_M_assign(__ptr, __refcount); } - - template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; - template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; - friend class __enable_shared_from_this<_Tp, _Lp>; - friend class experimental::enable_shared_from_this<_Tp>; - friend class enable_shared_from_this<_Tp>; - }; - -_GLIBCXX_END_NAMESPACE_VERSION - -namespace experimental -{ -inline namespace fundamentals_v2 -{ -_GLIBCXX_BEGIN_NAMESPACE_VERSION - - // 8.2.1 - - template<typename _Tp> class shared_ptr; - template<typename _Tp> class weak_ptr; - - template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> - using __shared_ptr = std::__shared_ptr<__libfund_v1<_Tp>, _Lp>; - - template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> - using __weak_ptr = std::__weak_ptr<__libfund_v1<_Tp>, _Lp>; + = std::__sp_is_constructible<_Tp, _Yp>::value; template<typename _Tp> class shared_ptr : public __shared_ptr<_Tp> @@ -1128,16 +483,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { __a.swap(__b); } /// C++14 §20.8.2.2.10 - template<typename _Del, typename _Tp, _Lock_policy _Lp> + template<typename _Del, typename _Tp> inline _Del* - get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept + get_deleter(const shared_ptr<_Tp>& __p) noexcept { return std::get_deleter<_Del>(__p); } // C++14 §20.8.2.2.11 - template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp> + template<typename _Ch, typename _Tr, typename _Tp> inline std::basic_ostream<_Ch, _Tr>& - operator<<(std::basic_ostream<_Ch, _Tr>& __os, - const __shared_ptr<_Tp, _Lp>& __p) + operator<<(std::basic_ostream<_Ch, _Tr>& __os, const shared_ptr<_Tp>& __p) { __os << __p.get(); return __os; diff --git a/libstdc++-v3/include/experimental/memory_resource b/libstdc++-v3/include/experimental/memory_resource index 39187c50881..52e0b031653 100644 --- a/libstdc++-v3/include/experimental/memory_resource +++ b/libstdc++-v3/include/experimental/memory_resource @@ -72,6 +72,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // 8.5 Class memory_resource class memory_resource { + protected: static constexpr size_t _S_max_align = alignof(max_align_t); public: diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future index fea915b0a87..8ba13069510 100644 --- a/libstdc++-v3/include/std/future +++ b/libstdc++-v3/include/std/future @@ -95,11 +95,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION */ class future_error : public logic_error { - error_code _M_code; - public: - explicit future_error(error_code __ec) - : logic_error("std::future_error: " + __ec.message()), _M_code(__ec) + explicit + future_error(future_errc __errc) + : future_error(std::make_error_code(__errc)) { } virtual ~future_error() noexcept; @@ -109,6 +108,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const error_code& code() const noexcept { return _M_code; } + + private: + explicit + future_error(error_code __ec) + : logic_error("std::future_error: " + __ec.message()), _M_code(__ec) + { } + + friend void __throw_future_error(int); + + error_code _M_code; }; // Forward declarations. @@ -426,8 +435,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { if (static_cast<bool>(__res)) { - error_code __ec(make_error_code(future_errc::broken_promise)); - __res->_M_error = make_exception_ptr(future_error(__ec)); + __res->_M_error = + make_exception_ptr(future_error(future_errc::broken_promise)); // This function is only called when the last asynchronous result // provider is abandoning this shared state, so noone can be // trying to make the shared state ready at the same time, and @@ -769,7 +778,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return std::move(this->_M_get_result()._M_value()); } - shared_future<_Res> share(); + shared_future<_Res> share() noexcept; }; /// Partial specialization for future<R&> @@ -812,7 +821,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return this->_M_get_result()._M_get(); } - shared_future<_Res&> share(); + shared_future<_Res&> share() noexcept; }; /// Explicit specialization for future<void> @@ -855,7 +864,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION this->_M_get_result(); } - shared_future<void> share(); + shared_future<void> share() noexcept; }; @@ -995,18 +1004,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : _M_state(std::move(__uf._M_state)) { } + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 2556. Wide contract for future::share() template<typename _Res> inline shared_future<_Res> - future<_Res>::share() + future<_Res>::share() noexcept { return shared_future<_Res>(std::move(*this)); } template<typename _Res> inline shared_future<_Res&> - future<_Res&>::share() + future<_Res&>::share() noexcept { return shared_future<_Res&>(std::move(*this)); } inline shared_future<void> - future<void>::share() + future<void>::share() noexcept { return shared_future<void>(std::move(*this)); } /// Primary template for promise diff --git a/libstdc++-v3/include/std/string_view b/libstdc++-v3/include/std/string_view index b2d2a296ba4..cf728dd83e9 100644 --- a/libstdc++-v3/include/std/string_view +++ b/libstdc++-v3/include/std/string_view @@ -640,6 +640,36 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { }; #endif + inline namespace literals + { + inline namespace string_view_literals + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + inline constexpr basic_string_view<char> + operator""sv(const char* __str, size_t __len) + { return basic_string_view<char>{__str, __len}; } + +#ifdef _GLIBCXX_USE_WCHAR_T + inline constexpr basic_string_view<wchar_t> + operator""sv(const wchar_t* __str, size_t __len) + { return basic_string_view<wchar_t>{__str, __len}; } +#endif + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + inline constexpr basic_string_view<char16_t> + operator""sv(const char16_t* __str, size_t __len) + { return basic_string_view<char16_t>{__str, __len}; } + + inline constexpr basic_string_view<char32_t> + operator""sv(const char32_t* __str, size_t __len) + { return basic_string_view<char32_t>{__str, __len}; } +#endif + + _GLIBCXX_END_NAMESPACE_VERSION + } // namespace string_literals + } // namespace literals + _GLIBCXX_END_NAMESPACE_VERSION } // namespace std |