diff options
| author | Andrey Khalyavin <halyavin@gmail.com> | 2022-02-10 16:46:29 +0300 |
|---|---|---|
| committer | Daniil Cherednik <dcherednik@yandex-team.ru> | 2022-02-10 16:46:29 +0300 |
| commit | f773626848a7c7456803654292e716b83d69cc12 (patch) | |
| tree | db052dfcf9134f492bdbb962cb6c16cea58e1ed3 /contrib/libs/cxxsupp/libcxx/include/variant | |
| parent | f43ab775d197d300eb67bd4497632b909cd7c2a5 (diff) | |
| download | ydb-f773626848a7c7456803654292e716b83d69cc12.tar.gz | |
Restoring authorship annotation for Andrey Khalyavin <halyavin@gmail.com>. Commit 1 of 2.
Diffstat (limited to 'contrib/libs/cxxsupp/libcxx/include/variant')
| -rw-r--r-- | contrib/libs/cxxsupp/libcxx/include/variant | 3476 |
1 files changed, 1738 insertions, 1738 deletions
diff --git a/contrib/libs/cxxsupp/libcxx/include/variant b/contrib/libs/cxxsupp/libcxx/include/variant index 972c18a811..5bcf07c67d 100644 --- a/contrib/libs/cxxsupp/libcxx/include/variant +++ b/contrib/libs/cxxsupp/libcxx/include/variant @@ -1,1778 +1,1778 @@ -// -*- C++ -*- -//===------------------------------ variant -------------------------------===// -// +// -*- C++ -*- +//===------------------------------ variant -------------------------------===// +// // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_VARIANT -#define _LIBCPP_VARIANT - -/* - variant synopsis - -namespace std { - - // 20.7.2, class template variant - template <class... Types> - class variant { - public: - - // 20.7.2.1, constructors - constexpr variant() noexcept(see below); +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_VARIANT +#define _LIBCPP_VARIANT + +/* + variant synopsis + +namespace std { + + // 20.7.2, class template variant + template <class... Types> + class variant { + public: + + // 20.7.2.1, constructors + constexpr variant() noexcept(see below); variant(const variant&); // constexpr in C++20 variant(variant&&) noexcept(see below); // constexpr in C++20 - - template <class T> constexpr variant(T&&) noexcept(see below); - - template <class T, class... Args> - constexpr explicit variant(in_place_type_t<T>, Args&&...); - - template <class T, class U, class... Args> - constexpr explicit variant( - in_place_type_t<T>, initializer_list<U>, Args&&...); - - template <size_t I, class... Args> - constexpr explicit variant(in_place_index_t<I>, Args&&...); - - template <size_t I, class U, class... Args> - constexpr explicit variant( - in_place_index_t<I>, initializer_list<U>, Args&&...); - - // 20.7.2.2, destructor - ~variant(); - - // 20.7.2.3, assignment + + template <class T> constexpr variant(T&&) noexcept(see below); + + template <class T, class... Args> + constexpr explicit variant(in_place_type_t<T>, Args&&...); + + template <class T, class U, class... Args> + constexpr explicit variant( + in_place_type_t<T>, initializer_list<U>, Args&&...); + + template <size_t I, class... Args> + constexpr explicit variant(in_place_index_t<I>, Args&&...); + + template <size_t I, class U, class... Args> + constexpr explicit variant( + in_place_index_t<I>, initializer_list<U>, Args&&...); + + // 20.7.2.2, destructor + ~variant(); + + // 20.7.2.3, assignment variant& operator=(const variant&); // constexpr in C++20 variant& operator=(variant&&) noexcept(see below); // constexpr in C++20 - - template <class T> variant& operator=(T&&) noexcept(see below); - - // 20.7.2.4, modifiers - template <class T, class... Args> - T& emplace(Args&&...); - - template <class T, class U, class... Args> - T& emplace(initializer_list<U>, Args&&...); - - template <size_t I, class... Args> - variant_alternative_t<I, variant>& emplace(Args&&...); - - template <size_t I, class U, class... Args> - variant_alternative_t<I, variant>& emplace(initializer_list<U>, Args&&...); - - // 20.7.2.5, value status - constexpr bool valueless_by_exception() const noexcept; - constexpr size_t index() const noexcept; - - // 20.7.2.6, swap - void swap(variant&) noexcept(see below); - }; - - // 20.7.3, variant helper classes - template <class T> struct variant_size; // undefined - - template <class T> - inline constexpr size_t variant_size_v = variant_size<T>::value; - - template <class T> struct variant_size<const T>; - template <class T> struct variant_size<volatile T>; - template <class T> struct variant_size<const volatile T>; - - template <class... Types> - struct variant_size<variant<Types...>>; - - template <size_t I, class T> struct variant_alternative; // undefined - - template <size_t I, class T> - using variant_alternative_t = typename variant_alternative<I, T>::type; - - template <size_t I, class T> struct variant_alternative<I, const T>; - template <size_t I, class T> struct variant_alternative<I, volatile T>; - template <size_t I, class T> struct variant_alternative<I, const volatile T>; - - template <size_t I, class... Types> - struct variant_alternative<I, variant<Types...>>; - - inline constexpr size_t variant_npos = -1; - - // 20.7.4, value access - template <class T, class... Types> - constexpr bool holds_alternative(const variant<Types...>&) noexcept; - - template <size_t I, class... Types> - constexpr variant_alternative_t<I, variant<Types...>>& - get(variant<Types...>&); - - template <size_t I, class... Types> - constexpr variant_alternative_t<I, variant<Types...>>&& - get(variant<Types...>&&); - - template <size_t I, class... Types> - constexpr variant_alternative_t<I, variant<Types...>> const& - get(const variant<Types...>&); - - template <size_t I, class... Types> - constexpr variant_alternative_t<I, variant<Types...>> const&& - get(const variant<Types...>&&); - - template <class T, class... Types> - constexpr T& get(variant<Types...>&); - - template <class T, class... Types> - constexpr T&& get(variant<Types...>&&); - - template <class T, class... Types> - constexpr const T& get(const variant<Types...>&); - - template <class T, class... Types> - constexpr const T&& get(const variant<Types...>&&); - - template <size_t I, class... Types> - constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>> - get_if(variant<Types...>*) noexcept; - - template <size_t I, class... Types> - constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>> - get_if(const variant<Types...>*) noexcept; - - template <class T, class... Types> - constexpr add_pointer_t<T> - get_if(variant<Types...>*) noexcept; - - template <class T, class... Types> - constexpr add_pointer_t<const T> - get_if(const variant<Types...>*) noexcept; - - // 20.7.5, relational operators - template <class... Types> - constexpr bool operator==(const variant<Types...>&, const variant<Types...>&); - - template <class... Types> - constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&); - - template <class... Types> - constexpr bool operator<(const variant<Types...>&, const variant<Types...>&); - - template <class... Types> - constexpr bool operator>(const variant<Types...>&, const variant<Types...>&); - - template <class... Types> - constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&); - - template <class... Types> - constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&); - - // 20.7.6, visitation - template <class Visitor, class... Variants> - constexpr see below visit(Visitor&&, Variants&&...); - - template <class R, class Visitor, class... Variants> - constexpr R visit(Visitor&&, Variants&&...); // since C++20 - - // 20.7.7, class monostate - struct monostate; - - // 20.7.8, monostate relational operators - constexpr bool operator<(monostate, monostate) noexcept; - constexpr bool operator>(monostate, monostate) noexcept; - constexpr bool operator<=(monostate, monostate) noexcept; - constexpr bool operator>=(monostate, monostate) noexcept; - constexpr bool operator==(monostate, monostate) noexcept; - constexpr bool operator!=(monostate, monostate) noexcept; - - // 20.7.9, specialized algorithms - template <class... Types> - void swap(variant<Types...>&, variant<Types...>&) noexcept(see below); - - // 20.7.10, class bad_variant_access - class bad_variant_access; - - // 20.7.11, hash support - template <class T> struct hash; - template <class... Types> struct hash<variant<Types...>>; - template <> struct hash<monostate>; - -} // namespace std - -*/ - -#include <__availability> -#include <__config> -#include <__functional/hash.h> -#include <__tuple> -#include <__utility/forward.h> -#include <__variant/monostate.h> -#include <compare> -#include <exception> -#include <initializer_list> -#include <limits> -#include <new> -#include <tuple> -#include <type_traits> -#include <utility> + + template <class T> variant& operator=(T&&) noexcept(see below); + + // 20.7.2.4, modifiers + template <class T, class... Args> + T& emplace(Args&&...); + + template <class T, class U, class... Args> + T& emplace(initializer_list<U>, Args&&...); + + template <size_t I, class... Args> + variant_alternative_t<I, variant>& emplace(Args&&...); + + template <size_t I, class U, class... Args> + variant_alternative_t<I, variant>& emplace(initializer_list<U>, Args&&...); + + // 20.7.2.5, value status + constexpr bool valueless_by_exception() const noexcept; + constexpr size_t index() const noexcept; + + // 20.7.2.6, swap + void swap(variant&) noexcept(see below); + }; + + // 20.7.3, variant helper classes + template <class T> struct variant_size; // undefined + + template <class T> + inline constexpr size_t variant_size_v = variant_size<T>::value; + + template <class T> struct variant_size<const T>; + template <class T> struct variant_size<volatile T>; + template <class T> struct variant_size<const volatile T>; + + template <class... Types> + struct variant_size<variant<Types...>>; + + template <size_t I, class T> struct variant_alternative; // undefined + + template <size_t I, class T> + using variant_alternative_t = typename variant_alternative<I, T>::type; + + template <size_t I, class T> struct variant_alternative<I, const T>; + template <size_t I, class T> struct variant_alternative<I, volatile T>; + template <size_t I, class T> struct variant_alternative<I, const volatile T>; + + template <size_t I, class... Types> + struct variant_alternative<I, variant<Types...>>; + + inline constexpr size_t variant_npos = -1; + + // 20.7.4, value access + template <class T, class... Types> + constexpr bool holds_alternative(const variant<Types...>&) noexcept; + + template <size_t I, class... Types> + constexpr variant_alternative_t<I, variant<Types...>>& + get(variant<Types...>&); + + template <size_t I, class... Types> + constexpr variant_alternative_t<I, variant<Types...>>&& + get(variant<Types...>&&); + + template <size_t I, class... Types> + constexpr variant_alternative_t<I, variant<Types...>> const& + get(const variant<Types...>&); + + template <size_t I, class... Types> + constexpr variant_alternative_t<I, variant<Types...>> const&& + get(const variant<Types...>&&); + + template <class T, class... Types> + constexpr T& get(variant<Types...>&); + + template <class T, class... Types> + constexpr T&& get(variant<Types...>&&); + + template <class T, class... Types> + constexpr const T& get(const variant<Types...>&); + + template <class T, class... Types> + constexpr const T&& get(const variant<Types...>&&); + + template <size_t I, class... Types> + constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>> + get_if(variant<Types...>*) noexcept; + + template <size_t I, class... Types> + constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>> + get_if(const variant<Types...>*) noexcept; + + template <class T, class... Types> + constexpr add_pointer_t<T> + get_if(variant<Types...>*) noexcept; + + template <class T, class... Types> + constexpr add_pointer_t<const T> + get_if(const variant<Types...>*) noexcept; + + // 20.7.5, relational operators + template <class... Types> + constexpr bool operator==(const variant<Types...>&, const variant<Types...>&); + + template <class... Types> + constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&); + + template <class... Types> + constexpr bool operator<(const variant<Types...>&, const variant<Types...>&); + + template <class... Types> + constexpr bool operator>(const variant<Types...>&, const variant<Types...>&); + + template <class... Types> + constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&); + + template <class... Types> + constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&); + + // 20.7.6, visitation + template <class Visitor, class... Variants> + constexpr see below visit(Visitor&&, Variants&&...); + + template <class R, class Visitor, class... Variants> + constexpr R visit(Visitor&&, Variants&&...); // since C++20 + + // 20.7.7, class monostate + struct monostate; + + // 20.7.8, monostate relational operators + constexpr bool operator<(monostate, monostate) noexcept; + constexpr bool operator>(monostate, monostate) noexcept; + constexpr bool operator<=(monostate, monostate) noexcept; + constexpr bool operator>=(monostate, monostate) noexcept; + constexpr bool operator==(monostate, monostate) noexcept; + constexpr bool operator!=(monostate, monostate) noexcept; + + // 20.7.9, specialized algorithms + template <class... Types> + void swap(variant<Types...>&, variant<Types...>&) noexcept(see below); + + // 20.7.10, class bad_variant_access + class bad_variant_access; + + // 20.7.11, hash support + template <class T> struct hash; + template <class... Types> struct hash<variant<Types...>>; + template <> struct hash<monostate>; + +} // namespace std + +*/ + +#include <__availability> +#include <__config> +#include <__functional/hash.h> +#include <__tuple> +#include <__utility/forward.h> +#include <__variant/monostate.h> +#include <compare> +#include <exception> +#include <initializer_list> +#include <limits> +#include <new> +#include <tuple> +#include <type_traits> +#include <utility> #include <version> - -#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -#pragma GCC system_header -#endif - -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - -namespace std { // explicitly not using versioning namespace - + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +namespace std { // explicitly not using versioning namespace + class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS bad_variant_access : public exception { -public: - virtual const char* what() const _NOEXCEPT; -}; - -} // namespace std - -_LIBCPP_BEGIN_NAMESPACE_STD - -#if _LIBCPP_STD_VER > 14 - -// Light N-dimensional array of function pointers. Used in place of std::array to avoid -// adding a dependency. -template<class _Tp, size_t _Size> -struct __farray { - static_assert(_Size > 0, "N-dimensional array should never be empty in std::visit"); - _Tp __buf_[_Size] = {}; - - _LIBCPP_INLINE_VISIBILITY constexpr - const _Tp &operator[](size_t __n) const noexcept { - return __buf_[__n]; - } -}; - -_LIBCPP_NORETURN -inline _LIBCPP_INLINE_VISIBILITY +public: + virtual const char* what() const _NOEXCEPT; +}; + +} // namespace std + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if _LIBCPP_STD_VER > 14 + +// Light N-dimensional array of function pointers. Used in place of std::array to avoid +// adding a dependency. +template<class _Tp, size_t _Size> +struct __farray { + static_assert(_Size > 0, "N-dimensional array should never be empty in std::visit"); + _Tp __buf_[_Size] = {}; + + _LIBCPP_INLINE_VISIBILITY constexpr + const _Tp &operator[](size_t __n) const noexcept { + return __buf_[__n]; + } +}; + +_LIBCPP_NORETURN +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS -void __throw_bad_variant_access() { -#ifndef _LIBCPP_NO_EXCEPTIONS - throw bad_variant_access(); -#else - _VSTD::abort(); -#endif -} - -template <class... _Types> -class _LIBCPP_TEMPLATE_VIS variant; - -template <class _Tp> -struct _LIBCPP_TEMPLATE_VIS variant_size; - -template <class _Tp> -inline constexpr size_t variant_size_v = variant_size<_Tp>::value; - -template <class _Tp> -struct _LIBCPP_TEMPLATE_VIS variant_size<const _Tp> : variant_size<_Tp> {}; - -template <class _Tp> -struct _LIBCPP_TEMPLATE_VIS variant_size<volatile _Tp> : variant_size<_Tp> {}; - -template <class _Tp> -struct _LIBCPP_TEMPLATE_VIS variant_size<const volatile _Tp> - : variant_size<_Tp> {}; - -template <class... _Types> -struct _LIBCPP_TEMPLATE_VIS variant_size<variant<_Types...>> - : integral_constant<size_t, sizeof...(_Types)> {}; - -template <size_t _Ip, class _Tp> -struct _LIBCPP_TEMPLATE_VIS variant_alternative; - -template <size_t _Ip, class _Tp> -using variant_alternative_t = typename variant_alternative<_Ip, _Tp>::type; - -template <size_t _Ip, class _Tp> -struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const _Tp> - : add_const<variant_alternative_t<_Ip, _Tp>> {}; - -template <size_t _Ip, class _Tp> -struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, volatile _Tp> - : add_volatile<variant_alternative_t<_Ip, _Tp>> {}; - -template <size_t _Ip, class _Tp> -struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const volatile _Tp> - : add_cv<variant_alternative_t<_Ip, _Tp>> {}; - -template <size_t _Ip, class... _Types> -struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, variant<_Types...>> { - static_assert(_Ip < sizeof...(_Types), "Index out of bounds in std::variant_alternative<>"); - using type = __type_pack_element<_Ip, _Types...>; -}; - -inline constexpr size_t variant_npos = static_cast<size_t>(-1); - -constexpr int __choose_index_type(unsigned int __num_elem) { - if (__num_elem < numeric_limits<unsigned char>::max()) - return 0; - if (__num_elem < numeric_limits<unsigned short>::max()) - return 1; - return 2; -} - -template <size_t _NumAlts> -using __variant_index_t = -#ifndef _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION - unsigned int; -#else - std::tuple_element_t< - __choose_index_type(_NumAlts), - std::tuple<unsigned char, unsigned short, unsigned int> - >; -#endif - -template <class _IndexType> -constexpr _IndexType __variant_npos = static_cast<_IndexType>(-1); - -template <class... _Types> -class _LIBCPP_TEMPLATE_VIS variant; - -template <class... _Types> -_LIBCPP_INLINE_VISIBILITY constexpr variant<_Types...>& -__as_variant(variant<_Types...>& __vs) noexcept { - return __vs; -} - -template <class... _Types> -_LIBCPP_INLINE_VISIBILITY constexpr const variant<_Types...>& -__as_variant(const variant<_Types...>& __vs) noexcept { - return __vs; -} - -template <class... _Types> -_LIBCPP_INLINE_VISIBILITY constexpr variant<_Types...>&& -__as_variant(variant<_Types...>&& __vs) noexcept { - return _VSTD::move(__vs); -} - -template <class... _Types> -_LIBCPP_INLINE_VISIBILITY constexpr const variant<_Types...>&& -__as_variant(const variant<_Types...>&& __vs) noexcept { - return _VSTD::move(__vs); -} - -namespace __find_detail { - -template <class _Tp, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr size_t __find_index() { - constexpr bool __matches[] = {is_same_v<_Tp, _Types>...}; - size_t __result = __not_found; - for (size_t __i = 0; __i < sizeof...(_Types); ++__i) { - if (__matches[__i]) { - if (__result != __not_found) { - return __ambiguous; - } - __result = __i; - } - } - return __result; -} - -template <size_t _Index> -struct __find_unambiguous_index_sfinae_impl - : integral_constant<size_t, _Index> {}; - -template <> -struct __find_unambiguous_index_sfinae_impl<__not_found> {}; - -template <> -struct __find_unambiguous_index_sfinae_impl<__ambiguous> {}; - -template <class _Tp, class... _Types> -struct __find_unambiguous_index_sfinae - : __find_unambiguous_index_sfinae_impl<__find_index<_Tp, _Types...>()> {}; - -} // namespace __find_detail - -namespace __variant_detail { - -struct __valueless_t {}; - -enum class _Trait { _TriviallyAvailable, _Available, _Unavailable }; - -template <typename _Tp, - template <typename> class _IsTriviallyAvailable, - template <typename> class _IsAvailable> -constexpr _Trait __trait = - _IsTriviallyAvailable<_Tp>::value - ? _Trait::_TriviallyAvailable - : _IsAvailable<_Tp>::value ? _Trait::_Available : _Trait::_Unavailable; - -inline _LIBCPP_INLINE_VISIBILITY -constexpr _Trait __common_trait(initializer_list<_Trait> __traits) { - _Trait __result = _Trait::_TriviallyAvailable; - for (_Trait __t : __traits) { - if (static_cast<int>(__t) > static_cast<int>(__result)) { - __result = __t; - } - } - return __result; -} - -template <typename... _Types> -struct __traits { - static constexpr _Trait __copy_constructible_trait = - __common_trait({__trait<_Types, - is_trivially_copy_constructible, - is_copy_constructible>...}); - - static constexpr _Trait __move_constructible_trait = - __common_trait({__trait<_Types, - is_trivially_move_constructible, - is_move_constructible>...}); - - static constexpr _Trait __copy_assignable_trait = __common_trait( - {__copy_constructible_trait, - __trait<_Types, is_trivially_copy_assignable, is_copy_assignable>...}); - - static constexpr _Trait __move_assignable_trait = __common_trait( - {__move_constructible_trait, - __trait<_Types, is_trivially_move_assignable, is_move_assignable>...}); - - static constexpr _Trait __destructible_trait = __common_trait( - {__trait<_Types, is_trivially_destructible, is_destructible>...}); -}; - -namespace __access { - -struct __union { - template <class _Vp> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<0>) { - return _VSTD::forward<_Vp>(__v).__head; - } - - template <class _Vp, size_t _Ip> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<_Ip>) { - return __get_alt(_VSTD::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>); - } -}; - -struct __base { - template <size_t _Ip, class _Vp> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto&& __get_alt(_Vp&& __v) { - return __union::__get_alt(_VSTD::forward<_Vp>(__v).__data, - in_place_index<_Ip>); - } -}; - -struct __variant { - template <size_t _Ip, class _Vp> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto&& __get_alt(_Vp&& __v) { - return __base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v).__impl); - } -}; - -} // namespace __access - -namespace __visitation { - -struct __base { - template <class _Visitor, class... _Vs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr decltype(auto) - __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) { - constexpr auto __fdiagonal = - __make_fdiagonal<_Visitor&&, - decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>(); - return __fdiagonal[__index](_VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Vs>(__vs).__as_base()...); - } - - template <class _Visitor, class... _Vs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor, - _Vs&&... __vs) { - constexpr auto __fmatrix = - __make_fmatrix<_Visitor&&, - decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>(); - return __at(__fmatrix, __vs.index()...)( - _VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Vs>(__vs).__as_base()...); - } - -private: - template <class _Tp> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr const _Tp& __at(const _Tp& __elem) { return __elem; } - - template <class _Tp, size_t _Np, typename... _Indices> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto&& __at(const __farray<_Tp, _Np>& __elems, - size_t __index, _Indices... __indices) { - return __at(__elems[__index], __indices...); - } - - template <class _Fp, class... _Fs> - static constexpr void __std_visit_visitor_return_type_check() { - static_assert( - __all<is_same_v<_Fp, _Fs>...>::value, - "`std::visit` requires the visitor to have a single return type."); - } - - template <class... _Fs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto __make_farray(_Fs&&... __fs) { - __std_visit_visitor_return_type_check<__uncvref_t<_Fs>...>(); - using __result = __farray<common_type_t<__uncvref_t<_Fs>...>, sizeof...(_Fs)>; - return __result{{_VSTD::forward<_Fs>(__fs)...}}; - } - - template <size_t... _Is> - struct __dispatcher { - template <class _Fp, class... _Vs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) { - return _VSTD::__invoke_constexpr( - static_cast<_Fp>(__f), - __access::__base::__get_alt<_Is>(static_cast<_Vs>(__vs))...); - } - }; - - template <class _Fp, class... _Vs, size_t... _Is> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto __make_dispatch(index_sequence<_Is...>) { - return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>; - } - - template <size_t _Ip, class _Fp, class... _Vs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto __make_fdiagonal_impl() { - return __make_dispatch<_Fp, _Vs...>( - index_sequence<((void)__identity<_Vs>{}, _Ip)...>{}); - } - - template <class _Fp, class... _Vs, size_t... _Is> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) { - return __base::__make_farray(__make_fdiagonal_impl<_Is, _Fp, _Vs...>()...); - } - - template <class _Fp, class _Vp, class... _Vs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto __make_fdiagonal() { - constexpr size_t _Np = __uncvref_t<_Vp>::__size(); - static_assert(__all<(_Np == __uncvref_t<_Vs>::__size())...>::value); - return __make_fdiagonal_impl<_Fp, _Vp, _Vs...>(make_index_sequence<_Np>{}); - } - - template <class _Fp, class... _Vs, size_t... _Is> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) { - return __make_dispatch<_Fp, _Vs...>(__is); - } - - template <class _Fp, class... _Vs, size_t... _Is, size_t... _Js, class... _Ls> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto __make_fmatrix_impl(index_sequence<_Is...>, - index_sequence<_Js...>, - _Ls... __ls) { - return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>( - index_sequence<_Is..., _Js>{}, __ls...)...); - } - - template <class _Fp, class... _Vs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto __make_fmatrix() { - return __make_fmatrix_impl<_Fp, _Vs...>( - index_sequence<>{}, make_index_sequence<__uncvref_t<_Vs>::__size()>{}...); - } -}; - -struct __variant { - template <class _Visitor, class... _Vs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr decltype(auto) - __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) { - return __base::__visit_alt_at(__index, - _VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Vs>(__vs).__impl...); - } - - template <class _Visitor, class... _Vs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor, - _Vs&&... __vs) { - return __base::__visit_alt( - _VSTD::forward<_Visitor>(__visitor), - _VSTD::__as_variant(_VSTD::forward<_Vs>(__vs)).__impl...); - } - - template <class _Visitor, class... _Vs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr decltype(auto) - __visit_value_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) { - return __visit_alt_at( - __index, - __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)), - _VSTD::forward<_Vs>(__vs)...); - } - - template <class _Visitor, class... _Vs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr decltype(auto) __visit_value(_Visitor&& __visitor, - _Vs&&... __vs) { - return __visit_alt( - __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)), - _VSTD::forward<_Vs>(__vs)...); - } - -#if _LIBCPP_STD_VER > 17 - template <class _Rp, class _Visitor, class... _Vs> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr _Rp __visit_value(_Visitor&& __visitor, - _Vs&&... __vs) { - return __visit_alt( - __make_value_visitor<_Rp>(_VSTD::forward<_Visitor>(__visitor)), - _VSTD::forward<_Vs>(__vs)...); - } -#endif - -private: - template <class _Visitor, class... _Values> - static constexpr void __std_visit_exhaustive_visitor_check() { - static_assert(is_invocable_v<_Visitor, _Values...>, - "`std::visit` requires the visitor to be exhaustive."); - } - - template <class _Visitor> - struct __value_visitor { - template <class... _Alts> - inline _LIBCPP_INLINE_VISIBILITY - constexpr decltype(auto) operator()(_Alts&&... __alts) const { - __std_visit_exhaustive_visitor_check< - _Visitor, - decltype((_VSTD::forward<_Alts>(__alts).__value))...>(); - return _VSTD::__invoke_constexpr(_VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Alts>(__alts).__value...); - } - _Visitor&& __visitor; - }; - -#if _LIBCPP_STD_VER > 17 - template <class _Rp, class _Visitor> - struct __value_visitor_return_type { - template <class... _Alts> - inline _LIBCPP_INLINE_VISIBILITY - constexpr _Rp operator()(_Alts&&... __alts) const { - __std_visit_exhaustive_visitor_check< - _Visitor, - decltype((_VSTD::forward<_Alts>(__alts).__value))...>(); - if constexpr (is_void_v<_Rp>) { - _VSTD::__invoke_constexpr(_VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Alts>(__alts).__value...); - } - else { - return _VSTD::__invoke_constexpr(_VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Alts>(__alts).__value...); - } - } - - _Visitor&& __visitor; - }; -#endif - - template <class _Visitor> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto __make_value_visitor(_Visitor&& __visitor) { - return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)}; - } - -#if _LIBCPP_STD_VER > 17 - template <class _Rp, class _Visitor> - inline _LIBCPP_INLINE_VISIBILITY - static constexpr auto __make_value_visitor(_Visitor&& __visitor) { - return __value_visitor_return_type<_Rp, _Visitor>{_VSTD::forward<_Visitor>(__visitor)}; - } -#endif -}; - -} // namespace __visitation - -template <size_t _Index, class _Tp> -struct _LIBCPP_TEMPLATE_VIS __alt { - using __value_type = _Tp; - - template <class... _Args> - inline _LIBCPP_INLINE_VISIBILITY - explicit constexpr __alt(in_place_t, _Args&&... __args) - : __value(_VSTD::forward<_Args>(__args)...) {} - - __value_type __value; -}; - -template <_Trait _DestructibleTrait, size_t _Index, class... _Types> -union _LIBCPP_TEMPLATE_VIS __union; - -template <_Trait _DestructibleTrait, size_t _Index> -union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {}; - -#define _LIBCPP_VARIANT_UNION(destructible_trait, destructor) \ - template <size_t _Index, class _Tp, class... _Types> \ - union _LIBCPP_TEMPLATE_VIS __union<destructible_trait, \ - _Index, \ - _Tp, \ - _Types...> { \ - public: \ - inline _LIBCPP_INLINE_VISIBILITY \ - explicit constexpr __union(__valueless_t) noexcept : __dummy{} {} \ - \ - template <class... _Args> \ - inline _LIBCPP_INLINE_VISIBILITY \ - explicit constexpr __union(in_place_index_t<0>, _Args&&... __args) \ - : __head(in_place, _VSTD::forward<_Args>(__args)...) {} \ - \ - template <size_t _Ip, class... _Args> \ - inline _LIBCPP_INLINE_VISIBILITY \ - explicit constexpr __union(in_place_index_t<_Ip>, _Args&&... __args) \ - : __tail(in_place_index<_Ip - 1>, _VSTD::forward<_Args>(__args)...) {} \ - \ - __union(const __union&) = default; \ - __union(__union&&) = default; \ - \ - destructor \ - \ - __union& operator=(const __union&) = default; \ - __union& operator=(__union&&) = default; \ - \ - private: \ - char __dummy; \ - __alt<_Index, _Tp> __head; \ - __union<destructible_trait, _Index + 1, _Types...> __tail; \ - \ - friend struct __access::__union; \ - } - -_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable, ~__union() = default;); -_LIBCPP_VARIANT_UNION(_Trait::_Available, ~__union() {}); -_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, ~__union() = delete;); - -#undef _LIBCPP_VARIANT_UNION - -template <_Trait _DestructibleTrait, class... _Types> -class _LIBCPP_TEMPLATE_VIS __base { -public: - using __index_t = __variant_index_t<sizeof...(_Types)>; - - inline _LIBCPP_INLINE_VISIBILITY - explicit constexpr __base(__valueless_t tag) noexcept - : __data(tag), __index(__variant_npos<__index_t>) {} - - template <size_t _Ip, class... _Args> - inline _LIBCPP_INLINE_VISIBILITY - explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args) - : - __data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...), - __index(_Ip) {} - - inline _LIBCPP_INLINE_VISIBILITY - constexpr bool valueless_by_exception() const noexcept { - return index() == variant_npos; - } - - inline _LIBCPP_INLINE_VISIBILITY - constexpr size_t index() const noexcept { - return __index == __variant_npos<__index_t> ? variant_npos : __index; - } - -protected: - inline _LIBCPP_INLINE_VISIBILITY - constexpr auto&& __as_base() & { return *this; } - - inline _LIBCPP_INLINE_VISIBILITY - constexpr auto&& __as_base() && { return _VSTD::move(*this); } - - inline _LIBCPP_INLINE_VISIBILITY - constexpr auto&& __as_base() const & { return *this; } - - inline _LIBCPP_INLINE_VISIBILITY - constexpr auto&& __as_base() const && { return _VSTD::move(*this); } - - inline _LIBCPP_INLINE_VISIBILITY - static constexpr size_t __size() { return sizeof...(_Types); } - - __union<_DestructibleTrait, 0, _Types...> __data; - __index_t __index; - - friend struct __access::__base; - friend struct __visitation::__base; -}; - -template <class _Traits, _Trait = _Traits::__destructible_trait> -class _LIBCPP_TEMPLATE_VIS __dtor; - -#define _LIBCPP_VARIANT_DESTRUCTOR(destructible_trait, destructor, destroy) \ - template <class... _Types> \ - class _LIBCPP_TEMPLATE_VIS __dtor<__traits<_Types...>, \ +void __throw_bad_variant_access() { +#ifndef _LIBCPP_NO_EXCEPTIONS + throw bad_variant_access(); +#else + _VSTD::abort(); +#endif +} + +template <class... _Types> +class _LIBCPP_TEMPLATE_VIS variant; + +template <class _Tp> +struct _LIBCPP_TEMPLATE_VIS variant_size; + +template <class _Tp> +inline constexpr size_t variant_size_v = variant_size<_Tp>::value; + +template <class _Tp> +struct _LIBCPP_TEMPLATE_VIS variant_size<const _Tp> : variant_size<_Tp> {}; + +template <class _Tp> +struct _LIBCPP_TEMPLATE_VIS variant_size<volatile _Tp> : variant_size<_Tp> {}; + +template <class _Tp> +struct _LIBCPP_TEMPLATE_VIS variant_size<const volatile _Tp> + : variant_size<_Tp> {}; + +template <class... _Types> +struct _LIBCPP_TEMPLATE_VIS variant_size<variant<_Types...>> + : integral_constant<size_t, sizeof...(_Types)> {}; + +template <size_t _Ip, class _Tp> +struct _LIBCPP_TEMPLATE_VIS variant_alternative; + +template <size_t _Ip, class _Tp> +using variant_alternative_t = typename variant_alternative<_Ip, _Tp>::type; + +template <size_t _Ip, class _Tp> +struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const _Tp> + : add_const<variant_alternative_t<_Ip, _Tp>> {}; + +template <size_t _Ip, class _Tp> +struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, volatile _Tp> + : add_volatile<variant_alternative_t<_Ip, _Tp>> {}; + +template <size_t _Ip, class _Tp> +struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const volatile _Tp> + : add_cv<variant_alternative_t<_Ip, _Tp>> {}; + +template <size_t _Ip, class... _Types> +struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, variant<_Types...>> { + static_assert(_Ip < sizeof...(_Types), "Index out of bounds in std::variant_alternative<>"); + using type = __type_pack_element<_Ip, _Types...>; +}; + +inline constexpr size_t variant_npos = static_cast<size_t>(-1); + +constexpr int __choose_index_type(unsigned int __num_elem) { + if (__num_elem < numeric_limits<unsigned char>::max()) + return 0; + if (__num_elem < numeric_limits<unsigned short>::max()) + return 1; + return 2; +} + +template <size_t _NumAlts> +using __variant_index_t = +#ifndef _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION + unsigned int; +#else + std::tuple_element_t< + __choose_index_type(_NumAlts), + std::tuple<unsigned char, unsigned short, unsigned int> + >; +#endif + +template <class _IndexType> +constexpr _IndexType __variant_npos = static_cast<_IndexType>(-1); + +template <class... _Types> +class _LIBCPP_TEMPLATE_VIS variant; + +template <class... _Types> +_LIBCPP_INLINE_VISIBILITY constexpr variant<_Types...>& +__as_variant(variant<_Types...>& __vs) noexcept { + return __vs; +} + +template <class... _Types> +_LIBCPP_INLINE_VISIBILITY constexpr const variant<_Types...>& +__as_variant(const variant<_Types...>& __vs) noexcept { + return __vs; +} + +template <class... _Types> +_LIBCPP_INLINE_VISIBILITY constexpr variant<_Types...>&& +__as_variant(variant<_Types...>&& __vs) noexcept { + return _VSTD::move(__vs); +} + +template <class... _Types> +_LIBCPP_INLINE_VISIBILITY constexpr const variant<_Types...>&& +__as_variant(const variant<_Types...>&& __vs) noexcept { + return _VSTD::move(__vs); +} + +namespace __find_detail { + +template <class _Tp, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr size_t __find_index() { + constexpr bool __matches[] = {is_same_v<_Tp, _Types>...}; + size_t __result = __not_found; + for (size_t __i = 0; __i < sizeof...(_Types); ++__i) { + if (__matches[__i]) { + if (__result != __not_found) { + return __ambiguous; + } + __result = __i; + } + } + return __result; +} + +template <size_t _Index> +struct __find_unambiguous_index_sfinae_impl + : integral_constant<size_t, _Index> {}; + +template <> +struct __find_unambiguous_index_sfinae_impl<__not_found> {}; + +template <> +struct __find_unambiguous_index_sfinae_impl<__ambiguous> {}; + +template <class _Tp, class... _Types> +struct __find_unambiguous_index_sfinae + : __find_unambiguous_index_sfinae_impl<__find_index<_Tp, _Types...>()> {}; + +} // namespace __find_detail + +namespace __variant_detail { + +struct __valueless_t {}; + +enum class _Trait { _TriviallyAvailable, _Available, _Unavailable }; + +template <typename _Tp, + template <typename> class _IsTriviallyAvailable, + template <typename> class _IsAvailable> +constexpr _Trait __trait = + _IsTriviallyAvailable<_Tp>::value + ? _Trait::_TriviallyAvailable + : _IsAvailable<_Tp>::value ? _Trait::_Available : _Trait::_Unavailable; + +inline _LIBCPP_INLINE_VISIBILITY +constexpr _Trait __common_trait(initializer_list<_Trait> __traits) { + _Trait __result = _Trait::_TriviallyAvailable; + for (_Trait __t : __traits) { + if (static_cast<int>(__t) > static_cast<int>(__result)) { + __result = __t; + } + } + return __result; +} + +template <typename... _Types> +struct __traits { + static constexpr _Trait __copy_constructible_trait = + __common_trait({__trait<_Types, + is_trivially_copy_constructible, + is_copy_constructible>...}); + + static constexpr _Trait __move_constructible_trait = + __common_trait({__trait<_Types, + is_trivially_move_constructible, + is_move_constructible>...}); + + static constexpr _Trait __copy_assignable_trait = __common_trait( + {__copy_constructible_trait, + __trait<_Types, is_trivially_copy_assignable, is_copy_assignable>...}); + + static constexpr _Trait __move_assignable_trait = __common_trait( + {__move_constructible_trait, + __trait<_Types, is_trivially_move_assignable, is_move_assignable>...}); + + static constexpr _Trait __destructible_trait = __common_trait( + {__trait<_Types, is_trivially_destructible, is_destructible>...}); +}; + +namespace __access { + +struct __union { + template <class _Vp> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<0>) { + return _VSTD::forward<_Vp>(__v).__head; + } + + template <class _Vp, size_t _Ip> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<_Ip>) { + return __get_alt(_VSTD::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>); + } +}; + +struct __base { + template <size_t _Ip, class _Vp> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto&& __get_alt(_Vp&& __v) { + return __union::__get_alt(_VSTD::forward<_Vp>(__v).__data, + in_place_index<_Ip>); + } +}; + +struct __variant { + template <size_t _Ip, class _Vp> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto&& __get_alt(_Vp&& __v) { + return __base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v).__impl); + } +}; + +} // namespace __access + +namespace __visitation { + +struct __base { + template <class _Visitor, class... _Vs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr decltype(auto) + __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) { + constexpr auto __fdiagonal = + __make_fdiagonal<_Visitor&&, + decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>(); + return __fdiagonal[__index](_VSTD::forward<_Visitor>(__visitor), + _VSTD::forward<_Vs>(__vs).__as_base()...); + } + + template <class _Visitor, class... _Vs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor, + _Vs&&... __vs) { + constexpr auto __fmatrix = + __make_fmatrix<_Visitor&&, + decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>(); + return __at(__fmatrix, __vs.index()...)( + _VSTD::forward<_Visitor>(__visitor), + _VSTD::forward<_Vs>(__vs).__as_base()...); + } + +private: + template <class _Tp> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr const _Tp& __at(const _Tp& __elem) { return __elem; } + + template <class _Tp, size_t _Np, typename... _Indices> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto&& __at(const __farray<_Tp, _Np>& __elems, + size_t __index, _Indices... __indices) { + return __at(__elems[__index], __indices...); + } + + template <class _Fp, class... _Fs> + static constexpr void __std_visit_visitor_return_type_check() { + static_assert( + __all<is_same_v<_Fp, _Fs>...>::value, + "`std::visit` requires the visitor to have a single return type."); + } + + template <class... _Fs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto __make_farray(_Fs&&... __fs) { + __std_visit_visitor_return_type_check<__uncvref_t<_Fs>...>(); + using __result = __farray<common_type_t<__uncvref_t<_Fs>...>, sizeof...(_Fs)>; + return __result{{_VSTD::forward<_Fs>(__fs)...}}; + } + + template <size_t... _Is> + struct __dispatcher { + template <class _Fp, class... _Vs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) { + return _VSTD::__invoke_constexpr( + static_cast<_Fp>(__f), + __access::__base::__get_alt<_Is>(static_cast<_Vs>(__vs))...); + } + }; + + template <class _Fp, class... _Vs, size_t... _Is> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto __make_dispatch(index_sequence<_Is...>) { + return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>; + } + + template <size_t _Ip, class _Fp, class... _Vs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto __make_fdiagonal_impl() { + return __make_dispatch<_Fp, _Vs...>( + index_sequence<((void)__identity<_Vs>{}, _Ip)...>{}); + } + + template <class _Fp, class... _Vs, size_t... _Is> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) { + return __base::__make_farray(__make_fdiagonal_impl<_Is, _Fp, _Vs...>()...); + } + + template <class _Fp, class _Vp, class... _Vs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto __make_fdiagonal() { + constexpr size_t _Np = __uncvref_t<_Vp>::__size(); + static_assert(__all<(_Np == __uncvref_t<_Vs>::__size())...>::value); + return __make_fdiagonal_impl<_Fp, _Vp, _Vs...>(make_index_sequence<_Np>{}); + } + + template <class _Fp, class... _Vs, size_t... _Is> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) { + return __make_dispatch<_Fp, _Vs...>(__is); + } + + template <class _Fp, class... _Vs, size_t... _Is, size_t... _Js, class... _Ls> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto __make_fmatrix_impl(index_sequence<_Is...>, + index_sequence<_Js...>, + _Ls... __ls) { + return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>( + index_sequence<_Is..., _Js>{}, __ls...)...); + } + + template <class _Fp, class... _Vs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto __make_fmatrix() { + return __make_fmatrix_impl<_Fp, _Vs...>( + index_sequence<>{}, make_index_sequence<__uncvref_t<_Vs>::__size()>{}...); + } +}; + +struct __variant { + template <class _Visitor, class... _Vs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr decltype(auto) + __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) { + return __base::__visit_alt_at(__index, + _VSTD::forward<_Visitor>(__visitor), + _VSTD::forward<_Vs>(__vs).__impl...); + } + + template <class _Visitor, class... _Vs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor, + _Vs&&... __vs) { + return __base::__visit_alt( + _VSTD::forward<_Visitor>(__visitor), + _VSTD::__as_variant(_VSTD::forward<_Vs>(__vs)).__impl...); + } + + template <class _Visitor, class... _Vs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr decltype(auto) + __visit_value_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) { + return __visit_alt_at( + __index, + __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)), + _VSTD::forward<_Vs>(__vs)...); + } + + template <class _Visitor, class... _Vs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr decltype(auto) __visit_value(_Visitor&& __visitor, + _Vs&&... __vs) { + return __visit_alt( + __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)), + _VSTD::forward<_Vs>(__vs)...); + } + +#if _LIBCPP_STD_VER > 17 + template <class _Rp, class _Visitor, class... _Vs> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr _Rp __visit_value(_Visitor&& __visitor, + _Vs&&... __vs) { + return __visit_alt( + __make_value_visitor<_Rp>(_VSTD::forward<_Visitor>(__visitor)), + _VSTD::forward<_Vs>(__vs)...); + } +#endif + +private: + template <class _Visitor, class... _Values> + static constexpr void __std_visit_exhaustive_visitor_check() { + static_assert(is_invocable_v<_Visitor, _Values...>, + "`std::visit` requires the visitor to be exhaustive."); + } + + template <class _Visitor> + struct __value_visitor { + template <class... _Alts> + inline _LIBCPP_INLINE_VISIBILITY + constexpr decltype(auto) operator()(_Alts&&... __alts) const { + __std_visit_exhaustive_visitor_check< + _Visitor, + decltype((_VSTD::forward<_Alts>(__alts).__value))...>(); + return _VSTD::__invoke_constexpr(_VSTD::forward<_Visitor>(__visitor), + _VSTD::forward<_Alts>(__alts).__value...); + } + _Visitor&& __visitor; + }; + +#if _LIBCPP_STD_VER > 17 + template <class _Rp, class _Visitor> + struct __value_visitor_return_type { + template <class... _Alts> + inline _LIBCPP_INLINE_VISIBILITY + constexpr _Rp operator()(_Alts&&... __alts) const { + __std_visit_exhaustive_visitor_check< + _Visitor, + decltype((_VSTD::forward<_Alts>(__alts).__value))...>(); + if constexpr (is_void_v<_Rp>) { + _VSTD::__invoke_constexpr(_VSTD::forward<_Visitor>(__visitor), + _VSTD::forward<_Alts>(__alts).__value...); + } + else { + return _VSTD::__invoke_constexpr(_VSTD::forward<_Visitor>(__visitor), + _VSTD::forward<_Alts>(__alts).__value...); + } + } + + _Visitor&& __visitor; + }; +#endif + + template <class _Visitor> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto __make_value_visitor(_Visitor&& __visitor) { + return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)}; + } + +#if _LIBCPP_STD_VER > 17 + template <class _Rp, class _Visitor> + inline _LIBCPP_INLINE_VISIBILITY + static constexpr auto __make_value_visitor(_Visitor&& __visitor) { + return __value_visitor_return_type<_Rp, _Visitor>{_VSTD::forward<_Visitor>(__visitor)}; + } +#endif +}; + +} // namespace __visitation + +template <size_t _Index, class _Tp> +struct _LIBCPP_TEMPLATE_VIS __alt { + using __value_type = _Tp; + + template <class... _Args> + inline _LIBCPP_INLINE_VISIBILITY + explicit constexpr __alt(in_place_t, _Args&&... __args) + : __value(_VSTD::forward<_Args>(__args)...) {} + + __value_type __value; +}; + +template <_Trait _DestructibleTrait, size_t _Index, class... _Types> +union _LIBCPP_TEMPLATE_VIS __union; + +template <_Trait _DestructibleTrait, size_t _Index> +union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {}; + +#define _LIBCPP_VARIANT_UNION(destructible_trait, destructor) \ + template <size_t _Index, class _Tp, class... _Types> \ + union _LIBCPP_TEMPLATE_VIS __union<destructible_trait, \ + _Index, \ + _Tp, \ + _Types...> { \ + public: \ + inline _LIBCPP_INLINE_VISIBILITY \ + explicit constexpr __union(__valueless_t) noexcept : __dummy{} {} \ + \ + template <class... _Args> \ + inline _LIBCPP_INLINE_VISIBILITY \ + explicit constexpr __union(in_place_index_t<0>, _Args&&... __args) \ + : __head(in_place, _VSTD::forward<_Args>(__args)...) {} \ + \ + template <size_t _Ip, class... _Args> \ + inline _LIBCPP_INLINE_VISIBILITY \ + explicit constexpr __union(in_place_index_t<_Ip>, _Args&&... __args) \ + : __tail(in_place_index<_Ip - 1>, _VSTD::forward<_Args>(__args)...) {} \ + \ + __union(const __union&) = default; \ + __union(__union&&) = default; \ + \ + destructor \ + \ + __union& operator=(const __union&) = default; \ + __union& operator=(__union&&) = default; \ + \ + private: \ + char __dummy; \ + __alt<_Index, _Tp> __head; \ + __union<destructible_trait, _Index + 1, _Types...> __tail; \ + \ + friend struct __access::__union; \ + } + +_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable, ~__union() = default;); +_LIBCPP_VARIANT_UNION(_Trait::_Available, ~__union() {}); +_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, ~__union() = delete;); + +#undef _LIBCPP_VARIANT_UNION + +template <_Trait _DestructibleTrait, class... _Types> +class _LIBCPP_TEMPLATE_VIS __base { +public: + using __index_t = __variant_index_t<sizeof...(_Types)>; + + inline _LIBCPP_INLINE_VISIBILITY + explicit constexpr __base(__valueless_t tag) noexcept + : __data(tag), __index(__variant_npos<__index_t>) {} + + template <size_t _Ip, class... _Args> + inline _LIBCPP_INLINE_VISIBILITY + explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args) + : + __data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...), + __index(_Ip) {} + + inline _LIBCPP_INLINE_VISIBILITY + constexpr bool valueless_by_exception() const noexcept { + return index() == variant_npos; + } + + inline _LIBCPP_INLINE_VISIBILITY + constexpr size_t index() const noexcept { + return __index == __variant_npos<__index_t> ? variant_npos : __index; + } + +protected: + inline _LIBCPP_INLINE_VISIBILITY + constexpr auto&& __as_base() & { return *this; } + + inline _LIBCPP_INLINE_VISIBILITY + constexpr auto&& __as_base() && { return _VSTD::move(*this); } + + inline _LIBCPP_INLINE_VISIBILITY + constexpr auto&& __as_base() const & { return *this; } + + inline _LIBCPP_INLINE_VISIBILITY + constexpr auto&& __as_base() const && { return _VSTD::move(*this); } + + inline _LIBCPP_INLINE_VISIBILITY + static constexpr size_t __size() { return sizeof...(_Types); } + + __union<_DestructibleTrait, 0, _Types...> __data; + __index_t __index; + + friend struct __access::__base; + friend struct __visitation::__base; +}; + +template <class _Traits, _Trait = _Traits::__destructible_trait> +class _LIBCPP_TEMPLATE_VIS __dtor; + +#define _LIBCPP_VARIANT_DESTRUCTOR(destructible_trait, destructor, destroy) \ + template <class... _Types> \ + class _LIBCPP_TEMPLATE_VIS __dtor<__traits<_Types...>, \ destructible_trait> \ - : public __base<destructible_trait, _Types...> { \ - using __base_type = __base<destructible_trait, _Types...>; \ - using __index_t = typename __base_type::__index_t; \ - \ - public: \ - using __base_type::__base_type; \ - using __base_type::operator=; \ - \ - __dtor(const __dtor&) = default; \ - __dtor(__dtor&&) = default; \ - destructor \ - __dtor& operator=(const __dtor&) = default; \ - __dtor& operator=(__dtor&&) = default; \ - \ - protected: \ - inline _LIBCPP_INLINE_VISIBILITY \ - destroy \ - } - -_LIBCPP_VARIANT_DESTRUCTOR( - _Trait::_TriviallyAvailable, - ~__dtor() = default;, - void __destroy() noexcept { this->__index = __variant_npos<__index_t>; }); - -_LIBCPP_VARIANT_DESTRUCTOR( - _Trait::_Available, - ~__dtor() { __destroy(); }, - void __destroy() noexcept { - if (!this->valueless_by_exception()) { - __visitation::__base::__visit_alt( - [](auto& __alt) noexcept { - using __alt_type = __uncvref_t<decltype(__alt)>; - __alt.~__alt_type(); - }, - *this); - } - this->__index = __variant_npos<__index_t>; - }); - -_LIBCPP_VARIANT_DESTRUCTOR( - _Trait::_Unavailable, - ~__dtor() = delete;, - void __destroy() noexcept = delete;); - -#undef _LIBCPP_VARIANT_DESTRUCTOR - -template <class _Traits> -class _LIBCPP_TEMPLATE_VIS __ctor : public __dtor<_Traits> { - using __base_type = __dtor<_Traits>; - -public: - using __base_type::__base_type; - using __base_type::operator=; - -protected: - template <size_t _Ip, class _Tp, class... _Args> - inline _LIBCPP_INLINE_VISIBILITY - static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) { - ::new ((void*)_VSTD::addressof(__a)) - __alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...); - return __a.__value; - } - - template <class _Rhs> - inline _LIBCPP_INLINE_VISIBILITY - static void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) { - __lhs.__destroy(); - if (!__rhs.valueless_by_exception()) { - __visitation::__base::__visit_alt_at( - __rhs.index(), - [](auto& __lhs_alt, auto&& __rhs_alt) { - __construct_alt( - __lhs_alt, - _VSTD::forward<decltype(__rhs_alt)>(__rhs_alt).__value); - }, - __lhs, _VSTD::forward<_Rhs>(__rhs)); - __lhs.__index = __rhs.index(); - } - } -}; - -template <class _Traits, _Trait = _Traits::__move_constructible_trait> -class _LIBCPP_TEMPLATE_VIS __move_constructor; - -#define _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, \ - move_constructor) \ - template <class... _Types> \ + : public __base<destructible_trait, _Types...> { \ + using __base_type = __base<destructible_trait, _Types...>; \ + using __index_t = typename __base_type::__index_t; \ + \ + public: \ + using __base_type::__base_type; \ + using __base_type::operator=; \ + \ + __dtor(const __dtor&) = default; \ + __dtor(__dtor&&) = default; \ + destructor \ + __dtor& operator=(const __dtor&) = default; \ + __dtor& operator=(__dtor&&) = default; \ + \ + protected: \ + inline _LIBCPP_INLINE_VISIBILITY \ + destroy \ + } + +_LIBCPP_VARIANT_DESTRUCTOR( + _Trait::_TriviallyAvailable, + ~__dtor() = default;, + void __destroy() noexcept { this->__index = __variant_npos<__index_t>; }); + +_LIBCPP_VARIANT_DESTRUCTOR( + _Trait::_Available, + ~__dtor() { __destroy(); }, + void __destroy() noexcept { + if (!this->valueless_by_exception()) { + __visitation::__base::__visit_alt( + [](auto& __alt) noexcept { + using __alt_type = __uncvref_t<decltype(__alt)>; + __alt.~__alt_type(); + }, + *this); + } + this->__index = __variant_npos<__index_t>; + }); + +_LIBCPP_VARIANT_DESTRUCTOR( + _Trait::_Unavailable, + ~__dtor() = delete;, + void __destroy() noexcept = delete;); + +#undef _LIBCPP_VARIANT_DESTRUCTOR + +template <class _Traits> +class _LIBCPP_TEMPLATE_VIS __ctor : public __dtor<_Traits> { + using __base_type = __dtor<_Traits>; + +public: + using __base_type::__base_type; + using __base_type::operator=; + +protected: + template <size_t _Ip, class _Tp, class... _Args> + inline _LIBCPP_INLINE_VISIBILITY + static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) { + ::new ((void*)_VSTD::addressof(__a)) + __alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...); + return __a.__value; + } + + template <class _Rhs> + inline _LIBCPP_INLINE_VISIBILITY + static void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) { + __lhs.__destroy(); + if (!__rhs.valueless_by_exception()) { + __visitation::__base::__visit_alt_at( + __rhs.index(), + [](auto& __lhs_alt, auto&& __rhs_alt) { + __construct_alt( + __lhs_alt, + _VSTD::forward<decltype(__rhs_alt)>(__rhs_alt).__value); + }, + __lhs, _VSTD::forward<_Rhs>(__rhs)); + __lhs.__index = __rhs.index(); + } + } +}; + +template <class _Traits, _Trait = _Traits::__move_constructible_trait> +class _LIBCPP_TEMPLATE_VIS __move_constructor; + +#define _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, \ + move_constructor) \ + template <class... _Types> \ class _LIBCPP_TEMPLATE_VIS __move_constructor<__traits<_Types...>, \ move_constructible_trait> \ - : public __ctor<__traits<_Types...>> { \ - using __base_type = __ctor<__traits<_Types...>>; \ - \ - public: \ - using __base_type::__base_type; \ - using __base_type::operator=; \ - \ - __move_constructor(const __move_constructor&) = default; \ - move_constructor \ - ~__move_constructor() = default; \ - __move_constructor& operator=(const __move_constructor&) = default; \ - __move_constructor& operator=(__move_constructor&&) = default; \ - } - -_LIBCPP_VARIANT_MOVE_CONSTRUCTOR( - _Trait::_TriviallyAvailable, - __move_constructor(__move_constructor&& __that) = default;); - -_LIBCPP_VARIANT_MOVE_CONSTRUCTOR( - _Trait::_Available, - __move_constructor(__move_constructor&& __that) noexcept( - __all<is_nothrow_move_constructible_v<_Types>...>::value) - : __move_constructor(__valueless_t{}) { - this->__generic_construct(*this, _VSTD::move(__that)); - }); - -_LIBCPP_VARIANT_MOVE_CONSTRUCTOR( - _Trait::_Unavailable, - __move_constructor(__move_constructor&&) = delete;); - -#undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR - -template <class _Traits, _Trait = _Traits::__copy_constructible_trait> -class _LIBCPP_TEMPLATE_VIS __copy_constructor; - -#define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, \ - copy_constructor) \ - template <class... _Types> \ - class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>, \ - copy_constructible_trait> \ - : public __move_constructor<__traits<_Types...>> { \ - using __base_type = __move_constructor<__traits<_Types...>>; \ - \ - public: \ - using __base_type::__base_type; \ - using __base_type::operator=; \ - \ - copy_constructor \ - __copy_constructor(__copy_constructor&&) = default; \ - ~__copy_constructor() = default; \ - __copy_constructor& operator=(const __copy_constructor&) = default; \ - __copy_constructor& operator=(__copy_constructor&&) = default; \ - } - -_LIBCPP_VARIANT_COPY_CONSTRUCTOR( - _Trait::_TriviallyAvailable, - __copy_constructor(const __copy_constructor& __that) = default;); - -_LIBCPP_VARIANT_COPY_CONSTRUCTOR( - _Trait::_Available, - __copy_constructor(const __copy_constructor& __that) - : __copy_constructor(__valueless_t{}) { - this->__generic_construct(*this, __that); - }); - -_LIBCPP_VARIANT_COPY_CONSTRUCTOR( - _Trait::_Unavailable, - __copy_constructor(const __copy_constructor&) = delete;); - -#undef _LIBCPP_VARIANT_COPY_CONSTRUCTOR - -template <class _Traits> -class _LIBCPP_TEMPLATE_VIS __assignment : public __copy_constructor<_Traits> { - using __base_type = __copy_constructor<_Traits>; - -public: - using __base_type::__base_type; - using __base_type::operator=; - - template <size_t _Ip, class... _Args> - inline _LIBCPP_INLINE_VISIBILITY - auto& __emplace(_Args&&... __args) { - this->__destroy(); - auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this), - _VSTD::forward<_Args>(__args)...); - this->__index = _Ip; - return __res; - } - -protected: - template <size_t _Ip, class _Tp, class _Arg> - inline _LIBCPP_INLINE_VISIBILITY - void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) { - if (this->index() == _Ip) { - __a.__value = _VSTD::forward<_Arg>(__arg); - } else { - struct { - void operator()(true_type) const { - __this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg)); - } - void operator()(false_type) const { - __this->__emplace<_Ip>(_Tp(_VSTD::forward<_Arg>(__arg))); - } - __assignment* __this; - _Arg&& __arg; - } __impl{this, _VSTD::forward<_Arg>(__arg)}; - __impl(bool_constant<is_nothrow_constructible_v<_Tp, _Arg> || - !is_nothrow_move_constructible_v<_Tp>>{}); - } - } - - template <class _That> - inline _LIBCPP_INLINE_VISIBILITY - void __generic_assign(_That&& __that) { - if (this->valueless_by_exception() && __that.valueless_by_exception()) { - // do nothing. - } else if (__that.valueless_by_exception()) { - this->__destroy(); - } else { - __visitation::__base::__visit_alt_at( - __that.index(), - [this](auto& __this_alt, auto&& __that_alt) { - this->__assign_alt( - __this_alt, - _VSTD::forward<decltype(__that_alt)>(__that_alt).__value); - }, - *this, _VSTD::forward<_That>(__that)); - } - } -}; - -template <class _Traits, _Trait = _Traits::__move_assignable_trait> -class _LIBCPP_TEMPLATE_VIS __move_assignment; - -#define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, \ - move_assignment) \ - template <class... _Types> \ - class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>, \ - move_assignable_trait> \ - : public __assignment<__traits<_Types...>> { \ - using __base_type = __assignment<__traits<_Types...>>; \ - \ - public: \ - using __base_type::__base_type; \ - using __base_type::operator=; \ - \ - __move_assignment(const __move_assignment&) = default; \ - __move_assignment(__move_assignment&&) = default; \ - ~__move_assignment() = default; \ - __move_assignment& operator=(const __move_assignment&) = default; \ - move_assignment \ - } - -_LIBCPP_VARIANT_MOVE_ASSIGNMENT( - _Trait::_TriviallyAvailable, - __move_assignment& operator=(__move_assignment&& __that) = default;); - -_LIBCPP_VARIANT_MOVE_ASSIGNMENT( - _Trait::_Available, - __move_assignment& operator=(__move_assignment&& __that) noexcept( - __all<(is_nothrow_move_constructible_v<_Types> && - is_nothrow_move_assignable_v<_Types>)...>::value) { - this->__generic_assign(_VSTD::move(__that)); - return *this; - }); - -_LIBCPP_VARIANT_MOVE_ASSIGNMENT( - _Trait::_Unavailable, - __move_assignment& operator=(__move_assignment&&) = delete;); - -#undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT - -template <class _Traits, _Trait = _Traits::__copy_assignable_trait> -class _LIBCPP_TEMPLATE_VIS __copy_assignment; - -#define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, \ - copy_assignment) \ - template <class... _Types> \ - class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>, \ - copy_assignable_trait> \ - : public __move_assignment<__traits<_Types...>> { \ - using __base_type = __move_assignment<__traits<_Types...>>; \ - \ - public: \ - using __base_type::__base_type; \ - using __base_type::operator=; \ - \ - __copy_assignment(const __copy_assignment&) = default; \ - __copy_assignment(__copy_assignment&&) = default; \ - ~__copy_assignment() = default; \ - copy_assignment \ - __copy_assignment& operator=(__copy_assignment&&) = default; \ - } - -_LIBCPP_VARIANT_COPY_ASSIGNMENT( - _Trait::_TriviallyAvailable, - __copy_assignment& operator=(const __copy_assignment& __that) = default;); - -_LIBCPP_VARIANT_COPY_ASSIGNMENT( - _Trait::_Available, - __copy_assignment& operator=(const __copy_assignment& __that) { - this->__generic_assign(__that); - return *this; - }); - -_LIBCPP_VARIANT_COPY_ASSIGNMENT( - _Trait::_Unavailable, - __copy_assignment& operator=(const __copy_assignment&) = delete;); - -#undef _LIBCPP_VARIANT_COPY_ASSIGNMENT - -template <class... _Types> -class _LIBCPP_TEMPLATE_VIS __impl - : public __copy_assignment<__traits<_Types...>> { - using __base_type = __copy_assignment<__traits<_Types...>>; - -public: - using __base_type::__base_type; - using __base_type::operator=; - - template <size_t _Ip, class _Arg> - inline _LIBCPP_INLINE_VISIBILITY - void __assign(_Arg&& __arg) { - this->__assign_alt(__access::__base::__get_alt<_Ip>(*this), - _VSTD::forward<_Arg>(__arg)); - } - - inline _LIBCPP_INLINE_VISIBILITY - void __swap(__impl& __that) { - if (this->valueless_by_exception() && __that.valueless_by_exception()) { - // do nothing. - } else if (this->index() == __that.index()) { - __visitation::__base::__visit_alt_at( - this->index(), - [](auto& __this_alt, auto& __that_alt) { - using _VSTD::swap; - swap(__this_alt.__value, __that_alt.__value); - }, - *this, - __that); - } else { - __impl* __lhs = this; - __impl* __rhs = _VSTD::addressof(__that); - if (__lhs->__move_nothrow() && !__rhs->__move_nothrow()) { - _VSTD::swap(__lhs, __rhs); - } - __impl __tmp(_VSTD::move(*__rhs)); -#ifndef _LIBCPP_NO_EXCEPTIONS - if constexpr (__all<is_nothrow_move_constructible_v<_Types>...>::value) { - this->__generic_construct(*__rhs, _VSTD::move(*__lhs)); - } else { - // EXTENSION: When the move construction of `__lhs` into `__rhs` throws - // and `__tmp` is nothrow move constructible then we move `__tmp` back + : public __ctor<__traits<_Types...>> { \ + using __base_type = __ctor<__traits<_Types...>>; \ + \ + public: \ + using __base_type::__base_type; \ + using __base_type::operator=; \ + \ + __move_constructor(const __move_constructor&) = default; \ + move_constructor \ + ~__move_constructor() = default; \ + __move_constructor& operator=(const __move_constructor&) = default; \ + __move_constructor& operator=(__move_constructor&&) = default; \ + } + +_LIBCPP_VARIANT_MOVE_CONSTRUCTOR( + _Trait::_TriviallyAvailable, + __move_constructor(__move_constructor&& __that) = default;); + +_LIBCPP_VARIANT_MOVE_CONSTRUCTOR( + _Trait::_Available, + __move_constructor(__move_constructor&& __that) noexcept( + __all<is_nothrow_move_constructible_v<_Types>...>::value) + : __move_constructor(__valueless_t{}) { + this->__generic_construct(*this, _VSTD::move(__that)); + }); + +_LIBCPP_VARIANT_MOVE_CONSTRUCTOR( + _Trait::_Unavailable, + __move_constructor(__move_constructor&&) = delete;); + +#undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR + +template <class _Traits, _Trait = _Traits::__copy_constructible_trait> +class _LIBCPP_TEMPLATE_VIS __copy_constructor; + +#define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, \ + copy_constructor) \ + template <class... _Types> \ + class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>, \ + copy_constructible_trait> \ + : public __move_constructor<__traits<_Types...>> { \ + using __base_type = __move_constructor<__traits<_Types...>>; \ + \ + public: \ + using __base_type::__base_type; \ + using __base_type::operator=; \ + \ + copy_constructor \ + __copy_constructor(__copy_constructor&&) = default; \ + ~__copy_constructor() = default; \ + __copy_constructor& operator=(const __copy_constructor&) = default; \ + __copy_constructor& operator=(__copy_constructor&&) = default; \ + } + +_LIBCPP_VARIANT_COPY_CONSTRUCTOR( + _Trait::_TriviallyAvailable, + __copy_constructor(const __copy_constructor& __that) = default;); + +_LIBCPP_VARIANT_COPY_CONSTRUCTOR( + _Trait::_Available, + __copy_constructor(const __copy_constructor& __that) + : __copy_constructor(__valueless_t{}) { + this->__generic_construct(*this, __that); + }); + +_LIBCPP_VARIANT_COPY_CONSTRUCTOR( + _Trait::_Unavailable, + __copy_constructor(const __copy_constructor&) = delete;); + +#undef _LIBCPP_VARIANT_COPY_CONSTRUCTOR + +template <class _Traits> +class _LIBCPP_TEMPLATE_VIS __assignment : public __copy_constructor<_Traits> { + using __base_type = __copy_constructor<_Traits>; + +public: + using __base_type::__base_type; + using __base_type::operator=; + + template <size_t _Ip, class... _Args> + inline _LIBCPP_INLINE_VISIBILITY + auto& __emplace(_Args&&... __args) { + this->__destroy(); + auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this), + _VSTD::forward<_Args>(__args)...); + this->__index = _Ip; + return __res; + } + +protected: + template <size_t _Ip, class _Tp, class _Arg> + inline _LIBCPP_INLINE_VISIBILITY + void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) { + if (this->index() == _Ip) { + __a.__value = _VSTD::forward<_Arg>(__arg); + } else { + struct { + void operator()(true_type) const { + __this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg)); + } + void operator()(false_type) const { + __this->__emplace<_Ip>(_Tp(_VSTD::forward<_Arg>(__arg))); + } + __assignment* __this; + _Arg&& __arg; + } __impl{this, _VSTD::forward<_Arg>(__arg)}; + __impl(bool_constant<is_nothrow_constructible_v<_Tp, _Arg> || + !is_nothrow_move_constructible_v<_Tp>>{}); + } + } + + template <class _That> + inline _LIBCPP_INLINE_VISIBILITY + void __generic_assign(_That&& __that) { + if (this->valueless_by_exception() && __that.valueless_by_exception()) { + // do nothing. + } else if (__that.valueless_by_exception()) { + this->__destroy(); + } else { + __visitation::__base::__visit_alt_at( + __that.index(), + [this](auto& __this_alt, auto&& __that_alt) { + this->__assign_alt( + __this_alt, + _VSTD::forward<decltype(__that_alt)>(__that_alt).__value); + }, + *this, _VSTD::forward<_That>(__that)); + } + } +}; + +template <class _Traits, _Trait = _Traits::__move_assignable_trait> +class _LIBCPP_TEMPLATE_VIS __move_assignment; + +#define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, \ + move_assignment) \ + template <class... _Types> \ + class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>, \ + move_assignable_trait> \ + : public __assignment<__traits<_Types...>> { \ + using __base_type = __assignment<__traits<_Types...>>; \ + \ + public: \ + using __base_type::__base_type; \ + using __base_type::operator=; \ + \ + __move_assignment(const __move_assignment&) = default; \ + __move_assignment(__move_assignment&&) = default; \ + ~__move_assignment() = default; \ + __move_assignment& operator=(const __move_assignment&) = default; \ + move_assignment \ + } + +_LIBCPP_VARIANT_MOVE_ASSIGNMENT( + _Trait::_TriviallyAvailable, + __move_assignment& operator=(__move_assignment&& __that) = default;); + +_LIBCPP_VARIANT_MOVE_ASSIGNMENT( + _Trait::_Available, + __move_assignment& operator=(__move_assignment&& __that) noexcept( + __all<(is_nothrow_move_constructible_v<_Types> && + is_nothrow_move_assignable_v<_Types>)...>::value) { + this->__generic_assign(_VSTD::move(__that)); + return *this; + }); + +_LIBCPP_VARIANT_MOVE_ASSIGNMENT( + _Trait::_Unavailable, + __move_assignment& operator=(__move_assignment&&) = delete;); + +#undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT + +template <class _Traits, _Trait = _Traits::__copy_assignable_trait> +class _LIBCPP_TEMPLATE_VIS __copy_assignment; + +#define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, \ + copy_assignment) \ + template <class... _Types> \ + class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>, \ + copy_assignable_trait> \ + : public __move_assignment<__traits<_Types...>> { \ + using __base_type = __move_assignment<__traits<_Types...>>; \ + \ + public: \ + using __base_type::__base_type; \ + using __base_type::operator=; \ + \ + __copy_assignment(const __copy_assignment&) = default; \ + __copy_assignment(__copy_assignment&&) = default; \ + ~__copy_assignment() = default; \ + copy_assignment \ + __copy_assignment& operator=(__copy_assignment&&) = default; \ + } + +_LIBCPP_VARIANT_COPY_ASSIGNMENT( + _Trait::_TriviallyAvailable, + __copy_assignment& operator=(const __copy_assignment& __that) = default;); + +_LIBCPP_VARIANT_COPY_ASSIGNMENT( + _Trait::_Available, + __copy_assignment& operator=(const __copy_assignment& __that) { + this->__generic_assign(__that); + return *this; + }); + +_LIBCPP_VARIANT_COPY_ASSIGNMENT( + _Trait::_Unavailable, + __copy_assignment& operator=(const __copy_assignment&) = delete;); + +#undef _LIBCPP_VARIANT_COPY_ASSIGNMENT + +template <class... _Types> +class _LIBCPP_TEMPLATE_VIS __impl + : public __copy_assignment<__traits<_Types...>> { + using __base_type = __copy_assignment<__traits<_Types...>>; + +public: + using __base_type::__base_type; + using __base_type::operator=; + + template <size_t _Ip, class _Arg> + inline _LIBCPP_INLINE_VISIBILITY + void __assign(_Arg&& __arg) { + this->__assign_alt(__access::__base::__get_alt<_Ip>(*this), + _VSTD::forward<_Arg>(__arg)); + } + + inline _LIBCPP_INLINE_VISIBILITY + void __swap(__impl& __that) { + if (this->valueless_by_exception() && __that.valueless_by_exception()) { + // do nothing. + } else if (this->index() == __that.index()) { + __visitation::__base::__visit_alt_at( + this->index(), + [](auto& __this_alt, auto& __that_alt) { + using _VSTD::swap; + swap(__this_alt.__value, __that_alt.__value); + }, + *this, + __that); + } else { + __impl* __lhs = this; + __impl* __rhs = _VSTD::addressof(__that); + if (__lhs->__move_nothrow() && !__rhs->__move_nothrow()) { + _VSTD::swap(__lhs, __rhs); + } + __impl __tmp(_VSTD::move(*__rhs)); +#ifndef _LIBCPP_NO_EXCEPTIONS + if constexpr (__all<is_nothrow_move_constructible_v<_Types>...>::value) { + this->__generic_construct(*__rhs, _VSTD::move(*__lhs)); + } else { + // EXTENSION: When the move construction of `__lhs` into `__rhs` throws + // and `__tmp` is nothrow move constructible then we move `__tmp` back // into `__rhs` and provide the strong exception safety guarantee. - try { - this->__generic_construct(*__rhs, _VSTD::move(*__lhs)); - } catch (...) { - if (__tmp.__move_nothrow()) { - this->__generic_construct(*__rhs, _VSTD::move(__tmp)); - } - throw; - } - } -#else - // this isn't consolidated with the `if constexpr` branch above due to - // `throw` being ill-formed with exceptions disabled even when discarded. - this->__generic_construct(*__rhs, _VSTD::move(*__lhs)); -#endif - this->__generic_construct(*__lhs, _VSTD::move(__tmp)); - } - } - -private: - inline _LIBCPP_INLINE_VISIBILITY - bool __move_nothrow() const { - constexpr bool __results[] = {is_nothrow_move_constructible_v<_Types>...}; - return this->valueless_by_exception() || __results[this->index()]; - } -}; - -struct __no_narrowing_check { - template <class _Dest, class _Source> - using _Apply = __identity<_Dest>; -}; - -struct __narrowing_check { - template <class _Dest> - static auto __test_impl(_Dest (&&)[1]) -> __identity<_Dest>; - template <class _Dest, class _Source> - using _Apply _LIBCPP_NODEBUG = decltype(__test_impl<_Dest>({declval<_Source>()})); -}; - -template <class _Dest, class _Source> -using __check_for_narrowing _LIBCPP_NODEBUG = - typename _If< -#ifdef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT - false && -#endif - is_arithmetic<_Dest>::value, - __narrowing_check, - __no_narrowing_check - >::template _Apply<_Dest, _Source>; - -template <class _Tp, size_t _Idx> -struct __overload { - template <class _Up> - auto operator()(_Tp, _Up&&) const -> __check_for_narrowing<_Tp, _Up>; -}; - -template <class _Tp, size_t> -struct __overload_bool { - template <class _Up, class _Ap = __uncvref_t<_Up>> - auto operator()(bool, _Up&&) const - -> enable_if_t<is_same_v<_Ap, bool>, __identity<_Tp>>; -}; - -template <size_t _Idx> -struct __overload<bool, _Idx> : __overload_bool<bool, _Idx> {}; -template <size_t _Idx> -struct __overload<bool const, _Idx> : __overload_bool<bool const, _Idx> {}; -template <size_t _Idx> -struct __overload<bool volatile, _Idx> : __overload_bool<bool volatile, _Idx> {}; -template <size_t _Idx> -struct __overload<bool const volatile, _Idx> : __overload_bool<bool const volatile, _Idx> {}; - -template <class ..._Bases> -struct __all_overloads : _Bases... { - void operator()() const; - using _Bases::operator()...; -}; - -// Change metaprogramming to satisfy MSVC. It doesn't like expression -// __overload<_Types, _Idx>... when _Types comes from using parameter but -// _Idx comes from structure template parameter. So I made them both -// structure template parameters. -template <class _IdxSeq, class ..._Types> -struct __make_overloads_imp; - -template <size_t ..._Idx, class ..._Types> -struct __make_overloads_imp<__tuple_indices<_Idx...>, _Types... > { - using _Apply _LIBCPP_NODEBUG = __all_overloads<__overload<_Types, _Idx>...>; -}; - + try { + this->__generic_construct(*__rhs, _VSTD::move(*__lhs)); + } catch (...) { + if (__tmp.__move_nothrow()) { + this->__generic_construct(*__rhs, _VSTD::move(__tmp)); + } + throw; + } + } +#else + // this isn't consolidated with the `if constexpr` branch above due to + // `throw` being ill-formed with exceptions disabled even when discarded. + this->__generic_construct(*__rhs, _VSTD::move(*__lhs)); +#endif + this->__generic_construct(*__lhs, _VSTD::move(__tmp)); + } + } + +private: + inline _LIBCPP_INLINE_VISIBILITY + bool __move_nothrow() const { + constexpr bool __results[] = {is_nothrow_move_constructible_v<_Types>...}; + return this->valueless_by_exception() || __results[this->index()]; + } +}; + +struct __no_narrowing_check { + template <class _Dest, class _Source> + using _Apply = __identity<_Dest>; +}; + +struct __narrowing_check { + template <class _Dest> + static auto __test_impl(_Dest (&&)[1]) -> __identity<_Dest>; + template <class _Dest, class _Source> + using _Apply _LIBCPP_NODEBUG = decltype(__test_impl<_Dest>({declval<_Source>()})); +}; + +template <class _Dest, class _Source> +using __check_for_narrowing _LIBCPP_NODEBUG = + typename _If< +#ifdef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT + false && +#endif + is_arithmetic<_Dest>::value, + __narrowing_check, + __no_narrowing_check + >::template _Apply<_Dest, _Source>; + +template <class _Tp, size_t _Idx> +struct __overload { + template <class _Up> + auto operator()(_Tp, _Up&&) const -> __check_for_narrowing<_Tp, _Up>; +}; + +template <class _Tp, size_t> +struct __overload_bool { + template <class _Up, class _Ap = __uncvref_t<_Up>> + auto operator()(bool, _Up&&) const + -> enable_if_t<is_same_v<_Ap, bool>, __identity<_Tp>>; +}; + +template <size_t _Idx> +struct __overload<bool, _Idx> : __overload_bool<bool, _Idx> {}; +template <size_t _Idx> +struct __overload<bool const, _Idx> : __overload_bool<bool const, _Idx> {}; +template <size_t _Idx> +struct __overload<bool volatile, _Idx> : __overload_bool<bool volatile, _Idx> {}; +template <size_t _Idx> +struct __overload<bool const volatile, _Idx> : __overload_bool<bool const volatile, _Idx> {}; + +template <class ..._Bases> +struct __all_overloads : _Bases... { + void operator()() const; + using _Bases::operator()...; +}; + +// Change metaprogramming to satisfy MSVC. It doesn't like expression +// __overload<_Types, _Idx>... when _Types comes from using parameter but +// _Idx comes from structure template parameter. So I made them both +// structure template parameters. +template <class _IdxSeq, class ..._Types> +struct __make_overloads_imp; + +template <size_t ..._Idx, class ..._Types> +struct __make_overloads_imp<__tuple_indices<_Idx...>, _Types... > { + using _Apply _LIBCPP_NODEBUG = __all_overloads<__overload<_Types, _Idx>...>; +}; + template <class ..._Types> -using _MakeOverloads _LIBCPP_NODEBUG = typename __make_overloads_imp< - __make_indices_imp<_Sizeof<_Types...>::value, 0>, _Types...>::_Apply; - -template <class _Tp, class... _Types> -using __best_match_t = - typename invoke_result_t<_MakeOverloads<_Types...>, _Tp, _Tp>::type; - -} // __variant_detail - -template <class... _Types> -class _LIBCPP_TEMPLATE_VIS variant - : private __sfinae_ctor_base< - __all<is_copy_constructible_v<_Types>...>::value, - __all<is_move_constructible_v<_Types>...>::value>, - private __sfinae_assign_base< - __all<(is_copy_constructible_v<_Types> && - is_copy_assignable_v<_Types>)...>::value, - __all<(is_move_constructible_v<_Types> && - is_move_assignable_v<_Types>)...>::value> { - static_assert(0 < sizeof...(_Types), - "variant must consist of at least one alternative."); - - static_assert(__all<!is_array_v<_Types>...>::value, - "variant can not have an array type as an alternative."); - - static_assert(__all<!is_reference_v<_Types>...>::value, - "variant can not have a reference type as an alternative."); - - static_assert(__all<!is_void_v<_Types>...>::value, - "variant can not have a void type as an alternative."); - - using __first_type = variant_alternative_t<0, variant>; - -public: - template <bool _Dummy = true, - enable_if_t<__dependent_type<is_default_constructible<__first_type>, - _Dummy>::value, - int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - constexpr variant() noexcept(is_nothrow_default_constructible_v<__first_type>) - : __impl(in_place_index<0>) {} - - variant(const variant&) = default; - variant(variant&&) = default; - - template < - class _Arg, - enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0, - enable_if_t<!__is_inplace_type<__uncvref_t<_Arg>>::value, int> = 0, - enable_if_t<!__is_inplace_index<__uncvref_t<_Arg>>::value, int> = 0, - class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>, - size_t _Ip = - __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, - enable_if_t<is_constructible_v<_Tp, _Arg>, int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - constexpr variant(_Arg&& __arg) noexcept( - is_nothrow_constructible_v<_Tp, _Arg>) - : __impl(in_place_index<_Ip>, _VSTD::forward<_Arg>(__arg)) {} - - template <size_t _Ip, class... _Args, - class = enable_if_t<(_Ip < sizeof...(_Types)), int>, - class _Tp = variant_alternative_t<_Ip, variant<_Types...>>, - enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - explicit constexpr variant( - in_place_index_t<_Ip>, - _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>) - : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {} - - template < - size_t _Ip, - class _Up, - class... _Args, - enable_if_t<(_Ip < sizeof...(_Types)), int> = 0, - class _Tp = variant_alternative_t<_Ip, variant<_Types...>>, - enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, - int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - explicit constexpr variant( - in_place_index_t<_Ip>, - initializer_list<_Up> __il, - _Args&&... __args) noexcept( - is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) - : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {} - - template < - class _Tp, - class... _Args, - size_t _Ip = - __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, - enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - explicit constexpr variant(in_place_type_t<_Tp>, _Args&&... __args) noexcept( - is_nothrow_constructible_v<_Tp, _Args...>) - : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {} - - template < - class _Tp, - class _Up, - class... _Args, - size_t _Ip = - __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, - enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, - int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - explicit constexpr variant( - in_place_type_t<_Tp>, - initializer_list<_Up> __il, - _Args&&... __args) noexcept( - is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>) - : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {} - - ~variant() = default; - - variant& operator=(const variant&) = default; - variant& operator=(variant&&) = default; - - template < - class _Arg, - enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0, - class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>, - size_t _Ip = - __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, - enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>, - int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - variant& operator=(_Arg&& __arg) noexcept( - is_nothrow_assignable_v<_Tp&, _Arg> && - is_nothrow_constructible_v<_Tp, _Arg>) { - __impl.template __assign<_Ip>(_VSTD::forward<_Arg>(__arg)); - return *this; - } - - template < - size_t _Ip, - class... _Args, - enable_if_t<(_Ip < sizeof...(_Types)), int> = 0, - class _Tp = variant_alternative_t<_Ip, variant<_Types...>>, - enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - _Tp& emplace(_Args&&... __args) { - return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...); - } - - template < - size_t _Ip, - class _Up, - class... _Args, - enable_if_t<(_Ip < sizeof...(_Types)), int> = 0, - class _Tp = variant_alternative_t<_Ip, variant<_Types...>>, - enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, - int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) { - return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...); - } - - template < - class _Tp, - class... _Args, - size_t _Ip = - __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, - enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - _Tp& emplace(_Args&&... __args) { - return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...); - } - - template < - class _Tp, - class _Up, - class... _Args, - size_t _Ip = - __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, - enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, - int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) { - return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...); - } - - inline _LIBCPP_INLINE_VISIBILITY - constexpr bool valueless_by_exception() const noexcept { - return __impl.valueless_by_exception(); - } - - inline _LIBCPP_INLINE_VISIBILITY - constexpr size_t index() const noexcept { return __impl.index(); } - - template < - bool _Dummy = true, - enable_if_t< - __all<( - __dependent_type<is_move_constructible<_Types>, _Dummy>::value && - __dependent_type<is_swappable<_Types>, _Dummy>::value)...>::value, - int> = 0> - inline _LIBCPP_INLINE_VISIBILITY - void swap(variant& __that) noexcept( - __all<(is_nothrow_move_constructible_v<_Types> && - is_nothrow_swappable_v<_Types>)...>::value) { - __impl.__swap(__that.__impl); - } - -private: - __variant_detail::__impl<_Types...> __impl; - - friend struct __variant_detail::__access::__variant; - friend struct __variant_detail::__visitation::__variant; -}; - -template <size_t _Ip, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept { - return __v.index() == _Ip; -} - -template <class _Tp, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept { - return __holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v); -} - -template <size_t _Ip, class _Vp> -inline _LIBCPP_INLINE_VISIBILITY +using _MakeOverloads _LIBCPP_NODEBUG = typename __make_overloads_imp< + __make_indices_imp<_Sizeof<_Types...>::value, 0>, _Types...>::_Apply; + +template <class _Tp, class... _Types> +using __best_match_t = + typename invoke_result_t<_MakeOverloads<_Types...>, _Tp, _Tp>::type; + +} // __variant_detail + +template <class... _Types> +class _LIBCPP_TEMPLATE_VIS variant + : private __sfinae_ctor_base< + __all<is_copy_constructible_v<_Types>...>::value, + __all<is_move_constructible_v<_Types>...>::value>, + private __sfinae_assign_base< + __all<(is_copy_constructible_v<_Types> && + is_copy_assignable_v<_Types>)...>::value, + __all<(is_move_constructible_v<_Types> && + is_move_assignable_v<_Types>)...>::value> { + static_assert(0 < sizeof...(_Types), + "variant must consist of at least one alternative."); + + static_assert(__all<!is_array_v<_Types>...>::value, + "variant can not have an array type as an alternative."); + + static_assert(__all<!is_reference_v<_Types>...>::value, + "variant can not have a reference type as an alternative."); + + static_assert(__all<!is_void_v<_Types>...>::value, + "variant can not have a void type as an alternative."); + + using __first_type = variant_alternative_t<0, variant>; + +public: + template <bool _Dummy = true, + enable_if_t<__dependent_type<is_default_constructible<__first_type>, + _Dummy>::value, + int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + constexpr variant() noexcept(is_nothrow_default_constructible_v<__first_type>) + : __impl(in_place_index<0>) {} + + variant(const variant&) = default; + variant(variant&&) = default; + + template < + class _Arg, + enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0, + enable_if_t<!__is_inplace_type<__uncvref_t<_Arg>>::value, int> = 0, + enable_if_t<!__is_inplace_index<__uncvref_t<_Arg>>::value, int> = 0, + class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>, + size_t _Ip = + __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, + enable_if_t<is_constructible_v<_Tp, _Arg>, int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + constexpr variant(_Arg&& __arg) noexcept( + is_nothrow_constructible_v<_Tp, _Arg>) + : __impl(in_place_index<_Ip>, _VSTD::forward<_Arg>(__arg)) {} + + template <size_t _Ip, class... _Args, + class = enable_if_t<(_Ip < sizeof...(_Types)), int>, + class _Tp = variant_alternative_t<_Ip, variant<_Types...>>, + enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + explicit constexpr variant( + in_place_index_t<_Ip>, + _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>) + : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {} + + template < + size_t _Ip, + class _Up, + class... _Args, + enable_if_t<(_Ip < sizeof...(_Types)), int> = 0, + class _Tp = variant_alternative_t<_Ip, variant<_Types...>>, + enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, + int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + explicit constexpr variant( + in_place_index_t<_Ip>, + initializer_list<_Up> __il, + _Args&&... __args) noexcept( + is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) + : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {} + + template < + class _Tp, + class... _Args, + size_t _Ip = + __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, + enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + explicit constexpr variant(in_place_type_t<_Tp>, _Args&&... __args) noexcept( + is_nothrow_constructible_v<_Tp, _Args...>) + : __impl(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {} + + template < + class _Tp, + class _Up, + class... _Args, + size_t _Ip = + __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, + enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, + int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + explicit constexpr variant( + in_place_type_t<_Tp>, + initializer_list<_Up> __il, + _Args&&... __args) noexcept( + is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>) + : __impl(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {} + + ~variant() = default; + + variant& operator=(const variant&) = default; + variant& operator=(variant&&) = default; + + template < + class _Arg, + enable_if_t<!is_same_v<__uncvref_t<_Arg>, variant>, int> = 0, + class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>, + size_t _Ip = + __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, + enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>, + int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + variant& operator=(_Arg&& __arg) noexcept( + is_nothrow_assignable_v<_Tp&, _Arg> && + is_nothrow_constructible_v<_Tp, _Arg>) { + __impl.template __assign<_Ip>(_VSTD::forward<_Arg>(__arg)); + return *this; + } + + template < + size_t _Ip, + class... _Args, + enable_if_t<(_Ip < sizeof...(_Types)), int> = 0, + class _Tp = variant_alternative_t<_Ip, variant<_Types...>>, + enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + _Tp& emplace(_Args&&... __args) { + return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...); + } + + template < + size_t _Ip, + class _Up, + class... _Args, + enable_if_t<(_Ip < sizeof...(_Types)), int> = 0, + class _Tp = variant_alternative_t<_Ip, variant<_Types...>>, + enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, + int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) { + return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...); + } + + template < + class _Tp, + class... _Args, + size_t _Ip = + __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, + enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + _Tp& emplace(_Args&&... __args) { + return __impl.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...); + } + + template < + class _Tp, + class _Up, + class... _Args, + size_t _Ip = + __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value, + enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, + int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) { + return __impl.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...); + } + + inline _LIBCPP_INLINE_VISIBILITY + constexpr bool valueless_by_exception() const noexcept { + return __impl.valueless_by_exception(); + } + + inline _LIBCPP_INLINE_VISIBILITY + constexpr size_t index() const noexcept { return __impl.index(); } + + template < + bool _Dummy = true, + enable_if_t< + __all<( + __dependent_type<is_move_constructible<_Types>, _Dummy>::value && + __dependent_type<is_swappable<_Types>, _Dummy>::value)...>::value, + int> = 0> + inline _LIBCPP_INLINE_VISIBILITY + void swap(variant& __that) noexcept( + __all<(is_nothrow_move_constructible_v<_Types> && + is_nothrow_swappable_v<_Types>)...>::value) { + __impl.__swap(__that.__impl); + } + +private: + __variant_detail::__impl<_Types...> __impl; + + friend struct __variant_detail::__access::__variant; + friend struct __variant_detail::__visitation::__variant; +}; + +template <size_t _Ip, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept { + return __v.index() == _Ip; +} + +template <class _Tp, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept { + return __holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v); +} + +template <size_t _Ip, class _Vp> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr auto&& __generic_get(_Vp&& __v) { - using __variant_detail::__access::__variant; - if (!__holds_alternative<_Ip>(__v)) { - __throw_bad_variant_access(); - } - return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value; -} - -template <size_t _Ip, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY + using __variant_detail::__access::__variant; + if (!__holds_alternative<_Ip>(__v)) { + __throw_bad_variant_access(); + } + return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value; +} + +template <size_t _Ip, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS -constexpr variant_alternative_t<_Ip, variant<_Types...>>& get( - variant<_Types...>& __v) { - static_assert(_Ip < sizeof...(_Types)); - static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); - return __generic_get<_Ip>(__v); -} - -template <size_t _Ip, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY +constexpr variant_alternative_t<_Ip, variant<_Types...>>& get( + variant<_Types...>& __v) { + static_assert(_Ip < sizeof...(_Types)); + static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); + return __generic_get<_Ip>(__v); +} + +template <size_t _Ip, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS -constexpr variant_alternative_t<_Ip, variant<_Types...>>&& get( - variant<_Types...>&& __v) { - static_assert(_Ip < sizeof...(_Types)); - static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); - return __generic_get<_Ip>(_VSTD::move(__v)); -} - -template <size_t _Ip, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY +constexpr variant_alternative_t<_Ip, variant<_Types...>>&& get( + variant<_Types...>&& __v) { + static_assert(_Ip < sizeof...(_Types)); + static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); + return __generic_get<_Ip>(_VSTD::move(__v)); +} + +template <size_t _Ip, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS -constexpr const variant_alternative_t<_Ip, variant<_Types...>>& get( - const variant<_Types...>& __v) { - static_assert(_Ip < sizeof...(_Types)); - static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); - return __generic_get<_Ip>(__v); -} - -template <size_t _Ip, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY +constexpr const variant_alternative_t<_Ip, variant<_Types...>>& get( + const variant<_Types...>& __v) { + static_assert(_Ip < sizeof...(_Types)); + static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); + return __generic_get<_Ip>(__v); +} + +template <size_t _Ip, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS -constexpr const variant_alternative_t<_Ip, variant<_Types...>>&& get( - const variant<_Types...>&& __v) { - static_assert(_Ip < sizeof...(_Types)); - static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); - return __generic_get<_Ip>(_VSTD::move(__v)); -} - -template <class _Tp, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY +constexpr const variant_alternative_t<_Ip, variant<_Types...>>&& get( + const variant<_Types...>&& __v) { + static_assert(_Ip < sizeof...(_Types)); + static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); + return __generic_get<_Ip>(_VSTD::move(__v)); +} + +template <class _Tp, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS -constexpr _Tp& get(variant<_Types...>& __v) { - static_assert(!is_void_v<_Tp>); - return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); -} - -template <class _Tp, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY +constexpr _Tp& get(variant<_Types...>& __v) { + static_assert(!is_void_v<_Tp>); + return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); +} + +template <class _Tp, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS -constexpr _Tp&& get(variant<_Types...>&& __v) { - static_assert(!is_void_v<_Tp>); - return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>( - _VSTD::move(__v)); -} - -template <class _Tp, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY +constexpr _Tp&& get(variant<_Types...>&& __v) { + static_assert(!is_void_v<_Tp>); + return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>( + _VSTD::move(__v)); +} + +template <class _Tp, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS -constexpr const _Tp& get(const variant<_Types...>& __v) { - static_assert(!is_void_v<_Tp>); - return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); -} - -template <class _Tp, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY +constexpr const _Tp& get(const variant<_Types...>& __v) { + static_assert(!is_void_v<_Tp>); + return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); +} + +template <class _Tp, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS -constexpr const _Tp&& get(const variant<_Types...>&& __v) { - static_assert(!is_void_v<_Tp>); - return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>( - _VSTD::move(__v)); -} - -template <size_t _Ip, class _Vp> -inline _LIBCPP_INLINE_VISIBILITY -constexpr auto* __generic_get_if(_Vp* __v) noexcept { - using __variant_detail::__access::__variant; - return __v && __holds_alternative<_Ip>(*__v) - ? _VSTD::addressof(__variant::__get_alt<_Ip>(*__v).__value) - : nullptr; -} - -template <size_t _Ip, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>> -get_if(variant<_Types...>* __v) noexcept { - static_assert(_Ip < sizeof...(_Types)); - static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); - return __generic_get_if<_Ip>(__v); -} - -template <size_t _Ip, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>> -get_if(const variant<_Types...>* __v) noexcept { - static_assert(_Ip < sizeof...(_Types)); - static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); - return __generic_get_if<_Ip>(__v); -} - -template <class _Tp, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr add_pointer_t<_Tp> -get_if(variant<_Types...>* __v) noexcept { - static_assert(!is_void_v<_Tp>); - return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v); -} - -template <class _Tp, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr add_pointer_t<const _Tp> -get_if(const variant<_Types...>* __v) noexcept { - static_assert(!is_void_v<_Tp>); - return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v); -} - +constexpr const _Tp&& get(const variant<_Types...>&& __v) { + static_assert(!is_void_v<_Tp>); + return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>( + _VSTD::move(__v)); +} + +template <size_t _Ip, class _Vp> +inline _LIBCPP_INLINE_VISIBILITY +constexpr auto* __generic_get_if(_Vp* __v) noexcept { + using __variant_detail::__access::__variant; + return __v && __holds_alternative<_Ip>(*__v) + ? _VSTD::addressof(__variant::__get_alt<_Ip>(*__v).__value) + : nullptr; +} + +template <size_t _Ip, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>> +get_if(variant<_Types...>* __v) noexcept { + static_assert(_Ip < sizeof...(_Types)); + static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); + return __generic_get_if<_Ip>(__v); +} + +template <size_t _Ip, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>> +get_if(const variant<_Types...>* __v) noexcept { + static_assert(_Ip < sizeof...(_Types)); + static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>); + return __generic_get_if<_Ip>(__v); +} + +template <class _Tp, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr add_pointer_t<_Tp> +get_if(variant<_Types...>* __v) noexcept { + static_assert(!is_void_v<_Tp>); + return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v); +} + +template <class _Tp, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr add_pointer_t<const _Tp> +get_if(const variant<_Types...>* __v) noexcept { + static_assert(!is_void_v<_Tp>); + return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v); +} + template <class _Operator> struct __convert_to_bool { template <class _T1, class _T2> _LIBCPP_INLINE_VISIBILITY constexpr bool operator()(_T1 && __t1, _T2&& __t2) const { - static_assert(is_convertible<decltype(_Operator{}(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2))), bool>::value, + static_assert(is_convertible<decltype(_Operator{}(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2))), bool>::value, "the relational operator does not return a type which is implicitly convertible to bool"); return _Operator{}(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2)); } }; -template <class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr bool operator==(const variant<_Types...>& __lhs, - const variant<_Types...>& __rhs) { - using __variant_detail::__visitation::__variant; - if (__lhs.index() != __rhs.index()) return false; - if (__lhs.valueless_by_exception()) return true; +template <class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr bool operator==(const variant<_Types...>& __lhs, + const variant<_Types...>& __rhs) { + using __variant_detail::__visitation::__variant; + if (__lhs.index() != __rhs.index()) return false; + if (__lhs.valueless_by_exception()) return true; return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<equal_to<>>{}, __lhs, __rhs); -} - -template <class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr bool operator!=(const variant<_Types...>& __lhs, - const variant<_Types...>& __rhs) { - using __variant_detail::__visitation::__variant; - if (__lhs.index() != __rhs.index()) return true; - if (__lhs.valueless_by_exception()) return false; - return __variant::__visit_value_at( +} + +template <class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr bool operator!=(const variant<_Types...>& __lhs, + const variant<_Types...>& __rhs) { + using __variant_detail::__visitation::__variant; + if (__lhs.index() != __rhs.index()) return true; + if (__lhs.valueless_by_exception()) return false; + return __variant::__visit_value_at( __lhs.index(), __convert_to_bool<not_equal_to<>>{}, __lhs, __rhs); -} - -template <class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr bool operator<(const variant<_Types...>& __lhs, - const variant<_Types...>& __rhs) { - using __variant_detail::__visitation::__variant; - if (__rhs.valueless_by_exception()) return false; - if (__lhs.valueless_by_exception()) return true; - if (__lhs.index() < __rhs.index()) return true; - if (__lhs.index() > __rhs.index()) return false; +} + +template <class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr bool operator<(const variant<_Types...>& __lhs, + const variant<_Types...>& __rhs) { + using __variant_detail::__visitation::__variant; + if (__rhs.valueless_by_exception()) return false; + if (__lhs.valueless_by_exception()) return true; + if (__lhs.index() < __rhs.index()) return true; + if (__lhs.index() > __rhs.index()) return false; return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<less<>>{}, __lhs, __rhs); -} - -template <class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr bool operator>(const variant<_Types...>& __lhs, - const variant<_Types...>& __rhs) { - using __variant_detail::__visitation::__variant; - if (__lhs.valueless_by_exception()) return false; - if (__rhs.valueless_by_exception()) return true; - if (__lhs.index() > __rhs.index()) return true; - if (__lhs.index() < __rhs.index()) return false; +} + +template <class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr bool operator>(const variant<_Types...>& __lhs, + const variant<_Types...>& __rhs) { + using __variant_detail::__visitation::__variant; + if (__lhs.valueless_by_exception()) return false; + if (__rhs.valueless_by_exception()) return true; + if (__lhs.index() > __rhs.index()) return true; + if (__lhs.index() < __rhs.index()) return false; return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<greater<>>{}, __lhs, __rhs); -} - -template <class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr bool operator<=(const variant<_Types...>& __lhs, - const variant<_Types...>& __rhs) { - using __variant_detail::__visitation::__variant; - if (__lhs.valueless_by_exception()) return true; - if (__rhs.valueless_by_exception()) return false; - if (__lhs.index() < __rhs.index()) return true; - if (__lhs.index() > __rhs.index()) return false; - return __variant::__visit_value_at( +} + +template <class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr bool operator<=(const variant<_Types...>& __lhs, + const variant<_Types...>& __rhs) { + using __variant_detail::__visitation::__variant; + if (__lhs.valueless_by_exception()) return true; + if (__rhs.valueless_by_exception()) return false; + if (__lhs.index() < __rhs.index()) return true; + if (__lhs.index() > __rhs.index()) return false; + return __variant::__visit_value_at( __lhs.index(), __convert_to_bool<less_equal<>>{}, __lhs, __rhs); -} - -template <class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr bool operator>=(const variant<_Types...>& __lhs, - const variant<_Types...>& __rhs) { - using __variant_detail::__visitation::__variant; - if (__rhs.valueless_by_exception()) return true; - if (__lhs.valueless_by_exception()) return false; - if (__lhs.index() > __rhs.index()) return true; - if (__lhs.index() < __rhs.index()) return false; - return __variant::__visit_value_at( +} + +template <class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr bool operator>=(const variant<_Types...>& __lhs, + const variant<_Types...>& __rhs) { + using __variant_detail::__visitation::__variant; + if (__rhs.valueless_by_exception()) return true; + if (__lhs.valueless_by_exception()) return false; + if (__lhs.index() > __rhs.index()) return true; + if (__lhs.index() < __rhs.index()) return false; + return __variant::__visit_value_at( __lhs.index(), __convert_to_bool<greater_equal<>>{}, __lhs, __rhs); -} - -template <class... _Vs> -inline _LIBCPP_INLINE_VISIBILITY - _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr void - __throw_if_valueless(_Vs&&... __vs) { - const bool __valueless = - (... || _VSTD::__as_variant(__vs).valueless_by_exception()); - if (__valueless) { - __throw_bad_variant_access(); - } - } - -template < - class _Visitor, class... _Vs, - typename = void_t<decltype(_VSTD::__as_variant(declval<_Vs>()))...> > -inline _LIBCPP_INLINE_VISIBILITY - _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr - decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) { - using __variant_detail::__visitation::__variant; - _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...); - return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Vs>(__vs)...); -} - -#if _LIBCPP_STD_VER > 17 -template < - class _Rp, class _Visitor, class... _Vs, - typename = void_t<decltype(_VSTD::__as_variant(declval<_Vs>()))...> > -inline _LIBCPP_INLINE_VISIBILITY - _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr _Rp - visit(_Visitor&& __visitor, _Vs&&... __vs) { - using __variant_detail::__visitation::__variant; - _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...); - return __variant::__visit_value<_Rp>(_VSTD::forward<_Visitor>(__visitor), - _VSTD::forward<_Vs>(__vs)...); -} -#endif - -template <class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -auto swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs) - noexcept(noexcept(__lhs.swap(__rhs))) - -> decltype( __lhs.swap(__rhs)) - { return __lhs.swap(__rhs); } - -template <class... _Types> -struct _LIBCPP_TEMPLATE_VIS hash< - __enable_hash_helper<variant<_Types...>, remove_const_t<_Types>...>> { - using argument_type = variant<_Types...>; - using result_type = size_t; - - inline _LIBCPP_INLINE_VISIBILITY - result_type operator()(const argument_type& __v) const { - using __variant_detail::__visitation::__variant; - size_t __res = - __v.valueless_by_exception() - ? 299792458 // Random value chosen by the universe upon creation - : __variant::__visit_alt( - [](const auto& __alt) { - using __alt_type = __uncvref_t<decltype(__alt)>; - using __value_type = remove_const_t< - typename __alt_type::__value_type>; - return hash<__value_type>{}(__alt.__value); - }, - __v); - return __hash_combine(__res, hash<size_t>{}(__v.index())); - } -}; - -// __unchecked_get is the same as std::get, except, it is UB to use it with the wrong -// type whereas std::get will throw or returning nullptr. This makes it faster than -// std::get. -template <size_t _Ip, class _Vp> -inline _LIBCPP_INLINE_VISIBILITY -constexpr auto&& __unchecked_get(_Vp&& __v) noexcept { - using __variant_detail::__access::__variant; - return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value; -} - -template <class _Tp, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr auto&& __unchecked_get(const variant<_Types...>& __v) noexcept { - return __unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); -} - -template <class _Tp, class... _Types> -inline _LIBCPP_INLINE_VISIBILITY -constexpr auto&& __unchecked_get(variant<_Types...>& __v) noexcept { - return __unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); -} - -#endif // _LIBCPP_STD_VER > 14 - -_LIBCPP_END_NAMESPACE_STD - -_LIBCPP_POP_MACROS - -#endif // _LIBCPP_VARIANT +} + +template <class... _Vs> +inline _LIBCPP_INLINE_VISIBILITY + _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr void + __throw_if_valueless(_Vs&&... __vs) { + const bool __valueless = + (... || _VSTD::__as_variant(__vs).valueless_by_exception()); + if (__valueless) { + __throw_bad_variant_access(); + } + } + +template < + class _Visitor, class... _Vs, + typename = void_t<decltype(_VSTD::__as_variant(declval<_Vs>()))...> > +inline _LIBCPP_INLINE_VISIBILITY + _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr + decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) { + using __variant_detail::__visitation::__variant; + _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...); + return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor), + _VSTD::forward<_Vs>(__vs)...); +} + +#if _LIBCPP_STD_VER > 17 +template < + class _Rp, class _Visitor, class... _Vs, + typename = void_t<decltype(_VSTD::__as_variant(declval<_Vs>()))...> > +inline _LIBCPP_INLINE_VISIBILITY + _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr _Rp + visit(_Visitor&& __visitor, _Vs&&... __vs) { + using __variant_detail::__visitation::__variant; + _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...); + return __variant::__visit_value<_Rp>(_VSTD::forward<_Visitor>(__visitor), + _VSTD::forward<_Vs>(__vs)...); +} +#endif + +template <class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +auto swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs) + noexcept(noexcept(__lhs.swap(__rhs))) + -> decltype( __lhs.swap(__rhs)) + { return __lhs.swap(__rhs); } + +template <class... _Types> +struct _LIBCPP_TEMPLATE_VIS hash< + __enable_hash_helper<variant<_Types...>, remove_const_t<_Types>...>> { + using argument_type = variant<_Types...>; + using result_type = size_t; + + inline _LIBCPP_INLINE_VISIBILITY + result_type operator()(const argument_type& __v) const { + using __variant_detail::__visitation::__variant; + size_t __res = + __v.valueless_by_exception() + ? 299792458 // Random value chosen by the universe upon creation + : __variant::__visit_alt( + [](const auto& __alt) { + using __alt_type = __uncvref_t<decltype(__alt)>; + using __value_type = remove_const_t< + typename __alt_type::__value_type>; + return hash<__value_type>{}(__alt.__value); + }, + __v); + return __hash_combine(__res, hash<size_t>{}(__v.index())); + } +}; + +// __unchecked_get is the same as std::get, except, it is UB to use it with the wrong +// type whereas std::get will throw or returning nullptr. This makes it faster than +// std::get. +template <size_t _Ip, class _Vp> +inline _LIBCPP_INLINE_VISIBILITY +constexpr auto&& __unchecked_get(_Vp&& __v) noexcept { + using __variant_detail::__access::__variant; + return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value; +} + +template <class _Tp, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr auto&& __unchecked_get(const variant<_Types...>& __v) noexcept { + return __unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); +} + +template <class _Tp, class... _Types> +inline _LIBCPP_INLINE_VISIBILITY +constexpr auto&& __unchecked_get(variant<_Types...>& __v) noexcept { + return __unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); +} + +#endif // _LIBCPP_STD_VER > 14 + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP_VARIANT |