Fix windows build.
[WebKit-https.git] / Source / WTF / wtf / Variant.h
1 // Copyright (c) 2015, Just Software Solutions Ltd
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or
5 // without modification, are permitted provided that the
6 // following conditions are met:
7 //
8 // 1. Redistributions of source code must retain the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer.
11 //
12 // 2. Redistributions in binary form must reproduce the above
13 // copyright notice, this list of conditions and the following
14 // disclaimer in the documentation and/or other materials
15 // provided with the distribution.
16 //
17 // 3. Neither the name of the copyright holder nor the names of
18 // its contributors may be used to endorse or promote products
19 // derived from this software without specific prior written
20 // permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
23 // CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
24 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
27 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
29 // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
33 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
34 // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35
36 // Copied from https://bitbucket.org/anthonyw/variant/src (5bce47fa788648f79e5ea1d77b0eef2e8f0b2999)
37
38 // Modified to make it compile with exceptions disabled.
39
40 #pragma once
41
42 #include <functional>
43 #include <limits.h>
44 #include <new>
45 #include <stddef.h>
46 #include <stdexcept>
47 #include <string>
48 #include <type_traits>
49 #include <utility>
50 #include <wtf/Compiler.h>
51
52 #if COMPILER(MSVC)
53 #pragma warning(push)
54 #pragma warning(disable:4245)
55 #pragma warning(disable:4521)
56 #pragma warning(disable:4522)
57 #pragma warning(disable:4814)
58 #endif
59
60 namespace std {
61 namespace experimental {
62
63 #if COMPILER_SUPPORTS(EXCEPTIONS)
64 #define __THROW_EXCEPTION(__exception) throw __exception;
65 #define __NOEXCEPT noexcept
66 #define __NOEXCEPT_(__exception) noexcept(__exception)
67 #else
68 #define __THROW_EXCEPTION(__exception) do { (void)__exception; CRASH(); } while (0);
69 #define __NOEXCEPT
70 #define __NOEXCEPT_(...)
71 #endif
72
73 struct __in_place_private{
74     template<typename>
75     struct __type_holder;
76
77     template<size_t>
78     struct __value_holder;
79 };
80
81
82 struct in_place_tag {
83     in_place_tag() = delete;
84 };
85
86 using in_place_t = in_place_tag(&)(__in_place_private&);
87
88 template <class _Type>
89 using in_place_type_t = in_place_tag(&)(__in_place_private::__type_holder<_Type>&);
90
91 template <size_t _Index>
92 using in_place_index_t = in_place_tag(&)(__in_place_private::__value_holder<_Index>&);
93
94 in_place_tag in_place(__in_place_private&);
95
96 template <class _Type>
97 in_place_tag in_place(__in_place_private::__type_holder<_Type> &) {
98     __THROW_EXCEPTION(__in_place_private());
99 }
100
101 template <size_t _Index>
102 in_place_tag in_place(__in_place_private::__value_holder<_Index> &) {
103     __THROW_EXCEPTION(__in_place_private());
104 }
105
106 class bad_variant_access: public std::logic_error{
107 public:
108     explicit bad_variant_access(const std::string& what_arg):
109         std::logic_error(what_arg)
110     {}
111     explicit bad_variant_access(const char* what_arg):
112         std::logic_error(what_arg)
113     {}
114 };
115
116 template<typename T>
117 NO_RETURN_DUE_TO_CRASH inline T __throw_bad_variant_access(const char* what_arg){
118     __THROW_EXCEPTION(bad_variant_access(what_arg))
119 }
120
121 template<ptrdiff_t _Offset,typename _Type,typename ... _Types>
122 struct __type_index_helper;
123
124 template<ptrdiff_t _Offset,typename _Type,typename _Head,typename ... _Rest>
125 struct __type_index_helper<_Offset,_Type,_Head,_Rest...>{
126     static constexpr ptrdiff_t __value=
127         __type_index_helper<_Offset+1,_Type,_Rest...>::__value;
128 };
129
130 template<ptrdiff_t _Offset,typename _Type,typename ... _Rest>
131 struct __type_index_helper<_Offset,_Type,_Type,_Rest...>{
132     static constexpr ptrdiff_t __value=_Offset;
133 };
134
135 template<typename _Type,typename ... _Types>
136 struct __type_index{
137     static constexpr ptrdiff_t __value=
138         __type_index_helper<0,_Type,_Types...>::__value;
139 };
140
141 template<ptrdiff_t _Index,typename ... _Types>
142 struct __indexed_type;
143
144 template<typename _Head,typename ... _Rest>
145 struct __indexed_type<0,_Head,_Rest...>{
146     typedef _Head __type;
147 };
148
149 template<typename _Head,typename ... _Rest>
150 struct __indexed_type<-1,_Head,_Rest...>{
151     typedef void __type;
152 };
153
154 template<ptrdiff_t _Index,typename _Head,typename ... _Rest>
155 struct __indexed_type<_Index,_Head,_Rest...>{
156     typedef typename __indexed_type<_Index-1,_Rest...>::__type __type;
157 };
158
159 template<ptrdiff_t _Index,typename ..._Types>
160 struct __next_index{
161     static constexpr ptrdiff_t __value=
162         (_Index>=ptrdiff_t(sizeof...(_Types)-1))?-1:_Index+1;
163 };
164
165 template<typename ... _Types>
166 class variant;
167
168 template<typename>
169 struct variant_size;
170
171 template <typename _Type>
172 struct variant_size<const _Type> : variant_size<_Type> {};
173
174 template <typename _Type>
175 struct variant_size<volatile _Type> : variant_size<_Type> {};
176
177 template <typename _Type>
178 struct variant_size<const volatile _Type> : variant_size<_Type> {};
179
180 template <typename... _Types>
181 struct variant_size<variant<_Types...>>
182     : std::integral_constant<size_t, sizeof...(_Types)> {};
183
184 template<size_t _Index,typename _Type>
185 struct variant_alternative;
186
187 template<size_t _Index,typename _Type>
188 using variant_alternative_t=typename variant_alternative<_Index,_Type>::type;
189
190 template <size_t _Index, typename _Type>
191 struct variant_alternative<_Index, const _Type>{
192     using type=std::add_const_t<variant_alternative_t<_Index,_Type>>;
193 };
194
195 template <size_t _Index, typename _Type>
196 struct variant_alternative<_Index, volatile _Type>{
197     using type=std::add_volatile_t<variant_alternative_t<_Index,_Type>>;
198 };
199
200 template <size_t _Index, typename _Type>
201 struct variant_alternative<_Index, volatile const _Type>{
202     using type=std::add_volatile_t<std::add_const_t<variant_alternative_t<_Index,_Type>>>;
203 };
204
205 template<size_t _Index,typename ... _Types>
206 struct variant_alternative<_Index,variant<_Types...>>{
207     using type=typename __indexed_type<_Index,_Types...>::__type;
208 };
209
210 constexpr size_t variant_npos=-1;
211
212 template<typename _Type,typename ... _Types>
213 constexpr _Type& get(variant<_Types...>&);
214
215 template<typename _Type,typename ... _Types>
216 constexpr _Type const& get(variant<_Types...> const&);
217
218 template<typename _Type,typename ... _Types>
219 constexpr _Type&& get(variant<_Types...>&&);
220
221 template<typename _Type,typename ... _Types>
222 constexpr const _Type&& get(variant<_Types...> const&&);
223
224 template<ptrdiff_t _Index,typename ... _Types>
225 constexpr typename __indexed_type<_Index,_Types...>::__type& get(variant<_Types...>&);
226
227 template<ptrdiff_t _Index,typename ... _Types>
228 constexpr typename __indexed_type<_Index,_Types...>::__type&& get(variant<_Types...>&&);
229
230 template<ptrdiff_t _Index,typename ... _Types>
231 constexpr typename __indexed_type<_Index,_Types...>::__type const& get(
232     variant<_Types...> const&);
233
234 template <ptrdiff_t _Index, typename... _Types>
235 constexpr const typename __indexed_type<_Index, _Types...>::__type &&
236 get(variant<_Types...> const &&);
237
238 template<typename _Type,typename ... _Types>
239 constexpr std::add_pointer_t<_Type> get_if(variant<_Types...>&);
240
241 template<typename _Type,typename ... _Types>
242 constexpr std::add_pointer_t<_Type const> get_if(variant<_Types...> const&);
243
244 template<ptrdiff_t _Index,typename ... _Types>
245 constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type> get_if(variant<_Types...>&);
246
247 template<ptrdiff_t _Index,typename ... _Types>
248 constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type const> get_if(
249     variant<_Types...> const&);
250
251 template<ptrdiff_t _Index,typename ... _Types>
252 struct __variant_accessor;
253
254 template<size_t __count,
255          bool __larger_than_char=(__count>SCHAR_MAX),
256     bool __larger_than_short=(__count>SHRT_MAX),
257     bool __larger_than_int=(__count>INT_MAX)>
258 struct __discriminator_type{
259     typedef signed char __type;
260 };
261
262 template<size_t __count>
263 struct __discriminator_type<__count,true,false,false>{
264     typedef signed short __type;
265 };
266
267 template<size_t __count>
268 struct __discriminator_type<__count,true,true,false>{
269     typedef int __type;
270 };
271 template<size_t __count>
272 struct __discriminator_type<__count,true,true,true>{
273     typedef signed long __type;
274 };
275
276 template<typename _Type>
277 struct __stored_type{
278     typedef _Type __type;
279 };
280
281 template<typename _Type>
282 struct __stored_type<_Type&>{
283     typedef _Type* __type;
284 };
285
286 template<typename ... _Types>
287 struct __all_trivially_destructible;
288
289 template<>
290 struct __all_trivially_destructible<> {
291     static constexpr bool __value=true;
292 };
293
294 template<typename _Type>
295 struct __all_trivially_destructible<_Type> {
296     static constexpr bool __value=
297         std::is_trivially_destructible<typename __stored_type<_Type>::__type>::value;
298 };
299
300 template<typename _Head,typename ... _Rest>
301 struct __all_trivially_destructible<_Head,_Rest...> {
302     static constexpr bool __value=
303         __all_trivially_destructible<_Head>::__value &&
304         __all_trivially_destructible<_Rest...>::__value;
305 };
306
307 template<typename _Target,typename ... _Args>
308 struct __storage_nothrow_constructible{
309     static const bool __value=
310         std::is_nothrow_constructible<_Target, _Args...>::value;
311 };
312
313 template<typename ... _Types>
314 struct __storage_nothrow_move_constructible;
315
316 template<>
317 struct __storage_nothrow_move_constructible<> {
318     static constexpr bool __value=true;
319 };
320
321 template<typename _Type>
322 struct __storage_nothrow_move_constructible<_Type> {
323     static constexpr bool __value=
324         std::is_nothrow_move_constructible<
325         typename __stored_type<_Type>::__type>::value;
326 };
327
328 template<typename _Head,typename ... _Rest>
329 struct __storage_nothrow_move_constructible<_Head,_Rest...> {
330     static constexpr bool __value=
331         __storage_nothrow_move_constructible<_Head>::__value &&
332         __storage_nothrow_move_constructible<_Rest...>::__value;
333 };
334
335 template<ptrdiff_t _Index,typename ... _Types>
336 struct __other_storage_nothrow_move_constructible;
337
338 template<typename _Head,typename ... _Rest>
339 struct __other_storage_nothrow_move_constructible<0,_Head,_Rest...>{
340     static const bool __value=__storage_nothrow_move_constructible<_Rest...>::__value;
341 };
342
343 template<typename _Head,typename ... _Rest>
344 struct __other_storage_nothrow_move_constructible<-1,_Head,_Rest...>{
345     static const bool __value=
346         __storage_nothrow_move_constructible<_Head,_Rest...>::__value;
347 };
348
349 template<ptrdiff_t _Index,typename _Head,typename ... _Rest>
350 struct __other_storage_nothrow_move_constructible<_Index,_Head,_Rest...>{
351     static const bool __value=
352         __storage_nothrow_move_constructible<_Head>::__value &&
353         __other_storage_nothrow_move_constructible<_Index-1,_Rest...>::__value;
354 };
355
356 template<ptrdiff_t _Index,typename ... _Types>
357 struct __backup_storage_required{
358     static const bool __value=
359         !__storage_nothrow_move_constructible<
360         typename __indexed_type<_Index,_Types...>::__type>::__value &&
361         !__other_storage_nothrow_move_constructible<_Index,_Types...>::__value;
362 };
363
364 template<ptrdiff_t _Index,ptrdiff_t _Count,typename ... _Types>
365 struct __any_backup_storage_required_impl{
366     static const bool __value=
367         __backup_storage_required<_Index,_Types...>::__value ||
368         __any_backup_storage_required_impl<_Index+1,_Count-1,_Types...>::__value;
369 };
370
371 template<ptrdiff_t _Index,typename ... _Types>
372 struct __any_backup_storage_required_impl<_Index,0,_Types...>{
373     static const bool __value=false;
374 };
375
376 template<typename _Variant>
377 struct __any_backup_storage_required;
378
379 template<typename ... _Types>
380 struct __any_backup_storage_required<variant<_Types...> >{
381     static const bool __value=
382         __any_backup_storage_required_impl<0,sizeof...(_Types),_Types...>::__value;
383 };
384
385 template<typename ... _Types>
386 union __variant_data;
387
388 template<typename _Type,bool=std::is_literal_type<_Type>::value>
389 struct __variant_storage{
390     typedef _Type __type;
391
392     static constexpr _Type& __get(__type& __val){
393         return __val;
394     }
395     static constexpr _Type&& __get_rref(__type& __val){
396         return std::move(__val);
397     }
398     static constexpr const _Type& __get(__type const& __val){
399         return __val;
400     }
401     static constexpr const _Type&& __get_rref(__type const& __val){
402         return std::move(__val);
403     }
404     static void __destroy(__type&){}
405 };
406
407 template<typename _Type>
408 struct __storage_wrapper{
409     typename std::aligned_storage<sizeof(_Type),alignof(_Type)>::type __storage;
410
411     template<typename ... _Args>
412     static constexpr void __construct(void* __p,_Args&& ... __args){
413         new (__p) _Type(std::forward<_Args>(__args)...);
414     }
415
416     template <typename _Dummy = _Type>
417     __storage_wrapper(
418         typename std::enable_if<std::is_default_constructible<_Dummy>::value,
419         void (__storage_wrapper::*)()>::type = nullptr) {
420       __construct(&__storage);
421     }
422
423     template <typename _Dummy = _Type>
424     __storage_wrapper(
425         typename std::enable_if<!std::is_default_constructible<_Dummy>::value,
426         void (__storage_wrapper::*)()>::type = nullptr) {
427     }
428     
429     template<typename _First,typename ... _Args>
430     __storage_wrapper(_First&& __first,_Args&& ... __args){
431         __construct(&__storage,std::forward<_First>(__first),std::forward<_Args>(__args)...);
432     }
433
434     _Type& __get(){
435         return *static_cast<_Type*>(static_cast<void*>(&__storage));
436     }
437     constexpr _Type const& __get() const{
438         return *static_cast<_Type const*>(static_cast<void const*>(&__storage));
439     }
440     void __destroy(){
441         __get().~_Type();
442     }
443 };
444
445 template<typename _Type>
446 struct __storage_wrapper<_Type&>{
447     _Type* __storage;
448
449     template<typename _Arg>
450     constexpr __storage_wrapper(_Arg& __arg):
451         __storage(&__arg){}
452
453     _Type& __get(){
454         return *__storage;
455     }
456     constexpr _Type const& __get() const{
457         return *__storage;
458     }
459 };
460
461 template<typename _Type>
462 struct __variant_storage<_Type,false>{
463     typedef __storage_wrapper<_Type> __type;
464
465     static constexpr _Type& __get(__type& __val){
466         return __val.__get();
467     }
468     static constexpr _Type&& __get_rref(__type& __val){
469         return std::move(__val.__get());
470     }
471     static constexpr const _Type& __get(__type const& __val){
472         return __val.__get();
473     }
474     static constexpr const _Type&& __get_rref(__type const& __val){
475         return std::move(__val.__get());
476     }
477     static void __destroy(__type& __val){
478         __val.__destroy();
479     }
480 };
481
482 template<typename _Type,bool __b>
483 struct __variant_storage<_Type&,__b>{
484     typedef _Type* __type;
485
486     static constexpr _Type& __get(__type& __val){
487         return *__val;
488     }
489     static constexpr _Type& __get_rref(__type& __val){
490         return *__val;
491     }
492     static constexpr _Type& __get(__type const& __val){
493         return *__val;
494     }
495     static constexpr _Type& __get_rref(__type const& __val){
496         return *__val;
497     }
498     static void __destroy(__type&){}
499 };
500
501 template<typename _Type,bool __b>
502 struct __variant_storage<_Type&&,__b>{
503     typedef _Type* __type;
504
505     static constexpr _Type&& __get(__type& __val){
506         return static_cast<_Type&&>(*__val);
507     }
508     static constexpr _Type&& __get_rref(__type& __val){
509         return static_cast<_Type&&>(*__val);
510     }
511     static constexpr _Type&& __get(__type const& __val){
512         return static_cast<_Type&&>(*__val);
513     }
514     static constexpr _Type&& __get_rref(__type const& __val){
515         return static_cast<_Type&&>(*__val);
516     }
517     static void __destroy(__type&){}
518 };
519
520 template<>
521 union __variant_data<>{
522     constexpr __variant_data(){}
523 };
524
525 template<typename _Type>
526 union __variant_data<_Type>{
527     typename __variant_storage<_Type>::__type __val;
528     struct __dummy_type{} __dummy;
529
530     constexpr __variant_data():__dummy(){}
531
532     template<typename ... _Args>
533     constexpr __variant_data(in_place_index_t<0>,_Args&& ... __args):
534         __val(std::forward<_Args>(__args)...){}
535
536     _Type& __get(in_place_index_t<0>){
537         return __variant_storage<_Type>::__get(__val);
538     }
539     /*constexpr*/ _Type&& __get_rref(in_place_index_t<0>){
540         return __variant_storage<_Type>::__get_rref(__val);
541     }
542     constexpr const _Type& __get(in_place_index_t<0>) const{
543         return __variant_storage<_Type>::__get(__val);
544     }
545     constexpr const _Type&& __get_rref(in_place_index_t<0>) const{
546         return __variant_storage<_Type>::__get_rref(__val);
547     }
548     void __destroy(in_place_index_t<0>){
549         __variant_storage<_Type>::__destroy(__val);
550     }
551 };
552
553 template<typename _Type>
554 union __variant_data<_Type&>{
555     typename __variant_storage<_Type&>::__type __val;
556     struct __dummy_type{} __dummy;
557
558     constexpr __variant_data():__dummy(){}
559
560     template<typename ... _Args>
561     constexpr __variant_data(in_place_index_t<0>,_Args&& ... __args):
562         __val(&std::forward<_Args>(__args)...){}
563
564     _Type& __get(in_place_index_t<0>){
565         return __variant_storage<_Type&>::__get(__val);
566     }
567     constexpr _Type& __get(in_place_index_t<0>) const{
568         return __variant_storage<_Type&>::__get(__val);
569     }
570
571     _Type& __get_rref(in_place_index_t<0>){
572         return __variant_storage<_Type&>::__get_rref(__val);
573     }
574     constexpr _Type& __get_rref(in_place_index_t<0>) const{
575         return __variant_storage<_Type&>::__get_rref(__val);
576     }
577     
578     void __destroy(in_place_index_t<0>){
579         __variant_storage<_Type&>::__destroy(__val);
580     }
581 };
582
583 template<typename _Type>
584 union __variant_data<_Type&&>{
585     typename __variant_storage<_Type&&>::__type __val;
586     struct __dummy_type{} __dummy;
587
588     constexpr __variant_data():__dummy(){}
589
590     template<typename _Arg>
591     __variant_data(in_place_index_t<0>,_Arg&& __arg):
592         __val(&__arg){}
593
594     _Type&& __get(in_place_index_t<0>){
595         return __variant_storage<_Type&&>::__get(__val);
596     }
597     constexpr _Type&& __get(in_place_index_t<0>) const{
598         return __variant_storage<_Type&&>::__get(__val);
599     }
600     _Type&& __get_rref(in_place_index_t<0>){
601         return __variant_storage<_Type&&>::__get_rref(__val);
602     }
603     constexpr _Type&& __get_rref(in_place_index_t<0>) const{
604         return __variant_storage<_Type&&>::__get_rref(__val);
605     }
606     void __destroy(in_place_index_t<0>){
607         __variant_storage<_Type&&>::__destroy(__val);
608     }
609 };
610
611 template<typename _Head,typename ... _Rest>
612 union __variant_data<_Head,_Rest...>{
613     __variant_data<_Head> __head;
614     __variant_data<_Rest...> __rest;
615
616     constexpr __variant_data():
617         __head(){}
618
619     template<typename ... _Args>
620     constexpr __variant_data(in_place_index_t<0>,_Args&& ... __args):
621         __head(in_place<0>,std::forward<_Args>(__args)...){}
622     template<size_t _Index,typename ... _Args>
623     constexpr __variant_data(in_place_index_t<_Index>,_Args&& ... __args):
624         __rest(in_place<_Index-1>,std::forward<_Args>(__args)...){}
625
626     _Head& __get(in_place_index_t<0>){
627         return __head.__get(in_place<0>);
628     }
629
630     /*constexpr*/ _Head&& __get_rref(in_place_index_t<0>){
631         return __head.__get_rref(in_place<0>);
632     }
633     
634     constexpr const _Head& __get(in_place_index_t<0>) const{
635         return __head.__get(in_place<0>);
636     }
637
638     constexpr const _Head&& __get_rref(in_place_index_t<0>) const{
639         return __head.__get_rref(in_place<0>);
640     }
641     
642     template<size_t _Index>
643     typename __indexed_type<_Index-1,_Rest...>::__type& __get(
644         in_place_index_t<_Index>){
645         return __rest.__get(in_place<_Index-1>);
646     }
647
648     template<size_t _Index>
649     /*constexpr*/ typename __indexed_type<_Index-1,_Rest...>::__type&& __get_rref(
650         in_place_index_t<_Index>){
651         return __rest.__get_rref(in_place<_Index-1>);
652     }
653     
654     template<size_t _Index>
655     constexpr const typename __indexed_type<_Index-1,_Rest...>::__type& __get(
656         in_place_index_t<_Index>) const{
657         return __rest.__get(in_place<_Index-1>);
658     }
659
660     template<size_t _Index>
661     constexpr const typename __indexed_type<_Index-1,_Rest...>::__type&& __get_rref(
662         in_place_index_t<_Index>) const{
663         return __rest.__get_rref(in_place<_Index-1>);
664     }
665     
666     
667     void __destroy(in_place_index_t<0>){
668         __head.__destroy(in_place<0>);
669     }
670     template<size_t _Index>
671     void __destroy(in_place_index_t<_Index>){
672         __rest.__destroy(in_place<_Index-1>);
673     }
674 };
675
676
677 template<ptrdiff_t... _Indices>
678 struct __index_sequence{
679     typedef __index_sequence<_Indices...,sizeof...(_Indices)> __next;
680     static constexpr size_t __length=sizeof...(_Indices);
681 };
682
683 template<typename ... _Types>
684 struct __type_indices;
685
686 template<>
687 struct __type_indices<>{
688     typedef __index_sequence<> __type;
689 };
690
691 template<typename _Type>
692 struct __type_indices<_Type>{
693     typedef __index_sequence<0> __type;
694 };
695
696 template<typename _Type,typename ... _Rest>
697 struct __type_indices<_Type,_Rest...>{
698     typedef typename __type_indices<_Rest...>::__type::__next __type;
699 };
700
701 template<typename _Variant>
702 struct __variant_indices;
703
704 template<typename ... _Types>
705 struct __variant_indices<variant<_Types...>>{
706     typedef typename __type_indices<_Types...>::__type __type;
707 };
708
709 template<typename _Variant,
710          typename _Indices=typename __variant_indices<_Variant>::__type>
711 struct __move_construct_op_table;
712
713 template<typename _Variant,ptrdiff_t ... _Indices>
714 struct __move_construct_op_table<_Variant,__index_sequence<_Indices...>>{
715     typedef void(* const __func_type)(_Variant*,_Variant&);
716     
717     template<ptrdiff_t _Index>
718     static void __move_construct_func(
719         _Variant * __lhs,_Variant& __rhs){
720         __lhs->template __emplace_construct<_Index>(
721             std::move(get<_Index>(__rhs)));
722     }
723
724     static const __func_type __apply[sizeof...(_Indices)];
725 };
726
727 template<typename _Variant,ptrdiff_t ... _Indices>
728 const typename __move_construct_op_table<_Variant,__index_sequence<_Indices...>>::
729 __func_type
730 __move_construct_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
731     sizeof...(_Indices)]={
732         &__move_construct_func<_Indices>...
733     };
734
735 template<typename _Variant,
736          typename _Indices=typename __variant_indices<_Variant>::__type>
737 struct __move_assign_op_table;
738
739 template<typename _Variant,ptrdiff_t ... _Indices>
740 struct __move_assign_op_table<_Variant,__index_sequence<_Indices...>>{
741     typedef void(* const __func_type)(_Variant*,_Variant&);
742     
743     template<ptrdiff_t _Index>
744     static void __move_assign_func(
745         _Variant * __lhs,_Variant& __rhs){
746         get<_Index>(*__lhs)=std::move(get<_Index>(__rhs));
747     }
748
749     static const __func_type __apply[sizeof...(_Indices)];
750 };
751
752 template<typename _Variant,ptrdiff_t ... _Indices>
753 const typename __move_assign_op_table<_Variant,__index_sequence<_Indices...>>::
754 __func_type
755 __move_assign_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
756     sizeof...(_Indices)]={
757         &__move_assign_func<_Indices>...
758     };
759
760 template<typename _Variant,
761          typename _Indices=typename __variant_indices<_Variant>::__type>
762 struct __copy_construct_op_table;
763
764 template<typename _Variant,ptrdiff_t ... _Indices>
765 struct __copy_construct_op_table<_Variant,__index_sequence<_Indices...>>{
766     typedef void(* const __func_type)(_Variant*,_Variant const&);
767     
768     template<ptrdiff_t _Index>
769     static void __copy_construct_func(
770         _Variant * __lhs,_Variant const& __rhs){
771         __lhs->template __emplace_construct<_Index>(
772             get<_Index>(__rhs));
773     }
774
775     static const __func_type __apply[sizeof...(_Indices)];
776 };
777
778 template<typename _Variant,ptrdiff_t ... _Indices>
779 const typename __copy_construct_op_table<_Variant,__index_sequence<_Indices...>>::
780 __func_type
781 __copy_construct_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
782     sizeof...(_Indices)]={
783         &__copy_construct_func<_Indices>...
784     };
785
786 template<typename _Variant,
787          typename _Indices=typename __variant_indices<_Variant>::__type>
788 struct __copy_assign_op_table;
789
790 template<typename _Variant,ptrdiff_t ... _Indices>
791 struct __copy_assign_op_table<_Variant,__index_sequence<_Indices...>>{
792     typedef void(* const __func_type)(_Variant*,_Variant const&);
793     
794     template<ptrdiff_t _Index>
795     static void __copy_assign_func(
796         _Variant * __lhs,_Variant const& __rhs){
797         get<_Index>(*__lhs)=get<_Index>(__rhs);
798     }
799
800     static const __func_type __apply[sizeof...(_Indices)];
801 };
802
803 template<typename _Variant,ptrdiff_t ... _Indices>
804 const typename __copy_assign_op_table<_Variant,__index_sequence<_Indices...>>::
805 __func_type
806 __copy_assign_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
807     sizeof...(_Indices)]={
808         &__copy_assign_func<_Indices>...
809     };
810
811 template<typename _Variant,
812          typename _Indices=typename __variant_indices<_Variant>::__type>
813 struct __destroy_op_table;
814
815 template<typename _Variant,ptrdiff_t ... _Indices>
816 struct __destroy_op_table<_Variant,__index_sequence<_Indices...>>{
817     typedef void(* const __func_type)(_Variant*);
818     
819     template<ptrdiff_t _Index>
820     static void __destroy_func(
821         _Variant * __self){
822         if(__self->__index>=0){
823             __self->__storage.__destroy(in_place<_Index>);
824         }
825     }
826
827     static const __func_type __apply[sizeof...(_Indices)];
828 };
829
830 template<typename _Variant,ptrdiff_t ... _Indices>
831 const typename __destroy_op_table<_Variant,__index_sequence<_Indices...>>::
832 __func_type
833 __destroy_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
834     sizeof...(_Indices)]={
835         &__destroy_func<_Indices>...
836     };
837
838 template<typename _Variant,
839          typename _Indices=typename __variant_indices<_Variant>::__type>
840 struct __swap_op_table;
841
842 template<typename _Variant,ptrdiff_t ... _Indices>
843 struct __swap_op_table<_Variant,__index_sequence<_Indices...>>{
844     typedef void(* const __func_type)(_Variant&,_Variant&);
845     
846     template<ptrdiff_t _Index>
847     static void __swap_func(
848         _Variant & __lhs,_Variant & __rhs){
849         swap(get<_Index>(__lhs),get<_Index>(__rhs));
850     }
851
852     static const __func_type __apply[sizeof...(_Indices)];
853 };
854
855 template<typename _Variant,ptrdiff_t ... _Indices>
856 const typename __swap_op_table<_Variant,__index_sequence<_Indices...>>::
857 __func_type
858 __swap_op_table<_Variant,__index_sequence<_Indices...>>::__apply[
859     sizeof...(_Indices)]={
860         &__swap_func<_Indices>...
861     };
862
863 template<typename _Variant,
864          typename _Indices=typename __variant_indices<_Variant>::__type>
865 struct __equality_op_table;
866
867 template<typename _Variant,ptrdiff_t ... _Indices>
868 struct __equality_op_table<_Variant,__index_sequence<_Indices...>>{
869     typedef bool(* const __compare_func_type)(_Variant const&,_Variant const&);
870     
871     template<ptrdiff_t _Index>
872     static constexpr bool __equality_compare_func(
873         _Variant const& __lhs,_Variant const& __rhs){
874         return get<_Index>(__lhs)==get<_Index>(__rhs);
875     }
876
877     static constexpr __compare_func_type __equality_compare[sizeof...(_Indices)]={
878         &__equality_compare_func<_Indices>...
879     };
880 };
881
882 template<typename _Variant,ptrdiff_t ... _Indices>
883 constexpr typename __equality_op_table<_Variant,__index_sequence<_Indices...>>::
884 __compare_func_type
885 __equality_op_table<_Variant,__index_sequence<_Indices...>>::__equality_compare[
886     sizeof...(_Indices)];
887
888 template<typename _Variant,
889          typename _Indices=typename __variant_indices<_Variant>::__type>
890 struct __less_than_op_table;
891
892 template<typename _Variant,ptrdiff_t ... _Indices>
893 struct __less_than_op_table<_Variant,__index_sequence<_Indices...>>{
894     typedef bool(* const __compare_func_type)(_Variant const&,_Variant const&);
895     
896     template<ptrdiff_t _Index>
897     static constexpr bool __less_than_compare_func(
898         _Variant const& __lhs,_Variant const& __rhs){
899         return get<_Index>(__lhs)<get<_Index>(__rhs);
900     }
901
902     static constexpr __compare_func_type __less_than_compare[sizeof...(_Indices)]={
903         &__less_than_compare_func<_Indices>...
904     };
905 };
906
907 template<typename _Variant,ptrdiff_t ... _Indices>
908 constexpr typename __less_than_op_table<_Variant,__index_sequence<_Indices...>>::
909 __compare_func_type
910 __less_than_op_table<_Variant,__index_sequence<_Indices...>>::__less_than_compare[
911     sizeof...(_Indices)];
912
913 template<typename _Variant>
914 struct __variant_storage_type;
915
916 template<typename _Derived,bool __trivial_destructor>
917 struct __variant_base
918 {
919     ~__variant_base(){
920         static_cast<_Derived*>(this)->__destroy_self();
921     }
922 };
923
924 template<typename _Derived>
925 struct __variant_base<_Derived,true>{
926 };
927
928
929 template<ptrdiff_t _Offset,typename _CurrentSequence,
930          typename _Type,typename ... _Types>
931 struct __all_indices_helper;
932
933 template<ptrdiff_t _Offset,ptrdiff_t ... _Indices,
934          typename _Type,typename ... _Rest>
935 struct __all_indices_helper<
936     _Offset,__index_sequence<_Indices...>,
937     _Type,_Type,_Rest...>{
938     typedef typename __all_indices_helper<
939         _Offset+1,__index_sequence<_Indices...,_Offset>,_Type,_Rest...>::__type
940         __type;
941 };
942
943 template<ptrdiff_t _Offset,typename _CurrentSequence,
944          typename _Type,typename _Head,typename ... _Rest>
945 struct __all_indices_helper<_Offset,_CurrentSequence,_Type,_Head,_Rest...>{
946     typedef typename __all_indices_helper<
947         _Offset+1,_CurrentSequence,_Type,_Rest...>::__type __type;
948 };
949
950 template<ptrdiff_t _Offset,typename _CurrentSequence,typename _Type>
951 struct __all_indices_helper<_Offset,_CurrentSequence,_Type>{
952     typedef _CurrentSequence __type;
953 };
954
955 template<typename _Type,typename ... _Types>
956 struct __all_indices{
957     typedef typename __all_indices_helper<
958         0,__index_sequence<>,_Type,_Types...>::__type __type;
959 };
960
961 template<typename ... _Sequences>
962 struct __combine_sequences;
963
964 template<ptrdiff_t ... _Indices1,ptrdiff_t ... _Indices2>
965 struct __combine_sequences<
966     __index_sequence<_Indices1...>,__index_sequence<_Indices2...>>{
967     typedef __index_sequence<_Indices1...,_Indices2...> __type;
968 };
969
970 template<typename _Sequence,typename ... _Rest>
971 struct __combine_sequences<_Sequence,_Rest...>{
972     typedef typename __combine_sequences<
973         _Sequence,
974         typename __combine_sequences<_Rest...>::__type>::__type __type;
975 };
976
977 template<typename _Indices>
978 struct __first_index;
979
980 template<ptrdiff_t _FirstIndex,ptrdiff_t ... _Rest>
981 struct __first_index<__index_sequence<_FirstIndex,_Rest...>>{
982     static constexpr ptrdiff_t __value=_FirstIndex;
983 };
984
985 template<ptrdiff_t _Offset,typename _CurrentSequence,
986          typename _Type,typename ... _Types>
987 struct __constructible_matches_helper;
988
989 template<ptrdiff_t _Offset,typename _Sequence,typename _Type>
990 struct __constructible_matches_helper<
991     _Offset,_Sequence,_Type>{
992     typedef _Sequence __type;
993 };
994
995 template<bool _Accept,ptrdiff_t _Entry>
996 struct __sequence_or_empty{
997     typedef __index_sequence<> __type;
998 };
999
1000 template<ptrdiff_t _Entry>
1001 struct __sequence_or_empty<true,_Entry>{
1002     typedef __index_sequence<_Entry> __type;
1003 };
1004
1005 template<ptrdiff_t _Offset,typename _CurrentSequence,
1006          typename _Type,typename _Head,typename ... _Rest>
1007 struct __constructible_matches_helper<
1008     _Offset,_CurrentSequence,_Type,_Head,_Rest...>{
1009     typedef
1010     typename __constructible_matches_helper<
1011         _Offset+1,
1012         typename __combine_sequences<
1013             _CurrentSequence,
1014             typename __sequence_or_empty<
1015                 std::is_constructible<_Head,_Type>::value,
1016                 _Offset>::__type>::__type,
1017         _Type,_Rest...>::__type __type;
1018 };
1019
1020 template<typename _Type,typename ... _Types>
1021 struct __constructible_matches{
1022     typedef typename __constructible_matches_helper<
1023         0,__index_sequence<>,_Type,_Types...>::__type __type;
1024 };
1025
1026 template<typename _Type,typename ... _Types>
1027 struct __type_index_to_construct{
1028     typedef typename __all_indices<_Type,_Types...>::__type __direct_matches;
1029     typedef typename __all_indices<
1030         typename std::remove_const<
1031             typename std::remove_reference<_Type>::type
1032             >::type,_Types...>::__type __value_matches;
1033     typedef typename __all_indices<
1034         _Type,
1035         typename std::remove_const<
1036             typename std::remove_reference<_Types>::type
1037             >::type...>::__type __rref_matches;
1038
1039     typedef typename __constructible_matches<_Type,_Types...>::__type
1040     __constructibles;
1041
1042     static_assert(
1043         (__direct_matches::__length>0) ||
1044         (__value_matches::__length>0) ||
1045         (__rref_matches::__length>0) ||
1046         (__constructibles::__length==1),
1047         "For conversion construction of variants, exactly one type must be constructible");
1048     
1049     typedef typename __combine_sequences<
1050         __direct_matches,__value_matches,__rref_matches,
1051         __constructibles>::__type __all_matches;
1052     
1053     static constexpr ptrdiff_t __value=__first_index<__all_matches>::__value;
1054 };
1055
1056 struct __replace_construct_helper{
1057     template<
1058         ptrdiff_t _Index,
1059         bool __construct_directly,
1060         bool __indexed_type_has_nothrow_move,
1061         bool __other_types_have_nothrow_move>
1062     struct __helper;
1063
1064     template<typename _Variant,
1065              typename _Indices=typename __variant_indices<_Variant>::__type>
1066     struct __op_table;
1067 };
1068
1069 template<
1070     ptrdiff_t _Index,
1071     bool __other_types_have_nothrow_move>
1072 struct __replace_construct_helper::__helper<
1073     _Index,false,true,__other_types_have_nothrow_move>{
1074
1075     template<typename _Variant,typename ... _Args>
1076     static void __trampoline(_Variant& __v,_Args&& ... __args){
1077         __v.template __two_stage_replace<_Index>(__args...);
1078     }
1079 };
1080
1081 template<
1082     ptrdiff_t _Index,
1083     bool __indexed_type_has_nothrow_move,
1084     bool __other_types_have_nothrow_move>
1085 struct __replace_construct_helper::__helper<
1086     _Index,true,__indexed_type_has_nothrow_move,
1087     __other_types_have_nothrow_move>{
1088
1089     template<typename _Variant,typename ... _Args>
1090     static void __trampoline(_Variant& __v,_Args&& ... __args){
1091         __v.template __direct_replace<_Index>(std::forward<_Args>(__args)...);
1092     }
1093 };
1094
1095
1096 template<
1097     ptrdiff_t _Index>
1098 struct __replace_construct_helper::__helper<
1099     _Index,false,false,true>{
1100
1101     template<typename _Variant,typename ... _Args>
1102     static void __trampoline(_Variant& __v,_Args&& ... __args){
1103         __v.template __local_backup_replace<_Index>(std::forward<_Args>(__args)...);
1104     }
1105 };
1106
1107 template<
1108     ptrdiff_t _Index>
1109 struct __replace_construct_helper::__helper<
1110     _Index,false,false,false>{
1111
1112     template<typename _Variant,typename ... _Args>
1113     static void __trampoline(_Variant& __v,_Args&& ... __args){
1114         __v.template __direct_replace<_Index>(std::forward<_Args>(__args)...);
1115     }
1116 };
1117
1118 template<typename _Variant,ptrdiff_t ... _Indices>
1119 struct __replace_construct_helper::__op_table<_Variant,__index_sequence<_Indices...>>{
1120     typedef void(* const __move_func_type)(_Variant*,_Variant&);
1121     typedef void(* const __copy_func_type)(_Variant*,_Variant const&);
1122     
1123     template<ptrdiff_t _Index>
1124     static void __move_assign_func(
1125         _Variant * __lhs,_Variant& __rhs){
1126         __lhs->template __replace_construct<_Index>(std::move(get<_Index>(__rhs)));
1127         __rhs.__destroy_self();
1128     }
1129
1130     template<ptrdiff_t _Index>
1131     static void __copy_assign_func(
1132         _Variant * __lhs,_Variant const& __rhs){
1133         __lhs->template __replace_construct<_Index>(get<_Index>(__rhs));
1134     }
1135     
1136     static const __move_func_type __move_assign[sizeof...(_Indices)];
1137     static const __copy_func_type __copy_assign[sizeof...(_Indices)];
1138 };
1139
1140 template<typename _Variant,ptrdiff_t ... _Indices>
1141 const typename __replace_construct_helper::__op_table<
1142     _Variant,__index_sequence<_Indices...>>::__move_func_type
1143 __replace_construct_helper::__op_table<
1144     _Variant,__index_sequence<_Indices...>>::__move_assign[
1145     sizeof...(_Indices)]={
1146         &__move_assign_func<_Indices>...
1147     };
1148
1149 template<typename _Variant,ptrdiff_t ... _Indices>
1150 const typename __replace_construct_helper::__op_table<
1151     _Variant,__index_sequence<_Indices...>>::__copy_func_type
1152 __replace_construct_helper::__op_table<
1153     _Variant,__index_sequence<_Indices...>>::__copy_assign[
1154     sizeof...(_Indices)]={
1155         &__copy_assign_func<_Indices>...
1156     };
1157
1158 template<ptrdiff_t _Index,ptrdiff_t _MaskIndex,typename _Storage>
1159 struct __backup_storage_ops{
1160     static void __move_construct_func(
1161         _Storage * __dest,_Storage& __source){
1162         new(__dest) _Storage(
1163             in_place<_Index>,
1164             std::move(__source.__get(in_place<_Index>)));
1165     }
1166     static void __destroy_func(_Storage * __obj){
1167         __obj->__destroy(in_place<_Index>);
1168     };
1169 };
1170
1171 template<ptrdiff_t _Index,typename _Storage>
1172 struct __backup_storage_ops<_Index,_Index,_Storage>{
1173     static void __move_construct_func(_Storage *,_Storage&){
1174         __THROW_EXCEPTION(std::bad_alloc());
1175     };
1176     static void __destroy_func(_Storage *){
1177         __THROW_EXCEPTION(std::bad_alloc());
1178     };
1179 };
1180
1181 template<ptrdiff_t _MaskIndex,typename _Storage,typename _Indices>
1182 struct __backup_storage_op_table;
1183
1184 template<ptrdiff_t _MaskIndex,typename _Storage,ptrdiff_t ... _Indices>
1185 struct __backup_storage_op_table<
1186     _MaskIndex,_Storage,__index_sequence<_Indices...> >
1187 {
1188     typedef void (*__move_func_type)(_Storage * __dest,_Storage& __source);
1189     typedef void (*__destroy_func_type)(_Storage * __obj);
1190     
1191     template<size_t _Index>
1192     struct __helper{
1193         typedef __backup_storage_ops<_Index,_MaskIndex,_Storage> __ops;
1194     };
1195
1196     static const __move_func_type __move_ops[sizeof...(_Indices)];
1197     static const __destroy_func_type __destroy_ops[sizeof...(_Indices)];
1198 };
1199
1200 template<ptrdiff_t _MaskIndex,typename _Storage,ptrdiff_t ... _Indices>
1201 const typename __backup_storage_op_table<
1202     _MaskIndex,_Storage,__index_sequence<_Indices...> >::__move_func_type
1203 __backup_storage_op_table<
1204     _MaskIndex,_Storage,__index_sequence<_Indices...> >::__move_ops[
1205         sizeof...(_Indices)]={
1206         &__helper<_Indices>::__ops::__move_construct_func...
1207     };
1208
1209 template<ptrdiff_t _MaskIndex,typename _Storage,ptrdiff_t ... _Indices>
1210 const typename __backup_storage_op_table<
1211     _MaskIndex,_Storage,__index_sequence<_Indices...> >::__destroy_func_type
1212 __backup_storage_op_table<
1213     _MaskIndex,_Storage,__index_sequence<_Indices...> >::__destroy_ops[
1214     sizeof...(_Indices)]={
1215         &__helper<_Indices>::__ops::__destroy_func...
1216     };
1217
1218 template<ptrdiff_t _Index,typename ... _Types>
1219 struct __backup_storage{
1220     typedef __variant_data<_Types...> __storage_type;
1221
1222     typedef __backup_storage_op_table<
1223         _Index,__storage_type,typename __type_indices<_Types...>::__type>
1224     __op_table_type;
1225
1226     ptrdiff_t __backup_index;
1227     __storage_type& __live_storage;
1228     __storage_type __backup;
1229
1230     __backup_storage(ptrdiff_t __live_index_,__storage_type& __live_storage_):
1231         __backup_index(__live_index_),__live_storage(__live_storage_){
1232         if(__backup_index>=0){
1233             __op_table_type::__move_ops[__backup_index](
1234                 &__backup,__live_storage);
1235             __op_table_type::__destroy_ops[__backup_index](
1236                 &__live_storage);
1237         }
1238     }
1239     void __destroy(){
1240         if(__backup_index>=0)
1241             __op_table_type::__destroy_ops[__backup_index](
1242                 &__backup);
1243         __backup_index=-1;
1244     }
1245     
1246     ~__backup_storage(){
1247         if(__backup_index>=0){
1248             __op_table_type::__move_ops[__backup_index](
1249                 &__live_storage,__backup);
1250             __destroy();
1251         }
1252     }
1253 };
1254
1255 template<typename ... _Types>
1256 struct __all_move_constructible;
1257
1258 template<typename _Head,typename ... _Rest>
1259 struct __all_move_constructible<_Head,_Rest...>
1260 {
1261     static constexpr bool value=std::is_move_constructible<_Head>::value && __all_move_constructible<_Rest...>::value;
1262 };
1263
1264 template<>
1265 struct __all_move_constructible<>:
1266     std::true_type{};
1267
1268 template<typename ... _Types>
1269 struct __all_move_assignable;
1270
1271 template<typename _Head,typename ... _Rest>
1272 struct __all_move_assignable<_Head,_Rest...>
1273 {
1274     static constexpr bool value=std::is_move_assignable<_Head>::value && __all_move_assignable<_Rest...>::value;
1275 };
1276
1277 template<>
1278 struct __all_move_assignable<>:
1279     std::true_type{};
1280
1281 template<typename ... _Types>
1282 struct __all_copy_assignable;
1283
1284 template<typename _Head,typename ... _Rest>
1285 struct __all_copy_assignable<_Head,_Rest...>
1286 {
1287     static constexpr bool value=std::is_copy_assignable<_Head>::value && __all_copy_assignable<_Rest...>::value;
1288 };
1289
1290 template<>
1291 struct __all_copy_assignable<>:
1292     std::true_type{};
1293
1294 namespace __swap_test_detail{
1295 using std::swap;
1296
1297 template<typename _Other>
1298 struct __swap_result{};
1299
1300 template<typename>
1301 static char __test(...);
1302 template <typename _Other>
1303 static std::pair<char, std::pair<char, __swap_result<decltype(
1304     swap(std::declval<_Other &>(),std::declval<_Other &>()))>>>
1305 __test(_Other *);
1306 }
1307
1308 template <typename _Type> struct __is_swappable {
1309     static constexpr bool value =
1310         sizeof(__swap_test_detail::__test<_Type>(0)) != 1;
1311 };
1312
1313 template<typename ... _Types>
1314 struct __all_swappable;
1315
1316 template<typename _Head,typename ... _Rest>
1317 struct __all_swappable<_Head,_Rest...>
1318 {
1319     static constexpr bool value=__is_swappable<_Head>::value && __all_swappable<_Rest...>::value;
1320 };
1321
1322 template<>
1323 struct __all_swappable<>:
1324     std::true_type{};
1325
1326 template<bool _MoveConstructible,typename ... _Types>
1327 struct __noexcept_variant_move_construct_impl{};
1328
1329 template<typename _Head,typename ... _Rest>
1330 struct __noexcept_variant_move_construct_impl<true,_Head,_Rest...>{
1331     static constexpr bool value=noexcept(_Head(std::declval<_Head&&>())) && __noexcept_variant_move_construct_impl<true,_Rest...>::value;
1332 };
1333
1334 template<>
1335 struct __noexcept_variant_move_construct_impl<true>{
1336     static constexpr bool value=true;
1337 };
1338
1339 template<typename ... _Types>
1340 struct __noexcept_variant_move_construct:
1341 __noexcept_variant_move_construct_impl<__all_move_constructible<_Types...>::value,_Types...>
1342 {};
1343
1344 template<bool _MoveAssignable,typename ... _Types>
1345 struct __noexcept_variant_move_assign_impl{};
1346
1347 template <typename _Head, typename... _Rest>
1348 struct __noexcept_variant_move_assign_impl<true, _Head, _Rest...> {
1349     static constexpr bool value =
1350         std::is_nothrow_move_assignable<_Head>::value &&
1351         std::is_nothrow_move_constructible<_Head>::value &&
1352         __noexcept_variant_move_assign_impl<true, _Rest...>::value;
1353 };
1354
1355 template<>
1356 struct __noexcept_variant_move_assign_impl<true>{
1357     static constexpr bool value=true;
1358 };
1359
1360 template <typename... _Types>
1361 struct __noexcept_variant_move_assign
1362     : __noexcept_variant_move_assign_impl<
1363           __all_move_assignable<_Types...>::value &&
1364               __all_move_constructible<_Types...>::value,
1365           _Types...> {};
1366
1367 template<typename ... _Types>
1368 struct __all_copy_constructible;
1369
1370 template<typename _Head,typename ... _Rest>
1371 struct __all_copy_constructible<_Head,_Rest...>
1372 {
1373     static constexpr bool value=std::is_copy_constructible<_Head>::value && __all_copy_constructible<_Rest...>::value;
1374 };
1375
1376 template<>
1377 struct __all_copy_constructible<>:
1378     std::true_type{};
1379
1380 template<bool _CopyConstructible,typename ... _Types>
1381 struct __noexcept_variant_const_copy_construct_impl{};
1382
1383 template<typename _Head,typename ... _Rest>
1384 struct __noexcept_variant_const_copy_construct_impl<true,_Head,_Rest...>{
1385     static constexpr bool value=noexcept(_Head(std::declval<_Head const&>())) && __noexcept_variant_const_copy_construct_impl<true,_Rest...>::value;
1386 };
1387
1388 template<>
1389 struct __noexcept_variant_const_copy_construct_impl<true>{
1390     static constexpr bool value=true;
1391 };
1392
1393 template<typename ... _Types>
1394 struct __noexcept_variant_const_copy_construct:
1395 __noexcept_variant_const_copy_construct_impl<__all_copy_constructible<_Types...>::value,_Types...>
1396 {};
1397
1398 template<bool _CopyNon_Constructible,typename ... _Types>
1399 struct __noexcept_variant_non_const_copy_construct_impl{};
1400
1401 template<typename _Head,typename ... _Rest>
1402 struct __noexcept_variant_non_const_copy_construct_impl<true,_Head,_Rest...>{
1403     static constexpr bool value=noexcept(_Head(std::declval<_Head&>())) && __noexcept_variant_non_const_copy_construct_impl<true,_Rest...>::value;
1404 };
1405
1406 template<>
1407 struct __noexcept_variant_non_const_copy_construct_impl<true>{
1408     static constexpr bool value=true;
1409 };
1410
1411 template<typename ... _Types>
1412 struct __noexcept_variant_non_const_copy_construct:
1413 __noexcept_variant_non_const_copy_construct_impl<__all_copy_constructible<_Types...>::value,_Types...>
1414 {};
1415
1416 template<bool _Swappable,typename ... _Types>
1417 struct __noexcept_variant_swap_impl{};
1418
1419 template <typename _Head, typename... _Rest>
1420 struct __noexcept_variant_swap_impl<true, _Head, _Rest...> {
1421     static constexpr bool value =
1422         noexcept(swap(std::declval<_Head&>(),std::declval<_Head&>())) &&
1423         __noexcept_variant_swap_impl<true, _Rest...>::value;
1424 };
1425
1426 template<>
1427 struct __noexcept_variant_swap_impl<true>{
1428     static constexpr bool value=true;
1429 };
1430
1431 template<typename ... _Types>
1432 struct __noexcept_variant_swap:
1433 __noexcept_variant_swap_impl<__all_swappable<_Types...>::value,_Types...>
1434 {};
1435
1436 template<typename ... _Types>
1437 class variant:
1438         private __variant_base<
1439     variant<_Types...>,__all_trivially_destructible<_Types...>::__value>
1440 {
1441     typedef __variant_base<variant<_Types...>,__all_trivially_destructible<_Types...>::__value> __base_type;
1442     friend __base_type;
1443     friend struct __copy_construct_op_table<variant>;
1444     friend struct __copy_assign_op_table<variant>;
1445     friend struct __move_construct_op_table<variant>;
1446     friend struct __move_assign_op_table<variant>;
1447     friend struct __destroy_op_table<variant>;
1448     
1449     template<ptrdiff_t _Index,typename ... _Types2>
1450     friend struct __variant_accessor;
1451
1452     friend struct __replace_construct_helper;
1453
1454     typedef __variant_data<_Types...> __storage_type;
1455     __storage_type __storage;
1456     typename __discriminator_type<sizeof ... (_Types)>::__type __index;
1457
1458     template<size_t _Index,typename ... _Args>
1459     size_t __emplace_construct(_Args&& ... __args){
1460         new(&__storage) __storage_type(
1461             in_place<_Index>,std::forward<_Args>(__args)...);
1462         return  _Index;
1463     }
1464     
1465     void __destroy_self(){
1466         if(valueless_by_exception())
1467             return;
1468         __destroy_op_table<variant>::__apply[index()](this);
1469         __index=-1;
1470     }
1471     
1472     ptrdiff_t __move_construct(variant& __other){
1473         ptrdiff_t const __other_index=__other.index();
1474         if(__other_index==-1)
1475             return -1;
1476         __move_construct_op_table<variant>::__apply[__other_index](this,__other);
1477         __other.__destroy_self();
1478         return __other_index;
1479     }
1480
1481     ptrdiff_t __copy_construct(variant const& __other){
1482         ptrdiff_t const __other_index=__other.index();
1483         if(__other_index==-1)
1484             return -1;
1485         __copy_construct_op_table<variant>::__apply[__other_index](this,__other);
1486         return __other_index;
1487     }
1488
1489     template<size_t _Index,typename ... _Args>
1490     void __replace_construct(_Args&& ... __args){
1491         typedef typename __indexed_type<_Index,_Types...>::__type __this_type;
1492         __replace_construct_helper::__helper<
1493             _Index,
1494             __storage_nothrow_constructible<__this_type,_Args...>::__value ||
1495             (sizeof...(_Types)==1),
1496             __storage_nothrow_move_constructible<__this_type>::__value,
1497             __other_storage_nothrow_move_constructible<
1498                 _Index,_Types...>::__value
1499             >::__trampoline(*this,std::forward<_Args>(__args)...);
1500     }
1501
1502     template<size_t _Index,typename ... _Args>
1503     void __two_stage_replace(_Args&& ... __args){
1504         typedef typename __indexed_type<_Index,_Types...>::__type __type;
1505         __variant_data<__type> __local(
1506             in_place<0>,std::forward<_Args>(__args)...);
1507         __destroy_self();
1508         __emplace_construct<_Index>(
1509             std::move(__local.__get(in_place<0>)));
1510         __index=_Index;
1511         __local.__destroy(in_place<0>);
1512     }
1513
1514     template<size_t _Index,typename ... _Args>
1515     void __local_backup_replace(_Args&& ... __args){
1516         __backup_storage<_Index,_Types...> __backup(__index,__storage);
1517         __emplace_construct<_Index>(std::forward<_Args>(__args)...);
1518         __index=_Index;
1519         __backup.__destroy();
1520     }
1521     
1522     template<size_t _Index,typename ... _Args>
1523     void __direct_replace(_Args&& ... __args) {
1524         __destroy_self();
1525         __emplace_construct<_Index>(std::forward<_Args>(__args)...);
1526         __index=_Index;
1527     }
1528
1529     struct __private_type{};
1530
1531 public:
1532     constexpr variant()
1533         __NOEXCEPT_(noexcept(typename __indexed_type<0,_Types...>::__type())):
1534         __storage(in_place<0>),
1535         __index(0)
1536     {}
1537
1538     constexpr variant(typename std::conditional<__all_move_constructible<_Types...>::value,variant,__private_type>::type&& __other)
1539     __NOEXCEPT_(__noexcept_variant_move_construct<_Types...>::value):
1540         __index(__move_construct(__other))
1541     {}
1542
1543     constexpr variant(typename std::conditional<!__all_move_constructible<_Types...>::value,variant,__private_type>::type&& __other)=delete;
1544     
1545     constexpr variant(typename std::conditional<__all_copy_constructible<_Types...>::value,variant,__private_type>::type& __other)
1546     __NOEXCEPT_(__noexcept_variant_non_const_copy_construct<_Types...>::value):
1547         __index(__copy_construct(__other))
1548     {}
1549
1550     constexpr variant(typename std::conditional<!__all_copy_constructible<_Types...>::value,variant,__private_type>::type& __other)=delete;
1551
1552     constexpr variant(typename std::conditional<__all_copy_constructible<_Types...>::value,variant,__private_type>::type const& __other)
1553     __NOEXCEPT_(__noexcept_variant_const_copy_construct<_Types...>::value):
1554         __index(__copy_construct(__other))
1555     {}
1556
1557     constexpr variant(typename std::conditional<!__all_copy_constructible<_Types...>::value,variant,__private_type>::type const& __other)=delete;
1558     
1559     template<typename _Type,typename ... _Args>
1560     explicit constexpr variant(in_place_type_t<_Type>,_Args&& ... __args):
1561         __storage(
1562             in_place<__type_index<_Type,_Types...>::__value>,
1563             std::forward<_Args>(__args)...),
1564         __index(__type_index<_Type,_Types...>::__value)
1565     {
1566         static_assert(std::is_constructible<_Type,_Args...>::value,"Type must be constructible from args");
1567     }
1568
1569     template<size_t _Index,typename ... _Args>
1570     explicit constexpr variant(in_place_index_t<_Index>,_Args&& ... __args):
1571         __storage(in_place<_Index>,std::forward<_Args>(__args)...),
1572         __index(_Index)
1573     {
1574         static_assert(std::is_constructible<typename __indexed_type<_Index,_Types...>::__type,_Args...>::value,"Type must be constructible from args");
1575     }
1576     
1577     template<typename _Type>
1578     constexpr variant(_Type&& __x):
1579         __storage(
1580             in_place<
1581             __type_index_to_construct<_Type,_Types...>::__value>,
1582             std::forward<_Type>(__x)),
1583         __index(__type_index_to_construct<_Type,_Types...>::__value)
1584     {}
1585
1586     template<typename _Type,
1587              typename _Enable=
1588              typename std::enable_if<
1589                  (__constructible_matches<std::initializer_list<_Type>,_Types...>::__type::__length>0)
1590              >::type>
1591     constexpr variant(std::initializer_list<_Type> __x):
1592         __storage(
1593             in_place<
1594             __type_index_to_construct<std::initializer_list<_Type>,_Types...>::__value>,
1595             __x),
1596         __index(__type_index_to_construct<std::initializer_list<_Type>,_Types...>::__value)
1597     {}
1598     
1599     template<typename _Type>
1600     variant& operator=(_Type&& __x){
1601         constexpr size_t _Index=
1602             __type_index_to_construct<_Type,_Types...>::__value;
1603         if(_Index==__index){
1604             get<_Index>(*this)=std::forward<_Type>(__x);
1605         }
1606         else{
1607             __replace_construct<_Index>(std::forward<_Type>(__x));
1608         }
1609         return *this;
1610     }
1611
1612     variant &operator=(
1613         typename std::conditional<
1614             !(__all_copy_constructible<_Types...>::value &&
1615               __all_move_constructible<_Types...>::value &&
1616               __all_copy_assignable<_Types...>::value),
1617             variant, __private_type>::type const &__other) = delete;
1618
1619     variant &operator=(
1620         typename std::conditional<
1621             __all_copy_constructible<_Types...>::value &&
1622                 __all_move_constructible<_Types...>::value &&
1623                 __all_copy_assignable<_Types...>::value,
1624             variant, __private_type>::type const &__other) {
1625         if (__other.valueless_by_exception()) {
1626             __destroy_self();
1627         }
1628         else if(__other.index()==index()){
1629             __copy_assign_op_table<variant>::__apply[index()](this,__other);
1630         }
1631         else{
1632             __replace_construct_helper::__op_table<variant>::__copy_assign[
1633                 __other.index()](this,__other);
1634         }
1635         return *this;
1636     }
1637     variant &operator=(
1638         typename std::conditional<
1639             !(__all_copy_constructible<_Types...>::value &&
1640               __all_move_constructible<_Types...>::value &&
1641               __all_copy_assignable<_Types...>::value),
1642             variant, __private_type>::type &__other) = delete;
1643
1644     variant &operator=(
1645         typename std::conditional<
1646             __all_copy_constructible<_Types...>::value &&
1647                 __all_move_constructible<_Types...>::value &&
1648                 __all_copy_assignable<_Types...>::value,
1649             variant, __private_type>::type &__other) {
1650         if(__other.valueless_by_exception()){
1651             __destroy_self();
1652         }
1653         else if(__other.index()==index()){
1654             __copy_assign_op_table<variant>::__apply[index()](this,__other);
1655         }
1656         else{
1657             __replace_construct_helper::__op_table<variant>::__copy_assign[
1658                 __other.index()](this,__other);
1659         }
1660         return *this;
1661     }
1662     variant &operator=(
1663         typename std::conditional<
1664             !(__all_move_constructible<_Types...>::value &&
1665               __all_move_assignable<_Types...>::value),
1666             variant, __private_type>::type &&__other) = delete;
1667
1668     variant &operator=(
1669         typename std::conditional<__all_move_constructible<_Types...>::value &&
1670                                       __all_move_assignable<_Types...>::value,
1671                                   variant, __private_type>::type &&
1672             __other) __NOEXCEPT_(__noexcept_variant_move_assign<_Types...>::value) {
1673         if (__other.valueless_by_exception()) {
1674             __destroy_self();
1675         }
1676         else if(__other.index()==index()){
1677             __move_assign_op_table<variant>::__apply[index()](this,__other);
1678             __other.__destroy_self();
1679         }
1680         else{
1681             __replace_construct_helper::__op_table<variant>::__move_assign[
1682                 __other.index()](this,__other);
1683         }
1684         return *this;
1685     }
1686
1687     template<typename _Type,typename ... _Args>
1688     void emplace(_Args&& ... __args){
1689         __direct_replace<__type_index<_Type,_Types...>::__value>(
1690             std::forward<_Args>(__args)...);
1691     }
1692     
1693     template<size_t _Index,typename ... _Args>
1694     void emplace(_Args&& ... __args){
1695         __direct_replace<_Index>(std::forward<_Args>(__args)...);
1696     }
1697     
1698     constexpr bool valueless_by_exception() const __NOEXCEPT{
1699         return __index==-1;
1700     }
1701     constexpr ptrdiff_t index() const __NOEXCEPT{
1702         return __index;
1703     }
1704
1705     void swap(
1706         typename std::conditional<
1707             __all_swappable<_Types...>::value &&
1708                 __all_move_constructible<_Types...>::value,
1709             variant, __private_type>::type
1710             &__other) __NOEXCEPT_(__noexcept_variant_swap<_Types...>::value) {
1711         if (__other.index() == index()) {
1712             if(!valueless_by_exception())
1713                 __swap_op_table<variant>::__apply[index()](*this,__other);
1714         }
1715         else{
1716             variant __temp(std::move(__other));
1717             __other.__index=__other.__move_construct(*this);
1718             __index=__move_construct(__temp);
1719         }
1720     }
1721 };
1722
1723 template<>
1724 class variant<>{
1725 public:
1726     variant()=delete;
1727     
1728     constexpr bool valueless_by_exception() const __NOEXCEPT{
1729         return true;
1730     }
1731     constexpr ptrdiff_t index() const __NOEXCEPT{
1732         return -1;
1733     }
1734
1735     void swap(variant&){}
1736 };
1737
1738 template <typename... _Types>
1739 typename std::enable_if<__all_swappable<_Types...>::value &&
1740                             __all_move_constructible<_Types...>::value,
1741                         void>::type
1742 swap(variant<_Types...> &__lhs, variant<_Types...> &__rhs) __NOEXCEPT_(
1743     __noexcept_variant_swap<_Types...>::value) {
1744     __lhs.swap(__rhs);
1745 }
1746
1747 template<ptrdiff_t _Index,typename ... _Types>
1748 struct __variant_accessor{
1749     typedef typename __indexed_type<_Index,_Types...>::__type __type;
1750     static constexpr __type& get(variant<_Types...>& __v){
1751         return __v.__storage.__get(in_place<_Index>);
1752     }
1753     static constexpr __type const& get(variant<_Types...> const& __v){
1754         return __v.__storage.__get(in_place<_Index>);
1755     }
1756     static constexpr __type&& get(variant<_Types...>&& __v){
1757         return __v.__storage.__get_rref(in_place<_Index>);
1758     }
1759     static constexpr const __type&& get(variant<_Types...> const&& __v){
1760         return __v.__storage.__get_rref(in_place<_Index>);
1761     }
1762 };
1763
1764 template<typename _Type,typename ... _Types>
1765 constexpr _Type& get(variant<_Types...>& __v){
1766     return get<__type_index<_Type,_Types...>::__value>(__v);
1767 }
1768
1769 template<typename _Type,typename ... _Types>
1770 constexpr _Type&& get(variant<_Types...>&& __v){
1771     return get<__type_index<_Type,_Types...>::__value>(std::move(__v));
1772 }
1773
1774 template<typename _Type,typename ... _Types>
1775 constexpr _Type const& get(variant<_Types...> const& __v){
1776     return get<__type_index<_Type,_Types...>::__value>(__v);
1777 }
1778
1779 template<typename _Type,typename ... _Types>
1780 constexpr const _Type&& get(variant<_Types...> const&& __v){
1781     return get<__type_index<_Type,_Types...>::__value>(std::move(__v));
1782 }
1783
1784
1785 template<ptrdiff_t _Index,typename ... _Types>
1786 constexpr typename __indexed_type<_Index,_Types...>::__type const& get(variant<_Types...> const& __v){
1787     return *(
1788         (_Index!=__v.index())
1789             ? &__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type const&>("Bad variant index in get")
1790             : &__variant_accessor<_Index,_Types...>::get(__v)
1791     );
1792 }
1793
1794 template<ptrdiff_t _Index,typename ... _Types>
1795 constexpr typename __indexed_type<_Index,_Types...>::__type& get(variant<_Types...>& __v){
1796     return *(
1797         (_Index!=__v.index())
1798             ? &__throw_bad_variant_access<typename __indexed_type<_Index,_Types...>::__type&>("Bad variant index in get")
1799             : &__variant_accessor<_Index,_Types...>::get(__v)
1800     );
1801 }
1802
1803 template<ptrdiff_t _Index,typename ... _Types>
1804 constexpr typename __indexed_type<_Index,_Types...>::__type&& get(variant<_Types...>&& __v){
1805     return __variant_accessor<_Index,_Types...>::get(
1806         (((_Index!=__v.index()) ? __throw_bad_variant_access<int>("Bad variant index in get") : 0), std::move(__v))
1807     );
1808 }
1809
1810 template<ptrdiff_t _Index,typename ... _Types>
1811 constexpr const typename __indexed_type<_Index,_Types...>::__type&& get(variant<_Types...> const&& __v){
1812     return __variant_accessor<_Index,_Types...>::get(
1813         (((_Index!=__v.index()) ? __throw_bad_variant_access<int>("Bad variant index in get") : 0), std::move(__v))
1814     );
1815 }
1816
1817 template<typename _Type,typename ... _Types>
1818 constexpr std::add_pointer_t<_Type> get_if(variant<_Types...>& __v){
1819     return (__type_index<_Type,_Types...>::__value!=__v.index())?nullptr:&get<_Type>(__v);
1820 }
1821
1822 template<typename _Type,typename ... _Types>
1823 constexpr std::add_pointer_t<_Type const> get_if(variant<_Types...> const& __v){
1824     return (__type_index<_Type,_Types...>::__value!=__v.index())?nullptr:&get<_Type>(__v);
1825 }
1826
1827 template<ptrdiff_t _Index,typename ... _Types>
1828 constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type> get_if(variant<_Types...>& __v){
1829     return ((_Index!=__v.index())?nullptr:
1830         &__variant_accessor<_Index,_Types...>::get(__v));
1831 }
1832
1833 template<ptrdiff_t _Index,typename ... _Types>
1834 constexpr std::add_pointer_t<typename __indexed_type<_Index,_Types...>::__type const> get_if(
1835     variant<_Types...> const& __v){
1836     return ((_Index!=__v.index())?nullptr:
1837         &__variant_accessor<_Index,_Types...>::get(__v));
1838 }
1839
1840 template<typename _Type,typename ... _Types>
1841 constexpr bool holds_alternative(variant<_Types...> const& __v) __NOEXCEPT{
1842     return __v.index()==__type_index<_Type,_Types...>::__value;
1843 }
1844
1845 template<typename _Visitor,typename ... _Types>
1846 struct __visitor_return_type;
1847
1848 template<typename _Visitor>
1849 struct __visitor_return_type<_Visitor>{
1850     typedef decltype(std::declval<_Visitor&>()()) __type;
1851 };
1852
1853 template<typename _Visitor,typename _Head,typename ... _Rest>
1854 struct __visitor_return_type<_Visitor,_Head,_Rest...>{
1855     typedef decltype(std::declval<_Visitor&>()(std::declval<_Head&>())) __type;
1856 };
1857
1858 template<typename _Visitor,typename ... _Types>
1859 struct __visitor_table{
1860     typedef variant<_Types...> __variant_type;
1861     typedef typename __visitor_return_type<_Visitor,_Types...>::__type __return_type;
1862     typedef __return_type (*__func_type)(_Visitor&,__variant_type&);
1863
1864     template<typename _Type>
1865     static __return_type __trampoline_func(_Visitor& __visitor,__variant_type& __v){
1866         return __visitor(get<_Type>(__v));
1867     }
1868
1869     static const __func_type __trampoline[sizeof...(_Types)];
1870 };
1871
1872 template<typename _Visitor,typename ... _Types>
1873 const typename __visitor_table<_Visitor,_Types...>::__func_type __visitor_table<_Visitor,_Types...>::__trampoline[sizeof...(_Types)]={
1874         &__trampoline_func<_Types>...
1875     };
1876
1877 template<typename _Visitor,typename ... _Types>
1878 constexpr typename __visitor_return_type<_Visitor,_Types...>::__type
1879 visit(_Visitor&& __visitor,variant<_Types...>& __v){
1880     return (__v.valueless_by_exception())
1881         ? __throw_bad_variant_access<typename __visitor_return_type<_Visitor,_Types...>::__type>("Visiting of empty variant")
1882         : __visitor_table<_Visitor,_Types...>::__trampoline[__v.index()](__visitor,__v);
1883 }
1884
1885 template<typename _Visitor,typename ... _Variants>
1886 struct __multi_visitor_return_type{
1887     typedef decltype(std::declval<_Visitor&>()(get<0>(std::declval<_Variants>())...))
1888     __type;
1889 };
1890
1891 template<size_t _VariantIndex,typename _Indices>
1892 struct __visit_helper;
1893
1894 template<ptrdiff_t ... _Indices>
1895 struct __visit_helper<0,__index_sequence<_Indices...>>{
1896     template<typename _Visitor,typename ... _Variants>
1897     static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
1898     __visit(_Visitor& __visitor,_Variants& ... __v){
1899         return __visitor(get<_Indices>(__v)...);
1900     }
1901 };
1902
1903 template<size_t _Index,typename ... _Args>
1904 struct __arg_selector_t;
1905
1906 template<typename _Head,typename ... _Rest>
1907 struct __arg_selector_t<0,_Head,_Rest...>{
1908     typedef _Head __type;
1909
1910     static constexpr __type& __select(_Head& __head,_Rest& ...){
1911         return __head;
1912     }
1913 };
1914
1915 template<size_t _Index,typename _Head,typename ... _Rest>
1916 struct __arg_selector_t<_Index,_Head,_Rest...>{
1917     typedef typename __arg_selector_t<_Index-1,_Rest...>::__type __type;
1918     static constexpr __type& __select(_Head&,_Rest& ... __rest){
1919         return __arg_selector_t<_Index-1,_Rest...>::__select(__rest...);
1920     }
1921 };
1922
1923 template<size_t _Index,typename ... _Args>
1924 constexpr typename __arg_selector_t<_Index,_Args...>::__type&& __arg_selector(_Args&& ... __args){
1925     return std::forward<typename __arg_selector_t<_Index,_Args...>::__type>(
1926         __arg_selector_t<_Index,_Args...>::__select(__args...));
1927 }
1928
1929 template<ptrdiff_t _Index,size_t _VariantIndex,ptrdiff_t ... _Indices>
1930 struct __visit_helper2{
1931     template<typename _Visitor,typename ... _Variants>
1932     static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
1933     __visit(_Visitor& __visitor,_Variants&& ... __v){
1934         return (__arg_selector<_VariantIndex-1>(__v...).index()==_Index)
1935             ? __visit_helper<_VariantIndex-1,__index_sequence<_Index,_Indices...>>::__visit(__visitor,std::forward<_Variants>(__v)...)
1936             : __visit_helper2<_Index-1,_VariantIndex,_Indices...>::__visit(__visitor,std::forward<_Variants>(__v)...);
1937     }
1938 };
1939
1940 template<size_t _VariantIndex,ptrdiff_t ... _Indices>
1941 struct __visit_helper2<-1,_VariantIndex,_Indices...>{
1942     template<typename _Visitor,typename ... _Variants>
1943     static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
1944     __visit(_Visitor&,_Variants&& ...){
1945         __throw_bad_variant_access<typename __multi_visitor_return_type<_Visitor,_Variants...>::__type>("Visiting of empty variant");
1946     }
1947 };
1948
1949 template<typename _Variant>
1950 struct __variant_type_count;
1951
1952 template<typename ... _Types>
1953 struct __variant_type_count<variant<_Types...>>{
1954     static constexpr size_t __value=sizeof...(_Types);
1955 };
1956
1957 template<typename _Variant>
1958 struct __variant_type_count<_Variant&>{
1959     static constexpr size_t __value=__variant_type_count<_Variant>::__value;
1960 };
1961
1962 template<typename _Variant>
1963 struct __variant_type_count<_Variant const&>{
1964     static constexpr size_t __value=__variant_type_count<_Variant>::__value;
1965 };
1966
1967 template<size_t _VariantIndex,ptrdiff_t ... _Indices>
1968 struct __visit_helper<_VariantIndex,__index_sequence<_Indices...>>{
1969
1970     template<typename _Visitor,typename ... _Variants>
1971     static constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
1972     __visit(_Visitor& __visitor,_Variants&& ... __v){
1973         return __visit_helper2<
1974             __variant_type_count<
1975                 typename __arg_selector_t<
1976                     _VariantIndex-1,_Variants...>::__type>::__value-1,
1977             _VariantIndex,_Indices...>::__visit(
1978                 __visitor,std::forward<_Variants&&>(__v)...);
1979     }
1980 };
1981
1982 template<typename _Visitor,typename ... _Variants>
1983 constexpr typename __multi_visitor_return_type<_Visitor,_Variants...>::__type
1984 visit(_Visitor&& __visitor,_Variants&& ... __v){
1985     return __visit_helper<sizeof...(_Variants),__index_sequence<>>::__visit(
1986         __visitor,std::forward<_Variants>(__v)...);
1987 }
1988
1989 template<typename ... _Types>
1990 constexpr bool operator==(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
1991     return (__lhs.index()==__rhs.index()) &&
1992         ((__lhs.index()==-1) ||
1993          __equality_op_table<variant<_Types...>>::__equality_compare[__lhs.index()](
1994              __lhs,__rhs));
1995 }
1996
1997 template<typename ... _Types>
1998 constexpr bool operator!=(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
1999     return !(__lhs==__rhs);
2000 }
2001
2002 template<typename ... _Types>
2003 constexpr bool operator<(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
2004     return (__lhs.index()<__rhs.index()) ||
2005         ((__lhs.index()==__rhs.index()) &&
2006          ((__lhs.index()!=-1) &&
2007           __less_than_op_table<variant<_Types...>>::
2008           __less_than_compare[__lhs.index()](__lhs,__rhs)));
2009 }
2010
2011 template<typename ... _Types>
2012 constexpr bool operator>(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
2013     return __rhs<__lhs;
2014 }
2015
2016 template<typename ... _Types>
2017 constexpr bool operator>=(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
2018     return !(__lhs<__rhs);
2019 }
2020
2021 template<typename ... _Types>
2022 constexpr bool operator<=(variant<_Types...> const& __lhs,variant<_Types...> const& __rhs){
2023     return !(__lhs>__rhs);
2024 }
2025
2026 struct monostate{};
2027
2028 constexpr inline bool operator==(monostate const&,monostate const&){ return true;}
2029 constexpr inline bool operator!=(monostate const&,monostate const&){ return false;}
2030 constexpr inline bool operator>=(monostate const&,monostate const&){ return true;}
2031 constexpr inline bool operator<=(monostate const&,monostate const&){ return true;}
2032 constexpr inline bool operator>(monostate const&,monostate const&){ return false;}
2033 constexpr inline bool operator<(monostate const&,monostate const&){ return false;}
2034
2035 struct __hash_visitor{
2036     template<typename _Type>
2037     size_t operator()(_Type const& __x){
2038         return std::hash<_Type>()(__x);
2039     }
2040 };
2041
2042 } // namespace experimental
2043
2044 template<>
2045 struct hash<experimental::monostate>{
2046     size_t operator()(experimental::monostate) __NOEXCEPT{
2047         return 42;
2048     }
2049 };
2050
2051 template<typename ... _Types>
2052 struct hash<experimental::variant<_Types...>>{
2053     size_t operator()(experimental::variant<_Types...> const &v) __NOEXCEPT {
2054         return std::hash<ptrdiff_t>()(v.index()) ^
2055                experimental::visit(experimental::__hash_visitor(), v);
2056     }
2057 };
2058
2059 } // namespace std
2060
2061 #if COMPILER(MSVC)
2062 #pragma warning(pop)
2063 #endif