diff options
Diffstat (limited to 'libstdc++-v3/include/std')
| -rw-r--r-- | libstdc++-v3/include/std/chrono | 2 | ||||
| -rw-r--r-- | libstdc++-v3/include/std/functional | 3 | ||||
| -rw-r--r-- | libstdc++-v3/include/std/optional | 86 | ||||
| -rw-r--r-- | libstdc++-v3/include/std/tuple | 96 | ||||
| -rw-r--r-- | libstdc++-v3/include/std/type_traits | 7 | ||||
| -rw-r--r-- | libstdc++-v3/include/std/variant | 79 |
6 files changed, 189 insertions, 84 deletions
diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono index f29d8e1adbc..11e7fa298c4 100644 --- a/libstdc++-v3/include/std/chrono +++ b/libstdc++-v3/include/std/chrono @@ -784,7 +784,7 @@ _GLIBCXX_END_NAMESPACE_VERSION // Clocks. // Why nanosecond resolution as the default? - // Why have std::system_clock always count in the higest + // Why have std::system_clock always count in the highest // resolution (ie nanoseconds), even if on some OSes the low 3 // or 9 decimal digits will be always zero? This allows later // implementations to change the system_clock::now() diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional index c750a8374bc..74e65c7b96f 100644 --- a/libstdc++-v3/include/std/functional +++ b/libstdc++-v3/include/std/functional @@ -1401,7 +1401,7 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type) void (_Undefined_class::*_M_member_pointer)(); }; - union _Any_data + union [[gnu::may_alias]] _Any_data { void* _M_access() { return &_M_pod_data[0]; } const void* _M_access() const { return &_M_pod_data[0]; } @@ -2206,6 +2206,7 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type) } // Searchers +#define __cpp_lib_boyer_moore_searcher 201603 template<typename _ForwardIterator1, typename _BinaryPredicate = equal_to<>> class default_searcher diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional index 2ff75eae638..21210ab6532 100644 --- a/libstdc++-v3/include/std/optional +++ b/libstdc++-v3/include/std/optional @@ -378,7 +378,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr bool _M_is_engaged() const noexcept { return this->_M_engaged; } - _Tp& + constexpr _Tp& _M_get() noexcept { return _M_payload; } @@ -423,19 +423,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Tp> class optional; - template<typename> - struct __is_optional_impl : false_type - { }; - - template<typename _Tp> - struct __is_optional_impl<optional<_Tp>> : true_type - { }; - - template<typename _Tp> - struct __is_optional - : public __is_optional_impl<std::remove_cv_t<std::remove_reference_t<_Tp>>> - { }; - + template<typename _Tp, typename _Up> + using __converts_from_optional = + __or_<is_constructible<_Tp, const optional<_Up>&>, + is_constructible<_Tp, optional<_Up>&>, + is_constructible<_Tp, const optional<_Up>&&>, + is_constructible<_Tp, optional<_Up>&&>, + is_convertible<const optional<_Up>&, _Tp>, + is_convertible<optional<_Up>&, _Tp>, + is_convertible<const optional<_Up>&&, _Tp>, + is_convertible<optional<_Up>&&, _Tp>>; + + template<typename _Tp, typename _Up> + using __assigns_from_optional = + __or_<is_assignable<_Tp&, const optional<_Up>&>, + is_assignable<_Tp&, optional<_Up>&>, + is_assignable<_Tp&, const optional<_Up>&&>, + is_assignable<_Tp&, optional<_Up>&&>>; /** * @brief Class template for optional values. @@ -474,7 +478,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Converting constructors for engaged optionals. template <typename _Up = _Tp, enable_if_t<__and_< - __not_<__is_optional<decay_t<_Up>>>, + __not_<is_same<optional<_Tp>, decay_t<_Up>>>, is_constructible<_Tp, _Up&&>, is_convertible<_Up&&, _Tp> >::value, bool> = true> @@ -483,7 +487,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template <typename _Up = _Tp, enable_if_t<__and_< - __not_<__is_optional<decay_t<_Up>>>, + __not_<is_same<optional<_Tp>, decay_t<_Up>>>, is_constructible<_Tp, _Up&&>, __not_<is_convertible<_Up&&, _Tp>> >::value, bool> = false> @@ -494,37 +498,53 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, is_constructible<_Tp, const _Up&>, - is_convertible<const _Up&, _Tp> + is_convertible<const _Up&, _Tp>, + __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = true> constexpr optional(const optional<_Up>& __t) - : _Base(__t ? _Base(std::in_place, *__t) : _Base()) { } + { + if (__t) + emplace(*__t); + } template <typename _Up, enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, is_constructible<_Tp, const _Up&>, - __not_<is_convertible<const _Up&, _Tp>> + __not_<is_convertible<const _Up&, _Tp>>, + __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = false> explicit constexpr optional(const optional<_Up>& __t) - : _Base(__t ? _Base(std::in_place, *__t) : _Base()) { } + { + if (__t) + emplace(*__t); + } template <typename _Up, enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, is_constructible<_Tp, _Up&&>, - is_convertible<_Up&&, _Tp> + is_convertible<_Up&&, _Tp>, + __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = true> constexpr optional(optional<_Up>&& __t) - : _Base(__t ? _Base(std::in_place, std::move(*__t)) : _Base()) { } + { + if (__t) + emplace(std::move(*__t)); + } template <typename _Up, enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, is_constructible<_Tp, _Up&&>, - __not_<is_convertible<_Up&&, _Tp>> + __not_<is_convertible<_Up&&, _Tp>>, + __not_<__converts_from_optional<_Tp, _Up>> >::value, bool> = false> explicit constexpr optional(optional<_Up>&& __t) - : _Base(__t ? _Base(std::in_place, std::move(*__t)) : _Base()) { } + { + if (__t) + emplace(std::move(*__t)); + } template<typename... _Args> explicit constexpr optional(in_place_t, _Args&&... __args) @@ -550,8 +570,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Up = _Tp, enable_if_t<__and_< - __not_<__is_optional<decay_t<_Up>>>, + __not_<is_same<optional<_Tp>, decay_t<_Up>>>, is_constructible<_Tp, _Up>, + __not_<__and_<is_scalar<_Tp>, + is_same<_Tp, decay_t<_Up>>>>, is_assignable<_Tp&, _Up>>::value, bool> = true> optional& @@ -568,8 +590,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename _Up, enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, - is_constructible<_Tp, _Up>, - is_assignable<_Tp&, _Up>>::value, + is_constructible<_Tp, const _Up&>, + is_assignable<_Tp&, _Up>, + __not_<__converts_from_optional<_Tp, _Up>>, + __not_<__assigns_from_optional<_Tp, _Up>> + >::value, bool> = true> optional& operator=(const optional<_Up>& __u) @@ -592,7 +617,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION enable_if_t<__and_< __not_<is_same<_Tp, _Up>>, is_constructible<_Tp, _Up>, - is_assignable<_Tp&, _Up>>::value, + is_assignable<_Tp&, _Up>, + __not_<__converts_from_optional<_Tp, _Up>>, + __not_<__assigns_from_optional<_Tp, _Up>> + >::value, bool> = true> optional& operator=(optional<_Up>&& __u) @@ -749,7 +777,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ? std::move(this->_M_get()) : static_cast<_Tp>(std::forward<_Up>(__u)); } - void reset() { this->_M_reset(); } + void reset() noexcept { this->_M_reset(); } }; template<typename _Tp> diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple index c06a040a960..32b932f79fd 100644 --- a/libstdc++-v3/include/std/tuple +++ b/libstdc++-v3/include/std/tuple @@ -220,8 +220,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr _Tuple_impl(const _Tuple_impl&) = default; constexpr - _Tuple_impl(_Tuple_impl&& __in) - noexcept(__and_<is_nothrow_move_constructible<_Head>, + _Tuple_impl(typename conditional< + __and_<is_move_constructible<_Head>, + is_move_constructible<_Inherited>>::value, + _Tuple_impl&&, __nonesuch&&>::type __in) + noexcept(__and_<is_nothrow_move_constructible<_Head>, is_nothrow_move_constructible<_Inherited>>::value) : _Inherited(std::move(_M_tail(__in))), _Base(std::forward<_Head>(_M_head(__in))) { } @@ -232,7 +235,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { } template<typename _UHead, typename... _UTails> - constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + constexpr _Tuple_impl(typename conditional< + __and_<is_move_constructible<_Head>, + is_move_constructible<_Inherited>>::value, + _Tuple_impl<_Idx, _UHead, _UTails...>&&, + __nonesuch&&>::type __in) : _Inherited(std::move (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), _Base(std::forward<_UHead> @@ -338,6 +345,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } }; + template<typename...> + struct __is_tuple_impl_trait_impl : false_type + { }; + + template<std::size_t _Idx, typename... _Tp> + struct __is_tuple_impl_trait_impl<_Tuple_impl<_Idx, _Tp...>> : true_type + { }; + + template<typename _Tp> + struct __is_tuple_impl_trait : public __is_tuple_impl_trait_impl<_Tp> + { }; + // Basis case of inheritance recursion. template<std::size_t _Idx, typename _Head> struct _Tuple_impl<_Idx, _Head> @@ -356,11 +375,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr _Tuple_impl() : _Base() { } + template<typename _Dummy=void, + typename enable_if<is_constructible<_Base, const _Head&>::value, + bool>::type=true> explicit constexpr _Tuple_impl(const _Head& __head) : _Base(__head) { } - template<typename _UHead> + template<typename _UHead, + typename enable_if<__and_<is_constructible<_Base, _UHead&&>, + __not_<__is_tuple_impl_trait< + typename + remove_reference<_UHead>::type>> + >::value, + bool>::type = true> explicit constexpr _Tuple_impl(_UHead&& __head) : _Base(std::forward<_UHead>(__head)) { } @@ -368,15 +396,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr _Tuple_impl(const _Tuple_impl&) = default; constexpr - _Tuple_impl(_Tuple_impl&& __in) + _Tuple_impl(typename conditional< + is_move_constructible<_Head>::value, + _Tuple_impl&&, __nonesuch&&>::type __in) noexcept(is_nothrow_move_constructible<_Head>::value) : _Base(std::forward<_Head>(_M_head(__in))) { } - template<typename _UHead> + template<typename _UHead, + typename enable_if<!is_same<_Head, _UHead>::value, + bool>::type = true> constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { } - template<typename _UHead> + template<typename _UHead, + typename enable_if<!is_same<_Head, _UHead>::value, + bool>::type = true> constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) { } @@ -832,14 +866,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { } tuple& - operator=(const tuple& __in) + operator=(typename + conditional<__and_<is_copy_assignable<_Elements>...>::value, + const tuple&, const __nonesuch&>::type __in) { static_cast<_Inherited&>(*this) = __in; return *this; } tuple& - operator=(tuple&& __in) + operator=(typename + conditional<__and_<is_move_assignable<_Elements>...>::value, + tuple&&, __nonesuch&&>::type __in) noexcept(is_nothrow_move_assignable<_Inherited>::value) { static_cast<_Inherited&>(*this) = std::move(__in); @@ -848,7 +886,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename... _UElements, typename = typename enable_if<sizeof...(_UElements) - == sizeof...(_Elements)>::type> + == sizeof...(_Elements) + && + __and_<is_assignable<_Elements&, + const _UElements&>...>::value>::type> tuple& operator=(const tuple<_UElements...>& __in) { @@ -858,7 +899,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<typename... _UElements, typename = typename enable_if<sizeof...(_UElements) - == sizeof...(_Elements)>::type> + == sizeof...(_Elements) + && + __and_<is_assignable<_Elements&, + _UElements&&>...>::value>::type> tuple& operator=(tuple<_UElements...>&& __in) { @@ -1189,14 +1233,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION std::forward<_U2>(__in.second)) { } tuple& - operator=(const tuple& __in) + operator=(typename + conditional<__and_<is_copy_assignable<_T1>, + is_copy_assignable<_T2>>::value, + const tuple&, const __nonesuch&>::type __in) { static_cast<_Inherited&>(*this) = __in; return *this; } tuple& - operator=(tuple&& __in) + operator=(typename + conditional<__and_<is_move_assignable<_T1>, + is_move_assignable<_T2>>::value, + tuple&&, __nonesuch&&>::type __in) noexcept(is_nothrow_move_assignable<_Inherited>::value) { static_cast<_Inherited&>(*this) = std::move(__in); @@ -1204,7 +1254,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template<typename _U1, typename _U2> - tuple& + typename + enable_if<__and_<is_assignable<_T1&, const _U1&>, + is_assignable<_T2&, const _U2&>>::value, + tuple&>::type operator=(const tuple<_U1, _U2>& __in) { static_cast<_Inherited&>(*this) = __in; @@ -1212,7 +1265,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template<typename _U1, typename _U2> - tuple& + typename + enable_if<__and_<is_assignable<_T1&, _U1&&>, + is_assignable<_T2&, _U2&&>>::value, + tuple&>::type operator=(tuple<_U1, _U2>&& __in) { static_cast<_Inherited&>(*this) = std::move(__in); @@ -1220,7 +1276,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template<typename _U1, typename _U2> - tuple& + typename + enable_if<__and_<is_assignable<_T1&, const _U1&>, + is_assignable<_T2&, const _U2&>>::value, + tuple&>::type operator=(const pair<_U1, _U2>& __in) { this->_M_head(*this) = __in.first; @@ -1229,7 +1288,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template<typename _U1, typename _U2> - tuple& + typename + enable_if<__and_<is_assignable<_T1&, _U1&&>, + is_assignable<_T2&, _U2&&>>::value, + tuple&>::type operator=(pair<_U1, _U2>&& __in) { this->_M_head(*this) = std::forward<_U1>(__in.first); diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits index 5085196f654..cd0ba99dcb8 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -2850,6 +2850,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __call_is_nothrow<result_of<_Fn(_Args...)>, _Fn, _Args...>>::type { }; + struct __nonesuch { + __nonesuch() = delete; + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; + #if __cplusplus > 201402L # define __cpp_lib_is_callable 201603 diff --git a/libstdc++-v3/include/std/variant b/libstdc++-v3/include/std/variant index 7dbb533dd83..ac483f3e6ab 100644 --- a/libstdc++-v3/include/std/variant +++ b/libstdc++-v3/include/std/variant @@ -296,15 +296,9 @@ namespace __variant { constexpr _Variant_storage() = default; - template<typename... _Args> - constexpr _Variant_storage(in_place_index_t<0>, _Args&&... __args) - : _M_first(in_place<0>, forward<_Args>(__args)...) - { } - - template<size_t _Np, typename... _Args, - typename = enable_if_t<0 < _Np && _Np < sizeof...(_Rest) + 1>> + template<size_t _Np, typename... _Args> constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args) - : _M_rest(in_place<_Np - 1>, forward<_Args>(__args)...) + : _M_union(in_place<_Np>, std::forward<_Args>(__args)...) { } ~_Variant_storage() = default; @@ -313,14 +307,27 @@ namespace __variant _M_storage() const { return const_cast<void*>( - static_cast<const void*>(std::addressof(_M_first._M_storage))); + static_cast<const void*>(std::addressof(_M_union._M_first._M_storage))); } - union + union _Union { + constexpr _Union() {}; + + template<typename... _Args> + constexpr _Union(in_place_index_t<0>, _Args&&... __args) + : _M_first(in_place<0>, std::forward<_Args>(__args)...) + { } + + template<size_t _Np, typename... _Args, + typename = enable_if_t<0 < _Np && _Np < sizeof...(_Rest) + 1>> + constexpr _Union(in_place_index_t<_Np>, _Args&&... __args) + : _M_rest(in_place<_Np - 1>, std::forward<_Args>(__args)...) + { } + _Uninitialized<__storage<_First>> _M_first; _Variant_storage<_Rest...> _M_rest; - }; + } _M_union; }; template<typename _Derived, bool __is_trivially_destructible> @@ -379,7 +386,7 @@ namespace __variant template<size_t _Np, typename... _Args> constexpr explicit _Variant_base(in_place_index_t<_Np> __i, _Args&&... __args) - : _Storage(__i, forward<_Args>(__args)...), _M_index(_Np) + : _Storage(__i, std::forward<_Args>(__args)...), _M_index(_Np) { } template<typename _Alloc> @@ -419,7 +426,7 @@ namespace __variant using _Storage = __storage<variant_alternative_t<_Np, variant<_Types...>>>; __uses_allocator_construct(__a, static_cast<_Storage*>(_M_storage()), - forward<_Args>(__args)...); + std::forward<_Args>(__args)...); __glibcxx_assert(_M_index == _Np); } @@ -574,7 +581,7 @@ namespace __variant decltype(auto) __access(_Variant&& __v) { return __get_alternative<__reserved_type_map<_Variant&&, __storage<_Tp>>>( - __get_storage(forward<_Variant>(__v))); + __get_storage(std::forward<_Variant>(__v))); } // A helper used to create variadic number of _To types. @@ -584,10 +591,11 @@ namespace __variant // Call the actual visitor. // _Args are qualified storage types. template<typename _Visitor, typename... _Args> - decltype(auto) __visit_invoke(_Visitor&& __visitor, - _To_type<_Args, void*>... __ptrs) + decltype(auto) + __visit_invoke(_Visitor&& __visitor, _To_type<_Args, void*>... __ptrs) { - return forward<_Visitor>(__visitor)(__get_alternative<_Args>(__ptrs)...); + return std::forward<_Visitor>(__visitor)( + __get_alternative<_Args>(__ptrs)...); } // Used for storing multi-dimensional vtable. @@ -1003,7 +1011,7 @@ namespace __variant constexpr variant(_Tp&& __t) noexcept(is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp&&>) - : variant(in_place<__accepted_index<_Tp&&>>, forward<_Tp>(__t)) + : variant(in_place<__accepted_index<_Tp&&>>, std::forward<_Tp>(__t)) { __glibcxx_assert(holds_alternative<__accepted_type<_Tp&&>>(*this)); } template<typename _Tp, typename... _Args, @@ -1011,7 +1019,7 @@ namespace __variant && is_constructible_v<_Tp, _Args&&...>>> constexpr explicit variant(in_place_type_t<_Tp>, _Args&&... __args) - : variant(in_place<__index_of<_Tp>>, forward<_Args>(__args)...) + : variant(in_place<__index_of<_Tp>>, std::forward<_Args>(__args)...) { __glibcxx_assert(holds_alternative<_Tp>(*this)); } template<typename _Tp, typename _Up, typename... _Args, @@ -1022,7 +1030,7 @@ namespace __variant variant(in_place_type_t<_Tp>, initializer_list<_Up> __il, _Args&&... __args) : variant(in_place<__index_of<_Tp>>, __il, - forward<_Args>(__args)...) + std::forward<_Args>(__args)...) { __glibcxx_assert(holds_alternative<_Tp>(*this)); } template<size_t _Np, typename... _Args, @@ -1030,7 +1038,7 @@ namespace __variant is_constructible_v<__to_type<_Np>, _Args&&...>>> constexpr explicit variant(in_place_index_t<_Np>, _Args&&... __args) - : _Base(in_place<_Np>, forward<_Args>(__args)...), + : _Base(in_place<_Np>, std::forward<_Args>(__args)...), _Default_ctor_enabler(_Enable_default_constructor_tag{}) { __glibcxx_assert(index() == _Np); } @@ -1040,7 +1048,7 @@ namespace __variant constexpr explicit variant(in_place_index_t<_Np>, initializer_list<_Up> __il, _Args&&... __args) - : _Base(in_place<_Np>, __il, forward<_Args>(__args)...), + : _Base(in_place<_Np>, __il, std::forward<_Args>(__args)...), _Default_ctor_enabler(_Enable_default_constructor_tag{}) { __glibcxx_assert(index() == _Np); } @@ -1077,7 +1085,7 @@ namespace __variant && !is_same_v<decay_t<_Tp>, variant>, variant&>> variant(allocator_arg_t, const _Alloc& __a, _Tp&& __t) : variant(allocator_arg, __a, in_place<__accepted_index<_Tp&&>>, - forward<_Tp>(__t)) + std::forward<_Tp>(__t)) { __glibcxx_assert(holds_alternative<__accepted_type<_Tp&&>>(*this)); } template<typename _Alloc, typename _Tp, typename... _Args, @@ -1088,7 +1096,7 @@ namespace __variant variant(allocator_arg_t, const _Alloc& __a, in_place_type_t<_Tp>, _Args&&... __args) : variant(allocator_arg, __a, in_place<__index_of<_Tp>>, - forward<_Args>(__args)...) + std::forward<_Args>(__args)...) { __glibcxx_assert(holds_alternative<_Tp>(*this)); } template<typename _Alloc, typename _Tp, typename _Up, typename... _Args, @@ -1099,7 +1107,7 @@ namespace __variant variant(allocator_arg_t, const _Alloc& __a, in_place_type_t<_Tp>, initializer_list<_Up> __il, _Args&&... __args) : variant(allocator_arg, __a, in_place<__index_of<_Tp>>, __il, - forward<_Args>(__args)...) + std::forward<_Args>(__args)...) { __glibcxx_assert(holds_alternative<_Tp>(*this)); } template<typename _Alloc, size_t _Np, typename... _Args, @@ -1108,7 +1116,7 @@ namespace __variant __to_type<_Np>, _Alloc, _Args&&...>>> variant(allocator_arg_t, const _Alloc& __a, in_place_index_t<_Np>, _Args&&... __args) - : _Base(__a, in_place<_Np>, forward<_Args>(__args)...), + : _Base(__a, in_place<_Np>, std::forward<_Args>(__args)...), _Default_ctor_enabler(_Enable_default_constructor_tag{}) { __glibcxx_assert(index() == _Np); } @@ -1118,7 +1126,7 @@ namespace __variant __to_type<_Np>, _Alloc, initializer_list<_Up>&, _Args&&...>>> variant(allocator_arg_t, const _Alloc& __a, in_place_index_t<_Np>, initializer_list<_Up> __il, _Args&&... __args) - : _Base(__a, in_place<_Np>, __il, forward<_Args>(__args)...), + : _Base(__a, in_place<_Np>, __il, std::forward<_Args>(__args)...), _Default_ctor_enabler(_Enable_default_constructor_tag{}) { __glibcxx_assert(index() == _Np); } @@ -1140,10 +1148,9 @@ namespace __variant { constexpr auto __index = __accepted_index<_Tp&&>; if (index() == __index) - *static_cast<__storage<__to_type<__index>>*>(this->_M_storage()) - = forward<_Tp>(__rhs); + std::get<__index>(*this) = std::forward<_Tp>(__rhs); else - this->emplace<__index>(forward<_Tp>(__rhs)); + this->emplace<__index>(std::forward<_Tp>(__rhs)); __glibcxx_assert(holds_alternative<__accepted_type<_Tp&&>>(*this)); return *this; } @@ -1153,7 +1160,7 @@ namespace __variant { static_assert(__exactly_once<_Tp>, "T should occur for exactly once in alternatives"); - this->emplace<__index_of<_Tp>>(forward<_Args>(__args)...); + this->emplace<__index_of<_Tp>>(std::forward<_Args>(__args)...); __glibcxx_assert(holds_alternative<_Tp>(*this)); } @@ -1162,7 +1169,7 @@ namespace __variant { static_assert(__exactly_once<_Tp>, "T should occur for exactly once in alternatives"); - this->emplace<__index_of<_Tp>>(__il, forward<_Args>(__args)...); + this->emplace<__index_of<_Tp>>(__il, std::forward<_Args>(__args)...); __glibcxx_assert(holds_alternative<_Tp>(*this)); } @@ -1175,7 +1182,7 @@ namespace __variant __try { ::new (this) variant(in_place<_Np>, - forward<_Args>(__args)...); + std::forward<_Args>(__args)...); } __catch (...) { @@ -1194,7 +1201,7 @@ namespace __variant __try { ::new (this) variant(in_place<_Np>, __il, - forward<_Args>(__args)...); + std::forward<_Args>(__args)...); } __catch (...) { @@ -1304,12 +1311,12 @@ namespace __variant visit(_Visitor&& __visitor, _Variants&&... __variants) { using _Result_type = - decltype(forward<_Visitor>(__visitor)(get<0>(__variants)...)); + decltype(std::forward<_Visitor>(__visitor)(get<0>(__variants)...)); static constexpr auto _S_vtable = __detail::__variant::__gen_vtable< _Result_type, _Visitor&&, _Variants&&...>::_S_apply(); auto __func_ptr = _S_vtable._M_access(__variants.index()...); - return (*__func_ptr)(forward<_Visitor>(__visitor), + return (*__func_ptr)(std::forward<_Visitor>(__visitor), __detail::__variant::__get_storage(__variants)...); } |