Index: include/experimental/variant =================================================================== --- /dev/null +++ include/experimental/variant @@ -0,0 +1,1614 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler _Infrastructure +// +// This file is dual licensed under the MIT and the _University of _Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_EXPERIMENTAL_VARIANT +#define _LIBCPP_EXPERIMENTAL_VARIANT + +/* + +// Header synopsis + +namespace std { +// 20.7.2, variant of value types +template +class variant; +// 20.7.3, variant helper classes +template +struct variant_size; // undefined +template +struct variant_size; +template +struct variant_size; +template +struct variant_size; +template +constexpr size_t variant_size_v = variant_size::value; +template +struct variant_size>; +template +struct variant_alternative; // undefined +template +struct variant_alternative; +template +struct variant_alternative; +template +struct variant_alternative; +template +using variant_alternative_t = typename variant_alternative::type; +template +struct variant_alternative>; +constexpr size_t variant_npos = -1; +// 20.7.4, value access +template +constexpr bool holds_alternative(const variant&) noexcept; +template +constexpr variant_alternative_t>& +get(variant&); +template +constexpr variant_alternative_t>&& +get(variant&&); +template +constexpr variant_alternative_t> const& +get(const variant&); +template +constexpr variant_alternative_t> +const&& get(const variant&&); +template +constexpr T& get(variant&); +template +constexpr T&& get(variant&&); +template +constexpr const T& get(const variant&); +template +constexpr const T&& get(const variant&&); +template +constexpr add_pointer_t>> +get_if(variant*) noexcept; +template +constexpr add_pointer_t>> +get_if(const variant*) noexcept; +template +constexpr add_pointer_t +get_if(variant*) noexcept; +template +constexpr add_pointer_t +get_if(const variant*) noexcept; +// 20.7.5, relational operators +template +constexpr bool operator==(const variant&, + const variant&); +template +constexpr bool operator!=(const variant&, + const variant&); +template +constexpr bool operator<(const variant&, + const variant&); +template +constexpr bool operator>(const variant&, + const variant&); +template +constexpr bool operator<=(const variant&, + const variant&); +template +constexpr bool operator>=(const variant&, + const variant&); +// 20.7.6, visitation +// template +// constexpr see below visit(_Visitor&&, Variants&&...); +// 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 +void swap(variant&, variant&) noexcept; //(see below) +// 20.7.10, class bad_variant_access +class bad_variant_access; +// 20.7.11, hash support +// template struct hash; +template struct hash>; +template <> struct hash; +// 20.7.12, allocator-related traits +// template struct uses_allocator; +template +struct uses_allocator, Alloc>; +} // namespace std + +namespace std { +template +class variant { +public: + // 20.7.2.1, constructors + constexpr variant() noexcept; //(see below) + variant(const variant&); + variant(variant&&) noexcept; //(see below) + template + constexpr variant(_T&&) noexcept; //(see below) + template + constexpr explicit variant(in_place_type_t, Args&&...); + template + constexpr explicit variant(in_place_type_t, initializer_list, Args&&...); + template + constexpr explicit variant(in_place_index_t, Args&&...); + template + constexpr explicit variant(in_place_index_t, initializer_list, Args&&...); + // allocator-extended constructors + template + variant(allocator_arg_t, const Alloc&); + template + variant(allocator_arg_t, const Alloc&, const variant&); + template + variant(allocator_arg_t, const Alloc&, variant&&); + template + variant(allocator_arg_t, const Alloc&, T&&); + template + variant(allocator_arg_t, const Alloc&, in_place_type_t, Args&&...); + template + variant(allocator_arg_t, const Alloc&, in_place_type_t, initializer_list, Args&&...); + template + variant(allocator_arg_t, const Alloc&, in_place_index_t, Args&&...); + template + variant(allocator_arg_t, const Alloc&, in_place_index_t, initializer_list, Args&&...); + // 20.7.2.2, destructor + ~variant(); + // 20.7.2.3, assignment + variant& operator=(const variant&); + variant& operator=(variant&&) noexcept; //(see below) + template variant& operator=(_T&&) noexcept; //(see below) + // 20.7.2.4, modifiers + template + void emplace(_Args&&...); + template + void emplace(initializer_list, Args&&...); + template + void emplace(_Args&&...); + template + void emplace(initializer_list, 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) + }; +} // namespace std + +*/ + +#include +#include +#include +#include +#include +#include + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#if _LIBCPP_STD_VER > 14 + +_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL + +// 20.7.10, class bad_variant_access +class _LIBCPP_EXCEPTION_ABI bad_variant_access : logic_error { +public: + bad_variant_access() : logic_error{"Bad variant Access"} {}; + virtual ~bad_variant_access() noexcept {}; +}; + +_LIBCPP_END_NAMESPACE_EXPERIMENTAL + +_LIBCPP_BEGIN_NAMESPACE_LFTS + +constexpr size_t variant_npos = -1; + +template +union __variant_storage; // undefined + +struct __trivial{}; + +struct __non_trivial{}; + +template +union __variant_storage<_Type,__trivial> +{ + _Type m_type; + + constexpr __variant_storage() : m_type{} + {} + + template + constexpr __variant_storage(in_place_type_t<_Type>, _Args&&... __args) : + m_type{forward<_Args>(__args)...} + {} +}; + +template +union __variant_storage<_Type,__non_trivial> +{ + aligned_storage_t __m_storage; + + constexpr __variant_storage() : __m_storage{} + {} + + template + __variant_storage(in_place_type_t<_Type>, _Args&&... __args) : + __m_storage{} + { + new(&__m_storage)_Type(forward<_Args>(__args)...); + } +}; + +template <> +union __variant_storage +{ + constexpr __variant_storage() = default; +}; + +template +union __variant_storage<_Type&,__trivial> +{ + reference_wrapper> m_type; + + constexpr __variant_storage() : m_type{} + {} + + template + constexpr __variant_storage(in_place_type_t<_Type&>, _Args&&... __args) : + m_type{forward<_Args>(__args)...} + {} +}; + +template +union __variant_storage<_Type> +{ + static constexpr bool trivial = is_trivially_destructible_v<_Type> || + is_same_v<_Type,void>; + + __variant_storage<_Type, conditional_t> + m_head; + + constexpr __variant_storage() : m_head{} + {} + + template , int> = 0 + > + constexpr __variant_storage(in_place_type_t<_T>, _Args&&... __args) : + m_head{in_place_type<_T>, forward<_Args>(__args)...} + {} + + template && trivial, int> = 0> + constexpr _T& get() + { + return m_head.m_type; + } + + template && trivial, int> = 0> + constexpr const _T& get() const + { + return m_head.m_type; + } + + template && !trivial, int> = 0> + constexpr _T& get() + { + return *reinterpret_cast<_T*>(&m_head.__m_storage); + } + + template && !trivial, int> = 0> + constexpr const _T& get() const + { + return *reinterpret_cast(&m_head.__m_storage); + } +}; + +template +union __variant_storage +{ + static constexpr bool trivial = is_trivially_destructible_v<_Type> || + is_same_v<_Type,void>; + + __variant_storage<_Type, conditional_t> + m_head; + + __variant_storage<_Types...> + m_tail; + + __variant_storage() + {} + + template , int> = 0 + > + constexpr __variant_storage(in_place_type_t<_T>, _Args&&... __args) : + m_head{in_place_type<_T>, forward<_Args>(__args)...} + {} + + template , int> = 0 + > + constexpr __variant_storage(in_place_type_t<_T>, _Args&&... __args) : + m_tail{in_place_type<_T>, forward<_Args>(__args)...} + {} + + template && trivial, int> = 0> + constexpr _T& get() + { + return m_head.m_type; + } + + template && trivial, int> = 0> + constexpr const _T& get() const + { + return m_head.m_type; + } + + template && !trivial, int> = 0> + constexpr _T& get() + { + return *reinterpret_cast<_T*>(&m_head.__m_storage); + } + + template && !trivial, int> = 0> + constexpr const _T& get() const + { + return *reinterpret_cast(&m_head.__m_storage); + } + + template , int> = 0> + constexpr _T& get() + { + return m_tail.template get<_T>(); + } + + template , int> = 0> + constexpr const _T& get() const + { + return m_tail.template get<_T>(); + } +}; + +template +struct __variant_index; // undefined + +template +constexpr size_t __variant_index_v = __variant_index<_T, _Types...>::value; + +template +struct __variant_index<_T> : + integral_constant {}; + +template +struct __variant_index<_T, _T, _Types...> : + integral_constant {}; + +template +struct __variant_index<_T, _U, _Types...> : + integral_constant> {}; + +// Variant Base Class + +template +class __variant_base; // undefined + +// Non_TiviallyDestructible Specialisation + +template +class __variant_base +{ +public: + + __variant_storage<_Types...> __m_storage; + +protected: + + size_t __m_index = variant_npos; + + __variant_base(const __variant_base&) = delete; + __variant_base(__variant_base&&) = delete; + __variant_base& operator=(const __variant_base&) = delete; + __variant_base& operator=(__variant_base&&) = delete; + + __variant_base() : + __m_storage{}, + __m_index{variant_npos} + {} + + template + __variant_base(in_place_type_t<_T>, _Args&&... __args) : + __m_storage{}, + __m_index{variant_npos} + { + __construct(in_place_type<_T>, forward<_Args>(__args) ...); + } + + template + __variant_base(allocator_arg_t, const _Alloc& __a, in_place_type_t<_T>, _Args&&... __args) : + __m_storage{}, + __m_index{variant_npos} + { + __construct(allocator_arg, __a, in_place_type<_T>, forward<_Args>(__args) ...); + } + + ~__variant_base() + { + if(__m_index != variant_npos) + __destroy(); + } + + template ,int> = 0 + > + void __construct(in_place_type_t<_T>, _Args&&... __args) + { + assert(__m_index == variant_npos); + new(&__m_storage) decay_t<_T>{forward<_Args>(__args) ...}; + __m_index = __variant_index_v<_T, _Types...>; + }; + + template ,int> = 0 + > + void __construct(allocator_arg_t, const _Alloc& __a, in_place_type_t<_T>, _Args&&... __args) + { + assert(__m_index == variant_npos); + new(&__m_storage) decay_t<_T>{allocator_arg, __a, forward<_Args>(__args) ...}; + __m_index = __variant_index_v<_T, _Types...>; + }; + + template ,int> = 0 + > + void __construct(allocator_arg_t, const _Alloc& __a, in_place_type_t<_T>, _Args&&... __args) + { + assert(__m_index == variant_npos); + new(&__m_storage) decay_t<_T>{forward<_Args>(__args) ..., __a}; + __m_index = __variant_index_v<_T, _Types...>; + }; + + template && + !is_constructible_v<_T,_Args...,const _Alloc&>,int> = 0 + > + void __construct(allocator_arg_t, const _Alloc& __a, in_place_type_t<_T>, _Args&&... __args) + { + assert(__m_index == variant_npos); + new(&__m_storage) decay_t<_T>{forward<_Args>(__args) ...}; + __m_index = __variant_index_v<_T, _Types...>; + }; + +private: + + template + void __private_copy(const __variant_base& __v) + { + __construct(in_place_type<_T>, __v.__m_storage.template get<_T>()); + } + + template + void __private_copy(allocator_arg_t, const _Alloc& __a, const __variant_base& __v) + { + __construct(allocator_arg, __a, in_place_type<_T>, __v.__m_storage.template get<_T>()); + } + +protected: + + void __copy(const __variant_base& __v) + { + assert(__v.__m_index != variant_npos); + assert(__v.__m_index < sizeof...(_Types)); + assert(__m_index == variant_npos); + using function = void(__variant_base::*)(const __variant_base&); + constexpr function __array[sizeof...(_Types)] = {&__variant_base::__private_copy<_Types> ...}; + (this->*__array[__v.__m_index])(__v); + } + + template + void __copy(allocator_arg_t, const _Alloc& __a, const __variant_base& __v) + { + assert(__v.__m_index != variant_npos); + assert(__v.__m_index < sizeof...(_Types)); + assert(__m_index == variant_npos); + using function = void(__variant_base::*)(allocator_arg_t, const _Alloc&, const __variant_base&); + constexpr function __array[sizeof...(_Types)] = {&__variant_base::__private_copy<_Alloc, _Types> ...}; + (this->*__array[__v.__m_index])(allocator_arg, __a, __v); + } + +private: + + template + void __private_move(__variant_base&& __v) + { + __construct(in_place_type<_T>, move(__v.__m_storage.template get<_T>())); + } + + template + void __private_move(allocator_arg_t, const _Alloc& __a, __variant_base&& __v) + { + __construct(allocator_arg, __a, in_place_type<_T>, move(__v.__m_storage.template get<_T>())); + } + +protected: + + void __move(__variant_base&& __v) + { + assert(__v.__m_index != variant_npos); + assert(__v.__m_index < sizeof...(_Types)); + assert(__m_index == variant_npos); + using function = void(__variant_base::*)(__variant_base&&); + constexpr function __array[sizeof...(_Types)] = {&__variant_base::__private_move<_Types> ...}; + (this->*__array[__v.__m_index])(forward<__variant_base>(__v)); + __v.__m_index = variant_npos; + } + + template + void __move(allocator_arg_t, const _Alloc& __a, __variant_base&& __v) + { + assert(__v.__m_index != variant_npos); + assert(__v.__m_index < sizeof...(_Types)); + assert(__m_index == variant_npos); + using function = void(__variant_base::*)(allocator_arg_t, const _Alloc&, __variant_base&&); + constexpr function __array[sizeof...(_Types)] = {&__variant_base::__private_move<_Alloc, _Types> ...}; + (this->*__array[__v.__m_index])(allocator_arg, __a, forward<__variant_base>(__v)); + __v.__m_index = variant_npos; + } + +private: + + template>,int> = 0> + void __private_destroy() + { + assert(__m_index != variant_npos); + reinterpret_cast>(&__m_storage)->~_T(); + __m_index = variant_npos; + }; + + template>,int> = 0> + void __private_destroy() + { + assert(__m_index != variant_npos); + __m_index = variant_npos; + }; + +protected: + + void __destroy() + { + assert(__m_index != variant_npos); + assert(__m_index < sizeof...(_Types)); + using function = void(__variant_base::*)(); + constexpr function __array[sizeof...(_Types)] = {&__variant_base::__private_destroy<_Types> ...}; + (this->*__array[__m_index])(); + }; +}; + +// _TiviallyDestructible Specialisation + +template +class __variant_base +{ +public: + + __variant_storage<_Types...> __m_storage; + +protected: + + size_t __m_index = variant_npos; + + __variant_base(const __variant_base&) = delete; + __variant_base(__variant_base&&) = delete; + __variant_base& operator=(const __variant_base&) = delete; + __variant_base& operator=(__variant_base&&) = delete; + ~__variant_base() = default; + + __variant_base() : + __m_storage{}, + __m_index{variant_npos} + {} + + template + constexpr __variant_base(in_place_type_t<_T>, _Args&&... __args) : + __m_storage{in_place_type<_T>, forward<_Args>(__args) ...}, + __m_index{__variant_index_v<_T, _Types...>} + {} + + template + void __construct(in_place_type_t<_T>, _Args&&... __args) + { + assert(__m_index == variant_npos); + new(&__m_storage) remove_reference_t<_T>{forward<_Args>(__args) ...}; + __m_index = __variant_index_v<_T, _Types...>; + }; + +private: + + template + void __private_copy(const __variant_base& __v) + { + __construct(in_place_type<_T>, __v.__m_storage.template get<_T>()); + } + +protected: + + void __copy(const __variant_base& __v) + { + assert(__v.__m_index != variant_npos && __v.__m_index < sizeof...(_Types)); + assert(__m_index == variant_npos); + using __function = void(__variant_base::*)(const __variant_base&); + constexpr __function __array[sizeof...(_Types)] = {&__variant_base::__private_copy<_Types> ...}; + (this->*__array[__v.__m_index])(__v); + } + + void __move(__variant_base&& __v) + { + __copy(__v); + __v.__m_index = variant_npos; + } + + void __destroy() + { + assert(__m_index != variant_npos); + __m_index = variant_npos; + }; +}; + +// _MoveAssignable Specialisation + +template +class __variant_base : +public __variant_base +{ + using __base = + __variant_base; + +protected: + + using __base::__base; + using __base::__move; + using __base::__destroy; + using __base::__m_index; + + __variant_base& + operator=(__variant_base&& __rhs) + noexcept(conjunction_v..., + is_nothrow_move_assignable<_Types>... >) + { + static_assert(conjunction_v ...> && + conjunction_v ...> , + R"(This function shall not participate in overload resolution + unless is_move_constructible_v<_Ti> && s_move_assignable_v<_Ti> is true for all i.)"); + if(__m_index != variant_npos) + __destroy(); + if(__rhs.__m_index != variant_npos) + __move(move(__rhs)); + return *this; + } +}; + +// _CopyAssignable Specialisation + +template +class __variant_base : +public __variant_base +{ + using __base = + __variant_base; + +protected: + + using __base::__base; + using __base::__copy; + using __base::__destroy; + using __base::__m_index; + + __variant_base& operator=(const __variant_base& __rhs) + { + static_assert(conjunction_v..., + is_move_constructible<_Types>..., + is_copy_assignable <_Types>...>, + R"(This function shall not participate in overload resolution + unless is_copy_constructible_v<_Ti> && is_move_constructible_v<_Ti> && + is_copy_assignable_v<_Ti> is true for all i.)"); + if(__m_index != variant_npos) + __destroy(); + if(__rhs.__m_index != variant_npos) + __copy(__rhs); + return *this; + } + __variant_base& operator=(__variant_base&&) = default; +}; + +// _MoveConstructible Specialisation + +template +class __variant_base : +public __variant_base +{ + using __base = + __variant_base; + +protected: + + using __base::__base; + using __base::__move; + using __base::__m_index; + + __variant_base(__variant_base&& __v) : + __base{} + { + static_assert(conjunction_v ...>, + R"(This function shall not participate in overload resolution + unless is_copy_constructible_v<_Ti> is true for all i.)"); + if(__v.__m_index != variant_npos) + { + __move(forward<__variant_base>(__v)); + __v.__m_index = variant_npos; + } + } + + __variant_base& operator=(const __variant_base&) = default; + __variant_base& operator=(__variant_base&&) = default; +}; + +// _CopyConstructible Specialisation + +template +class __variant_base : +public __variant_base +{ + using __base = + __variant_base; + +protected: + + using __base::__base; + using __base::__copy; + + __variant_base(const __variant_base& __v) : + __base{} + { + static_assert(conjunction_v ...>, + R"(This function shall not participate in overload resolution + unless is_move_constructible_v<_Ti> is true for all i.)"); + if(__v.__m_index != variant_npos) + __copy(__v); + } + + __variant_base(__variant_base&&) = default; + __variant_base& operator=(const __variant_base&) = default; + __variant_base& operator=(__variant_base&&) = default; +}; + +// Some helper templates + +template < template class _Test, class... _Types> +struct __first_or_last; + +template < template class _Test, class... _Types> +using __first_or_last_t = typename __first_or_last<_Test, _Types...>::type; + +template < template class _Test, class _T> +struct __first_or_last<_Test, _T> {using type = _T;}; + +template < template class _Test, class _T, class... _Types> +struct __first_or_last<_Test, _T, _Types...> +{ + static constexpr _Test<_T> test; + using type = conditional_t>; +}; + +template +struct __argument {using type = _T;}; + +template +struct __imaginary_function; // undefined + +template <> +struct __imaginary_function<> {constexpr void operator()() const noexcept;}; + +template +struct __imaginary_function : __imaginary_function<_Ts...> +{ + using __imaginary_function<_Ts...>::operator(); + constexpr __argument operator()() const noexcept; +}; + +template +struct __imaginary_function<_T, _Ts...> : __imaginary_function<_Ts...> +{ + using __imaginary_function<_Ts...>::operator(); + constexpr __argument<_T> operator()(_T) const noexcept; +}; + +template +using __imaginary_function_argument_t = + typename result_of_t<__imaginary_function<_Types...>(_T)>::type; + +template +struct __count; // undefined + +template +constexpr size_t __count_v = __count<_T, _Types...>::value; + +template +struct __count<_T,_U> : + integral_constant> {}; + +template +struct __count<_T, _U, _Types...> : + integral_constant + __count_v<_T, _Types...>> {}; + +template +struct __is_imaginary_function_well_formed : + bool_constant<(__count_v<_T, _Types...> == 1)> {}; + +template +constexpr bool __is_imaginary_function_well_formed_v = + __is_imaginary_function_well_formed<_T, _Types...>::value; + +// 20.7.2, variant of value types +template +class variant; + +// 20.7.3, variant helper classes +template struct variant_size; // undefined +template struct variant_size; +template struct variant_size; +template struct variant_size; + +template constexpr size_t variant_size_v = variant_size<_T>::value; + +template +struct variant_size> : + integral_constant {}; + +template struct variant_alternative; // undefined +template struct variant_alternative<_I, const _T>; +template struct variant_alternative<_I, volatile _T>; +template struct variant_alternative<_I, const volatile _T>; + +template +using variant_alternative_t = typename variant_alternative<_I, _T>::type; + +template +struct variant_alternative<_I, variant<_Types...>> +{ + static_assert(_I < sizeof...(_Types), "variant_alternative index out of range"); + using type = tuple_element_t<_I, tuple<_Types...>>; +}; + +// 20.7.4, value access +template +_LIBCPP_INLINE_VISIBILITY +constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept +{ + return __variant_index_v<_T, _Types...> == __v.index(); +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr variant_alternative_t<_I, variant<_Types...>>& +get(variant<_Types...>& __v) +{ + using _T = variant_alternative_t<_I, variant<_Types...>>; + return get<_T>(__v); +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr variant_alternative_t<_I, variant<_Types...>>&& +get(variant<_Types...>&& __v) +{ + using _T = variant_alternative_t<_I, variant<_Types...>>; + return move(get<_T>(__v)); +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr variant_alternative_t<_I, variant<_Types...>> const& +get(const variant<_Types...>& __v) +{ + using _T = variant_alternative_t<_I, variant<_Types...>>; + return get<_T>(__v); +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr variant_alternative_t<_I, variant<_Types...>> const&& +get(const variant<_Types...>&& __v) +{ + using _T = variant_alternative_t<_I, variant<_Types...>>; + return move(get<_T>(__v)); +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr _T& +get(variant<_Types...>& __v) +{ + static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative"); + if(holds_alternative<_T>(__v)) + return __v.__m_storage.template get<_T>(); + throw bad_variant_access{}; +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr _T&& +get(variant<_Types...>&& __v) +{ + static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative"); + if(holds_alternative<_T>(__v)) + return __v.__m_storage.template get<_T>(); + throw bad_variant_access{}; +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr const _T& +get(const variant<_Types...>& __v) +{ + static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative"); + if(holds_alternative<_T>(__v)) + return __v.__m_storage.template get<_T>(); + throw bad_variant_access{}; +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr const _T&& +get(const variant<_Types...>&& __v) +{ + static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative"); + if(holds_alternative<_T>(__v)) + return __v.__m_storage.template get<_T>(); + throw bad_variant_access{}; +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr add_pointer_t>> +get_if(variant<_Types...>* __v) noexcept +{ + using _T = variant_alternative_t<_I, variant<_Types...>>; + return get_if<_T>(__v); +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr add_pointer_t>> +get_if(const variant<_Types...>* __v) noexcept +{ + using _T = variant_alternative_t<_I, variant<_Types...>>; + return get_if<_T>(__v); +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr add_pointer_t<_T> +get_if(variant<_Types...>* __v) noexcept +{ + static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative"); + if(holds_alternative<_T>(*__v)) + return &(__v->__m_storage.template get<_T>()); + return nullptr; +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr add_pointer_t +get_if(const variant<_Types...>* __v) noexcept +{ + static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative"); + if(holds_alternative<_T>(*__v)) + return &(__v->__m_storage.template get<_T>()); + return nullptr; +}; + +template +using __comparison_function_type = + bool(*)(const variant<_Types...>&, const variant<_Types...>&); + +template +constexpr bool +__variant_equal_to(const variant<_Types...>& __v, const variant<_Types...>& __w) +{ + return get<_T>(__v) == get<_T>(__w); +} + +template +constexpr array<__comparison_function_type<_Types...>, sizeof...(_Types)> +__make_equal_to_array() +{ + return { __variant_equal_to<_Types, _Types...> ... }; +} + +template +constexpr bool +__variant_less(const variant<_Types...>& __v, const variant<_Types...>& __w) +{ + return get<_T>(__v) < get<_T>(__w); +} + +template +constexpr array<__comparison_function_type<_Types...>, sizeof...(_Types)> +__make_less_array() +{ + return { __variant_less<_Types, _Types...> ... }; +} + +template +using __invoker_function_type = auto(*)(_Visitor&&, _Variants&&...) +-> result_of_t<_Visitor(variant_alternative_t<0, decay_t<_Variants>> ...)>; + +template +auto +__alternative_invoker(_Visitor&& __vis, _Variants&&... __vars) +{ + return invoke(forward<_Visitor>(__vis), get<_I>(forward<_Variants>(__vars)) ...); +} + +template +constexpr array<__invoker_function_type<_Visitor, _Variants...>, sizeof...(_I)> +__make_invoker_array(index_sequence<_I...>) +{ + return { __alternative_invoker<_I, _Visitor, _Variants...> ... }; +} + +template +auto +__variant_invoke(_Visitor&& __vis, variant<_Types...>& __var, _Variants&&... __vars) +{ + constexpr auto __array = + __make_invoker_array<_Visitor, variant<_Types...>, _Variants...> + (index_sequence_for<_Types...>{}); + + return __array[__var.index()](forward<_Visitor>(__vis), + forward>(__var), + forward<_Variants>(__vars)...); +} + +template +auto +__variant_invoke(_Visitor&& __vis, const variant<_Types...>& __var, _Variants&&... __vars) +{ + constexpr auto __array = + __make_invoker_array<_Visitor, const variant<_Types...>&, _Variants...> + (index_sequence_for<_Types...>{}); + + return __array[__var.index()](forward<_Visitor>(__vis), __var, __vars...); +} + +template +using __swap_function_type = void(*)(variant<_Types...>&, variant<_Types...>&); + +template +constexpr void +__swap(variant<_Types...>& __v, variant<_Types...>& __w) noexcept +{ + swap(get<_T>(__v), get<_T>(__w)); +} + +template +constexpr array<__swap_function_type<_Types...>, sizeof...(_Types)> +__make_swap_array() +{ + return { __swap<_Types, _Types...> ... }; +} + +template +using __hash_function_type = size_t(*)(const variant<_Types...>&); + +template +constexpr size_t __hash(const variant<_Types...>& __v) +{ + return hash<_T>{}(get<_T>(__v)); +} + +template +constexpr array<__hash_function_type<_Types...>, sizeof...(_Types)> +__make_hash_array() +{ + return { __hash<_Types, _Types...> ... }; +} + +// 20.7.5, relational operators +template +_LIBCPP_INLINE_VISIBILITY +constexpr bool operator==(const variant<_Types...>& __v, const variant<_Types...>& __w) +{ + constexpr auto __equals_to = __make_equal_to_array<_Types...>(); + return (__v.valueless_by_exception() && __w.valueless_by_exception()) || + (__v.index() == __w.index() && __equals_to[__v.index()](__v,__w)); +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr bool operator!=(const variant<_Types...>& __v, const variant<_Types...>& __w) +{ + return !(__v == __w); +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr bool operator<(const variant<_Types...>& __v, const variant<_Types...>& __w) +{ + constexpr auto __less = __make_less_array<_Types...>(); + return (__v.index() < __w.index()) || (__v.index() == __w.index() && + !__v.valueless_by_exception() && __less[__v.index()](__v,__w)); +}; + +template +_LIBCPP_INLINE_VISIBILITY +constexpr bool operator>(const variant<_Types...>& __v, const variant<_Types...>& __w) +{ + return __w < __v; +} + +template +constexpr bool operator<=(const variant<_Types...>& __v, const variant<_Types...>& __w) +{ + return !(__v > __w); +} + +template +_LIBCPP_INLINE_VISIBILITY +constexpr bool operator>=(const variant<_Types...>& __v, const variant<_Types...>& __w) +{ + return !(__v < __w); +} + +// 20.7.6, visitation +template +_LIBCPP_INLINE_VISIBILITY +constexpr auto visit(_Visitor&& __vis, _Variants&&... __vars) +{ + return __variant_invoke(forward<_Visitor>(__vis), forward<_Variants>(__vars) ...); +}; + +// 20.7.7, class monostate +struct monostate {}; + +// 20.7.8, monostate relational operators +_LIBCPP_INLINE_VISIBILITY +constexpr bool operator<(monostate, monostate) noexcept {return false;}; +_LIBCPP_INLINE_VISIBILITY +constexpr bool operator>(monostate, monostate) noexcept {return false;}; +_LIBCPP_INLINE_VISIBILITY +constexpr bool operator<=(monostate, monostate) noexcept {return true;}; +_LIBCPP_INLINE_VISIBILITY +constexpr bool operator>=(monostate, monostate) noexcept {return true;}; +_LIBCPP_INLINE_VISIBILITY +constexpr bool operator==(monostate, monostate) noexcept {return true;}; +_LIBCPP_INLINE_VISIBILITY +constexpr bool operator!=(monostate, monostate) noexcept {return false;}; + +// 20.7.9, specialized algorithms +template +_LIBCPP_INLINE_VISIBILITY +void swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs) + noexcept(conjunction_v ...> && + conjunction_v ...>) +{ + __lhs.swap(__rhs); +}; + +template +class variant : public __variant_base...>, + conjunction_v...>, + conjunction_v...>, + conjunction_v...>, + conjunction_v...>, + _Types...> +{ + using __base = __variant_base...>, + conjunction_v...>, + conjunction_v...>, + conjunction_v...>, + conjunction_v...>, + _Types...>; + using __base::__copy; + using __base::__move; + using __base::__construct; + using __base::__destroy; + using __base::__m_index; + +public: + + // 20.7.2.1, constructors + + template , + enable_if_t, int> = 0> + _LIBCPP_INLINE_VISIBILITY + constexpr + variant() noexcept(is_nothrow_default_constructible_v<_T0>) : + __base{in_place_type<_T0>} + { + static_assert(is_default_constructible_v<_T0>, + R"(This function shall not participate in overload resolution + unless is_default_constructible_v<_T0> is true.)"); + }; + + template , + enable_if_t, int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + constexpr + variant() noexcept(is_nothrow_default_constructible_v<_T0>) = delete; + + // We'll inherit the copy and move constructors from the __base + + _LIBCPP_INLINE_VISIBILITY + variant(const variant&) = default; + + _LIBCPP_INLINE_VISIBILITY + variant(variant&&) = default; + + template , + enable_if_t,variant>>, + is_constructible<_Tj, _T>, + __is_imaginary_function_well_formed<_Tj, _Types...>>,int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + constexpr + variant(_T&& __t) noexcept(is_nothrow_constructible_v<_Tj, _T>) : + __base{in_place_type<_Tj>, forward<_T>(__t)} + { + static_assert(!is_same_v,variant> && + is_constructible_v<_Tj, _T> && + __is_imaginary_function_well_formed_v<_Tj, _Types...>, + R"(This function shall not participate in overload resolution + unless is_same_v, variant> is false, + unless is_constructible_v<_Tj, _T> is true, and + unless the expression FUN(std::forward<_T>(__t)) + (with FUN being the above-mentioned set of imaginary functions) + is well formed.)"); + }; + + template , int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + constexpr explicit + variant(in_place_type_t<_T>, _Args&&... __args) : + __base{in_place_type<_T>, forward<_Args>(__args)...} + {}; + + template &, _Args...>, int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + constexpr explicit + variant(in_place_type_t<_T>, initializer_list<_U> __il, _Args&&... __args) : + __base{in_place_type<_T>, forward>(__il), forward<_Args>(__args)...} + {}; + + template , + enable_if_t, int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + constexpr explicit + variant(in_place_index_t<_I>, _Args&&... __args) : + __base{in_place_type<_T>, forward<_Args>(__args)...} + {}; + + template , + enable_if_t&, _Args...>, int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + constexpr explicit + variant(in_place_index_t<_I>, initializer_list<_U> __il, _Args&&... __args) : + __base{in_place_type<_Ti>, forward>(__il), forward<_Args>(__args)...} + {}; + + // allocator-extended constructors + template , + enable_if_t, int> = 0> + _LIBCPP_INLINE_VISIBILITY + variant(allocator_arg_t, const _Alloc& __a) : + __base{allocator_arg, __a, in_place_type<_T0>} + { + static_assert(is_default_constructible_v<_T0>, + R"(This function shall not participate in overload resolution + unless is_default_constructible_v<_T0> is true.)"); + }; + + template , + enable_if_t, int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + variant(allocator_arg_t, const _Alloc& __a, const variant& __v) : + __base{} + { + static_assert(conjunction_v ...>, + R"(This function shall not participate in overload resolution + unless is_copy_constructible_v<_Ti> is true for all i.)"); + if(!__v.valueless_by_exception()) + __copy(allocator_arg, __a, __v); + } + + template , + enable_if_t, int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + variant(allocator_arg_t, const _Alloc& __a, variant&& __v) : + __base{} + { + static_assert(conjunction_v ...>, + R"(This function shall not participate in overload resolution + unless is_move_constructible_v<_Ti> is true for all i.)"); + if(!__v.valueless_by_exception()) + __move(allocator_arg, __a, forward(__v)); + } + + template , + enable_if_t,variant>>, + is_constructible<_Tj, _T>, + __is_imaginary_function_well_formed<_Tj, _Types...>>,int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + variant(allocator_arg_t, const _Alloc& __a, _T&& __t) : + __base{allocator_arg, __a, in_place_type<_Tj>, forward<_T>(__t)} + { + static_assert(!is_same_v,variant> && + is_constructible_v<_Tj, _T> && + __is_imaginary_function_well_formed_v<_Tj, _Types...>, + R"(This function shall not participate in overload resolution + unless is_same_v, variant> is false, + unless is_constructible_v<_Tj, _T> is true, and + unless the expression FUN( std::forward<_T>(__t)) + (with FUN being the above-mentioned set of imaginary functions) + is well formed.)"); + }; + + template , int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + variant(allocator_arg_t, const _Alloc& __a, in_place_type_t<_T>, _Args&&... __args) : + __base{allocator_arg, __a, in_place_type<_T>, forward<_Args>(__args) ...} + {}; + + template &, _Args...>, int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + variant(allocator_arg_t, const _Alloc& __a, + in_place_type_t<_T>, initializer_list<_U> __il, _Args&&... __args) : + __base{allocator_arg, __a, + in_place_type<_T>, forward>(__il), forward<_Args>(__args) ...} + {}; + + template , + enable_if_t, int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + variant(allocator_arg_t, const _Alloc& __a, in_place_index_t<_I>, _Args&&... __args) : + __base{allocator_arg, __a, in_place_type<_T>, forward<_Args>(__args) ...} + {}; + + template , + enable_if_t&, _Args...>, int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + variant(allocator_arg_t, const _Alloc& __a, in_place_index_t<_I>, initializer_list<_U> __il, _Args&&... __args) : + __base{allocator_arg, __a, in_place_type<_T>, forward>(__il), forward<_Args>(__args) ...} + {}; + + // 20.7.2.2, destructor + _LIBCPP_INLINE_VISIBILITY + ~variant() = default; + + // 20.7.2.3, assignment + _LIBCPP_INLINE_VISIBILITY + variant& operator=(const variant&) = default; + + _LIBCPP_INLINE_VISIBILITY + variant& operator=(variant&&) = default; + + template , + enable_if_t,variant>>, + is_assignable_v<_Tj&, _T>, + is_constructible<_Tj, _T>, + __is_imaginary_function_well_formed<_Tj, _Types...>>,int> = 0 + > + _LIBCPP_INLINE_VISIBILITY + variant& operator=(_T&& __rhs) + noexcept(conjunction_v..., + is_nothrow_constructible<_Types&, _Types>...>) + { + static_assert(!is_same_v, variant> && + is_assignable_v<_Tj&, _T> && is_constructible_v<_Tj, _T> && + __is_imaginary_function_well_formed_v<_Tj, _Types...>, + R"(This function shall not participate in overload resolution + unless is_same_v, variant> is false, + unless is_assignable_v<_Tj&, _T> && is_constructible_v<_Tj, _T> is true, and + unless the expression FUN (std::forward<_T>(__t)) + (with FUN being the above-mentioned set of imaginary functions) is well formed.)"); + if(!valueless_by_exception()) + __destroy(); + __construct(in_place_type<_Tj>, forward<_T>(__rhs)); + return *this; + }; + + // 20.7.2.4, modifiers + + template + _LIBCPP_INLINE_VISIBILITY + void emplace(_Args&&... __args) + { + static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative"); + static_assert(!is_lvalue_reference_v<_T>, "references cannot be reassigned"); + if(!valueless_by_exception()) + __destroy(); + __construct(in_place_type<_T>, forward<_Args>(__args)...); + }; + + template + _LIBCPP_INLINE_VISIBILITY + void emplace(initializer_list<_U> __il, _Args&&... __args) + { + static_assert(__count_v<_T, _Types...> > 0, "_Type is not an alternative"); + static_assert(!is_lvalue_reference_v<_T>, "references cannot be reassigned"); + if(!valueless_by_exception()) + __destroy(); + __construct(in_place_type<_T>, __il, forward<_Args>(__args)...); + }; + + template + _LIBCPP_INLINE_VISIBILITY + void emplace(_Args&&... __args) + { + using _T = variant_alternative_t<_I, variant>; + emplace<_T>(forward<_Args>(__args)...); + }; + + template + _LIBCPP_INLINE_VISIBILITY + void emplace(initializer_list<_U> __il, _Args&&... __args) + { + using _T = variant_alternative_t<_I, variant>; + emplace<_T>(__il, forward<_Args>(__args)...); + }; + + // 20.7.2.5, value status + _LIBCPP_INLINE_VISIBILITY + constexpr bool valueless_by_exception() const noexcept + { + return __m_index == variant_npos; + } + + _LIBCPP_INLINE_VISIBILITY + constexpr size_t index() const noexcept + { + return __m_index; + }; + + // 20.7.2.6, swap + _LIBCPP_INLINE_VISIBILITY + void swap(variant& __rhs) + noexcept(conjunction_v..., + is_nothrow_swappable<_Types>...>) + { + constexpr auto __swap = __make_swap_array<_Types...>(); + variant& __lhs = *this; + if(__lhs.valueless_by_exception() && __rhs.valueless_by_exception()) + return; + if(__lhs.__m_index == __rhs.__m_index) + __swap[__lhs.__m_index](__lhs,__rhs); + else + { + variant __tmp{__rhs}; + __rhs.__m_index = __lhs.__m_index; + __swap[__lhs.__m_index](__rhs,__lhs); + __lhs.__m_index = __tmp.__m_index; + __swap[__lhs.__m_index](__lhs,__tmp); + } + } +}; + +_LIBCPP_END_NAMESPACE_LFTS + +_LIBCPP_BEGIN_NAMESPACE_STD + +// 20.7.11, hash support +// template struct hash; +template +struct hash<_VSTD_LFTS::variant<_Types...>> +{ + _LIBCPP_INLINE_VISIBILITY + size_t operator()(const _VSTD_LFTS::variant<_Types...>& __v) noexcept + { + constexpr auto __hash = _VSTD_LFTS::__make_hash_array<_Types...>(); + return __hash[__v.index()](__v); + } +}; + +template <> +struct hash<_VSTD_LFTS::monostate> +{ + _LIBCPP_INLINE_VISIBILITY + size_t operator()(_VSTD_LFTS::monostate) noexcept + { + return 42; + } +}; + +// 20.7.12, allocator-related traits +// template struct uses_allocator; + +template +struct uses_allocator<_VSTD_LFTS::variant<_Types...>, _Alloc> : true_type {}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_STD_VER > 14 + +#endif // _LIBCPP__EXPERIMENTAL_VARIANT Index: test/std/experimental/variant/variant.general/variant.hash/hash.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.general/variant.hash/hash.pass.cpp @@ -0,0 +1,35 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include + +using std::experimental::variant; + +struct foo{}; + +int main() +{ + std::hash> hv; + std::hash hu; + std::hash hd; + std::hash hc; + + variant v; + + v = 123u; + assert(hv(v) == hu(123u)); + + v = 123.456; + assert(hv(v) == hd(123.456)); + + v = 'R'; + assert(hv(v) == hc('R')); +} Index: test/std/experimental/variant/variant.general/variant.helper/helper.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.general/variant.helper/helper.pass.cpp @@ -0,0 +1,24 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::variant_size_v; +using std::experimental::variant_alternative_t; + +int main() +{ + using V = variant>; + static_assert(variant_size_v == 6); + static_assert(std::is_same_v, std::vector>); +} Index: test/std/experimental/variant/variant.general/variant.bad.access/bad_variant_access.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.general/variant.bad.access/bad_variant_access.pass.cpp @@ -0,0 +1,57 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include + +using std::experimental::variant; +using std::experimental::get; +using std::experimental::bad_variant_access; + +int main() +{ + try + { + variant v{9u}; + get(v); + assert(false); + } + catch(bad_variant_access& bad) + {} + + try + { + variant v{9u}; + get<2>(v); + assert(false); + } + catch(bad_variant_access& bad) + {} + + try + { + variant v{9u}; + get(v); + } + catch(bad_variant_access& bad) + { + assert(false); + } + + try + { + variant v{9u}; + get<0>(v); + } + catch(bad_variant_access& bad) + { + assert(false); + } + } Index: test/std/experimental/variant/variant.general/variant.get/get.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.general/variant.get/get.pass.cpp @@ -0,0 +1,120 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::get; +using std::experimental::get_if; + +void test_constexpr_get() +{ + using test = variant; + + constexpr test t1{}; + static_assert(get<0>(t1) == false); + static_assert(get(t1) == false); + + constexpr test t2{true}; + static_assert(get<0>(t2) == true); + static_assert(get(t2) == true); + + constexpr test t3{11}; + static_assert(get<1>(t3) == 11); + static_assert(get(t3) == 11); + + constexpr test t4{22.22}; + static_assert(get<2>(t4) == 22.22); + static_assert(get(t4) == 22.22); + + static_assert(get<2>(test{3.3}) == 3.3); +} + +void test_constexpr_get_if() +{ + using test = variant; + + constexpr test t1{}; + static_assert(get_if<0>(&t1) != nullptr); + static_assert(get_if(&t1) != nullptr); + static_assert(get_if<1>(&t1) == nullptr); + static_assert(get_if(&t1) == nullptr); + static_assert(get_if<2>(&t1) == nullptr); + static_assert(get_if(&t1) == nullptr); + + constexpr test t2{true}; + static_assert(*get_if<0>(&t2) == true); + static_assert(get_if<0>(&t2) != nullptr); + static_assert(get_if(&t2) != nullptr); + static_assert(get_if<1>(&t2) == nullptr); + static_assert(get_if(&t2) == nullptr); + static_assert(get_if<2>(&t2) == nullptr); + static_assert(get_if(&t2) == nullptr); + + constexpr test t3{11}; + static_assert(*get_if<1>(&t3) == 11); + static_assert(get_if<0>(&t3) == nullptr); + static_assert(get_if(&t3) == nullptr); + static_assert(get_if<1>(&t3) != nullptr); + static_assert(get_if(&t3) != nullptr); + static_assert(get_if<2>(&t3) == nullptr); + static_assert(get_if(&t3) == nullptr); + + constexpr test t4{22.22}; + static_assert(*get_if<2>(&t4) == 22.22); + static_assert(get_if<0>(&t4) == nullptr); + static_assert(get_if(&t4) == nullptr); + static_assert(get_if<1>(&t4) == nullptr); + static_assert(get_if(&t4) == nullptr); + static_assert(get_if<2>(&t4) != nullptr); + static_assert(get_if(&t4) != nullptr); +} + +void test_get() +{ + using test = variant; + + test t1{false}; + get<0>(t1) = true; + assert(get<0>(t1) == true); + + test t2{std::string{}}; + get<3>(t2) = "ABCDEFG"; + assert(get<3>(t2) == "ABCDEFG"); + + const test t3{1}; + assert(get<1>(t3) == 1); +} + +void test_get_if() +{ + using test = variant; + + test t1{false}; + *get_if<0>(&t1) = true; + assert(*get_if<0>(&t1) == true); + + test t2{std::string{}}; + *get_if<3>(&t2) = "ABCDEFG"; + assert(*get_if<3>(&t2) == "ABCDEFG"); + + const test t3{1}; + assert(*get_if<1>(&t3) == 1); +} + +int main() +{ + test_constexpr_get(); + test_constexpr_get_if(); + test_get(); + // test_get_if(); +} Index: test/std/experimental/variant/variant.general/variant.monostate/monostate.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.general/variant.monostate/monostate.pass.cpp @@ -0,0 +1,34 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::monostate; +using std::experimental::holds_alternative; + +struct foo +{ + foo() = delete; + foo(const foo&) = delete; + foo(foo&&) = delete; + foo(bool){} + virtual ~foo(){} +}; + +int main() +{ + variant v; + assert(holds_alternative(v)); + v.emplace(true); + assert(holds_alternative(v)); +} Index: test/std/experimental/variant/variant.general/variant.relops/equal_to.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.general/variant.relops/equal_to.pass.cpp @@ -0,0 +1,31 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include + +using std::experimental::variant; + +void test_comple_time_equal_to() +{ + using test = variant; + constexpr test t1{1}; + constexpr test t2{1}; + constexpr test t3{true}; + static_assert(t1 == t2); + static_assert(!(t1 != t2)); + static_assert(!(t1 == t3)); + static_assert(t2 != t3); +} + +int main() +{ + test_comple_time_equal_to(); +} Index: test/std/experimental/variant/variant.general/variant.specalg/swap.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.general/variant.specalg/swap.pass.cpp @@ -0,0 +1,30 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include + +using std::experimental::variant; +using std::experimental::get; +using std::experimental::swap; + +struct foo{}; + +int main() +{ + variant v1, v2; + v1 = 123456u; + v2 = 'A'; + assert(get<1>(v1) == 123456u); + assert(get<3>(v2) == 'A'); + swap(v1,v2); + assert(get<1>(v2) == 123456u); + assert(get<3>(v1) == 'A'); +} Index: test/std/experimental/variant/variant.general/variant.traits/uses_allocator.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.general/variant.traits/uses_allocator.pass.cpp @@ -0,0 +1,25 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include + +using std::experimental::variant; +using std::uses_allocator_v; + +int main() +{ + struct foo {}; + static_assert(uses_allocator_v,std::allocator>); + static_assert(uses_allocator_v,std::allocator>); + static_assert(uses_allocator_v,std::allocator>); + static_assert(uses_allocator_v,std::allocator>); + static_assert(uses_allocator_v,std::allocator>); +} Index: test/std/experimental/variant/variant.general/variant.visit/visit.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.general/variant.visit/visit.pass.cpp @@ -0,0 +1,117 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include +#include +#include + +using std::experimental::variant; +using std::experimental::monostate; +using std::experimental::visit; + +using test = variant; + +struct visitor +{ + bool operator () (bool b1, bool b2, bool b3) + { + call = "bool"; + std::cout << call << "\n"; + return true; + } + bool operator () (int i1, int i2, int i3) + { + call = "int"; + std::cout << call << "\n"; + return true; + } + bool operator () (double d1, double d2, double d3) + { + call = "double"; + std::cout << call << "\n"; + return true; + } + bool operator () (const std::string& str1, const std::string& str2, const std::string& str3) + { + call = "string"; + std::cout << call << "\n"; + return true; + } + std::string call; +}; + +void test_functor() +{ + visitor vis; + test var1, var2, var3; + + var1 = var2 = var3 = true; + visit(vis, var1, var2, var3); + assert(vis.call == "bool"); + + var1 = var2 = var3 = 13; + visit(vis, var1, var2, var3); + assert(vis.call == "int"); + + var1 = var2 = var3 = 21.12; + visit(vis, var1, var2, var3); + assert(vis.call == "double"); + + var1 = var2 = var3 = std::string{}; + visit(vis, var1, var2, var3); + assert(vis.call == "string"); +} + +void test_lambda() +{ + std::string call; + test var1, var2; + + var1 = var2 = true; + visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2); + assert(call == "x"); + + var1 = var2 = 13; + visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2); + assert(call == "xx"); + + var1 = var2 = 21.12; + visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2); + assert(call == "xxx"); + + var1 = var2 = std::string{"Hello!"}; + visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2); + assert(call == "xxxx"); +} + +void test_complex() +{ + using type = variant; + + const auto value = type{}; + + visit([](const auto& arg){return "pöö";}, value); +} + +int main() +{ + test_functor(); + test_lambda(); + test_complex(); +} Index: test/std/experimental/variant/variant.variant/variant.assign/assignment.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.assign/assignment.pass.cpp @@ -0,0 +1,66 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::get; + +void test_copy_assign() +{ + variant v1, v2; + + v1 = 21.12; + assert(get(v1) == 21.12); + assert(get<3>(v1) == 21.12); + + v2 = v1; + assert(get(v2) == 21.12); + assert(get<3>(v2) == 21.12); +} + +void test_move_assign() +{ + variant v; + v = variant{std::string{"rush"}}; + + assert(get(v) == "rush"); + assert(get<2>(v) == "rush"); +} + +void test_alternative_assign() +{ + variant v; + + v = 13; + assert(get(v) == 13); + assert(get<0>(v) == 13); + + v = false; + assert(get(v) == false); + assert(get<1>(v) == false); + + v = std::string{"abc"}; + assert(get(v) == "abc"); + assert(get<2>(v) == "abc"); + + v = 21.12; + assert(get(v) == 21.12); + assert(get<3>(v) == 21.12); +} + +int main() +{ + test_copy_assign(); + test_move_assign(); + test_alternative_assign(); +} Index: test/std/experimental/variant/variant.variant/variant.assign/copy.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.assign/copy.pass.cpp @@ -0,0 +1,37 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include + +using std::experimental::variant; + +struct foo +{ + foo& operator = (const foo&) = default; +}; + +struct bar +{ + bar& operator = (const bar&) = delete; +}; + +int main() +{ + static_assert(std::is_copy_assignable_v>); + static_assert(std::is_copy_assignable_v>); + static_assert(std::is_copy_assignable_v>); + static_assert(std::is_copy_assignable_v>); + + static_assert(!std::is_copy_assignable_v>); + static_assert(!std::is_copy_assignable_v>); + static_assert(!std::is_copy_assignable_v>); + static_assert(!std::is_copy_assignable_v>); +} Index: test/std/experimental/variant/variant.variant/variant.assign/move.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.assign/move.pass.cpp @@ -0,0 +1,37 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include + +using std::experimental::variant; + +struct foo +{ + foo& operator = (foo&&) = default; +}; + +struct bar +{ + bar& operator = (bar&&) = delete; +}; + +int main() +{ + static_assert(std::is_move_assignable_v>); + static_assert(std::is_move_assignable_v>); + static_assert(std::is_move_assignable_v>); + static_assert(std::is_move_assignable_v>); + + static_assert(!std::is_move_assignable_v>); + static_assert(!std::is_move_assignable_v>); + static_assert(!std::is_move_assignable_v>); + static_assert(!std::is_move_assignable_v>); +} Index: test/std/experimental/variant/variant.variant/variant.ctor/allocators.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.ctor/allocators.pass.cpp @@ -0,0 +1,101 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include +#include +#include + +using std::experimental::variant; +using std::experimental::get; + +struct foo +{ + foo(const foo&) = default; + foo(foo&&) = default; +}; + +struct bar +{ + bar() = delete; + bar(const bar&) = delete; + bar(bar&&) = delete; +}; + +void test_type_traits() +{ + // Default + static_assert(std::is_constructible_v, std::allocator_arg_t, std::allocator, foo>); + static_assert(!std::is_constructible_v, std::allocator_arg_t, std::allocator, bar>); + + // Copy + static_assert(std::is_constructible_v, std::allocator_arg_t, std::allocator, variant&>); + static_assert(!std::is_constructible_v, std::allocator_arg_t, std::allocator, variant&>); + + // Move + static_assert(std::is_constructible_v, std::allocator_arg_t, std::allocator, variant&&>); + static_assert(!std::is_constructible_v, std::allocator_arg_t, const std::allocator&, variant&&>); +} + +void test_constructors() +{ + using variant = variant,std::string>; + std::allocator a; + + variant v1{std::allocator_arg_t{}, a}; + assert(v1.index() == 0); + assert(get<0>(v1) == false); + + variant v2{std::allocator_arg_t{}, a, 1}; + assert(v2.index() == 1); + assert(get<1>(v2) == 1); + + variant v3{std::allocator_arg_t{}, a, 2.2}; + assert(v3.index() == 2); + assert(get<2>(v3) == 2.2); + + variant v4{std::allocator_arg_t{}, a, std::in_place_type>, {1,2,3,4,5,6,7}}; + assert(v4.index() == 3); + assert(get<3>(v4).size() == 7); + + variant v5{std::allocator_arg_t{}, a, std::in_place_index<3>, {1,2,3,4,5,6,7,8}}; + assert(v5.index() == 3); + assert(get<3>(v5).size() == 8); + + variant v6{std::allocator_arg_t{}, a, std::in_place_type, "foo"}; + assert(v6.index() == 4); + assert(get<4>(v6) == "foo"); + + variant v7{std::allocator_arg_t{}, a, std::in_place_index<4>, "bar"}; + assert(v7.index() == 4); + assert(get<4>(v7) == "bar"); + + variant v8{std::allocator_arg_t{}, a, std::in_place_type, {'a','b','c','d'}}; + assert(v8.index() == 4); + assert(get<4>(v8) == "abcd"); + + variant v9{std::allocator_arg_t{}, a, std::in_place_index<4>, std::size_t{10}, 'a'}; + assert(v9.index() == 4); + assert(get<4>(v9) == "aaaaaaaaaa"); + + variant v22{std::allocator_arg_t{}, a, v2}; + assert(v22.index() == 1); + assert(get<1>(v22) == 1); + + variant v23{std::allocator_arg_t{}, a, std::move(v3)}; + assert(v23.index() == 2); + assert(get<2>(v23) == 2.2); +} + +int main() +{ + test_type_traits(); + test_constructors(); +} Index: test/std/experimental/variant/variant.variant/variant.ctor/constexpr.fail.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.ctor/constexpr.fail.cpp @@ -0,0 +1,20 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include +#include + +using std::experimental::variant; + +int main() +{ + // constexpr variant> v1{}; +} Index: test/std/experimental/variant/variant.variant/variant.ctor/constexpr.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.ctor/constexpr.pass.cpp @@ -0,0 +1,31 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include +#include + +using std::experimental::variant; + +int main() +{ + using test = variant; + constexpr test t1{}; + static_assert(t1.index() == 0); + + constexpr test t2{true}; + static_assert(t2.index() == 0); + + constexpr test t3{1}; + static_assert(t3.index() == 1); + + constexpr test t4{2.2}; + static_assert(t4.index() == 2); +} Index: test/std/experimental/variant/variant.variant/variant.ctor/conversions.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.ctor/conversions.pass.cpp @@ -0,0 +1,56 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include +#include + +using std::experimental::variant; + +struct foo +{ + foo() noexcept = default; + foo(const foo&) noexcept = default; + foo(foo&&) noexcept = default; +}; + +struct bar +{ + bar() = delete; + bar(const bar&) = delete; + bar(bar&&) = delete; +}; + +void test_type_traits() +{ + // Well formed + static_assert(std::is_nothrow_constructible_v,foo>); + static_assert(std::is_nothrow_constructible_v,int>); + static_assert(std::is_nothrow_constructible_v,bool>); + + static_assert(!std::is_nothrow_constructible_v,bar>); + static_assert(std::is_nothrow_constructible_v,double>); + static_assert(!std::is_nothrow_constructible_v,bar>); + + static_assert(std::is_constructible_v,std::string>); + static_assert(std::is_constructible_v,const std::string&>); + static_assert(std::is_constructible_v,std::string&&>); + static_assert(std::is_constructible_v,char*>); + static_assert(std::is_constructible_v,const char*>); + + // Ill formed + static_assert(!std::is_nothrow_constructible_v,bool>); + static_assert(!std::is_nothrow_constructible_v,const char*>); +} + +int main() +{ + test_type_traits(); +} Index: test/std/experimental/variant/variant.variant/variant.ctor/copy.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.ctor/copy.pass.cpp @@ -0,0 +1,37 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include + +using std::experimental::variant; + +struct foo +{ + foo(const foo&) = default; +}; + +struct bar +{ + bar(const bar&) = delete; +}; + +int main() +{ + static_assert(std::is_copy_constructible_v>); + static_assert(std::is_copy_constructible_v>); + static_assert(std::is_copy_constructible_v>); + static_assert(std::is_copy_constructible_v>); + + static_assert(!std::is_copy_constructible_v>); + static_assert(!std::is_copy_constructible_v>); + static_assert(!std::is_copy_constructible_v>); + static_assert(!std::is_copy_constructible_v>); +} Index: test/std/experimental/variant/variant.variant/variant.ctor/default.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.ctor/default.pass.cpp @@ -0,0 +1,65 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include + +using std::experimental::variant; +using std::experimental::holds_alternative; + +struct foo +{ + foo() noexcept = default; +}; + +struct bar +{ + bar() = delete; + ~bar() = default; +}; + +void test_type_traits() +{ + static_assert(std::is_default_constructible_v>); + static_assert(std::is_default_constructible_v>); + static_assert(std::is_default_constructible_v>); + + static_assert(std::is_nothrow_default_constructible_v>); + static_assert(std::is_nothrow_default_constructible_v>); + static_assert(std::is_nothrow_default_constructible_v>); + + static_assert(!std::is_default_constructible_v>); + static_assert(std::is_default_constructible_v>); + static_assert(!std::is_default_constructible_v>); + + static_assert(!std::is_nothrow_default_constructible_v>); + static_assert(std::is_nothrow_default_constructible_v>); + static_assert(!std::is_nothrow_default_constructible_v>); + + static_assert(std::is_nothrow_default_constructible_v>); + static_assert(!std::is_nothrow_default_constructible_v>); +} + +void test_constructors() +{ + constexpr variant v1; + static_assert(v1.index() == 0); + static_assert(holds_alternative(v1)); + + constexpr variant v2; + static_assert(v2.index() == 0); + static_assert(holds_alternative(v2)); +} + +int main() +{ + test_type_traits(); + test_constructors(); +} Index: test/std/experimental/variant/variant.variant/variant.ctor/move.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.ctor/move.pass.cpp @@ -0,0 +1,59 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::holds_alternative; +using std::experimental::variant_npos; + +struct foo +{ + foo(foo&&) = default; +}; + +struct bar +{ + bar(bar&&) = delete; +}; + +void test_type_traits() +{ + static_assert(std::is_move_constructible_v>); + static_assert(std::is_move_constructible_v>); + static_assert(std::is_move_constructible_v>); + static_assert(std::is_move_constructible_v>); + + static_assert(!std::is_move_constructible_v>); + static_assert(!std::is_move_constructible_v>); + static_assert(!std::is_move_constructible_v>); + static_assert(!std::is_move_constructible_v>); +} + +void test_constructors() +{ + variant v1{2.2}; + assert(v1.index() == 2); + assert(holds_alternative(v1)); + + variant v2{std::move(v1)}; + assert(v2.index() == 2); + assert(holds_alternative(v2)); + + std::cout << v1.index() << " vs " << variant_npos << std::endl; +} + +int main() +{ + test_type_traits(); + test_constructors(); +} Index: test/std/experimental/variant/variant.variant/variant.dtor/dtor.pss.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.dtor/dtor.pss.cpp @@ -0,0 +1,40 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include + +using std::experimental::variant; + +static int count = 0; + +struct foo +{ + ~foo() = default; +}; + +struct bar +{ + bar() {++count;} // count == 1 + ~bar(){++count;} // count == 2 +}; + +int main() +{ + static_assert(std::is_trivially_destructible_v> == true); + + static_assert(std::is_trivially_destructible_v> == false); + + assert(count == 0); + { + variant v{std::in_place_type}; + assert(count == 1); + } + assert(count == 2); +} Index: test/std/experimental/variant/variant.variant/variant.mod/emplace.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.mod/emplace.pass.cpp @@ -0,0 +1,35 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include + +using std::experimental::variant; + +static int count = 0; + +struct foo +{ + foo(int) {++count;} // count == 1 + ~foo(){++count;} // count == 2 +}; + +int main() +{ + variant v{}; + assert(count == 0); + v.emplace(13); + assert(count == 1); + v.emplace(true); + assert(count == 2); + v.emplace(13); + assert(count == 3); + v.emplace(true); + assert(count == 4); +} Index: test/std/experimental/variant/variant.variant/variant.status/index.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.status/index.pass.cpp @@ -0,0 +1,46 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include + +using std::experimental::variant; + +void test_ctor() +{ + using test = variant; + constexpr test t1{}; + static_assert(t1.index() == 0); + constexpr test t2{true}; + static_assert(t2.index() == 0); + constexpr test t3{1}; + static_assert(t3.index() == 1); + constexpr test t4{2.2}; + static_assert(t4.index() == 2); +} + +void test_assign() +{ + using test = variant; + test t1{}; + assert(t1.index() == 0); + t1 = true; + assert(t1.index() == 0); + t1 = 1; + assert(t1.index() == 1); + t1 = 2.2; + assert(t1.index() == 2); +} + +int main() +{ + test_ctor(); + test_assign(); +} Index: test/std/experimental/variant/variant.variant/variant.swap/swap.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant.variant/variant.swap/swap.pass.cpp @@ -0,0 +1,29 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include +#include + +using std::experimental::variant; +using std::experimental::get; + +struct foo{}; + +int main() +{ + variant v1, v2; + v1 = 123456u; + v2 = 'A'; + assert(get<1>(v1) == 123456u); + assert(get<3>(v2) == 'A'); + v1.swap(v2); + assert(get<1>(v2) == 123456u); + assert(get<3>(v1) == 'A'); +} Index: test/std/experimental/variant/variant/variant.general/variant.hash/hash.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.general/variant.hash/hash.pass.cpp @@ -0,0 +1,37 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include + +using std::experimental::variant; + +struct foo{}; + +int main() +{ + std::hash> hv; + std::hash hu; + std::hash hd; + std::hash hc; + + variant v; + + v = 123u; + assert(hv(v) == hu(123u)); + + v = 123.456; + assert(hv(v) == hd(123.456)); + + v = 'R'; + assert(hv(v) == hc('R')); +} Index: test/std/experimental/variant/variant/variant.general/variant.helper/helper.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.general/variant.helper/helper.pass.cpp @@ -0,0 +1,26 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::variant_size_v; +using std::experimental::variant_alternative_t; + +int main() +{ + using V = variant>; + static_assert(variant_size_v == 6); + static_assert(std::is_same_v, std::vector>); +} Index: test/std/experimental/variant/variant/variant.general/variant.bad.access/bad_variant_access.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.general/variant.bad.access/bad_variant_access.pass.cpp @@ -0,0 +1,59 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include + +using std::experimental::variant; +using std::experimental::get; +using std::experimental::bad_variant_access; + +int main() +{ + try + { + variant v{9u}; + get(v); + assert(false); + } + catch(bad_variant_access& bad) + {} + + try + { + variant v{9u}; + get<2>(v); + assert(false); + } + catch(bad_variant_access& bad) + {} + + try + { + variant v{9u}; + get(v); + } + catch(bad_variant_access& bad) + { + assert(false); + } + + try + { + variant v{9u}; + get<0>(v); + } + catch(bad_variant_access& bad) + { + assert(false); + } + } Index: test/std/experimental/variant/variant/variant.general/variant.get/get.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.general/variant.get/get.pass.cpp @@ -0,0 +1,137 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::get; +using std::experimental::get_if; + +void test_constexpr_get() +{ + using test = variant; + + constexpr test t1{}; + static_assert(get<0>(t1) == false); + static_assert(get(t1) == false); + + constexpr test t2{true}; + static_assert(get<0>(t2) == true); + static_assert(get(t2) == true); + + constexpr test t3{11}; + static_assert(get<1>(t3) == 11); + static_assert(get(t3) == 11); + + constexpr test t4{22.22}; + static_assert(get<2>(t4) == 22.22); + static_assert(get(t4) == 22.22); + + static_assert(get<2>(test{3.3}) == 3.3); +} + +void test_constexpr_get_if() +{ + using test = variant; + + constexpr test t1{}; + static_assert(get_if<0>(&t1) != nullptr); + static_assert(get_if(&t1) != nullptr); + static_assert(get_if<1>(&t1) == nullptr); + static_assert(get_if(&t1) == nullptr); + static_assert(get_if<2>(&t1) == nullptr); + static_assert(get_if(&t1) == nullptr); + + constexpr test t2{true}; + static_assert(*get_if<0>(&t2) == true); + static_assert(get_if<0>(&t2) != nullptr); + static_assert(get_if(&t2) != nullptr); + static_assert(get_if<1>(&t2) == nullptr); + static_assert(get_if(&t2) == nullptr); + static_assert(get_if<2>(&t2) == nullptr); + static_assert(get_if(&t2) == nullptr); + + constexpr test t3{11}; + static_assert(*get_if<1>(&t3) == 11); + static_assert(get_if<0>(&t3) == nullptr); + static_assert(get_if(&t3) == nullptr); + static_assert(get_if<1>(&t3) != nullptr); + static_assert(get_if(&t3) != nullptr); + static_assert(get_if<2>(&t3) == nullptr); + static_assert(get_if(&t3) == nullptr); + + constexpr test t4{22.22}; + static_assert(*get_if<2>(&t4) == 22.22); + static_assert(get_if<0>(&t4) == nullptr); + static_assert(get_if(&t4) == nullptr); + static_assert(get_if<1>(&t4) == nullptr); + static_assert(get_if(&t4) == nullptr); + static_assert(get_if<2>(&t4) != nullptr); + static_assert(get_if(&t4) != nullptr); +} + +void test_get() +{ + using test = variant; + + test t1{false}; + get<0>(t1) = true; + assert(get<0>(t1) == true); + + test t2{std::string{}}; + get<3>(t2) = "ABCDEFG"; + assert(get<3>(t2) == "ABCDEFG"); + + const test t3{1}; + assert(get<1>(t3) == 1); +} + +void test_get_if() +{ + using test = variant; + + test t1{false}; + *get_if<0>(&t1) = true; + assert(*get_if<0>(&t1) == true); + + test t2{std::string{}}; + *get_if<3>(&t2) = "ABCDEFG"; + assert(*get_if<3>(&t2) == "ABCDEFG"); + + const test t3{1}; + assert(*get_if<1>(&t3) == 1); +} + +void test_get_odds() +{ + auto vola1 = variant{33}; + assert(get(vola1) == 33); + + variant vola2{"Variant"}; + assert(get(vola2) == std::string{"Variant"}); + assert(get<2>(vola2) == std::string{"Variant"}); + + auto vola3 = variant{44}; + assert(get(vola3) == 44); + assert(get<2>(vola3) == 44); +} + +int main() +{ + test_constexpr_get(); + test_constexpr_get_if(); + test_get(); + test_get_if(); + test_get_odds(); +} Index: test/std/experimental/variant/variant/variant.general/variant.monostate/monostate.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.general/variant.monostate/monostate.pass.cpp @@ -0,0 +1,36 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::monostate; +using std::experimental::holds_alternative; + +struct foo +{ + foo() = delete; + foo(const foo&) = delete; + foo(foo&&) = delete; + foo(bool){} + virtual ~foo(){} +}; + +int main() +{ + variant v; + assert(holds_alternative(v)); + v.emplace(true); + assert(holds_alternative(v)); +} Index: test/std/experimental/variant/variant/variant.general/variant.relops/equal_to.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.general/variant.relops/equal_to.pass.cpp @@ -0,0 +1,33 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include + +using std::experimental::variant; + +void test_comple_time_equal_to() +{ + using test = variant; + constexpr test t1{1}; + constexpr test t2{1}; + constexpr test t3{true}; + static_assert(t1 == t2); + static_assert(!(t1 != t2)); + static_assert(!(t1 == t3)); + static_assert(t2 != t3); +} + +int main() +{ + test_comple_time_equal_to(); +} Index: test/std/experimental/variant/variant/variant.general/variant.specalg/swap.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.general/variant.specalg/swap.pass.cpp @@ -0,0 +1,32 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include + +using std::experimental::variant; +using std::experimental::get; +using std::experimental::swap; + +struct foo{}; + +int main() +{ + variant v1, v2; + v1 = 123456u; + v2 = 'A'; + assert(get<1>(v1) == 123456u); + assert(get<3>(v2) == 'A'); + swap(v1,v2); + assert(get<1>(v2) == 123456u); + assert(get<3>(v1) == 'A'); +} Index: test/std/experimental/variant/variant/variant.general/variant.traits/uses_allocator.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.general/variant.traits/uses_allocator.pass.cpp @@ -0,0 +1,27 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include + +using std::experimental::variant; +using std::uses_allocator_v; + +int main() +{ + struct foo {}; + static_assert(uses_allocator_v,std::allocator>); + static_assert(uses_allocator_v,std::allocator>); + static_assert(uses_allocator_v,std::allocator>); + static_assert(uses_allocator_v,std::allocator>); + static_assert(uses_allocator_v,std::allocator>); +} Index: test/std/experimental/variant/variant/variant.general/variant.visit/visit.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.general/variant.visit/visit.pass.cpp @@ -0,0 +1,119 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include +#include +#include + +using std::experimental::variant; +using std::experimental::monostate; +using std::experimental::visit; + +using test = variant; + +struct visitor +{ + bool operator () (bool b1, bool b2, bool b3) + { + call = "bool"; + std::cout << call << "\n"; + return true; + } + bool operator () (int i1, int i2, int i3) + { + call = "int"; + std::cout << call << "\n"; + return true; + } + bool operator () (double d1, double d2, double d3) + { + call = "double"; + std::cout << call << "\n"; + return true; + } + bool operator () (const std::string& str1, const std::string& str2, const std::string& str3) + { + call = "string"; + std::cout << call << "\n"; + return true; + } + std::string call; +}; + +void test_functor() +{ + visitor vis; + test var1, var2, var3; + + var1 = var2 = var3 = true; + visit(vis, var1, var2, var3); + assert(vis.call == "bool"); + + var1 = var2 = var3 = 13; + visit(vis, var1, var2, var3); + assert(vis.call == "int"); + + var1 = var2 = var3 = 21.12; + visit(vis, var1, var2, var3); + assert(vis.call == "double"); + + var1 = var2 = var3 = std::string{}; + visit(vis, var1, var2, var3); + assert(vis.call == "string"); +} + +void test_lambda() +{ + std::string call; + test var1, var2; + + var1 = var2 = true; + visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2); + assert(call == "x"); + + var1 = var2 = 13; + visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2); + assert(call == "xx"); + + var1 = var2 = 21.12; + visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2); + assert(call == "xxx"); + + var1 = var2 = std::string{"Hello!"}; + visit([&call](const auto& arg1,const auto& arg2){call += "x";std::cout << arg1 << "\n";}, var1, var2); + assert(call == "xxxx"); +} + +void test_complex() +{ + using type = variant; + + const auto value = type{}; + + visit([](const auto& arg){return "pöö";}, value); +} + +int main() +{ + test_functor(); + test_lambda(); + test_complex(); +} Index: test/std/experimental/variant/variant/variant.variant/variant.assign/assignment.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.assign/assignment.pass.cpp @@ -0,0 +1,120 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::get; +using std::experimental::holds_alternative; + +void test_copy_assign() +{ + variant v1, v2; + + v1 = 21.12; + assert(get(v1) == 21.12); + assert(get<3>(v1) == 21.12); + + v2 = v1; + assert(get(v2) == 21.12); + assert(get<3>(v2) == 21.12); +} + +void test_move_assign() +{ + variant v; + v = variant{std::string{"rush"}}; + assert(get(v) == "rush"); + assert(get<2>(v) == "rush"); +} + +void test_alternative_assign() +{ + variant v; + + v = 13; + assert(get(v) == 13); + assert(get<0>(v) == 13); + + v = false; + assert(get(v) == false); + assert(get<1>(v) == false); + + v = std::string{"abc"}; + assert(get(v) == "abc"); + assert(get<2>(v) == "abc"); + + v = 21.12; + assert(get(v) == 21.12); + assert(get<3>(v) == 21.12); + + v = short{2}; + assert(get(v) == 2); + assert(get<0>(v) == 2); +} + +void test_string_assign() +{ + auto v1 = variant,std::string>{}; + v1 = "Test 123 456?"; + assert(get(v1) == "Test 123 456?"); + assert(get<1>(v1) == "Test 123 456?"); + + auto v2 = variant,std::string>{}; + v2 = "Test 123 456?"; + assert(get(v2) == "Test 123 456?"); + assert(get<1>(v2) == "Test 123 456?"); +} + +void test_pointer_assignent() +{ + auto v = variant{}; + auto i = 13; + auto b = false; + auto str = std::string{"TEST123"}; + auto d = 21.12; + + v = &i; + assert(v.index() == 0); + assert(holds_alternative(v)); + assert(*get(v) == i); + assert(*get<0>(v) == i); + + v = &b; + assert(v.index() == 1); + assert(holds_alternative(v)); + assert(*get(v) == b); + assert(*get<1>(v) == b); + + v = &str; + assert(v.index() == 2); + assert(holds_alternative(v)); + assert(*get(v) == str); + assert(*get<2>(v) == str); + + v = &d; + assert(v.index() == 3); + assert(holds_alternative(v)); + assert(*get(v) == d); + assert(*get<3>(v) == d); +} + +int main() +{ + test_copy_assign(); + test_move_assign(); + test_alternative_assign(); + test_string_assign(); + test_pointer_assignent(); +} Index: test/std/experimental/variant/variant/variant.variant/variant.assign/copy.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.assign/copy.pass.cpp @@ -0,0 +1,39 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include + +using std::experimental::variant; + +struct foo +{ + foo& operator = (const foo&) = default; +}; + +struct bar +{ + bar& operator = (const bar&) = delete; +}; + +int main() +{ + static_assert(std::is_copy_assignable_v>); + static_assert(std::is_copy_assignable_v>); + static_assert(std::is_copy_assignable_v>); + static_assert(std::is_copy_assignable_v>); + + static_assert(!std::is_copy_assignable_v>); + static_assert(!std::is_copy_assignable_v>); + static_assert(!std::is_copy_assignable_v>); + static_assert(!std::is_copy_assignable_v>); +} Index: test/std/experimental/variant/variant/variant.variant/variant.assign/move.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.assign/move.pass.cpp @@ -0,0 +1,39 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include + +using std::experimental::variant; + +struct foo +{ + foo& operator = (foo&&) = default; +}; + +struct bar +{ + bar& operator = (bar&&) = delete; +}; + +int main() +{ + static_assert(std::is_move_assignable_v>); + static_assert(std::is_move_assignable_v>); + static_assert(std::is_move_assignable_v>); + static_assert(std::is_move_assignable_v>); + + static_assert(!std::is_move_assignable_v>); + static_assert(!std::is_move_assignable_v>); + static_assert(!std::is_move_assignable_v>); + static_assert(!std::is_move_assignable_v>); +} Index: test/std/experimental/variant/variant/variant.variant/variant.ctor/allocators.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.ctor/allocators.pass.cpp @@ -0,0 +1,127 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include +#include +#include + +using std::experimental::variant; +using std::experimental::get; + +struct foo +{ + foo(const foo&) = default; + foo(foo&&) = default; +}; + +struct bar +{ + bar() = delete; + bar(const bar&) = delete; + bar(bar&&) = delete; +}; + +void test_type_traits() +{ + // Default + static_assert(std::is_constructible_v, std::allocator_arg_t, std::allocator, foo>); + static_assert(!std::is_constructible_v, std::allocator_arg_t, std::allocator, bar>); + + // Copy + static_assert(std::is_constructible_v, std::allocator_arg_t, std::allocator, variant&>); + static_assert(!std::is_constructible_v, std::allocator_arg_t, std::allocator, variant&>); + + // Move + static_assert(std::is_constructible_v, std::allocator_arg_t, std::allocator, variant&&>); + static_assert(!std::is_constructible_v, std::allocator_arg_t, const std::allocator&, variant&&>); +} + +void test_constructors_1() +{ + using variant = variant,std::string>; + std::allocator a; + + variant v1{std::allocator_arg_t{}, a}; + assert(v1.index() == 0); + assert(get<0>(v1) == false); + + variant v2{std::allocator_arg_t{}, a, 1l}; + assert(v2.index() == 1); + assert(get<1>(v2) == 1); + + variant v3{std::allocator_arg_t{}, a, 2.2}; + assert(v3.index() == 2); + assert(get<2>(v3) == 2.2); + + variant v4{std::allocator_arg_t{}, a, std::in_place_type>, {1,2,3,4,5,6,7}}; + assert(v4.index() == 3); + assert(get<3>(v4).size() == 7); + assert(get<3>(v4)[3] == 4); + + variant v5{std::allocator_arg_t{}, a, std::in_place_index<3>, {1,2,3,4,5,6,7,8}}; + assert(v5.index() == 3); + assert(get<3>(v5).size() == 8); + + variant v6{std::allocator_arg_t{}, a, std::in_place_type, "foo"}; + assert(v6.index() == 4); + assert(get<4>(v6) == "foo"); + + variant v7{std::allocator_arg_t{}, a, std::in_place_index<4>, "bar"}; + assert(v7.index() == 4); + assert(get<4>(v7) == "bar"); + + variant v8{std::allocator_arg_t{}, a, std::in_place_type, {'a','b','c','d'}}; + assert(v8.index() == 4); + assert(get<4>(v8) == "abcd"); + + variant v9{std::allocator_arg_t{}, a, std::in_place_index<4>, std::size_t{10}, 'a'}; + assert(v9.index() == 4); + assert(get<4>(v9) == "aaaaaaaaaa"); + + variant v22{std::allocator_arg_t{}, a, v2}; + assert(v22.index() == 1); + assert(get<1>(v22) == 1); + + variant v23{std::allocator_arg_t{}, a, std::move(v3)}; + assert(v23.index() == 2); + assert(get<2>(v23) == 2.2); + + variant v30{std::allocator_arg_t{}, a, std::string{"test"}}; + assert(v30.index() == 4); + assert(get<4>(v30) == "test"); +} + +void test_constructors_2() +{ + using variant = variant,std::string>; + std::allocator a; + + variant v31{std::allocator_arg_t{}, a, short{31}}; + assert(v31.index() == 0); + assert(get<0>(v31) == 31); + + variant v32{std::allocator_arg_t{}, a, int{32}}; + assert(v32.index() == 0); + assert(get<0>(v32) == 32); + + variant v33{std::allocator_arg_t{}, a, unsigned{33}}; + assert(v33.index() == 0); + assert(get<0>(v33) == 33); +} + +int main() +{ + test_type_traits(); + test_constructors_1(); + test_constructors_2(); +} Index: test/std/experimental/variant/variant/variant.variant/variant.ctor/constexpr.fail.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.ctor/constexpr.fail.cpp @@ -0,0 +1,22 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include +#include + +using std::experimental::variant; + +int main() +{ + // constexpr variant> v1{}; +} Index: test/std/experimental/variant/variant/variant.variant/variant.ctor/constexpr.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.ctor/constexpr.pass.cpp @@ -0,0 +1,33 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include +#include + +using std::experimental::variant; + +int main() +{ + using test = variant; + constexpr test t1{}; + static_assert(t1.index() == 0); + + constexpr test t2{true}; + static_assert(t2.index() == 0); + + constexpr test t3{1}; + static_assert(t3.index() == 1); + + constexpr test t4{2.2}; + static_assert(t4.index() == 2); +} Index: test/std/experimental/variant/variant/variant.variant/variant.ctor/conversions.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.ctor/conversions.pass.cpp @@ -0,0 +1,78 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::get; + +struct foo +{ + foo() noexcept = default; + foo(const foo&) noexcept = default; + foo(foo&&) noexcept = default; +}; + +struct bar +{ + bar() = delete; + bar(const bar&) = delete; + bar(bar&&) = delete; +}; + +void test_type_traits() +{ + // Well formed + static_assert(std::is_nothrow_constructible_v,foo>); + static_assert(std::is_nothrow_constructible_v,int>); + static_assert(std::is_nothrow_constructible_v,bool>); + + static_assert(!std::is_nothrow_constructible_v,bar>); + static_assert(std::is_nothrow_constructible_v,double>); + static_assert(!std::is_nothrow_constructible_v,bar>); + + static_assert(std::is_constructible_v,std::string>); + static_assert(std::is_constructible_v,const std::string&>); + static_assert(std::is_constructible_v,std::string&&>); + static_assert(std::is_constructible_v,char*>); + static_assert(std::is_constructible_v,const char*>); + + // Ill formed + static_assert(!std::is_nothrow_constructible_v,bool>); + static_assert(!std::is_nothrow_constructible_v,const char*>); +} + +void test_odds() +{ + auto i = 13; + variant odd1{std::in_place_type, i}; + assert(odd1.index() == 1); + assert(get<1>(odd1) == i); + + const auto str = std::string{"Jee!"}; + variant odd2{std::in_place_type, str}; + assert(odd2.index() == 3); + assert(get<3>(odd2) == str); + + auto b = false; + variant odd3{std::in_place_type, &b}; + assert(odd3.index() == 0); + assert(*get<0>(odd3) == b); +} + +int main() +{ + test_type_traits(); + test_odds(); +} Index: test/std/experimental/variant/variant/variant.variant/variant.ctor/copy.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.ctor/copy.pass.cpp @@ -0,0 +1,39 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include + +using std::experimental::variant; + +struct foo +{ + foo(const foo&) = default; +}; + +struct bar +{ + bar(const bar&) = delete; +}; + +int main() +{ + static_assert(std::is_copy_constructible_v>); + static_assert(std::is_copy_constructible_v>); + static_assert(std::is_copy_constructible_v>); + static_assert(std::is_copy_constructible_v>); + + static_assert(!std::is_copy_constructible_v>); + static_assert(!std::is_copy_constructible_v>); + static_assert(!std::is_copy_constructible_v>); + static_assert(!std::is_copy_constructible_v>); +} Index: test/std/experimental/variant/variant/variant.variant/variant.ctor/default.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.ctor/default.pass.cpp @@ -0,0 +1,112 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::monostate; +using std::experimental::holds_alternative; +using std::experimental::get; + +struct foo +{ + foo() noexcept = default; +}; + +struct bar +{ + bar() = delete; + ~bar() = default; +}; + +void test_type_traits() +{ + static_assert(std::is_default_constructible_v>); + static_assert(std::is_default_constructible_v>); + static_assert(std::is_default_constructible_v>); + + static_assert(std::is_nothrow_default_constructible_v>); + static_assert(std::is_nothrow_default_constructible_v>); + static_assert(std::is_nothrow_default_constructible_v>); + + static_assert(!std::is_default_constructible_v>); + static_assert(std::is_default_constructible_v>); + static_assert(!std::is_default_constructible_v>); + + static_assert(!std::is_nothrow_default_constructible_v>); + static_assert(std::is_nothrow_default_constructible_v>); + static_assert(!std::is_nothrow_default_constructible_v>); + + static_assert(std::is_nothrow_default_constructible_v>); + static_assert(!std::is_nothrow_default_constructible_v>); +} + +void test_constructors() +{ + constexpr variant v1; + static_assert(v1.index() == 0); + static_assert(holds_alternative(v1)); + + constexpr variant v2; + static_assert(v2.index() == 0); + static_assert(holds_alternative(v2)); +} + +void test_odds() +{ + auto i = 13; + variant odd1{i}; + assert(holds_alternative(odd1)); + assert(!holds_alternative(odd1)); + assert(!holds_alternative(odd1)); + assert(!holds_alternative(odd1)); + assert(!holds_alternative(odd1)); + assert(!holds_alternative(odd1)); + assert(odd1.index() == 1); + assert(get<1>(odd1) == i); + + const auto str = std::string{"Jee!"}; + variant odd2{str}; + assert(holds_alternative(odd2)); + assert(!holds_alternative(odd2)); + assert(!holds_alternative(odd2)); + assert(!holds_alternative(odd2)); + assert(!holds_alternative(odd2)); + assert(odd2.index() == 3); + assert(get<3>(odd2) == str); + + auto b = false; + variant odd3{&b}; + assert(holds_alternative(odd3)); + assert(!holds_alternative(odd3)); + assert(!holds_alternative(odd3)); + assert(odd3.index() == 0); + assert(*get<0>(odd3) == b); + + variant vola{33}; + assert(holds_alternative(vola)); + assert(!holds_alternative(vola)); + assert(!holds_alternative(vola)); + assert(!holds_alternative(vola)); + assert(!holds_alternative(vola)); + assert(vola.index() == 0); + assert(get<0>(vola) == 33); +} + +int main() +{ + test_type_traits(); + test_constructors(); + test_odds(); +} Index: test/std/experimental/variant/variant/variant.variant/variant.ctor/move.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.ctor/move.pass.cpp @@ -0,0 +1,65 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include +#include + +using std::experimental::variant; +using std::experimental::holds_alternative; +using std::experimental::variant_npos; + +struct foo +{ + foo(foo&&) = default; +}; + +struct bar +{ + bar(bar&&) = delete; +}; + +void test_type_traits() +{ + static_assert(std::is_move_constructible_v>); + static_assert(std::is_move_constructible_v>); + static_assert(std::is_move_constructible_v>); + static_assert(std::is_move_constructible_v>); + + static_assert(!std::is_move_constructible_v>); + static_assert(!std::is_move_constructible_v>); + static_assert(!std::is_move_constructible_v>); + static_assert(!std::is_move_constructible_v>); +} + +void test_constructors() +{ + auto v1 = variant{2.2}; + assert(v1.index() == 2); + assert(holds_alternative(v1)); + + auto v2 = variant{std::move(v1)}; + assert(v2.index() == 2); + assert(holds_alternative(v2)); + + assert(v1.index() == variant_npos); + + auto vola = variant{33}; + assert(vola.index() == 2); + assert(holds_alternative(vola)); +} + +int main() +{ + test_type_traits(); + test_constructors(); +} Index: test/std/experimental/variant/variant/variant.variant/variant.dtor/dtor.pss.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.dtor/dtor.pss.cpp @@ -0,0 +1,42 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include + +using std::experimental::variant; + +static int count = 0; + +struct foo +{ + ~foo() = default; +}; + +struct bar +{ + bar() {++count;} // count == 1 + ~bar(){++count;} // count == 2 +}; + +int main() +{ + static_assert(std::is_trivially_destructible_v> == true); + + static_assert(std::is_trivially_destructible_v> == false); + + assert(count == 0); + { + variant v{std::in_place_type}; + assert(count == 1); + } + assert(count == 2); +} Index: test/std/experimental/variant/variant/variant.variant/variant.mod/emplace.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.mod/emplace.pass.cpp @@ -0,0 +1,54 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include + +using std::experimental::variant; +using std::experimental::get; + +static int count = 0; + +struct foo +{ + foo(int) {++count;} // count == 1 + ~foo(){++count;} // count == 2 +}; + +void test_basics() +{ + variant v{}; + assert(count == 0); + v.emplace(13); + assert(count == 1); + v.emplace(true); + assert(count == 2); + v.emplace(13); + assert(count == 3); + v.emplace(true); + assert(count == 4); +} + +void test_odds() +{ + auto b = false; + variant odd3{}; + odd3.emplace<0>(&b); + assert(odd3.index() == 0); + assert(*get<0>(odd3) == b); +} + +int main() +{ + test_basics(); + test_odds(); +} Index: test/std/experimental/variant/variant/variant.variant/variant.status/index.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.status/index.pass.cpp @@ -0,0 +1,67 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include + +using std::experimental::variant; +using std::experimental::bad_variant_access; +using std::experimental::variant_npos; + +void test_ctor() +{ + using test = variant; + constexpr test t1{}; + static_assert(t1.index() == 0); + constexpr test t2{true}; + static_assert(t2.index() == 0); + constexpr test t3{1}; + static_assert(t3.index() == 1); + constexpr test t4{2.2}; + static_assert(t4.index() == 2); +} + +void test_assign() +{ + using test = variant; + test t1{}; + assert(t1.index() == 0); + t1 = true; + assert(t1.index() == 0); + t1 = 1; + assert(t1.index() == 1); + t1 = 2.2; + assert(t1.index() == 2); +} + +void test_valueless_by_exception() +{ + struct S { operator int() { throw 42; }}; + variant v{12.f}; + assert(v.index() == 0); + assert(!v.valueless_by_exception()); + try + { + v.emplace<1>(S()); + } + catch(...) + {} + assert(v.index() == variant_npos); + assert(v.valueless_by_exception()); +} + +int main() +{ + test_ctor(); + test_assign(); + test_valueless_by_exception(); +} Index: test/std/experimental/variant/variant/variant.variant/variant.swap/swap.pass.cpp =================================================================== --- /dev/null +++ test/std/experimental/variant/variant/variant.variant/variant.swap/swap.pass.cpp @@ -0,0 +1,31 @@ +// -*- C++ -*- +//===-------------------------- variant ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++98, c++03, c++11, c++14 + +#include +#include + +using std::experimental::variant; +using std::experimental::get; + +struct foo{}; + +int main() +{ + variant v1, v2; + v1 = 123456u; + v2 = 'A'; + assert(get<1>(v1) == 123456u); + assert(get<3>(v2) == 'A'); + v1.swap(v2); + assert(get<1>(v2) == 123456u); + assert(get<3>(v1) == 'A'); +}