Modified: trunk/Source/WTF/wtf/Variant.h (283981 => 283982)
--- trunk/Source/WTF/wtf/Variant.h 2021-10-12 15:43:57 UTC (rev 283981)
+++ trunk/Source/WTF/wtf/Variant.h 2021-10-12 15:47:13 UTC (rev 283982)
@@ -47,19 +47,10 @@
#include <string>
#include <type_traits>
#include <utility>
+#include <variant>
#include <wtf/Compiler.h>
#include <wtf/StdLibExtras.h>
-#if COMPILER(MSVC)
-#pragma warning(push)
-#pragma warning(disable:4245)
-#pragma warning(disable:4521)
-#pragma warning(disable:4522)
-#pragma warning(disable:4814)
-#endif
-
-#if !COMPILER(CLANG) || WTF_CPP_STD_VER >= 14
-
namespace WTF {
#if COMPILER_SUPPORTS(EXCEPTIONS)
@@ -72,1980 +63,71 @@
#define __NOEXCEPT_(...)
#endif
-struct __in_place_private{
- template<typename>
- struct __type_holder;
+using Monostate = std::monostate;
+template<typename... Types>
+using Variant = std::variant<Types...>;
- template<size_t>
- struct __value_holder;
-};
-
-
-struct in_place_tag {
- in_place_tag() = delete;
-};
-
-using in_place_t = in_place_tag(&)(__in_place_private&);
-
-template <class _Type>
-using in_place_type_t = in_place_tag(&)(__in_place_private::__type_holder<_Type>&);
-
-template <size_t _Index>
-using in_place_index_t = in_place_tag(&)(__in_place_private::__value_holder<_Index>&);
-
-in_place_tag in_place(__in_place_private&);
-
-template <class _Type>
-in_place_tag in_place(__in_place_private::__type_holder<_Type> &) {
- __THROW_EXCEPTION(__in_place_private());
-}
-
-template <size_t _Index>
-in_place_tag in_place(__in_place_private::__value_holder<_Index> &) {
- __THROW_EXCEPTION(__in_place_private());
-}
-
-class bad_variant_access: public std::logic_error{
-public:
- explicit bad_variant_access(const std::string& what_arg):
- std::logic_error(what_arg)
- {}
- explicit bad_variant_access(const char* what_arg):
- std::logic_error(what_arg)
- {}
-};
-
-template<typename T>
-NO_RETURN_DUE_TO_CRASH inline T __throw_bad_variant_access(const char* what_arg){
- __THROW_EXCEPTION(bad_variant_access(what_arg))
-}
-
-template<ptrdiff_t _Offset,typename _Type,typename ... _Types>
-struct __type_index_helper;
-
-template<ptrdiff_t _Offset,typename _Type,typename _Head,typename ... _Rest>
-struct __type_index_helper<_Offset,_Type,_Head,_Rest...>{
- static constexpr ptrdiff_t __value=
- __type_index_helper<_Offset+1,_Type,_Rest...>::__value;
-};
-
-template<ptrdiff_t _Offset,typename _Type,typename ... _Rest>
-struct __type_index_helper<_Offset,_Type,_Type,_Rest...>{
- static constexpr ptrdiff_t __value=_Offset;
-};
-
template<typename _Type,typename ... _Types>
-struct __type_index{
- static constexpr ptrdiff_t __value=
- __type_index_helper<0,_Type,_Types...>::__value;
-};
-
-template<ptrdiff_t _Index,typename ... _Types>
-struct __indexed_type;
-
-template<typename _Head,typename ... _Rest>
-struct __indexed_type<0,_Head,_Rest...>{
- typedef _Head __type;
-};
-
-template<typename _Head,typename ... _Rest>
-struct __indexed_type<-1,_Head,_Rest...>{
- typedef void __type;
-};
-
-template<ptrdiff_t _Index,typename _Head,typename ... _Rest>
-struct __indexed_type<_Index,_Head,_Rest...>{
- typedef typename __indexed_type<_Index-1,_Rest...>::__type __type;
-};
-
-template<ptrdiff_t _Index,typename ..._Types>
-struct __next_index{
- static constexpr ptrdiff_t __value=
- (_Index>=ptrdiff_t(sizeof...(_Types)-1))?-1:_Index+1;
-};
-
-template<typename ... _Types>
-class Variant;
-
-template<typename>
-struct variant_size;
-
-template <typename _Type>
-struct variant_size<const _Type> : variant_size<_Type> {};
-
-template <typename _Type>
-struct variant_size<volatile _Type> : variant_size<_Type> {};
-
-template <typename _Type>
-struct variant_size<const volatile _Type> : variant_size<_Type> {};
-
-template <typename... _Types>
-struct variant_size<Variant<_Types...>>
- : std::integral_constant<size_t, sizeof...(_Types)> {};
-
-template<size_t _Index,typename _Type>
-struct variant_alternative;
-
-template<size_t _Index,typename _Type>
-using variant_alternative_t=typename variant_alternative<_Index,_Type>::type;
-
-template <size_t _Index, typename _Type>
-struct variant_alternative<_Index, const _Type>{
- using type=std::add_const_t<variant_alternative_t<_Index,_Type>>;
-};
-
-template <size_t _Index, typename _Type>
-struct variant_alternative<_Index, volatile _Type>{
- using type=std::add_volatile_t<variant_alternative_t<_Index,_Type>>;
-};
-
-template <size_t _Index, typename _Type>
-struct variant_alternative<_Index, volatile const _Type>{
- using type=std::add_volatile_t<std::add_const_t<variant_alternative_t<_Index,_Type>>>;
-};
-
-template<size_t _Index,typename ... _Types>
-struct variant_alternative<_Index,Variant<_Types...>>{
- using type=typename __indexed_type<_Index,_Types...>::__type;
-};
-
-constexpr size_t variant_npos=-1;
-
-template<typename _Type,typename ... _Types>
-constexpr _Type& get(Variant<_Types...>&);
-
-template<typename _Type,typename ... _Types>
-constexpr _Type const& get(Variant<_Types...> const&);
-
-template<typename _Type,typename ... _Types>
-constexpr _Type&& get(Variant<_Types...>&&);
-
-template<typename _Type,typename ... _Types>
-constexpr const _Type&& get(Variant<_Types...> const&&);
-
-template<ptrdiff_t _Index,typename ... _Types>
-constexpr typename __indexed_type<_Index,_Types...>::__type& get(Variant<_Types...>&);
-
-template<ptrdiff_t _Index,typename ... _Types>
-constexpr typename __indexed_type<_Index,_Types...>::__type&& get(Variant<_Types...>&&);
-
-template<ptrdiff_t _Index,typename ... _Types>
-constexpr typename __indexed_type<_Index,_Types...>::__type const& get(
- Variant<_Types...> const&);
-
-template <ptrdiff_t _Index, typename... _Types>
-constexpr const typename __indexed_type<_Index, _Types...>::__type &&
-get(Variant<_Types...> const &&);
-
-template<typename _Type,typename ... _Types>
-constexpr std::add_pointer_t<_Type> get_if(Variant<_Types...>*);
-
-template<typename _Type,typename ... _Types>
-constexpr std::add_pointer_t<_Type const> get_if(Variant<_Types...> const*);
-
-template<ptrdiff_t _Index,typename ... _Types>
-constexpr std::add_pointer_t<typename __indexed_type<_Index, _Types...>::__type> get_if(Variant<_Types...>*);
-
-template<ptrdiff_t _Index,typename ... _Types>
-constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type const> get_if(
- Variant<_Types...> const*);
-
-template<ptrdiff_t _Index,typename ... _Types>
-struct __variant_accessor;
-
-template<size_t __count,
- bool __larger_than_char=(__count>SCHAR_MAX),
- bool __larger_than_short=(__count>SHRT_MAX),
- bool __larger_than_int=(__count>INT_MAX)>
-struct __discriminator_type{
- typedef signed char __type;
-};
-
-template<size_t __count>
-struct __discriminator_type<__count,true,false,false>{
- typedef signed short __type;
-};
-
-template<size_t __count>
-struct __discriminator_type<__count,true,true,false>{
- typedef int __type;
-};
-template<size_t __count>
-struct __discriminator_type<__count,true,true,true>{
- typedef signed long __type;
-};
-
-template<typename _Type>
-struct __stored_type{
- typedef _Type __type;
-};
-
-template<typename _Type>
-struct __stored_type<_Type&>{
- typedef _Type* __type;
-};
-
-template<typename ... _Types>
-struct __all_trivially_destructible;
-
-template<>
-struct __all_trivially_destructible<> {
- static constexpr bool __value=true;
-};
-
-template<typename _Type>
-struct __all_trivially_destructible<_Type> {
- static constexpr bool __value=
- std::is_trivially_destructible<typename __stored_type<_Type>::__type>::value;
-};
-
-template<typename _Head,typename ... _Rest>
-struct __all_trivially_destructible<_Head,_Rest...> {
- static constexpr bool __value=
- __all_trivially_destructible<_Head>::__value &&
- __all_trivially_destructible<_Rest...>::__value;
-};
-
-template<typename _Target,typename ... _Args>
-struct __storage_nothrow_constructible{
- static const bool __value=
- std::is_nothrow_constructible<_Target, _Args...>::value;
-};
-
-template<typename ... _Types>
-struct __storage_nothrow_move_constructible;
-
-template<>
-struct __storage_nothrow_move_constructible<> {
- static constexpr bool __value=true;
-};
-
-template<typename _Type>
-struct __storage_nothrow_move_constructible<_Type> {
- static constexpr bool __value=
- std::is_nothrow_move_constructible<
- typename __stored_type<_Type>::__type>::value;
-};
-
-template<typename _Head,typename ... _Rest>
-struct __storage_nothrow_move_constructible<_Head,_Rest...> {
- static constexpr bool __value=
- __storage_nothrow_move_constructible<_Head>::__value &&
- __storage_nothrow_move_constructible<_Rest...>::__value;
-};
-
-template<ptrdiff_t _Index,typename ... _Types>
-struct __other_storage_nothrow_move_constructible;
-
-template<typename _Head,typename ... _Rest>
-struct __other_storage_nothrow_move_constructible<0,_Head,_Rest...>{
- static const bool __value=__storage_nothrow_move_constructible<_Rest...>::__value;
-};
-
-template<typename _Head,typename ... _Rest>
-struct __other_storage_nothrow_move_constructible<-1,_Head,_Rest...>{
- static const bool __value=
- __storage_nothrow_move_constructible<_Head,_Rest...>::__value;
-};
-
-template<ptrdiff_t _Index,typename _Head,typename ... _Rest>
-struct __other_storage_nothrow_move_constructible<_Index,_Head,_Rest...>{
- static const bool __value=
- __storage_nothrow_move_constructible<_Head>::__value &&
- __other_storage_nothrow_move_constructible<_Index-1,_Rest...>::__value;
-};
-
-template<ptrdiff_t _Index,typename ... _Types>
-struct __backup_storage_required{
- static const bool __value=
- !__storage_nothrow_move_constructible<
- typename __indexed_type<_Index,_Types...>::__type>::__value &&
- !__other_storage_nothrow_move_constructible<_Index,_Types...>::__value;
-};
-
-template<ptrdiff_t _Index,ptrdiff_t _Count,typename ... _Types>
-struct __any_backup_storage_required_impl{
- static const bool __value=
- __backup_storage_required<_Index,_Types...>::__value ||
- __any_backup_storage_required_impl<_Index+1,_Count-1,_Types...>::__value;
-};
-
-template<ptrdiff_t _Index,typename ... _Types>
-struct __any_backup_storage_required_impl<_Index,0,_Types...>{
- static const bool __value=false;
-};
-
-template<typename _Variant>
-struct __any_backup_storage_required;
-
-template<typename ... _Types>
-struct __any_backup_storage_required<Variant<_Types...> >{
- static const bool __value=
- __any_backup_storage_required_impl<0,sizeof...(_Types),_Types...>::__value;
-};
-
-template<typename ... _Types>
-union __variant_data;
-
-// std::is_literal_type is deprecated in C++17 and removed in C++20
-ALLOW_DEPRECATED_DECLARATIONS_BEGIN
-template<typename _Type,bool=std::is_literal_type<_Type>::value>
-struct __variant_storage{
- typedef _Type __type;
-
- static constexpr _Type& __get(__type& __val){
- return __val;
- }
- static constexpr _Type&& __get_rref(__type& __val){
- return std::move(__val);
- }
- static constexpr const _Type& __get(__type const& __val){
- return __val;
- }
- static constexpr const _Type&& __get_rref(__type const& __val){
- return std::move(__val);
- }
- static void __destroy(__type&){}
-};
-ALLOW_DEPRECATED_DECLARATIONS_END
-
-template<typename _Type>
-struct __storage_wrapper{
- typename std::aligned_storage<sizeof(_Type),alignof(_Type)>::type __storage;
-
- template<typename ... _Args>
- static constexpr void __construct(void* __p,_Args&& ... __args){
- new (__p) _Type(std::forward<_Args>(__args)...);
- }
-
- template <typename _Dummy = _Type>
- __storage_wrapper(
- typename std::enable_if<std::is_default_constructible<_Dummy>::value,
- void (__storage_wrapper::*)()>::type = nullptr) {
- __construct(&__storage);
- }
-
- template <typename _Dummy = _Type>
- __storage_wrapper(
- typename std::enable_if<!std::is_default_constructible<_Dummy>::value,
- void (__storage_wrapper::*)()>::type = nullptr) {
- }
-
- template<typename _First,typename ... _Args>
- __storage_wrapper(_First&& __first,_Args&& ... __args){
- __construct(&__storage,std::forward<_First>(__first),std::forward<_Args>(__args)...);
- }
-
- _Type& __get(){
- return *static_cast<_Type*>(static_cast<void*>(&__storage));
- }
- constexpr _Type const& __get() const{
- return *static_cast<_Type const*>(static_cast<void const*>(&__storage));
- }
- void __destroy(){
- __get().~_Type();
- }
-};
-
-template<typename _Type>
-struct __storage_wrapper<_Type&>{
- _Type* __storage;
-
- template<typename _Arg>
- constexpr __storage_wrapper(_Arg& __arg):
- __storage(&__arg){}
-
- _Type& __get(){
- return *__storage;
- }
- constexpr _Type const& __get() const{
- return *__storage;
- }
-};
-
-template<typename _Type>
-struct __variant_storage<_Type,false>{
- typedef __storage_wrapper<_Type> __type;
-
- static constexpr _Type& __get(__type& __val){
- return __val.__get();
- }
- static constexpr _Type&& __get_rref(__type& __val){
- return std::move(__val.__get());
- }
- static constexpr const _Type& __get(__type const& __val){
- return __val.__get();
- }
- static constexpr const _Type&& __get_rref(__type const& __val){
- return std::move(__val.__get());
- }
- static void __destroy(__type& __val){
- __val.__destroy();
- }
-};
-
-template<typename _Type,bool __b>
-struct __variant_storage<_Type&,__b>{
- typedef _Type* __type;
-
- static constexpr _Type& __get(__type& __val){
- return *__val;
- }
- static constexpr _Type& __get_rref(__type& __val){
- return *__val;
- }
- static constexpr _Type& __get(__type const& __val){
- return *__val;
- }
- static constexpr _Type& __get_rref(__type const& __val){
- return *__val;
- }
- static void __destroy(__type&){}
-};
-
-template<typename _Type,bool __b>
-struct __variant_storage<_Type&&,__b>{
- typedef _Type* __type;
-
- static constexpr _Type&& __get(__type& __val){
- return static_cast<_Type&&>(*__val);
- }
- static constexpr _Type&& __get_rref(__type& __val){
- return static_cast<_Type&&>(*__val);
- }
- static constexpr _Type&& __get(__type const& __val){
- return static_cast<_Type&&>(*__val);
- }
- static constexpr _Type&& __get_rref(__type const& __val){
- return static_cast<_Type&&>(*__val);
- }
- static void __destroy(__type&){}
-};
-
-template<>
-union __variant_data<>{
- constexpr __variant_data(){}
-};
-
-template<typename _Type>
-union __variant_data<_Type>{
- typename __variant_storage<_Type>::__type __val;
- struct __dummy_type{} __dummy;
-
- constexpr __variant_data():__dummy(){}
-
- template<typename ... _Args>
- constexpr __variant_data(in_place_index_t<0>,_Args&& ... __args):
- __val(std::forward<_Args>(__args)...){}
-
- _Type& __get(in_place_index_t<0>){
- return __variant_storage<_Type>::__get(__val);
- }
- /*constexpr*/ _Type&& __get_rref(in_place_index_t<0>){
- return __variant_storage<_Type>::__get_rref(__val);
- }
- constexpr const _Type& __get(in_place_index_t<0>) const{
- return __variant_storage<_Type>::__get(__val);
- }
- constexpr const _Type&& __get_rref(in_place_index_t<0>) const{
- return __variant_storage<_Type>::__get_rref(__val);
- }
- void __destroy(in_place_index_t<0>){
- __variant_storage<_Type>::__destroy(__val);
- }
-};
-
-template<typename _Type>
-union __variant_data<_Type&>{
- typename __variant_storage<_Type&>::__type __val;
- struct __dummy_type{} __dummy;
-
- constexpr __variant_data():__dummy(){}
-
- template<typename ... _Args>
- constexpr __variant_data(in_place_index_t<0>,_Args&& ... __args):
- __val(&std::forward<_Args>(__args)...){}
-
- _Type& __get(in_place_index_t<0>){
- return __variant_storage<_Type&>::__get(__val);
- }
- constexpr _Type& __get(in_place_index_t<0>) const{
- return __variant_storage<_Type&>::__get(__val);
- }
-
- _Type& __get_rref(in_place_index_t<0>){
- return __variant_storage<_Type&>::__get_rref(__val);
- }
- constexpr _Type& __get_rref(in_place_index_t<0>) const{
- return __variant_storage<_Type&>::__get_rref(__val);
- }
-
- void __destroy(in_place_index_t<0>){
- __variant_storage<_Type&>::__destroy(__val);
- }
-};
-
-template<typename _Type>
-union __variant_data<_Type&&>{
- typename __variant_storage<_Type&&>::__type __val;
- struct __dummy_type{} __dummy;
-
- constexpr __variant_data():__dummy(){}
-
- template<typename _Arg>
- __variant_data(in_place_index_t<0>,_Arg&& __arg):
- __val(&__arg){}
-
- _Type&& __get(in_place_index_t<0>){
- return __variant_storage<_Type&&>::__get(__val);
- }
- constexpr _Type&& __get(in_place_index_t<0>) const{
- return __variant_storage<_Type&&>::__get(__val);
- }
- _Type&& __get_rref(in_place_index_t<0>){
- return __variant_storage<_Type&&>::__get_rref(__val);
- }
- constexpr _Type&& __get_rref(in_place_index_t<0>) const{
- return __variant_storage<_Type&&>::__get_rref(__val);
- }
- void __destroy(in_place_index_t<0>){
- __variant_storage<_Type&&>::__destroy(__val);
- }
-};
-
-template<typename _Head,typename ... _Rest>
-union __variant_data<_Head,_Rest...>{
- __variant_data<_Head> __head;
- __variant_data<_Rest...> __rest;
-
- constexpr __variant_data():
- __head(){}
-
- template<typename ... _Args>
- constexpr __variant_data(in_place_index_t<0>,_Args&& ... __args):
- __head(in_place<0>,std::forward<_Args>(__args)...){}
- template<size_t _Index,typename ... _Args>
- constexpr __variant_data(in_place_index_t<_Index>,_Args&& ... __args):
- __rest(in_place<_Index-1>,std::forward<_Args>(__args)...){}
-
- _Head& __get(in_place_index_t<0>){
- return __head.__get(in_place<0>);
- }
-
- /*constexpr*/ _Head&& __get_rref(in_place_index_t<0>){
- return __head.__get_rref(in_place<0>);
- }
-
- constexpr const _Head& __get(in_place_index_t<0>) const{
- return __head.__get(in_place<0>);
- }
-
- constexpr const _Head&& __get_rref(in_place_index_t<0>) const{
- return __head.__get_rref(in_place<0>);
- }
-
- template<size_t _Index>
- typename __indexed_type<_Index-1,_Rest...>::__type& __get(
- in_place_index_t<_Index>){
- return __rest.__get(in_place<_Index-1>);
- }
-
- template<size_t _Index>
- /*constexpr*/ typename __indexed_type<_Index-1,_Rest...>::__type&& __get_rref(
- in_place_index_t<_Index>){
- return __rest.__get_rref(in_place<_Index-1>);
- }
-
- template<size_t _Index>
- constexpr const typename __indexed_type<_Index-1,_Rest...>::__type& __get(
- in_place_index_t<_Index>) const{
- return __rest.__get(in_place<_Index-1>);
- }
-
- template<size_t _Index>
- constexpr const typename __indexed_type<_Index-1,_Rest...>::__type&& __get_rref(
- in_place_index_t<_Index>) const{
- return __rest.__get_rref(in_place<_Index-1>);
- }
-
-
- void __destroy(in_place_index_t<0>){
- __head.__destroy(in_place<0>);
- }
- template<size_t _Index>
- void __destroy(in_place_index_t<_Index>){
- __rest.__destroy(in_place<_Index-1>);
- }
-};
-
-
-template<ptrdiff_t... _Indices>
-struct __index_sequence{
- typedef __index_sequence<_Indices...,sizeof...(_Indices)> __next;
- static constexpr size_t __length=sizeof...(_Indices);
-};
-
-template<typename ... _Types>
-struct __type_indices;
-
-template<>
-struct __type_indices<>{
- typedef __index_sequence<> __type;
-};
-
-template<typename _Type>
-struct __type_indices<_Type>{
- typedef __index_sequence<0> __type;
-};
-
-template<typename _Type,typename ... _Rest>
-struct __type_indices<_Type,_Rest...>{
- typedef typename __type_indices<_Rest...>::__type::__next __type;
-};
-
-template<typename _Variant>
-struct __variant_indices;
-
-template<typename ... _Types>
-struct __variant_indices<Variant<_Types...>>{
- typedef typename __type_indices<_Types...>::__type __type;
-};
-
-template<typename _Variant,
- typename _Indices=typename __variant_indices<_Variant>::__type>
-struct __move_construct_op_table;
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-struct __move_construct_op_table<_Variant,__index_sequence<_Indices...>>{
- typedef void(* const __func_type)(_Variant*,_Variant&);
-
- template<ptrdiff_t _Index>
- static void __move_construct_func(
- _Variant * __lhs,_Variant& __rhs){
- __lhs->template __emplace_construct<_Index>(
- std::move(get<_Index>(__rhs)));
- }
-
- static const __func_type __apply[sizeof...(_Indices)];
-};
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-const typename __move_construct_op_table<_Variant,__index_sequence<_Indices...>>::
-__func_type
-__move_construct_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
- sizeof...(_Indices)]={
- &__move_construct_func<_Indices>...
- };
-
-template<typename _Variant,
- typename _Indices=typename __variant_indices<_Variant>::__type>
-struct __move_assign_op_table;
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-struct __move_assign_op_table<_Variant,__index_sequence<_Indices...>>{
- typedef void(* const __func_type)(_Variant*,_Variant&);
-
- template<ptrdiff_t _Index>
- static void __move_assign_func(
- _Variant * __lhs,_Variant& __rhs){
- get<_Index>(*__lhs)=std::move(get<_Index>(__rhs));
- }
-
- static const __func_type __apply[sizeof...(_Indices)];
-};
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-const typename __move_assign_op_table<_Variant,__index_sequence<_Indices...>>::
-__func_type
-__move_assign_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
- sizeof...(_Indices)]={
- &__move_assign_func<_Indices>...
- };
-
-template<typename _Variant,
- typename _Indices=typename __variant_indices<_Variant>::__type>
-struct __copy_construct_op_table;
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-struct __copy_construct_op_table<_Variant,__index_sequence<_Indices...>>{
- typedef void(* const __func_type)(_Variant*,_Variant const&);
-
- template<ptrdiff_t _Index>
- static void __copy_construct_func(
- _Variant * __lhs,_Variant const& __rhs){
- __lhs->template __emplace_construct<_Index>(
- get<_Index>(__rhs));
- }
-
- static const __func_type __apply[sizeof...(_Indices)];
-};
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-const typename __copy_construct_op_table<_Variant,__index_sequence<_Indices...>>::
-__func_type
-__copy_construct_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
- sizeof...(_Indices)]={
- &__copy_construct_func<_Indices>...
- };
-
-template<typename _Variant,
- typename _Indices=typename __variant_indices<_Variant>::__type>
-struct __copy_assign_op_table;
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-struct __copy_assign_op_table<_Variant,__index_sequence<_Indices...>>{
- typedef void(* const __func_type)(_Variant*,_Variant const&);
-
- template<ptrdiff_t _Index>
- static void __copy_assign_func(
- _Variant * __lhs,_Variant const& __rhs){
- get<_Index>(*__lhs)=get<_Index>(__rhs);
- }
-
- static const __func_type __apply[sizeof...(_Indices)];
-};
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-const typename __copy_assign_op_table<_Variant,__index_sequence<_Indices...>>::
-__func_type
-__copy_assign_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
- sizeof...(_Indices)]={
- &__copy_assign_func<_Indices>...
- };
-
-template<typename _Variant,
- typename _Indices=typename __variant_indices<_Variant>::__type>
-struct __destroy_op_table;
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-struct __destroy_op_table<_Variant,__index_sequence<_Indices...>>{
- typedef void(* const __func_type)(_Variant*);
-
- template<ptrdiff_t _Index>
- static void __destroy_func(
- _Variant * __self){
- if(__self->__index>=0){
- __self->__storage.__destroy(in_place<_Index>);
- }
- }
-
- static const __func_type __apply[sizeof...(_Indices)];
-};
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-const typename __destroy_op_table<_Variant,__index_sequence<_Indices...>>::
-__func_type
-__destroy_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
- sizeof...(_Indices)]={
- &__destroy_func<_Indices>...
- };
-
-template<typename _Variant,
- typename _Indices=typename __variant_indices<_Variant>::__type>
-struct __swap_op_table;
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-struct __swap_op_table<_Variant,__index_sequence<_Indices...>>{
- typedef void(* const __func_type)(_Variant&,_Variant&);
-
- template<ptrdiff_t _Index>
- static void __swap_func(
- _Variant & __lhs,_Variant & __rhs){
- swap(get<_Index>(__lhs),get<_Index>(__rhs));
- }
-
- static const __func_type __apply[sizeof...(_Indices)];
-};
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-const typename __swap_op_table<_Variant,__index_sequence<_Indices...>>::
-__func_type
-__swap_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
- sizeof...(_Indices)]={
- &__swap_func<_Indices>...
- };
-
-template<typename _Variant,
- typename _Indices=typename __variant_indices<_Variant>::__type>
-struct __equality_op_table;
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-struct __equality_op_table<_Variant,__index_sequence<_Indices...>>{
- typedef bool(* const __compare_func_type)(_Variant const&,_Variant const&);
-
- template<ptrdiff_t _Index>
- static constexpr bool __equality_compare_func(
- _Variant const& __lhs,_Variant const& __rhs){
- return get<_Index>(__lhs)==get<_Index>(__rhs);
- }
-
- static constexpr __compare_func_type __equality_compare[sizeof...(_Indices)]={
- &__equality_compare_func<_Indices>...
- };
-};
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-constexpr typename __equality_op_table<_Variant,__index_sequence<_Indices...>>::
-__compare_func_type
-__equality_op_table<_Variant,__index_sequence<_Indices...>>::__equality_compare[
- sizeof...(_Indices)];
-
-template<typename _Variant,
- typename _Indices=typename __variant_indices<_Variant>::__type>
-struct __less_than_op_table;
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-struct __less_than_op_table<_Variant,__index_sequence<_Indices...>>{
- typedef bool(* const __compare_func_type)(_Variant const&,_Variant const&);
-
- template<ptrdiff_t _Index>
- static constexpr bool __less_than_compare_func(
- _Variant const& __lhs,_Variant const& __rhs){
- return get<_Index>(__lhs)<get<_Index>(__rhs);
- }
-
- static constexpr __compare_func_type __less_than_compare[sizeof...(_Indices)]={
- &__less_than_compare_func<_Indices>...
- };
-};
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-constexpr typename __less_than_op_table<_Variant,__index_sequence<_Indices...>>::
-__compare_func_type
-__less_than_op_table<_Variant,__index_sequence<_Indices...>>::__less_than_compare[
- sizeof...(_Indices)];
-
-template<typename _Variant>
-struct __variant_storage_type;
-
-template<typename _Derived,bool __trivial_destructor>
-struct __variant_base
+constexpr bool holds_alternative(Variant<_Types...> const& __v) __NOEXCEPT
{
- ~__variant_base(){
- static_cast<_Derived*>(this)->__destroy_self();
- }
-};
+ return std::holds_alternative<_Type>(__v);
+}
-template<typename _Derived>
-struct __variant_base<_Derived,true>{
-};
-
-
-template<ptrdiff_t _Offset,typename _CurrentSequence,
- typename _Type,typename ... _Types>
-struct __all_indices_helper;
-
-template<ptrdiff_t _Offset,ptrdiff_t ... _Indices,
- typename _Type,typename ... _Rest>
-struct __all_indices_helper<
- _Offset,__index_sequence<_Indices...>,
- _Type,_Type,_Rest...>{
- typedef typename __all_indices_helper<
- _Offset+1,__index_sequence<_Indices...,_Offset>,_Type,_Rest...>::__type
- __type;
-};
-
-template<ptrdiff_t _Offset,typename _CurrentSequence,
- typename _Type,typename _Head,typename ... _Rest>
-struct __all_indices_helper<_Offset,_CurrentSequence,_Type,_Head,_Rest...>{
- typedef typename __all_indices_helper<
- _Offset+1,_CurrentSequence,_Type,_Rest...>::__type __type;
-};
-
-template<ptrdiff_t _Offset,typename _CurrentSequence,typename _Type>
-struct __all_indices_helper<_Offset,_CurrentSequence,_Type>{
- typedef _CurrentSequence __type;
-};
-
template<typename _Type,typename ... _Types>
-struct __all_indices{
- typedef typename __all_indices_helper<
- 0,__index_sequence<>,_Type,_Types...>::__type __type;
-};
-
-template<typename ... _Sequences>
-struct __combine_sequences;
-
-template<ptrdiff_t ... _Indices1,ptrdiff_t ... _Indices2>
-struct __combine_sequences<
- __index_sequence<_Indices1...>,__index_sequence<_Indices2...>>{
- typedef __index_sequence<_Indices1...,_Indices2...> __type;
-};
-
-template<typename _Sequence,typename ... _Rest>
-struct __combine_sequences<_Sequence,_Rest...>{
- typedef typename __combine_sequences<
- _Sequence,
- typename __combine_sequences<_Rest...>::__type>::__type __type;
-};
-
-template<typename _Indices>
-struct __first_index;
-
-template<ptrdiff_t _FirstIndex,ptrdiff_t ... _Rest>
-struct __first_index<__index_sequence<_FirstIndex,_Rest...>>{
- static constexpr ptrdiff_t __value=_FirstIndex;
-};
-
-template<ptrdiff_t _Offset,typename _CurrentSequence,
- typename _Type,typename ... _Types>
-struct __constructible_matches_helper;
-
-template<ptrdiff_t _Offset,typename _Sequence,typename _Type>
-struct __constructible_matches_helper<
- _Offset,_Sequence,_Type>{
- typedef _Sequence __type;
-};
-
-template<bool _Accept,ptrdiff_t _Entry>
-struct __sequence_or_empty{
- typedef __index_sequence<> __type;
-};
-
-template<ptrdiff_t _Entry>
-struct __sequence_or_empty<true,_Entry>{
- typedef __index_sequence<_Entry> __type;
-};
-
-template<ptrdiff_t _Offset,typename _CurrentSequence,
- typename _Type,typename _Head,typename ... _Rest>
-struct __constructible_matches_helper<
- _Offset,_CurrentSequence,_Type,_Head,_Rest...>{
- typedef
- typename __constructible_matches_helper<
- _Offset+1,
- typename __combine_sequences<
- _CurrentSequence,
- typename __sequence_or_empty<
- std::is_constructible<_Head,_Type>::value,
- _Offset>::__type>::__type,
- _Type,_Rest...>::__type __type;
-};
-
-template<typename _Type,typename ... _Types>
-struct __constructible_matches{
- typedef typename __constructible_matches_helper<
- 0,__index_sequence<>,_Type,_Types...>::__type __type;
-};
-
-template<typename _Type,typename ... _Types>
-struct __type_index_to_construct{
- typedef typename __all_indices<_Type,_Types...>::__type __direct_matches;
- typedef typename __all_indices<
- typename std::remove_const<
- typename std::remove_reference<_Type>::type
- >::type,_Types...>::__type __value_matches;
- typedef typename __all_indices<
- _Type,
- typename std::remove_const<
- typename std::remove_reference<_Types>::type
- >::type...>::__type __rref_matches;
-
- typedef typename __constructible_matches<_Type,_Types...>::__type
- __constructibles;
-
- static_assert(
- (__direct_matches::__length>0) ||
- (__value_matches::__length>0) ||
- (__rref_matches::__length>0) ||
- (__constructibles::__length==1),
- "For conversion construction of variants, exactly one type must be constructible");
-
- typedef typename __combine_sequences<
- __direct_matches,__value_matches,__rref_matches,
- __constructibles>::__type __all_matches;
-
- static constexpr ptrdiff_t __value=__first_index<__all_matches>::__value;
-};
-
-struct __replace_construct_helper{
- template<
- ptrdiff_t _Index,
- bool __construct_directly,
- bool __indexed_type_has_nothrow_move,
- bool __other_types_have_nothrow_move>
- struct __helper;
-
- template<typename _Variant,
- typename _Indices=typename __variant_indices<_Variant>::__type>
- struct __op_table;
-};
-
-template<
- ptrdiff_t _Index,
- bool __other_types_have_nothrow_move>
-struct __replace_construct_helper::__helper<
- _Index,false,true,__other_types_have_nothrow_move>{
-
- template<typename _Variant,typename ... _Args>
- static void __trampoline(_Variant& __v,_Args&& ... __args){
- __v.template __two_stage_replace<_Index>(__args...);
- }
-};
-
-template<
- ptrdiff_t _Index,
- bool __indexed_type_has_nothrow_move,
- bool __other_types_have_nothrow_move>
-struct __replace_construct_helper::__helper<
- _Index,true,__indexed_type_has_nothrow_move,
- __other_types_have_nothrow_move>{
-
- template<typename _Variant,typename ... _Args>
- static void __trampoline(_Variant& __v,_Args&& ... __args){
- __v.template __direct_replace<_Index>(std::forward<_Args>(__args)...);
- }
-};
-
-
-template<
- ptrdiff_t _Index>
-struct __replace_construct_helper::__helper<
- _Index,false,false,true>{
-
- template<typename _Variant,typename ... _Args>
- static void __trampoline(_Variant& __v,_Args&& ... __args){
- __v.template __local_backup_replace<_Index>(std::forward<_Args>(__args)...);
- }
-};
-
-template<
- ptrdiff_t _Index>
-struct __replace_construct_helper::__helper<
- _Index,false,false,false>{
-
- template<typename _Variant,typename ... _Args>
- static void __trampoline(_Variant& __v,_Args&& ... __args){
- __v.template __direct_replace<_Index>(std::forward<_Args>(__args)...);
- }
-};
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-struct __replace_construct_helper::__op_table<_Variant,__index_sequence<_Indices...>>{
- typedef void(* const __move_func_type)(_Variant*,_Variant&);
- typedef void(* const __copy_func_type)(_Variant*,_Variant const&);
-
- template<ptrdiff_t _Index>
- static void __move_assign_func(
- _Variant * __lhs,_Variant& __rhs){
- __lhs->template __replace_construct<_Index>(std::move(get<_Index>(__rhs)));
- __rhs.__destroy_self();
- }
-
- template<ptrdiff_t _Index>
- static void __copy_assign_func(
- _Variant * __lhs,_Variant const& __rhs){
- __lhs->template __replace_construct<_Index>(get<_Index>(__rhs));
- }
-
- static const __move_func_type __move_assign[sizeof...(_Indices)];
- static const __copy_func_type __copy_assign[sizeof...(_Indices)];
-};
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-const typename __replace_construct_helper::__op_table<
- _Variant,__index_sequence<_Indices...>>::__move_func_type
-__replace_construct_helper::__op_table<
- _Variant,__index_sequence<_Indices...>>::__move_assign[
- sizeof...(_Indices)]={
- &__move_assign_func<_Indices>...
- };
-
-template<typename _Variant,ptrdiff_t ... _Indices>
-const typename __replace_construct_helper::__op_table<
- _Variant,__index_sequence<_Indices...>>::__copy_func_type
-__replace_construct_helper::__op_table<
- _Variant,__index_sequence<_Indices...>>::__copy_assign[
- sizeof...(_Indices)]={
- &__copy_assign_func<_Indices>...
- };
-
-template<ptrdiff_t _Index,ptrdiff_t _MaskIndex,typename _Storage>
-struct __backup_storage_ops{
- static void __move_construct_func(
- _Storage * __dest,_Storage& __source){
- new(__dest) _Storage(
- in_place<_Index>,
- std::move(__source.__get(in_place<_Index>)));
- }
- static void __destroy_func(_Storage * __obj){
- __obj->__destroy(in_place<_Index>);
- };
-};
-
-template<ptrdiff_t _Index,typename _Storage>
-struct __backup_storage_ops<_Index,_Index,_Storage>{
- static void __move_construct_func(_Storage *,_Storage&){
- __THROW_EXCEPTION(std::bad_alloc());
- };
- static void __destroy_func(_Storage *){
- __THROW_EXCEPTION(std::bad_alloc());
- };
-};
-
-template<ptrdiff_t _MaskIndex,typename _Storage,typename _Indices>
-struct __backup_storage_op_table;
-
-template<ptrdiff_t _MaskIndex,typename _Storage,ptrdiff_t ... _Indices>
-struct __backup_storage_op_table<
- _MaskIndex,_Storage,__index_sequence<_Indices...> >
+constexpr _Type& get(Variant<_Types...>& __v)
{
- typedef void (*__move_func_type)(_Storage * __dest,_Storage& __source);
- typedef void (*__destroy_func_type)(_Storage * __obj);
-
- template<size_t _Index>
- struct __helper{
- typedef __backup_storage_ops<_Index,_MaskIndex,_Storage> __ops;
- };
-
- static const __move_func_type __move_ops[sizeof...(_Indices)];
- static const __destroy_func_type __destroy_ops[sizeof...(_Indices)];
-};
-
-template<ptrdiff_t _MaskIndex,typename _Storage,ptrdiff_t ... _Indices>
-const typename __backup_storage_op_table<
- _MaskIndex,_Storage,__index_sequence<_Indices...> >::__move_func_type
-__backup_storage_op_table<
- _MaskIndex,_Storage,__index_sequence<_Indices...> >::__move_ops[
- sizeof...(_Indices)]={
- &__helper<_Indices>::__ops::__move_construct_func...
- };
-
-template<ptrdiff_t _MaskIndex,typename _Storage,ptrdiff_t ... _Indices>
-const typename __backup_storage_op_table<
- _MaskIndex,_Storage,__index_sequence<_Indices...> >::__destroy_func_type
-__backup_storage_op_table<
- _MaskIndex,_Storage,__index_sequence<_Indices...> >::__destroy_ops[
- sizeof...(_Indices)]={
- &__helper<_Indices>::__ops::__destroy_func...
- };
-
-template<ptrdiff_t _Index,typename ... _Types>
-struct __backup_storage{
- typedef __variant_data<_Types...> __storage_type;
-
- typedef __backup_storage_op_table<
- _Index,__storage_type,typename __type_indices<_Types...>::__type>
- __op_table_type;
-
- ptrdiff_t __backup_index;
- __storage_type& __live_storage;
- __storage_type __backup;
-
- __backup_storage(ptrdiff_t __live_index_,__storage_type& __live_storage_):
- __backup_index(__live_index_),__live_storage(__live_storage_){
- if(__backup_index>=0){
- __op_table_type::__move_ops[__backup_index](
- &__backup,__live_storage);
- __op_table_type::__destroy_ops[__backup_index](
- &__live_storage);
- }
- }
- void __destroy(){
- if(__backup_index>=0)
- __op_table_type::__destroy_ops[__backup_index](
- &__backup);
- __backup_index=-1;
- }
-
- ~__backup_storage(){
- if(__backup_index>=0){
- __op_table_type::__move_ops[__backup_index](
- &__live_storage,__backup);
- __destroy();
- }
- }
-};
-
-template<typename ... _Types>
-struct __all_move_constructible;
-
-template<typename _Head,typename ... _Rest>
-struct __all_move_constructible<_Head,_Rest...>
-{
- static constexpr bool value=std::is_move_constructible<_Head>::value && __all_move_constructible<_Rest...>::value;
-};
-
-template<>
-struct __all_move_constructible<>:
- std::true_type{};
-
-template<typename ... _Types>
-struct __all_move_assignable;
-
-template<typename _Head,typename ... _Rest>
-struct __all_move_assignable<_Head,_Rest...>
-{
- static constexpr bool value=std::is_move_assignable<_Head>::value && __all_move_assignable<_Rest...>::value;
-};
-
-template<>
-struct __all_move_assignable<>:
- std::true_type{};
-
-template<typename ... _Types>
-struct __all_copy_assignable;
-
-template<typename _Head,typename ... _Rest>
-struct __all_copy_assignable<_Head,_Rest...>
-{
- static constexpr bool value=std::is_copy_assignable<_Head>::value && __all_copy_assignable<_Rest...>::value;
-};
-
-template<>
-struct __all_copy_assignable<>:
- std::true_type{};
-
-namespace __swap_test_detail{
-using std::swap;
-
-template<typename _Other>
-struct __swap_result{};
-
-template<typename>
-static char __test(...);
-template <typename _Other>
-static std::pair<char, std::pair<char, __swap_result<decltype(
- swap(std::declval<_Other &>(),std::declval<_Other &>()))>>>
-__test(_Other *);
+ return std::get<_Type>(__v);
}
-template <typename _Type> struct __is_swappable {
- static constexpr bool value =
- sizeof(__swap_test_detail::__test<_Type>(nullptr)) != 1;
-};
-
-template<typename ... _Types>
-struct __all_swappable;
-
-template<typename _Head,typename ... _Rest>
-struct __all_swappable<_Head,_Rest...>
+template<typename _Type,typename ... _Types>
+constexpr _Type&& get(Variant<_Types...>&& __v)
{
- static constexpr bool value=__is_swappable<_Head>::value && __all_swappable<_Rest...>::value;
-};
-
-template<>
-struct __all_swappable<>:
- std::true_type{};
-
-template<bool _MoveConstructible,typename ... _Types>
-struct __noexcept_variant_move_construct_impl{};
-
-template<typename _Head,typename ... _Rest>
-struct __noexcept_variant_move_construct_impl<true,_Head,_Rest...>{
- static constexpr bool value=noexcept(_Head(std::declval<_Head&&>())) && __noexcept_variant_move_construct_impl<true,_Rest...>::value;
-};
-
-template<>
-struct __noexcept_variant_move_construct_impl<true>{
- static constexpr bool value=true;
-};
-
-template<typename ... _Types>
-struct __noexcept_variant_move_construct:
-__noexcept_variant_move_construct_impl<__all_move_constructible<_Types...>::value,_Types...>
-{};
-
-template<bool _MoveAssignable,typename ... _Types>
-struct __noexcept_variant_move_assign_impl{};
-
-template <typename _Head, typename... _Rest>
-struct __noexcept_variant_move_assign_impl<true, _Head, _Rest...> {
- static constexpr bool value =
- std::is_nothrow_move_assignable<_Head>::value &&
- std::is_nothrow_move_constructible<_Head>::value &&
- __noexcept_variant_move_assign_impl<true, _Rest...>::value;
-};
-
-template<>
-struct __noexcept_variant_move_assign_impl<true>{
- static constexpr bool value=true;
-};
-
-template <typename... _Types>
-struct __noexcept_variant_move_assign
- : __noexcept_variant_move_assign_impl<
- __all_move_assignable<_Types...>::value &&
- __all_move_constructible<_Types...>::value,
- _Types...> {};
-
-template<typename ... _Types>
-struct __all_copy_constructible;
-
-template<typename _Head,typename ... _Rest>
-struct __all_copy_constructible<_Head,_Rest...>
-{
- static constexpr bool value=std::is_copy_constructible<_Head>::value && __all_copy_constructible<_Rest...>::value;
-};
-
-template<>
-struct __all_copy_constructible<>:
- std::true_type{};
-
-template<bool _CopyConstructible,typename ... _Types>
-struct __noexcept_variant_const_copy_construct_impl{};
-
-template<typename _Head,typename ... _Rest>
-struct __noexcept_variant_const_copy_construct_impl<true,_Head,_Rest...>{
- static constexpr bool value=noexcept(_Head(std::declval<_Head const&>())) && __noexcept_variant_const_copy_construct_impl<true,_Rest...>::value;
-};
-
-template<>
-struct __noexcept_variant_const_copy_construct_impl<true>{
- static constexpr bool value=true;
-};
-
-template<typename ... _Types>
-struct __noexcept_variant_const_copy_construct:
-__noexcept_variant_const_copy_construct_impl<__all_copy_constructible<_Types...>::value,_Types...>
-{};
-
-template<bool _CopyNon_Constructible,typename ... _Types>
-struct __noexcept_variant_non_const_copy_construct_impl{};
-
-template<typename _Head,typename ... _Rest>
-struct __noexcept_variant_non_const_copy_construct_impl<true,_Head,_Rest...>{
- static constexpr bool value=noexcept(_Head(std::declval<_Head&>())) && __noexcept_variant_non_const_copy_construct_impl<true,_Rest...>::value;
-};
-
-template<>
-struct __noexcept_variant_non_const_copy_construct_impl<true>{
- static constexpr bool value=true;
-};
-
-template<typename ... _Types>
-struct __noexcept_variant_non_const_copy_construct:
-__noexcept_variant_non_const_copy_construct_impl<__all_copy_constructible<_Types...>::value,_Types...>
-{};
-
-template<bool _Swappable,typename ... _Types>
-struct __noexcept_variant_swap_impl{};
-
-template <typename _Head, typename... _Rest>
-struct __noexcept_variant_swap_impl<true, _Head, _Rest...> {
- static constexpr bool value =
- noexcept(swap(std::declval<_Head&>(),std::declval<_Head&>())) &&
- __noexcept_variant_swap_impl<true, _Rest...>::value;
-};
-
-template<>
-struct __noexcept_variant_swap_impl<true>{
- static constexpr bool value=true;
-};
-
-template<typename ... _Types>
-struct __noexcept_variant_swap:
-__noexcept_variant_swap_impl<__all_swappable<_Types...>::value,_Types...>
-{};
-
-template<typename ... _Types>
-class Variant:
- private __variant_base<
- Variant<_Types...>,__all_trivially_destructible<_Types...>::__value>
-{
- WTF_MAKE_FAST_ALLOCATED;
- typedef __variant_base<Variant<_Types...>,__all_trivially_destructible<_Types...>::__value> __base_type;
- friend __base_type;
- friend struct __copy_construct_op_table<Variant>;
- friend struct __copy_assign_op_table<Variant>;
- friend struct __move_construct_op_table<Variant>;
- friend struct __move_assign_op_table<Variant>;
- friend struct __destroy_op_table<Variant>;
-
- template<ptrdiff_t _Index,typename ... _Types2>
- friend struct __variant_accessor;
-
- friend struct __replace_construct_helper;
-
- typedef __variant_data<_Types...> __storage_type;
- __storage_type __storage;
- typename __discriminator_type<sizeof ... (_Types)>::__type __index;
-
- template<size_t _Index,typename ... _Args>
- size_t __emplace_construct(_Args&& ... __args){
- new(&__storage) __storage_type(
- in_place<_Index>,std::forward<_Args>(__args)...);
- return _Index;
- }
-
- void __destroy_self(){
- if(valueless_by_exception())
- return;
- __destroy_op_table<Variant>::__apply[index()](this);
- __index=-1;
- }
-
- ptrdiff_t __move_construct(Variant& __other){
- ptrdiff_t const __other_index=__other.index();
- if(__other_index==-1)
- return -1;
- __move_construct_op_table<Variant>::__apply[__other_index](this,__other);
- __other.__destroy_self();
- return __other_index;
- }
-
- ptrdiff_t __copy_construct(Variant const& __other){
- ptrdiff_t const __other_index=__other.index();
- if(__other_index==-1)
- return -1;
- __copy_construct_op_table<Variant>::__apply[__other_index](this,__other);
- return __other_index;
- }
-
- template<size_t _Index,typename ... _Args>
- void __replace_construct(_Args&& ... __args){
- typedef typename __indexed_type<_Index,_Types...>::__type __this_type;
- __replace_construct_helper::__helper<
- _Index,
- __storage_nothrow_constructible<__this_type,_Args...>::__value ||
- (sizeof...(_Types)==1),
- __storage_nothrow_move_constructible<__this_type>::__value,
- __other_storage_nothrow_move_constructible<
- _Index,_Types...>::__value
- >::__trampoline(*this,std::forward<_Args>(__args)...);
- }
-
- template<size_t _Index,typename ... _Args>
- void __two_stage_replace(_Args&& ... __args){
- typedef typename __indexed_type<_Index,_Types...>::__type __type;
- __variant_data<__type> __local(
- in_place<0>,std::forward<_Args>(__args)...);
- __destroy_self();
- __emplace_construct<_Index>(
- std::move(__local.__get(in_place<0>)));
- __index=_Index;
- __local.__destroy(in_place<0>);
- }
-
- template<size_t _Index,typename ... _Args>
- void __local_backup_replace(_Args&& ... __args){
- __backup_storage<_Index,_Types...> __backup(__index,__storage);
- __emplace_construct<_Index>(std::forward<_Args>(__args)...);
- __index=_Index;
- __backup.__destroy();
- }
-
- template<size_t _Index,typename ... _Args>
- void __direct_replace(_Args&& ... __args) {
- __destroy_self();
- __emplace_construct<_Index>(std::forward<_Args>(__args)...);
- __index=_Index;
- }
-
- struct __private_type{};
-
-public:
- constexpr Variant()
- __NOEXCEPT_(noexcept(typename __indexed_type<0,_Types...>::__type())):
- __storage(in_place<0>),
- __index(0)
- {}
-
- constexpr Variant(typename std::conditional<__all_move_constructible<_Types...>::value,Variant,__private_type>::type&& __other)
- __NOEXCEPT_(__noexcept_variant_move_construct<_Types...>::value):
- __index(__move_construct(__other))
- {}
-
- constexpr Variant(typename std::conditional<!__all_move_constructible<_Types...>::value,Variant,__private_type>::type&& __other)=delete;
-
- constexpr Variant(typename std::conditional<__all_copy_constructible<_Types...>::value,Variant,__private_type>::type& __other)
- __NOEXCEPT_(__noexcept_variant_non_const_copy_construct<_Types...>::value):
- __index(__copy_construct(__other))
- {}
-
- constexpr Variant(typename std::conditional<!__all_copy_constructible<_Types...>::value,Variant,__private_type>::type& __other)=delete;
-
- constexpr Variant(typename std::conditional<__all_copy_constructible<_Types...>::value,Variant,__private_type>::type const& __other)
- __NOEXCEPT_(__noexcept_variant_const_copy_construct<_Types...>::value):
- __index(__copy_construct(__other))
- {}
-
- constexpr Variant(typename std::conditional<!__all_copy_constructible<_Types...>::value,Variant,__private_type>::type const& __other)=delete;
-
- template<typename _Type,typename ... _Args>
- explicit constexpr Variant(in_place_type_t<_Type>,_Args&& ... __args):
- __storage(
- in_place<__type_index<_Type,_Types...>::__value>,
- std::forward<_Args>(__args)...),
- __index(__type_index<_Type,_Types...>::__value)
- {
- static_assert(std::is_constructible<_Type,_Args...>::value,"Type must be constructible from args");
- }
-
- template<size_t _Index,typename ... _Args>
- explicit constexpr Variant(in_place_index_t<_Index>,_Args&& ... __args):
- __storage(in_place<_Index>,std::forward<_Args>(__args)...),
- __index(_Index)
- {
- static_assert(std::is_constructible<typename __indexed_type<_Index,_Types...>::__type,_Args...>::value,"Type must be constructible from args");
- }
-
- template<typename _Type>
- constexpr Variant(_Type&& __x):
- __storage(
- in_place<
- __type_index_to_construct<_Type,_Types...>::__value>,
- std::forward<_Type>(__x)),
- __index(__type_index_to_construct<_Type,_Types...>::__value)
- {}
-
- template<typename _Type,
- typename _Enable=
- typename std::enable_if<
- (__constructible_matches<std::initializer_list<_Type>,_Types...>::__type::__length>0)
- >::type>
- constexpr Variant(std::initializer_list<_Type> __x):
- __storage(
- in_place<
- __type_index_to_construct<std::initializer_list<_Type>,_Types...>::__value>,
- __x),
- __index(__type_index_to_construct<std::initializer_list<_Type>,_Types...>::__value)
- {}
-
- template<typename _Type>
- Variant& operator=(_Type&& __x){
- constexpr size_t _Index=
- __type_index_to_construct<_Type,_Types...>::__value;
- if(_Index==__index){
- get<_Index>(*this)=std::forward<_Type>(__x);
- }
- else{
- __replace_construct<_Index>(std::forward<_Type>(__x));
- }
- return *this;
- }
-
- Variant &operator=(
- typename std::conditional<
- !(__all_copy_constructible<_Types...>::value &&
- __all_move_constructible<_Types...>::value &&
- __all_copy_assignable<_Types...>::value),
- Variant, __private_type>::type const &__other) = delete;
-
- Variant &operator=(
- typename std::conditional<
- __all_copy_constructible<_Types...>::value &&
- __all_move_constructible<_Types...>::value &&
- __all_copy_assignable<_Types...>::value,
- Variant, __private_type>::type const &__other) {
- if (__other.valueless_by_exception()) {
- __destroy_self();
- }
- else if(__other.index()==index()){
- __copy_assign_op_table<Variant>::__apply[index()](this,__other);
- }
- else{
- __replace_construct_helper::__op_table<Variant>::__copy_assign[
- __other.index()](this,__other);
- }
- return *this;
- }
- Variant &operator=(
- typename std::conditional<
- !(__all_copy_constructible<_Types...>::value &&
- __all_move_constructible<_Types...>::value &&
- __all_copy_assignable<_Types...>::value),
- Variant, __private_type>::type &__other) = delete;
-
- Variant &operator=(
- typename std::conditional<
- __all_copy_constructible<_Types...>::value &&
- __all_move_constructible<_Types...>::value &&
- __all_copy_assignable<_Types...>::value,
- Variant, __private_type>::type &__other) {
- if(__other.valueless_by_exception()){
- __destroy_self();
- }
- else if(__other.index()==index()){
- __copy_assign_op_table<Variant>::__apply[index()](this,__other);
- }
- else{
- __replace_construct_helper::__op_table<Variant>::__copy_assign[
- __other.index()](this,__other);
- }
- return *this;
- }
- Variant &operator=(
- typename std::conditional<
- !(__all_move_constructible<_Types...>::value &&
- __all_move_assignable<_Types...>::value),
- Variant, __private_type>::type &&__other) = delete;
-
- Variant &operator=(
- typename std::conditional<__all_move_constructible<_Types...>::value &&
- __all_move_assignable<_Types...>::value,
- Variant, __private_type>::type &&
- __other) __NOEXCEPT_(__noexcept_variant_move_assign<_Types...>::value) {
- if (__other.valueless_by_exception()) {
- __destroy_self();
- }
- else if(__other.index()==index()){
- __move_assign_op_table<Variant>::__apply[index()](this,__other);
- __other.__destroy_self();
- }
- else{
- __replace_construct_helper::__op_table<Variant>::__move_assign[
- __other.index()](this,__other);
- }
- return *this;
- }
-
- template<typename _Type,typename ... _Args>
- void emplace(_Args&& ... __args){
- __direct_replace<__type_index<_Type,_Types...>::__value>(
- std::forward<_Args>(__args)...);
- }
-
- template<size_t _Index,typename ... _Args>
- void emplace(_Args&& ... __args){
- __direct_replace<_Index>(std::forward<_Args>(__args)...);
- }
-
- constexpr bool valueless_by_exception() const __NOEXCEPT{
- return __index==-1;
- }
- constexpr ptrdiff_t index() const __NOEXCEPT{
- return __index;
- }
-
- void swap(
- typename std::conditional<
- __all_swappable<_Types...>::value &&
- __all_move_constructible<_Types...>::value,
- Variant, __private_type>::type
- &__other) __NOEXCEPT_(__noexcept_variant_swap<_Types...>::value) {
- if (__other.index() == index()) {
- if(!valueless_by_exception())
- __swap_op_table<Variant>::__apply[index()](*this,__other);
- }
- else{
- Variant __temp(std::move(__other));
- __other.__index=__other.__move_construct(*this);
- __index=__move_construct(__temp);
- }
- }
-};
-
-template<>
-class Variant<>{
-public:
- WTF_MAKE_FAST_ALLOCATED;
- Variant()=delete;
-
- constexpr bool valueless_by_exception() const __NOEXCEPT{
- return true;
- }
- constexpr ptrdiff_t index() const __NOEXCEPT{
- return -1;
- }
-
- void swap(Variant&){}
-};
-
-template <typename... _Types>
-typename std::enable_if<__all_swappable<_Types...>::value &&
- __all_move_constructible<_Types...>::value,
- void>::type
-swap(Variant<_Types...> &__lhs, Variant<_Types...> &__rhs) __NOEXCEPT_(
- __noexcept_variant_swap<_Types...>::value) {
- __lhs.swap(__rhs);
+ return std::get<_Type>(WTFMove(__v));
}
-template<ptrdiff_t _Index,typename ... _Types>
-struct __variant_accessor{
- typedef typename __indexed_type<_Index,_Types...>::__type __type;
- static constexpr __type& get(Variant<_Types...>& __v){
- return __v.__storage.__get(in_place<_Index>);
- }
- static constexpr __type const& get(Variant<_Types...> const& __v){
- return __v.__storage.__get(in_place<_Index>);
- }
- static constexpr __type&& get(Variant<_Types...>&& __v){
- return __v.__storage.__get_rref(in_place<_Index>);
- }
- static constexpr const __type&& get(Variant<_Types...> const&& __v){
- return __v.__storage.__get_rref(in_place<_Index>);
- }
-};
-
template<typename _Type,typename ... _Types>
-constexpr _Type& get(Variant<_Types...>& __v){
- return get<__type_index<_Type,_Types...>::__value>(__v);
+constexpr _Type const& get(Variant<_Types...> const& __v)
+{
+ return std::get<_Type>(__v);
}
template<typename _Type,typename ... _Types>
-constexpr _Type&& get(Variant<_Types...>&& __v){
- return get<__type_index<_Type,_Types...>::__value>(std::move(__v));
+constexpr const _Type&& get(Variant<_Types...> const&& __v)
+{
+ return std::get<_Type>(WTFMove(__v));
}
-template<typename _Type,typename ... _Types>
-constexpr _Type const& get(Variant<_Types...> const& __v){
- return get<__type_index<_Type,_Types...>::__value>(__v);
+template <typename Visitor, typename... Variants>
+constexpr auto visit(Visitor&& visitor, Variants&&... variants) -> decltype(std::visit(std::forward<Visitor>(visitor), std::forward<Variants>(variants)...))
+{
+ return std::visit(std::forward<Visitor>(visitor), std::forward<Variants>(variants)...);
}
template<typename _Type,typename ... _Types>
-constexpr const _Type&& get(Variant<_Types...> const&& __v){
- return get<__type_index<_Type,_Types...>::__value>(std::move(__v));
+constexpr std::add_pointer_t<_Type> get_if(Variant<_Types...>* variant)
+{
+ return std::get_if<_Type>(variant);
}
-
-template<ptrdiff_t _Index,typename ... _Types>
-constexpr typename __indexed_type<_Index,_Types...>::__type const& get(Variant<_Types...> const& __v){
- return *(
- (_Index!=__v.index())
- ? std::addressof(__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type const&>("Bad Variant index in get"))
- : std::addressof(__variant_accessor<_Index,_Types...>::get(__v))
- );
-}
-
-template<ptrdiff_t _Index,typename ... _Types>
-constexpr typename __indexed_type<_Index,_Types...>::__type& get(Variant<_Types...>& __v){
- return *(
- (_Index!=__v.index())
- ? std::addressof(__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type&>("Bad Variant index in get"))
- : std::addressof(__variant_accessor<_Index,_Types...>::get(__v))
- );
-}
-
-template<ptrdiff_t _Index,typename ... _Types>
-constexpr typename __indexed_type<_Index,_Types...>::__type&& get(Variant<_Types...>&& __v){
- return __variant_accessor<_Index,_Types...>::get(
- (((_Index!=__v.index()) ? __throw_bad_variant_access<int>("Bad Variant index in get") : 0), std::move(__v))
- );
-}
-
-template<ptrdiff_t _Index,typename ... _Types>
-constexpr const typename __indexed_type<_Index,_Types...>::__type&& get(Variant<_Types...> const&& __v){
- return __variant_accessor<_Index,_Types...>::get(
- (((_Index!=__v.index()) ? __throw_bad_variant_access<int>("Bad Variant index in get") : 0), std::move(__v))
- );
-}
-
template<typename _Type,typename ... _Types>
-constexpr std::add_pointer_t<_Type> get_if(Variant<_Types...>* __v) {
- return (__type_index<_Type, _Types...>::__value != __v->index()) ? nullptr : std::addressof(get<_Type>(*__v));
+constexpr std::add_pointer_t<_Type const> get_if(Variant<_Types...> const* variant)
+{
+ return std::get_if<_Type>(variant);
}
-template<typename _Type,typename ... _Types>
-constexpr std::add_pointer_t<_Type const> get_if(Variant<_Types...> const* __v) {
- return (__type_index<_Type, _Types...>::__value != __v->index()) ? nullptr : std::addressof(get<_Type>(*__v));
-}
-
template<ptrdiff_t _Index,typename ... _Types>
-constexpr std::add_pointer_t<typename __indexed_type<_Index, _Types...>::__type> get_if(Variant<_Types...>* __v) {
- return ((_Index != __v->index()) ? nullptr :
- std::addressof(__variant_accessor<_Index, _Types...>::get(*__v)));
+constexpr typename std::add_pointer_t<std::variant_alternative_t<_Index, std::variant<_Types...>>>::__type get_if(Variant<_Types...>* variant)
+{
+ return std::get_if<_Index>(variant);
}
template<ptrdiff_t _Index,typename ... _Types>
-constexpr std::add_pointer_t<typename __indexed_type<_Index, _Types...>::__type const> get_if(
- Variant<_Types...> const* __v) {
- return ((_Index != __v->index()) ? nullptr :
- std::addressof(__variant_accessor<_Index, _Types...>::get(*__v)));
+constexpr typename std::add_pointer_t<std::variant_alternative_t<_Index, std::variant<_Types...>>>::__type const get_if(
+ Variant<_Types...> const* variant)
+{
+ return std::get_if<_Index>(variant);
}
-template<typename _Type,typename ... _Types>
-constexpr bool holds_alternative(Variant<_Types...> const& __v) __NOEXCEPT{
- return __v.index()==__type_index<_Type,_Types...>::__value;
-}
-
-template<typename _Visitor,typename ... _Types>
-struct __visitor_return_type;
-
-template<typename _Visitor>
-struct __visitor_return_type<_Visitor>{
- typedef decltype(std::declval<_Visitor&>()()) __type;
-};
-
-template<typename _Visitor,typename _Head,typename ... _Rest>
-struct __visitor_return_type<_Visitor,_Head,_Rest...>{
- typedef decltype(std::declval<_Visitor&>()(std::declval<_Head&>())) __type;
-};
-
-template<typename _Visitor,typename ... _Types>
-struct __visitor_table{
- typedef Variant<_Types...> __variant_type;
- typedef typename __visitor_return_type<_Visitor,_Types...>::__type __return_type;
- typedef __return_type (*__func_type)(_Visitor&,__variant_type&);
-
- template<typename _Type>
- static __return_type __trampoline_func(_Visitor& __visitor,__variant_type& __v){
- return __visitor(get<_Type>(__v));
- }
-
- static const __func_type __trampoline[sizeof...(_Types)];
-};
-
-template<typename _Visitor,typename ... _Types>
-const typename __visitor_table<_Visitor,_Types...>::__func_type __visitor_table<_Visitor,_Types...>::__trampoline[sizeof...(_Types)]={
- &__trampoline_func<_Types>...
- };
-
-template<typename _Visitor,typename ... _Types>
-constexpr typename __visitor_return_type<_Visitor,_Types...>::__type
-visit(_Visitor&& __visitor,Variant<_Types...>& __v){
- return (__v.valueless_by_exception())
- ? __throw_bad_variant_access<typename __visitor_return_type<_Visitor,_Types...>::__type>("Visiting of empty Variant")
- : __visitor_table<_Visitor,_Types...>::__trampoline[__v.index()](__visitor,__v);
-}
-
-template<typename _Visitor,typename ... _Variants>
-struct __multi_visitor_return_type{
- typedef decltype(std::declval<_Visitor&>()(get<0>(std::declval<_Variants>())...))
- __type;
-};
-
-template<size_t _VariantIndex,typename _Indices>
-struct __visit_helper;
-
-template<ptrdiff_t ... _Indices>
-struct __visit_helper<0,__index_sequence<_Indices...>>{
- template<typename _Visitor,typename ... _Variants>
- static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
- __visit(_Visitor& __visitor,_Variants& ... __v){
- return __visitor(get<_Indices>(__v)...);
- }
-};
-
-template<size_t _Index,typename ... _Args>
-struct __arg_selector_t;
-
-template<typename _Head,typename ... _Rest>
-struct __arg_selector_t<0,_Head,_Rest...>{
- typedef _Head __type;
-
- static constexpr __type& __select(_Head& __head,_Rest& ...){
- return __head;
- }
-};
-
-template<size_t _Index,typename _Head,typename ... _Rest>
-struct __arg_selector_t<_Index,_Head,_Rest...>{
- typedef typename __arg_selector_t<_Index-1,_Rest...>::__type __type;
- static constexpr __type& __select(_Head&,_Rest& ... __rest){
- return __arg_selector_t<_Index-1,_Rest...>::__select(__rest...);
- }
-};
-
-template<size_t _Index,typename ... _Args>
-constexpr typename __arg_selector_t<_Index,_Args...>::__type&& __arg_selector(_Args&& ... __args){
- return std::forward<typename __arg_selector_t<_Index,_Args...>::__type>(
- __arg_selector_t<_Index,_Args...>::__select(__args...));
-}
-
-template<ptrdiff_t _Index,size_t _VariantIndex,ptrdiff_t ... _Indices>
-struct __visit_helper2{
- template<typename _Visitor,typename ... _Variants>
- static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
- __visit(_Visitor& __visitor,_Variants&& ... __v){
- return (__arg_selector<_VariantIndex-1>(__v...).index()==_Index)
- ? __visit_helper<_VariantIndex-1,__index_sequence<_Index,_Indices...>>::__visit(__visitor,std::forward<_Variants>(__v)...)
- : __visit_helper2<_Index-1,_VariantIndex,_Indices...>::__visit(__visitor,std::forward<_Variants>(__v)...);
- }
-};
-
-template<size_t _VariantIndex,ptrdiff_t ... _Indices>
-struct __visit_helper2<-1,_VariantIndex,_Indices...>{
- template<typename _Visitor,typename ... _Variants>
- static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
- __visit(_Visitor&,_Variants&& ...){
- return __throw_bad_variant_access<typename __multi_visitor_return_type<_Visitor,_Variants...>::__type>("Visiting of empty Variant");
- }
-};
-
-template<typename _Variant>
-struct __variant_type_count;
-
-template<typename ... _Types>
-struct __variant_type_count<Variant<_Types...>>{
- static constexpr size_t __value=sizeof...(_Types);
-};
-
-template<typename _Variant>
-struct __variant_type_count<_Variant&>{
- static constexpr size_t __value=__variant_type_count<_Variant>::__value;
-};
-
-template<typename _Variant>
-struct __variant_type_count<_Variant const&>{
- static constexpr size_t __value=__variant_type_count<_Variant>::__value;
-};
-
-template<size_t _VariantIndex,ptrdiff_t ... _Indices>
-struct __visit_helper<_VariantIndex,__index_sequence<_Indices...>>{
-
- template<typename _Visitor,typename ... _Variants>
- static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
- __visit(_Visitor& __visitor,_Variants&& ... __v){
- return __visit_helper2<
- __variant_type_count<
- typename __arg_selector_t<
- _VariantIndex-1,_Variants...>::__type>::__value-1,
- _VariantIndex,_Indices...>::__visit(
- __visitor,std::forward<_Variants&&>(__v)...);
- }
-};
-
-template<typename _Visitor,typename ... _Variants>
-constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
-visit(_Visitor&& __visitor,_Variants&& ... __v){
- return __visit_helper<sizeof...(_Variants),__index_sequence<>>::__visit(
- __visitor,std::forward<_Variants>(__v)...);
-}
-
-template<typename ... _Types>
-constexpr bool operator==(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
- return (__lhs.index()==__rhs.index()) &&
- ((__lhs.index()==-1) ||
- __equality_op_table<Variant<_Types...>>::__equality_compare[__lhs.index()](
- __lhs,__rhs));
-}
-
-template<typename ... _Types>
-constexpr bool operator!=(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
- return !(__lhs==__rhs);
-}
-
-template<typename ... _Types>
-constexpr bool operator<(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
- return (__lhs.index()<__rhs.index()) ||
- ((__lhs.index()==__rhs.index()) &&
- ((__lhs.index()!=-1) &&
- __less_than_op_table<Variant<_Types...>>::
- __less_than_compare[__lhs.index()](__lhs,__rhs)));
-}
-
-template<typename ... _Types>
-constexpr bool operator>(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
- return __rhs<__lhs;
-}
-
-template<typename ... _Types>
-constexpr bool operator>=(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
- return !(__lhs<__rhs);
-}
-
-template<typename ... _Types>
-constexpr bool operator<=(Variant<_Types...> const& __lhs,Variant<_Types...> const& __rhs){
- return !(__lhs>__rhs);
-}
-
-struct Monostate{};
-
-constexpr bool operator==(Monostate const&, Monostate const&) { return true; }
-constexpr bool operator!=(Monostate const&, Monostate const&) { return false; }
-constexpr bool operator>=(Monostate const&, Monostate const&) { return true; }
-constexpr bool operator<=(Monostate const&, Monostate const&) { return true; }
-constexpr bool operator>(Monostate const&, Monostate const&) { return false; }
-constexpr bool operator<(Monostate const&, Monostate const&) { return false; }
-
-struct __hash_visitor{
- template<typename _Type>
- size_t operator()(_Type const& __x){
- return std::hash<_Type>()(__x);
- }
-};
-
// -- WebKit Additions --
template<class V, class... F>
@@ -2056,29 +138,5 @@
} // namespace WTF
-namespace std {
-
-template<>
-struct hash<WTF::Monostate>{
- size_t operator()(WTF::Monostate) __NOEXCEPT{
- return 42;
- }
-};
-
-template<typename ... _Types>
-struct hash<WTF::Variant<_Types...>>{
- size_t operator()(WTF::Variant<_Types...> const &v) __NOEXCEPT {
- return std::hash<ptrdiff_t>()(v.index()) ^ WTF::visit(WTF::__hash_visitor(), v);
- }
-};
-
-} // namespace std
-
using WTF::Monostate;
using WTF::Variant;
-
-#endif // !COMPILER(CLANG) || WTF_CPP_STD_VER >= 14
-
-#if COMPILER(MSVC)
-#pragma warning(pop)
-#endif
