Embedded Template Library 1.0
Loading...
Searching...
No Matches
variant_select_do_operator.h
1/******************************************************************************
2The MIT License(MIT)
3
4Embedded Template Library.
5https://github.com/ETLCPP/etl
6https://www.etlcpp.com
7
8Copyright(c) 2025 John Wellbelove
9
10Permission is hereby granted, free of charge, to any person obtaining a copy
11of this software and associated documentation files(the "Software"), to deal
12in the Software without restriction, including without limitation the rights
13to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
14copies of the Software, and to permit persons to whom the Software is
15furnished to do so, subject to the following conditions :
16
17The above copyright notice and this permission notice shall be included in all
18copies or substantial portions of the Software.
19
20THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
23AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26SOFTWARE.
27******************************************************************************/
28
29//***************************************************************************
30// This file is included in variant_variadic.h for C++11 and C++14, as they
31// do not support template fold expressions.
32//***************************************************************************
33
34namespace private_variant
35{
36 //***************************************************************************
37 // Selects a do_operator inplementation that is configured for the number of
38 // types.
39 //***************************************************************************
40 template <size_t NTypes>
41 struct select_do_operator;
42
43 //***************************************************************************
44 template <>
45 struct select_do_operator<1>
46 {
47 template <typename TVariant, typename TVisitor>
48 static void do_operator(TVariant& the_variant, TVisitor& visitor)
49 {
50 switch (the_variant.index())
51 {
52 case 0:
53 {
54 visitor(etl::get<0>(the_variant));
55 break;
56 }
57 default: break;
58 }
59 }
60 };
61
62 //***************************************************************************
63 template <>
64 struct select_do_operator<2>
65 {
66 template <typename TVariant, typename TVisitor>
67 static void do_operator(TVariant& the_variant, TVisitor& visitor)
68 {
69 switch (the_variant.index())
70 {
71 case 0:
72 {
73 visitor(etl::get<0>(the_variant));
74 break;
75 }
76 case 1:
77 {
78 visitor(etl::get<1>(the_variant));
79 break;
80 }
81 default: break;
82 }
83 }
84 };
85
86 //***************************************************************************
87 template <>
88 struct select_do_operator<3>
89 {
90 template <typename TVariant, typename TVisitor>
91 static void do_operator(TVariant& the_variant, TVisitor& visitor)
92 {
93 switch (the_variant.index())
94 {
95 case 0:
96 {
97 visitor(etl::get<0>(the_variant));
98 break;
99 }
100 case 1:
101 {
102 visitor(etl::get<1>(the_variant));
103 break;
104 }
105 case 2:
106 {
107 visitor(etl::get<2>(the_variant));
108 break;
109 }
110 default: break;
111 }
112 }
113 };
114
115 //***************************************************************************
116 template <>
117 struct select_do_operator<4>
118 {
119 template <typename TVariant, typename TVisitor>
120 static void do_operator(TVariant& the_variant, TVisitor& visitor)
121 {
122 switch (the_variant.index())
123 {
124 case 0:
125 {
126 visitor(etl::get<0>(the_variant));
127 break;
128 }
129 case 1:
130 {
131 visitor(etl::get<1>(the_variant));
132 break;
133 }
134 case 2:
135 {
136 visitor(etl::get<2>(the_variant));
137 break;
138 }
139 case 3:
140 {
141 visitor(etl::get<3>(the_variant));
142 break;
143 }
144 default: break;
145 }
146 }
147 };
148
149 //***************************************************************************
150 template <>
151 struct select_do_operator<5>
152 {
153 template <typename TVariant, typename TVisitor>
154 static void do_operator(TVariant& the_variant, TVisitor& visitor)
155 {
156 switch (the_variant.index())
157 {
158 case 0:
159 {
160 visitor(etl::get<0>(the_variant));
161 break;
162 }
163 case 1:
164 {
165 visitor(etl::get<1>(the_variant));
166 break;
167 }
168 case 2:
169 {
170 visitor(etl::get<2>(the_variant));
171 break;
172 }
173 case 3:
174 {
175 visitor(etl::get<3>(the_variant));
176 break;
177 }
178 case 4:
179 {
180 visitor(etl::get<4>(the_variant));
181 break;
182 }
183 default: break;
184 }
185 }
186 };
187
188 //***************************************************************************
189 template <>
190 struct select_do_operator<6>
191 {
192 template <typename TVariant, typename TVisitor>
193 static void do_operator(TVariant& the_variant, TVisitor& visitor)
194 {
195 switch (the_variant.index())
196 {
197 case 0:
198 {
199 visitor(etl::get<0>(the_variant));
200 break;
201 }
202 case 1:
203 {
204 visitor(etl::get<1>(the_variant));
205 break;
206 }
207 case 2:
208 {
209 visitor(etl::get<2>(the_variant));
210 break;
211 }
212 case 3:
213 {
214 visitor(etl::get<3>(the_variant));
215 break;
216 }
217 case 4:
218 {
219 visitor(etl::get<4>(the_variant));
220 break;
221 }
222 case 5:
223 {
224 visitor(etl::get<5>(the_variant));
225 break;
226 }
227 default: break;
228 }
229 }
230 };
231
232 //***************************************************************************
233 template <>
234 struct select_do_operator<7>
235 {
236 template <typename TVariant, typename TVisitor>
237 static void do_operator(TVariant& the_variant, TVisitor& visitor)
238 {
239 switch (the_variant.index())
240 {
241 case 0:
242 {
243 visitor(etl::get<0>(the_variant));
244 break;
245 }
246 case 1:
247 {
248 visitor(etl::get<1>(the_variant));
249 break;
250 }
251 case 2:
252 {
253 visitor(etl::get<2>(the_variant));
254 break;
255 }
256 case 3:
257 {
258 visitor(etl::get<3>(the_variant));
259 break;
260 }
261 case 4:
262 {
263 visitor(etl::get<4>(the_variant));
264 break;
265 }
266 case 5:
267 {
268 visitor(etl::get<5>(the_variant));
269 break;
270 }
271 case 6:
272 {
273 visitor(etl::get<6>(the_variant));
274 break;
275 }
276 default: break;
277 }
278 }
279 };
280
281 //***************************************************************************
282 template <>
283 struct select_do_operator<8>
284 {
285 template <typename TVariant, typename TVisitor>
286 static void do_operator(TVariant& the_variant, TVisitor& visitor)
287 {
288 switch (the_variant.index())
289 {
290 case 0:
291 {
292 visitor(etl::get<0>(the_variant));
293 break;
294 }
295 case 1:
296 {
297 visitor(etl::get<1>(the_variant));
298 break;
299 }
300 case 2:
301 {
302 visitor(etl::get<2>(the_variant));
303 break;
304 }
305 case 3:
306 {
307 visitor(etl::get<3>(the_variant));
308 break;
309 }
310 case 4:
311 {
312 visitor(etl::get<4>(the_variant));
313 break;
314 }
315 case 5:
316 {
317 visitor(etl::get<5>(the_variant));
318 break;
319 }
320 case 6:
321 {
322 visitor(etl::get<6>(the_variant));
323 break;
324 }
325 case 7:
326 {
327 visitor(etl::get<7>(the_variant));
328 break;
329 }
330 default: break;
331 }
332 }
333 };
334#if !defined(ETL_VARIANT_CPP11_MAX_8_TYPES)
335 //***************************************************************************
336 template <>
337 struct select_do_operator<9>
338 {
339 template <typename TVariant, typename TVisitor>
340 static void do_operator(TVariant& the_variant, TVisitor& visitor)
341 {
342 switch (the_variant.index())
343 {
344 case 0:
345 {
346 visitor(etl::get<0>(the_variant));
347 break;
348 }
349 case 1:
350 {
351 visitor(etl::get<1>(the_variant));
352 break;
353 }
354 case 2:
355 {
356 visitor(etl::get<2>(the_variant));
357 break;
358 }
359 case 3:
360 {
361 visitor(etl::get<3>(the_variant));
362 break;
363 }
364 case 4:
365 {
366 visitor(etl::get<4>(the_variant));
367 break;
368 }
369 case 5:
370 {
371 visitor(etl::get<5>(the_variant));
372 break;
373 }
374 case 6:
375 {
376 visitor(etl::get<6>(the_variant));
377 break;
378 }
379 case 7:
380 {
381 visitor(etl::get<7>(the_variant));
382 break;
383 }
384 case 8:
385 {
386 visitor(etl::get<8>(the_variant));
387 break;
388 }
389 default: break;
390 }
391 }
392 };
393
394 //***************************************************************************
395 template <>
396 struct select_do_operator<10>
397 {
398 template <typename TVariant, typename TVisitor>
399 static void do_operator(TVariant& the_variant, TVisitor& visitor)
400 {
401 switch (the_variant.index())
402 {
403 case 0:
404 {
405 visitor(etl::get<0>(the_variant));
406 break;
407 }
408 case 1:
409 {
410 visitor(etl::get<1>(the_variant));
411 break;
412 }
413 case 2:
414 {
415 visitor(etl::get<2>(the_variant));
416 break;
417 }
418 case 3:
419 {
420 visitor(etl::get<3>(the_variant));
421 break;
422 }
423 case 4:
424 {
425 visitor(etl::get<4>(the_variant));
426 break;
427 }
428 case 5:
429 {
430 visitor(etl::get<5>(the_variant));
431 break;
432 }
433 case 6:
434 {
435 visitor(etl::get<6>(the_variant));
436 break;
437 }
438 case 7:
439 {
440 visitor(etl::get<7>(the_variant));
441 break;
442 }
443 case 8:
444 {
445 visitor(etl::get<8>(the_variant));
446 break;
447 }
448 case 9:
449 {
450 visitor(etl::get<9>(the_variant));
451 break;
452 }
453 default: break;
454 }
455 }
456 };
457
458 //***************************************************************************
459 template <>
460 struct select_do_operator<11>
461 {
462 template <typename TVariant, typename TVisitor>
463 static void do_operator(TVariant& the_variant, TVisitor& visitor)
464 {
465 switch (the_variant.index())
466 {
467 case 0:
468 {
469 visitor(etl::get<0>(the_variant));
470 break;
471 }
472 case 1:
473 {
474 visitor(etl::get<1>(the_variant));
475 break;
476 }
477 case 2:
478 {
479 visitor(etl::get<2>(the_variant));
480 break;
481 }
482 case 3:
483 {
484 visitor(etl::get<3>(the_variant));
485 break;
486 }
487 case 4:
488 {
489 visitor(etl::get<4>(the_variant));
490 break;
491 }
492 case 5:
493 {
494 visitor(etl::get<5>(the_variant));
495 break;
496 }
497 case 6:
498 {
499 visitor(etl::get<6>(the_variant));
500 break;
501 }
502 case 7:
503 {
504 visitor(etl::get<7>(the_variant));
505 break;
506 }
507 case 8:
508 {
509 visitor(etl::get<8>(the_variant));
510 break;
511 }
512 case 9:
513 {
514 visitor(etl::get<9>(the_variant));
515 break;
516 }
517 case 10:
518 {
519 visitor(etl::get<10>(the_variant));
520 break;
521 }
522 default: break;
523 }
524 }
525 };
526
527 //***************************************************************************
528 template <>
529 struct select_do_operator<12>
530 {
531 template <typename TVariant, typename TVisitor>
532 static void do_operator(TVariant& the_variant, TVisitor& visitor)
533 {
534 switch (the_variant.index())
535 {
536 case 0:
537 {
538 visitor(etl::get<0>(the_variant));
539 break;
540 }
541 case 1:
542 {
543 visitor(etl::get<1>(the_variant));
544 break;
545 }
546 case 2:
547 {
548 visitor(etl::get<2>(the_variant));
549 break;
550 }
551 case 3:
552 {
553 visitor(etl::get<3>(the_variant));
554 break;
555 }
556 case 4:
557 {
558 visitor(etl::get<4>(the_variant));
559 break;
560 }
561 case 5:
562 {
563 visitor(etl::get<5>(the_variant));
564 break;
565 }
566 case 6:
567 {
568 visitor(etl::get<6>(the_variant));
569 break;
570 }
571 case 7:
572 {
573 visitor(etl::get<7>(the_variant));
574 break;
575 }
576 case 8:
577 {
578 visitor(etl::get<8>(the_variant));
579 break;
580 }
581 case 9:
582 {
583 visitor(etl::get<9>(the_variant));
584 break;
585 }
586 case 10:
587 {
588 visitor(etl::get<10>(the_variant));
589 break;
590 }
591 case 11:
592 {
593 visitor(etl::get<11>(the_variant));
594 break;
595 }
596 default: break;
597 }
598 }
599 };
600
601 //***************************************************************************
602 template <>
603 struct select_do_operator<13>
604 {
605 template <typename TVariant, typename TVisitor>
606 static void do_operator(TVariant& the_variant, TVisitor& visitor)
607 {
608 switch (the_variant.index())
609 {
610 case 0:
611 {
612 visitor(etl::get<0>(the_variant));
613 break;
614 }
615 case 1:
616 {
617 visitor(etl::get<1>(the_variant));
618 break;
619 }
620 case 2:
621 {
622 visitor(etl::get<2>(the_variant));
623 break;
624 }
625 case 3:
626 {
627 visitor(etl::get<3>(the_variant));
628 break;
629 }
630 case 4:
631 {
632 visitor(etl::get<4>(the_variant));
633 break;
634 }
635 case 5:
636 {
637 visitor(etl::get<5>(the_variant));
638 break;
639 }
640 case 6:
641 {
642 visitor(etl::get<6>(the_variant));
643 break;
644 }
645 case 7:
646 {
647 visitor(etl::get<7>(the_variant));
648 break;
649 }
650 case 8:
651 {
652 visitor(etl::get<8>(the_variant));
653 break;
654 }
655 case 9:
656 {
657 visitor(etl::get<9>(the_variant));
658 break;
659 }
660 case 10:
661 {
662 visitor(etl::get<10>(the_variant));
663 break;
664 }
665 case 11:
666 {
667 visitor(etl::get<11>(the_variant));
668 break;
669 }
670 case 12:
671 {
672 visitor(etl::get<12>(the_variant));
673 break;
674 }
675 default: break;
676 }
677 }
678 };
679
680 //***************************************************************************
681 template <>
682 struct select_do_operator<14>
683 {
684 template <typename TVariant, typename TVisitor>
685 static void do_operator(TVariant& the_variant, TVisitor& visitor)
686 {
687 switch (the_variant.index())
688 {
689 case 0:
690 {
691 visitor(etl::get<0>(the_variant));
692 break;
693 }
694 case 1:
695 {
696 visitor(etl::get<1>(the_variant));
697 break;
698 }
699 case 2:
700 {
701 visitor(etl::get<2>(the_variant));
702 break;
703 }
704 case 3:
705 {
706 visitor(etl::get<3>(the_variant));
707 break;
708 }
709 case 4:
710 {
711 visitor(etl::get<4>(the_variant));
712 break;
713 }
714 case 5:
715 {
716 visitor(etl::get<5>(the_variant));
717 break;
718 }
719 case 6:
720 {
721 visitor(etl::get<6>(the_variant));
722 break;
723 }
724 case 7:
725 {
726 visitor(etl::get<7>(the_variant));
727 break;
728 }
729 case 8:
730 {
731 visitor(etl::get<8>(the_variant));
732 break;
733 }
734 case 9:
735 {
736 visitor(etl::get<9>(the_variant));
737 break;
738 }
739 case 10:
740 {
741 visitor(etl::get<10>(the_variant));
742 break;
743 }
744 case 11:
745 {
746 visitor(etl::get<11>(the_variant));
747 break;
748 }
749 case 12:
750 {
751 visitor(etl::get<12>(the_variant));
752 break;
753 }
754 case 13:
755 {
756 visitor(etl::get<13>(the_variant));
757 break;
758 }
759 default: break;
760 }
761 }
762 };
763
764 //***************************************************************************
765 template <>
766 struct select_do_operator<15>
767 {
768 template <typename TVariant, typename TVisitor>
769 static void do_operator(TVariant& the_variant, TVisitor& visitor)
770 {
771 switch (the_variant.index())
772 {
773 case 0:
774 {
775 visitor(etl::get<0>(the_variant));
776 break;
777 }
778 case 1:
779 {
780 visitor(etl::get<1>(the_variant));
781 break;
782 }
783 case 2:
784 {
785 visitor(etl::get<2>(the_variant));
786 break;
787 }
788 case 3:
789 {
790 visitor(etl::get<3>(the_variant));
791 break;
792 }
793 case 4:
794 {
795 visitor(etl::get<4>(the_variant));
796 break;
797 }
798 case 5:
799 {
800 visitor(etl::get<5>(the_variant));
801 break;
802 }
803 case 6:
804 {
805 visitor(etl::get<6>(the_variant));
806 break;
807 }
808 case 7:
809 {
810 visitor(etl::get<7>(the_variant));
811 break;
812 }
813 case 8:
814 {
815 visitor(etl::get<8>(the_variant));
816 break;
817 }
818 case 9:
819 {
820 visitor(etl::get<9>(the_variant));
821 break;
822 }
823 case 10:
824 {
825 visitor(etl::get<10>(the_variant));
826 break;
827 }
828 case 11:
829 {
830 visitor(etl::get<11>(the_variant));
831 break;
832 }
833 case 12:
834 {
835 visitor(etl::get<12>(the_variant));
836 break;
837 }
838 case 13:
839 {
840 visitor(etl::get<13>(the_variant));
841 break;
842 }
843 case 14:
844 {
845 visitor(etl::get<14>(the_variant));
846 break;
847 }
848 default: break;
849 }
850 }
851 };
852
853 //***************************************************************************
854 template <>
855 struct select_do_operator<16>
856 {
857 template <typename TVariant, typename TVisitor>
858 static void do_operator(TVariant& the_variant, TVisitor& visitor)
859 {
860 switch (the_variant.index())
861 {
862 case 0:
863 {
864 visitor(etl::get<0>(the_variant));
865 break;
866 }
867 case 1:
868 {
869 visitor(etl::get<1>(the_variant));
870 break;
871 }
872 case 2:
873 {
874 visitor(etl::get<2>(the_variant));
875 break;
876 }
877 case 3:
878 {
879 visitor(etl::get<3>(the_variant));
880 break;
881 }
882 case 4:
883 {
884 visitor(etl::get<4>(the_variant));
885 break;
886 }
887 case 5:
888 {
889 visitor(etl::get<5>(the_variant));
890 break;
891 }
892 case 6:
893 {
894 visitor(etl::get<6>(the_variant));
895 break;
896 }
897 case 7:
898 {
899 visitor(etl::get<7>(the_variant));
900 break;
901 }
902 case 8:
903 {
904 visitor(etl::get<8>(the_variant));
905 break;
906 }
907 case 9:
908 {
909 visitor(etl::get<9>(the_variant));
910 break;
911 }
912 case 10:
913 {
914 visitor(etl::get<10>(the_variant));
915 break;
916 }
917 case 11:
918 {
919 visitor(etl::get<11>(the_variant));
920 break;
921 }
922 case 12:
923 {
924 visitor(etl::get<12>(the_variant));
925 break;
926 }
927 case 13:
928 {
929 visitor(etl::get<13>(the_variant));
930 break;
931 }
932 case 14:
933 {
934 visitor(etl::get<14>(the_variant));
935 break;
936 }
937 case 15:
938 {
939 visitor(etl::get<15>(the_variant));
940 break;
941 }
942 default: break;
943 }
944 }
945 };
946 #if !defined(ETL_VARIANT_CPP11_MAX_16_TYPES)
947 //***************************************************************************
948 template <>
949 struct select_do_operator<17>
950 {
951 template <typename TVariant, typename TVisitor>
952 static void do_operator(TVariant& the_variant, TVisitor& visitor)
953 {
954 switch (the_variant.index())
955 {
956 case 0:
957 {
958 visitor(etl::get<0>(the_variant));
959 break;
960 }
961 case 1:
962 {
963 visitor(etl::get<1>(the_variant));
964 break;
965 }
966 case 2:
967 {
968 visitor(etl::get<2>(the_variant));
969 break;
970 }
971 case 3:
972 {
973 visitor(etl::get<3>(the_variant));
974 break;
975 }
976 case 4:
977 {
978 visitor(etl::get<4>(the_variant));
979 break;
980 }
981 case 5:
982 {
983 visitor(etl::get<5>(the_variant));
984 break;
985 }
986 case 6:
987 {
988 visitor(etl::get<6>(the_variant));
989 break;
990 }
991 case 7:
992 {
993 visitor(etl::get<7>(the_variant));
994 break;
995 }
996 case 8:
997 {
998 visitor(etl::get<8>(the_variant));
999 break;
1000 }
1001 case 9:
1002 {
1003 visitor(etl::get<9>(the_variant));
1004 break;
1005 }
1006 case 10:
1007 {
1008 visitor(etl::get<10>(the_variant));
1009 break;
1010 }
1011 case 11:
1012 {
1013 visitor(etl::get<11>(the_variant));
1014 break;
1015 }
1016 case 12:
1017 {
1018 visitor(etl::get<12>(the_variant));
1019 break;
1020 }
1021 case 13:
1022 {
1023 visitor(etl::get<13>(the_variant));
1024 break;
1025 }
1026 case 14:
1027 {
1028 visitor(etl::get<14>(the_variant));
1029 break;
1030 }
1031 case 15:
1032 {
1033 visitor(etl::get<15>(the_variant));
1034 break;
1035 }
1036 case 16:
1037 {
1038 visitor(etl::get<16>(the_variant));
1039 break;
1040 }
1041 default: break;
1042 }
1043 }
1044 };
1045
1046 //***************************************************************************
1047 template <>
1048 struct select_do_operator<18>
1049 {
1050 template <typename TVariant, typename TVisitor>
1051 static void do_operator(TVariant& the_variant, TVisitor& visitor)
1052 {
1053 switch (the_variant.index())
1054 {
1055 case 0:
1056 {
1057 visitor(etl::get<0>(the_variant));
1058 break;
1059 }
1060 case 1:
1061 {
1062 visitor(etl::get<1>(the_variant));
1063 break;
1064 }
1065 case 2:
1066 {
1067 visitor(etl::get<2>(the_variant));
1068 break;
1069 }
1070 case 3:
1071 {
1072 visitor(etl::get<3>(the_variant));
1073 break;
1074 }
1075 case 4:
1076 {
1077 visitor(etl::get<4>(the_variant));
1078 break;
1079 }
1080 case 5:
1081 {
1082 visitor(etl::get<5>(the_variant));
1083 break;
1084 }
1085 case 6:
1086 {
1087 visitor(etl::get<6>(the_variant));
1088 break;
1089 }
1090 case 7:
1091 {
1092 visitor(etl::get<7>(the_variant));
1093 break;
1094 }
1095 case 8:
1096 {
1097 visitor(etl::get<8>(the_variant));
1098 break;
1099 }
1100 case 9:
1101 {
1102 visitor(etl::get<9>(the_variant));
1103 break;
1104 }
1105 case 10:
1106 {
1107 visitor(etl::get<10>(the_variant));
1108 break;
1109 }
1110 case 11:
1111 {
1112 visitor(etl::get<11>(the_variant));
1113 break;
1114 }
1115 case 12:
1116 {
1117 visitor(etl::get<12>(the_variant));
1118 break;
1119 }
1120 case 13:
1121 {
1122 visitor(etl::get<13>(the_variant));
1123 break;
1124 }
1125 case 14:
1126 {
1127 visitor(etl::get<14>(the_variant));
1128 break;
1129 }
1130 case 15:
1131 {
1132 visitor(etl::get<15>(the_variant));
1133 break;
1134 }
1135 case 16:
1136 {
1137 visitor(etl::get<16>(the_variant));
1138 break;
1139 }
1140 case 17:
1141 {
1142 visitor(etl::get<17>(the_variant));
1143 break;
1144 }
1145 default: break;
1146 }
1147 }
1148 };
1149
1150 //***************************************************************************
1151 template <>
1152 struct select_do_operator<19>
1153 {
1154 template <typename TVariant, typename TVisitor>
1155 static void do_operator(TVariant& the_variant, TVisitor& visitor)
1156 {
1157 switch (the_variant.index())
1158 {
1159 case 0:
1160 {
1161 visitor(etl::get<0>(the_variant));
1162 break;
1163 }
1164 case 1:
1165 {
1166 visitor(etl::get<1>(the_variant));
1167 break;
1168 }
1169 case 2:
1170 {
1171 visitor(etl::get<2>(the_variant));
1172 break;
1173 }
1174 case 3:
1175 {
1176 visitor(etl::get<3>(the_variant));
1177 break;
1178 }
1179 case 4:
1180 {
1181 visitor(etl::get<4>(the_variant));
1182 break;
1183 }
1184 case 5:
1185 {
1186 visitor(etl::get<5>(the_variant));
1187 break;
1188 }
1189 case 6:
1190 {
1191 visitor(etl::get<6>(the_variant));
1192 break;
1193 }
1194 case 7:
1195 {
1196 visitor(etl::get<7>(the_variant));
1197 break;
1198 }
1199 case 8:
1200 {
1201 visitor(etl::get<8>(the_variant));
1202 break;
1203 }
1204 case 9:
1205 {
1206 visitor(etl::get<9>(the_variant));
1207 break;
1208 }
1209 case 10:
1210 {
1211 visitor(etl::get<10>(the_variant));
1212 break;
1213 }
1214 case 11:
1215 {
1216 visitor(etl::get<11>(the_variant));
1217 break;
1218 }
1219 case 12:
1220 {
1221 visitor(etl::get<12>(the_variant));
1222 break;
1223 }
1224 case 13:
1225 {
1226 visitor(etl::get<13>(the_variant));
1227 break;
1228 }
1229 case 14:
1230 {
1231 visitor(etl::get<14>(the_variant));
1232 break;
1233 }
1234 case 15:
1235 {
1236 visitor(etl::get<15>(the_variant));
1237 break;
1238 }
1239 case 16:
1240 {
1241 visitor(etl::get<16>(the_variant));
1242 break;
1243 }
1244 case 17:
1245 {
1246 visitor(etl::get<17>(the_variant));
1247 break;
1248 }
1249 case 18:
1250 {
1251 visitor(etl::get<18>(the_variant));
1252 break;
1253 }
1254 default: break;
1255 }
1256 }
1257 };
1258
1259 //***************************************************************************
1260 template <>
1261 struct select_do_operator<20>
1262 {
1263 template <typename TVariant, typename TVisitor>
1264 static void do_operator(TVariant& the_variant, TVisitor& visitor)
1265 {
1266 switch (the_variant.index())
1267 {
1268 case 0:
1269 {
1270 visitor(etl::get<0>(the_variant));
1271 break;
1272 }
1273 case 1:
1274 {
1275 visitor(etl::get<1>(the_variant));
1276 break;
1277 }
1278 case 2:
1279 {
1280 visitor(etl::get<2>(the_variant));
1281 break;
1282 }
1283 case 3:
1284 {
1285 visitor(etl::get<3>(the_variant));
1286 break;
1287 }
1288 case 4:
1289 {
1290 visitor(etl::get<4>(the_variant));
1291 break;
1292 }
1293 case 5:
1294 {
1295 visitor(etl::get<5>(the_variant));
1296 break;
1297 }
1298 case 6:
1299 {
1300 visitor(etl::get<6>(the_variant));
1301 break;
1302 }
1303 case 7:
1304 {
1305 visitor(etl::get<7>(the_variant));
1306 break;
1307 }
1308 case 8:
1309 {
1310 visitor(etl::get<8>(the_variant));
1311 break;
1312 }
1313 case 9:
1314 {
1315 visitor(etl::get<9>(the_variant));
1316 break;
1317 }
1318 case 10:
1319 {
1320 visitor(etl::get<10>(the_variant));
1321 break;
1322 }
1323 case 11:
1324 {
1325 visitor(etl::get<11>(the_variant));
1326 break;
1327 }
1328 case 12:
1329 {
1330 visitor(etl::get<12>(the_variant));
1331 break;
1332 }
1333 case 13:
1334 {
1335 visitor(etl::get<13>(the_variant));
1336 break;
1337 }
1338 case 14:
1339 {
1340 visitor(etl::get<14>(the_variant));
1341 break;
1342 }
1343 case 15:
1344 {
1345 visitor(etl::get<15>(the_variant));
1346 break;
1347 }
1348 case 16:
1349 {
1350 visitor(etl::get<16>(the_variant));
1351 break;
1352 }
1353 case 17:
1354 {
1355 visitor(etl::get<17>(the_variant));
1356 break;
1357 }
1358 case 18:
1359 {
1360 visitor(etl::get<18>(the_variant));
1361 break;
1362 }
1363 case 19:
1364 {
1365 visitor(etl::get<19>(the_variant));
1366 break;
1367 }
1368 default: break;
1369 }
1370 }
1371 };
1372
1373 //***************************************************************************
1374 template <>
1375 struct select_do_operator<21>
1376 {
1377 template <typename TVariant, typename TVisitor>
1378 static void do_operator(TVariant& the_variant, TVisitor& visitor)
1379 {
1380 switch (the_variant.index())
1381 {
1382 case 0:
1383 {
1384 visitor(etl::get<0>(the_variant));
1385 break;
1386 }
1387 case 1:
1388 {
1389 visitor(etl::get<1>(the_variant));
1390 break;
1391 }
1392 case 2:
1393 {
1394 visitor(etl::get<2>(the_variant));
1395 break;
1396 }
1397 case 3:
1398 {
1399 visitor(etl::get<3>(the_variant));
1400 break;
1401 }
1402 case 4:
1403 {
1404 visitor(etl::get<4>(the_variant));
1405 break;
1406 }
1407 case 5:
1408 {
1409 visitor(etl::get<5>(the_variant));
1410 break;
1411 }
1412 case 6:
1413 {
1414 visitor(etl::get<6>(the_variant));
1415 break;
1416 }
1417 case 7:
1418 {
1419 visitor(etl::get<7>(the_variant));
1420 break;
1421 }
1422 case 8:
1423 {
1424 visitor(etl::get<8>(the_variant));
1425 break;
1426 }
1427 case 9:
1428 {
1429 visitor(etl::get<9>(the_variant));
1430 break;
1431 }
1432 case 10:
1433 {
1434 visitor(etl::get<10>(the_variant));
1435 break;
1436 }
1437 case 11:
1438 {
1439 visitor(etl::get<11>(the_variant));
1440 break;
1441 }
1442 case 12:
1443 {
1444 visitor(etl::get<12>(the_variant));
1445 break;
1446 }
1447 case 13:
1448 {
1449 visitor(etl::get<13>(the_variant));
1450 break;
1451 }
1452 case 14:
1453 {
1454 visitor(etl::get<14>(the_variant));
1455 break;
1456 }
1457 case 15:
1458 {
1459 visitor(etl::get<15>(the_variant));
1460 break;
1461 }
1462 case 16:
1463 {
1464 visitor(etl::get<16>(the_variant));
1465 break;
1466 }
1467 case 17:
1468 {
1469 visitor(etl::get<17>(the_variant));
1470 break;
1471 }
1472 case 18:
1473 {
1474 visitor(etl::get<18>(the_variant));
1475 break;
1476 }
1477 case 19:
1478 {
1479 visitor(etl::get<19>(the_variant));
1480 break;
1481 }
1482 case 20:
1483 {
1484 visitor(etl::get<20>(the_variant));
1485 break;
1486 }
1487 default: break;
1488 }
1489 }
1490 };
1491
1492 //***************************************************************************
1493 template <>
1494 struct select_do_operator<22>
1495 {
1496 template <typename TVariant, typename TVisitor>
1497 static void do_operator(TVariant& the_variant, TVisitor& visitor)
1498 {
1499 switch (the_variant.index())
1500 {
1501 case 0:
1502 {
1503 visitor(etl::get<0>(the_variant));
1504 break;
1505 }
1506 case 1:
1507 {
1508 visitor(etl::get<1>(the_variant));
1509 break;
1510 }
1511 case 2:
1512 {
1513 visitor(etl::get<2>(the_variant));
1514 break;
1515 }
1516 case 3:
1517 {
1518 visitor(etl::get<3>(the_variant));
1519 break;
1520 }
1521 case 4:
1522 {
1523 visitor(etl::get<4>(the_variant));
1524 break;
1525 }
1526 case 5:
1527 {
1528 visitor(etl::get<5>(the_variant));
1529 break;
1530 }
1531 case 6:
1532 {
1533 visitor(etl::get<6>(the_variant));
1534 break;
1535 }
1536 case 7:
1537 {
1538 visitor(etl::get<7>(the_variant));
1539 break;
1540 }
1541 case 8:
1542 {
1543 visitor(etl::get<8>(the_variant));
1544 break;
1545 }
1546 case 9:
1547 {
1548 visitor(etl::get<9>(the_variant));
1549 break;
1550 }
1551 case 10:
1552 {
1553 visitor(etl::get<10>(the_variant));
1554 break;
1555 }
1556 case 11:
1557 {
1558 visitor(etl::get<11>(the_variant));
1559 break;
1560 }
1561 case 12:
1562 {
1563 visitor(etl::get<12>(the_variant));
1564 break;
1565 }
1566 case 13:
1567 {
1568 visitor(etl::get<13>(the_variant));
1569 break;
1570 }
1571 case 14:
1572 {
1573 visitor(etl::get<14>(the_variant));
1574 break;
1575 }
1576 case 15:
1577 {
1578 visitor(etl::get<15>(the_variant));
1579 break;
1580 }
1581 case 16:
1582 {
1583 visitor(etl::get<16>(the_variant));
1584 break;
1585 }
1586 case 17:
1587 {
1588 visitor(etl::get<17>(the_variant));
1589 break;
1590 }
1591 case 18:
1592 {
1593 visitor(etl::get<18>(the_variant));
1594 break;
1595 }
1596 case 19:
1597 {
1598 visitor(etl::get<19>(the_variant));
1599 break;
1600 }
1601 case 20:
1602 {
1603 visitor(etl::get<20>(the_variant));
1604 break;
1605 }
1606 case 21:
1607 {
1608 visitor(etl::get<21>(the_variant));
1609 break;
1610 }
1611 default: break;
1612 }
1613 }
1614 };
1615
1616 //***************************************************************************
1617 template <>
1618 struct select_do_operator<23>
1619 {
1620 template <typename TVariant, typename TVisitor>
1621 static void do_operator(TVariant& the_variant, TVisitor& visitor)
1622 {
1623 switch (the_variant.index())
1624 {
1625 case 0:
1626 {
1627 visitor(etl::get<0>(the_variant));
1628 break;
1629 }
1630 case 1:
1631 {
1632 visitor(etl::get<1>(the_variant));
1633 break;
1634 }
1635 case 2:
1636 {
1637 visitor(etl::get<2>(the_variant));
1638 break;
1639 }
1640 case 3:
1641 {
1642 visitor(etl::get<3>(the_variant));
1643 break;
1644 }
1645 case 4:
1646 {
1647 visitor(etl::get<4>(the_variant));
1648 break;
1649 }
1650 case 5:
1651 {
1652 visitor(etl::get<5>(the_variant));
1653 break;
1654 }
1655 case 6:
1656 {
1657 visitor(etl::get<6>(the_variant));
1658 break;
1659 }
1660 case 7:
1661 {
1662 visitor(etl::get<7>(the_variant));
1663 break;
1664 }
1665 case 8:
1666 {
1667 visitor(etl::get<8>(the_variant));
1668 break;
1669 }
1670 case 9:
1671 {
1672 visitor(etl::get<9>(the_variant));
1673 break;
1674 }
1675 case 10:
1676 {
1677 visitor(etl::get<10>(the_variant));
1678 break;
1679 }
1680 case 11:
1681 {
1682 visitor(etl::get<11>(the_variant));
1683 break;
1684 }
1685 case 12:
1686 {
1687 visitor(etl::get<12>(the_variant));
1688 break;
1689 }
1690 case 13:
1691 {
1692 visitor(etl::get<13>(the_variant));
1693 break;
1694 }
1695 case 14:
1696 {
1697 visitor(etl::get<14>(the_variant));
1698 break;
1699 }
1700 case 15:
1701 {
1702 visitor(etl::get<15>(the_variant));
1703 break;
1704 }
1705 case 16:
1706 {
1707 visitor(etl::get<16>(the_variant));
1708 break;
1709 }
1710 case 17:
1711 {
1712 visitor(etl::get<17>(the_variant));
1713 break;
1714 }
1715 case 18:
1716 {
1717 visitor(etl::get<18>(the_variant));
1718 break;
1719 }
1720 case 19:
1721 {
1722 visitor(etl::get<19>(the_variant));
1723 break;
1724 }
1725 case 20:
1726 {
1727 visitor(etl::get<20>(the_variant));
1728 break;
1729 }
1730 case 21:
1731 {
1732 visitor(etl::get<21>(the_variant));
1733 break;
1734 }
1735 case 22:
1736 {
1737 visitor(etl::get<22>(the_variant));
1738 break;
1739 }
1740 default: break;
1741 }
1742 }
1743 };
1744
1745 //***************************************************************************
1746 template <>
1747 struct select_do_operator<24>
1748 {
1749 template <typename TVariant, typename TVisitor>
1750 static void do_operator(TVariant& the_variant, TVisitor& visitor)
1751 {
1752 switch (the_variant.index())
1753 {
1754 case 0:
1755 {
1756 visitor(etl::get<0>(the_variant));
1757 break;
1758 }
1759 case 1:
1760 {
1761 visitor(etl::get<1>(the_variant));
1762 break;
1763 }
1764 case 2:
1765 {
1766 visitor(etl::get<2>(the_variant));
1767 break;
1768 }
1769 case 3:
1770 {
1771 visitor(etl::get<3>(the_variant));
1772 break;
1773 }
1774 case 4:
1775 {
1776 visitor(etl::get<4>(the_variant));
1777 break;
1778 }
1779 case 5:
1780 {
1781 visitor(etl::get<5>(the_variant));
1782 break;
1783 }
1784 case 6:
1785 {
1786 visitor(etl::get<6>(the_variant));
1787 break;
1788 }
1789 case 7:
1790 {
1791 visitor(etl::get<7>(the_variant));
1792 break;
1793 }
1794 case 8:
1795 {
1796 visitor(etl::get<8>(the_variant));
1797 break;
1798 }
1799 case 9:
1800 {
1801 visitor(etl::get<9>(the_variant));
1802 break;
1803 }
1804 case 10:
1805 {
1806 visitor(etl::get<10>(the_variant));
1807 break;
1808 }
1809 case 11:
1810 {
1811 visitor(etl::get<11>(the_variant));
1812 break;
1813 }
1814 case 12:
1815 {
1816 visitor(etl::get<12>(the_variant));
1817 break;
1818 }
1819 case 13:
1820 {
1821 visitor(etl::get<13>(the_variant));
1822 break;
1823 }
1824 case 14:
1825 {
1826 visitor(etl::get<14>(the_variant));
1827 break;
1828 }
1829 case 15:
1830 {
1831 visitor(etl::get<15>(the_variant));
1832 break;
1833 }
1834 case 16:
1835 {
1836 visitor(etl::get<16>(the_variant));
1837 break;
1838 }
1839 case 17:
1840 {
1841 visitor(etl::get<17>(the_variant));
1842 break;
1843 }
1844 case 18:
1845 {
1846 visitor(etl::get<18>(the_variant));
1847 break;
1848 }
1849 case 19:
1850 {
1851 visitor(etl::get<19>(the_variant));
1852 break;
1853 }
1854 case 20:
1855 {
1856 visitor(etl::get<20>(the_variant));
1857 break;
1858 }
1859 case 21:
1860 {
1861 visitor(etl::get<21>(the_variant));
1862 break;
1863 }
1864 case 22:
1865 {
1866 visitor(etl::get<22>(the_variant));
1867 break;
1868 }
1869 case 23:
1870 {
1871 visitor(etl::get<23>(the_variant));
1872 break;
1873 }
1874 default: break;
1875 }
1876 }
1877 };
1878 #if !defined(ETL_VARIANT_CPP11_MAX_24_TYPES)
1879 //***************************************************************************
1880 template <>
1881 struct select_do_operator<25>
1882 {
1883 template <typename TVariant, typename TVisitor>
1884 static void do_operator(TVariant& the_variant, TVisitor& visitor)
1885 {
1886 switch (the_variant.index())
1887 {
1888 case 0:
1889 {
1890 visitor(etl::get<0>(the_variant));
1891 break;
1892 }
1893 case 1:
1894 {
1895 visitor(etl::get<1>(the_variant));
1896 break;
1897 }
1898 case 2:
1899 {
1900 visitor(etl::get<2>(the_variant));
1901 break;
1902 }
1903 case 3:
1904 {
1905 visitor(etl::get<3>(the_variant));
1906 break;
1907 }
1908 case 4:
1909 {
1910 visitor(etl::get<4>(the_variant));
1911 break;
1912 }
1913 case 5:
1914 {
1915 visitor(etl::get<5>(the_variant));
1916 break;
1917 }
1918 case 6:
1919 {
1920 visitor(etl::get<6>(the_variant));
1921 break;
1922 }
1923 case 7:
1924 {
1925 visitor(etl::get<7>(the_variant));
1926 break;
1927 }
1928 case 8:
1929 {
1930 visitor(etl::get<8>(the_variant));
1931 break;
1932 }
1933 case 9:
1934 {
1935 visitor(etl::get<9>(the_variant));
1936 break;
1937 }
1938 case 10:
1939 {
1940 visitor(etl::get<10>(the_variant));
1941 break;
1942 }
1943 case 11:
1944 {
1945 visitor(etl::get<11>(the_variant));
1946 break;
1947 }
1948 case 12:
1949 {
1950 visitor(etl::get<12>(the_variant));
1951 break;
1952 }
1953 case 13:
1954 {
1955 visitor(etl::get<13>(the_variant));
1956 break;
1957 }
1958 case 14:
1959 {
1960 visitor(etl::get<14>(the_variant));
1961 break;
1962 }
1963 case 15:
1964 {
1965 visitor(etl::get<15>(the_variant));
1966 break;
1967 }
1968 case 16:
1969 {
1970 visitor(etl::get<16>(the_variant));
1971 break;
1972 }
1973 case 17:
1974 {
1975 visitor(etl::get<17>(the_variant));
1976 break;
1977 }
1978 case 18:
1979 {
1980 visitor(etl::get<18>(the_variant));
1981 break;
1982 }
1983 case 19:
1984 {
1985 visitor(etl::get<19>(the_variant));
1986 break;
1987 }
1988 case 20:
1989 {
1990 visitor(etl::get<20>(the_variant));
1991 break;
1992 }
1993 case 21:
1994 {
1995 visitor(etl::get<21>(the_variant));
1996 break;
1997 }
1998 case 22:
1999 {
2000 visitor(etl::get<22>(the_variant));
2001 break;
2002 }
2003 case 23:
2004 {
2005 visitor(etl::get<23>(the_variant));
2006 break;
2007 }
2008 case 24:
2009 {
2010 visitor(etl::get<24>(the_variant));
2011 break;
2012 }
2013 default: break;
2014 }
2015 }
2016 };
2017
2018 //***************************************************************************
2019 template <>
2020 struct select_do_operator<26>
2021 {
2022 template <typename TVariant, typename TVisitor>
2023 static void do_operator(TVariant& the_variant, TVisitor& visitor)
2024 {
2025 switch (the_variant.index())
2026 {
2027 case 0:
2028 {
2029 visitor(etl::get<0>(the_variant));
2030 break;
2031 }
2032 case 1:
2033 {
2034 visitor(etl::get<1>(the_variant));
2035 break;
2036 }
2037 case 2:
2038 {
2039 visitor(etl::get<2>(the_variant));
2040 break;
2041 }
2042 case 3:
2043 {
2044 visitor(etl::get<3>(the_variant));
2045 break;
2046 }
2047 case 4:
2048 {
2049 visitor(etl::get<4>(the_variant));
2050 break;
2051 }
2052 case 5:
2053 {
2054 visitor(etl::get<5>(the_variant));
2055 break;
2056 }
2057 case 6:
2058 {
2059 visitor(etl::get<6>(the_variant));
2060 break;
2061 }
2062 case 7:
2063 {
2064 visitor(etl::get<7>(the_variant));
2065 break;
2066 }
2067 case 8:
2068 {
2069 visitor(etl::get<8>(the_variant));
2070 break;
2071 }
2072 case 9:
2073 {
2074 visitor(etl::get<9>(the_variant));
2075 break;
2076 }
2077 case 10:
2078 {
2079 visitor(etl::get<10>(the_variant));
2080 break;
2081 }
2082 case 11:
2083 {
2084 visitor(etl::get<11>(the_variant));
2085 break;
2086 }
2087 case 12:
2088 {
2089 visitor(etl::get<12>(the_variant));
2090 break;
2091 }
2092 case 13:
2093 {
2094 visitor(etl::get<13>(the_variant));
2095 break;
2096 }
2097 case 14:
2098 {
2099 visitor(etl::get<14>(the_variant));
2100 break;
2101 }
2102 case 15:
2103 {
2104 visitor(etl::get<15>(the_variant));
2105 break;
2106 }
2107 case 16:
2108 {
2109 visitor(etl::get<16>(the_variant));
2110 break;
2111 }
2112 case 17:
2113 {
2114 visitor(etl::get<17>(the_variant));
2115 break;
2116 }
2117 case 18:
2118 {
2119 visitor(etl::get<18>(the_variant));
2120 break;
2121 }
2122 case 19:
2123 {
2124 visitor(etl::get<19>(the_variant));
2125 break;
2126 }
2127 case 20:
2128 {
2129 visitor(etl::get<20>(the_variant));
2130 break;
2131 }
2132 case 21:
2133 {
2134 visitor(etl::get<21>(the_variant));
2135 break;
2136 }
2137 case 22:
2138 {
2139 visitor(etl::get<22>(the_variant));
2140 break;
2141 }
2142 case 23:
2143 {
2144 visitor(etl::get<23>(the_variant));
2145 break;
2146 }
2147 case 24:
2148 {
2149 visitor(etl::get<24>(the_variant));
2150 break;
2151 }
2152 case 25:
2153 {
2154 visitor(etl::get<25>(the_variant));
2155 break;
2156 }
2157 default: break;
2158 }
2159 }
2160 };
2161
2162 //***************************************************************************
2163 template <>
2164 struct select_do_operator<27>
2165 {
2166 template <typename TVariant, typename TVisitor>
2167 static void do_operator(TVariant& the_variant, TVisitor& visitor)
2168 {
2169 switch (the_variant.index())
2170 {
2171 case 0:
2172 {
2173 visitor(etl::get<0>(the_variant));
2174 break;
2175 }
2176 case 1:
2177 {
2178 visitor(etl::get<1>(the_variant));
2179 break;
2180 }
2181 case 2:
2182 {
2183 visitor(etl::get<2>(the_variant));
2184 break;
2185 }
2186 case 3:
2187 {
2188 visitor(etl::get<3>(the_variant));
2189 break;
2190 }
2191 case 4:
2192 {
2193 visitor(etl::get<4>(the_variant));
2194 break;
2195 }
2196 case 5:
2197 {
2198 visitor(etl::get<5>(the_variant));
2199 break;
2200 }
2201 case 6:
2202 {
2203 visitor(etl::get<6>(the_variant));
2204 break;
2205 }
2206 case 7:
2207 {
2208 visitor(etl::get<7>(the_variant));
2209 break;
2210 }
2211 case 8:
2212 {
2213 visitor(etl::get<8>(the_variant));
2214 break;
2215 }
2216 case 9:
2217 {
2218 visitor(etl::get<9>(the_variant));
2219 break;
2220 }
2221 case 10:
2222 {
2223 visitor(etl::get<10>(the_variant));
2224 break;
2225 }
2226 case 11:
2227 {
2228 visitor(etl::get<11>(the_variant));
2229 break;
2230 }
2231 case 12:
2232 {
2233 visitor(etl::get<12>(the_variant));
2234 break;
2235 }
2236 case 13:
2237 {
2238 visitor(etl::get<13>(the_variant));
2239 break;
2240 }
2241 case 14:
2242 {
2243 visitor(etl::get<14>(the_variant));
2244 break;
2245 }
2246 case 15:
2247 {
2248 visitor(etl::get<15>(the_variant));
2249 break;
2250 }
2251 case 16:
2252 {
2253 visitor(etl::get<16>(the_variant));
2254 break;
2255 }
2256 case 17:
2257 {
2258 visitor(etl::get<17>(the_variant));
2259 break;
2260 }
2261 case 18:
2262 {
2263 visitor(etl::get<18>(the_variant));
2264 break;
2265 }
2266 case 19:
2267 {
2268 visitor(etl::get<19>(the_variant));
2269 break;
2270 }
2271 case 20:
2272 {
2273 visitor(etl::get<20>(the_variant));
2274 break;
2275 }
2276 case 21:
2277 {
2278 visitor(etl::get<21>(the_variant));
2279 break;
2280 }
2281 case 22:
2282 {
2283 visitor(etl::get<22>(the_variant));
2284 break;
2285 }
2286 case 23:
2287 {
2288 visitor(etl::get<23>(the_variant));
2289 break;
2290 }
2291 case 24:
2292 {
2293 visitor(etl::get<24>(the_variant));
2294 break;
2295 }
2296 case 25:
2297 {
2298 visitor(etl::get<25>(the_variant));
2299 break;
2300 }
2301 case 26:
2302 {
2303 visitor(etl::get<26>(the_variant));
2304 break;
2305 }
2306 default: break;
2307 }
2308 }
2309 };
2310
2311 //***************************************************************************
2312 template <>
2313 struct select_do_operator<28>
2314 {
2315 template <typename TVariant, typename TVisitor>
2316 static void do_operator(TVariant& the_variant, TVisitor& visitor)
2317 {
2318 switch (the_variant.index())
2319 {
2320 case 0:
2321 {
2322 visitor(etl::get<0>(the_variant));
2323 break;
2324 }
2325 case 1:
2326 {
2327 visitor(etl::get<1>(the_variant));
2328 break;
2329 }
2330 case 2:
2331 {
2332 visitor(etl::get<2>(the_variant));
2333 break;
2334 }
2335 case 3:
2336 {
2337 visitor(etl::get<3>(the_variant));
2338 break;
2339 }
2340 case 4:
2341 {
2342 visitor(etl::get<4>(the_variant));
2343 break;
2344 }
2345 case 5:
2346 {
2347 visitor(etl::get<5>(the_variant));
2348 break;
2349 }
2350 case 6:
2351 {
2352 visitor(etl::get<6>(the_variant));
2353 break;
2354 }
2355 case 7:
2356 {
2357 visitor(etl::get<7>(the_variant));
2358 break;
2359 }
2360 case 8:
2361 {
2362 visitor(etl::get<8>(the_variant));
2363 break;
2364 }
2365 case 9:
2366 {
2367 visitor(etl::get<9>(the_variant));
2368 break;
2369 }
2370 case 10:
2371 {
2372 visitor(etl::get<10>(the_variant));
2373 break;
2374 }
2375 case 11:
2376 {
2377 visitor(etl::get<11>(the_variant));
2378 break;
2379 }
2380 case 12:
2381 {
2382 visitor(etl::get<12>(the_variant));
2383 break;
2384 }
2385 case 13:
2386 {
2387 visitor(etl::get<13>(the_variant));
2388 break;
2389 }
2390 case 14:
2391 {
2392 visitor(etl::get<14>(the_variant));
2393 break;
2394 }
2395 case 15:
2396 {
2397 visitor(etl::get<15>(the_variant));
2398 break;
2399 }
2400 case 16:
2401 {
2402 visitor(etl::get<16>(the_variant));
2403 break;
2404 }
2405 case 17:
2406 {
2407 visitor(etl::get<17>(the_variant));
2408 break;
2409 }
2410 case 18:
2411 {
2412 visitor(etl::get<18>(the_variant));
2413 break;
2414 }
2415 case 19:
2416 {
2417 visitor(etl::get<19>(the_variant));
2418 break;
2419 }
2420 case 20:
2421 {
2422 visitor(etl::get<20>(the_variant));
2423 break;
2424 }
2425 case 21:
2426 {
2427 visitor(etl::get<21>(the_variant));
2428 break;
2429 }
2430 case 22:
2431 {
2432 visitor(etl::get<22>(the_variant));
2433 break;
2434 }
2435 case 23:
2436 {
2437 visitor(etl::get<23>(the_variant));
2438 break;
2439 }
2440 case 24:
2441 {
2442 visitor(etl::get<24>(the_variant));
2443 break;
2444 }
2445 case 25:
2446 {
2447 visitor(etl::get<25>(the_variant));
2448 break;
2449 }
2450 case 26:
2451 {
2452 visitor(etl::get<26>(the_variant));
2453 break;
2454 }
2455 case 27:
2456 {
2457 visitor(etl::get<27>(the_variant));
2458 break;
2459 }
2460 default: break;
2461 }
2462 }
2463 };
2464
2465 //***************************************************************************
2466 template <>
2467 struct select_do_operator<29>
2468 {
2469 template <typename TVariant, typename TVisitor>
2470 static void do_operator(TVariant& the_variant, TVisitor& visitor)
2471 {
2472 switch (the_variant.index())
2473 {
2474 case 0:
2475 {
2476 visitor(etl::get<0>(the_variant));
2477 break;
2478 }
2479 case 1:
2480 {
2481 visitor(etl::get<1>(the_variant));
2482 break;
2483 }
2484 case 2:
2485 {
2486 visitor(etl::get<2>(the_variant));
2487 break;
2488 }
2489 case 3:
2490 {
2491 visitor(etl::get<3>(the_variant));
2492 break;
2493 }
2494 case 4:
2495 {
2496 visitor(etl::get<4>(the_variant));
2497 break;
2498 }
2499 case 5:
2500 {
2501 visitor(etl::get<5>(the_variant));
2502 break;
2503 }
2504 case 6:
2505 {
2506 visitor(etl::get<6>(the_variant));
2507 break;
2508 }
2509 case 7:
2510 {
2511 visitor(etl::get<7>(the_variant));
2512 break;
2513 }
2514 case 8:
2515 {
2516 visitor(etl::get<8>(the_variant));
2517 break;
2518 }
2519 case 9:
2520 {
2521 visitor(etl::get<9>(the_variant));
2522 break;
2523 }
2524 case 10:
2525 {
2526 visitor(etl::get<10>(the_variant));
2527 break;
2528 }
2529 case 11:
2530 {
2531 visitor(etl::get<11>(the_variant));
2532 break;
2533 }
2534 case 12:
2535 {
2536 visitor(etl::get<12>(the_variant));
2537 break;
2538 }
2539 case 13:
2540 {
2541 visitor(etl::get<13>(the_variant));
2542 break;
2543 }
2544 case 14:
2545 {
2546 visitor(etl::get<14>(the_variant));
2547 break;
2548 }
2549 case 15:
2550 {
2551 visitor(etl::get<15>(the_variant));
2552 break;
2553 }
2554 case 16:
2555 {
2556 visitor(etl::get<16>(the_variant));
2557 break;
2558 }
2559 case 17:
2560 {
2561 visitor(etl::get<17>(the_variant));
2562 break;
2563 }
2564 case 18:
2565 {
2566 visitor(etl::get<18>(the_variant));
2567 break;
2568 }
2569 case 19:
2570 {
2571 visitor(etl::get<19>(the_variant));
2572 break;
2573 }
2574 case 20:
2575 {
2576 visitor(etl::get<20>(the_variant));
2577 break;
2578 }
2579 case 21:
2580 {
2581 visitor(etl::get<21>(the_variant));
2582 break;
2583 }
2584 case 22:
2585 {
2586 visitor(etl::get<22>(the_variant));
2587 break;
2588 }
2589 case 23:
2590 {
2591 visitor(etl::get<23>(the_variant));
2592 break;
2593 }
2594 case 24:
2595 {
2596 visitor(etl::get<24>(the_variant));
2597 break;
2598 }
2599 case 25:
2600 {
2601 visitor(etl::get<25>(the_variant));
2602 break;
2603 }
2604 case 26:
2605 {
2606 visitor(etl::get<26>(the_variant));
2607 break;
2608 }
2609 case 27:
2610 {
2611 visitor(etl::get<27>(the_variant));
2612 break;
2613 }
2614 case 28:
2615 {
2616 visitor(etl::get<28>(the_variant));
2617 break;
2618 }
2619 default: break;
2620 }
2621 }
2622 };
2623
2624 //***************************************************************************
2625 template <>
2626 struct select_do_operator<30>
2627 {
2628 template <typename TVariant, typename TVisitor>
2629 static void do_operator(TVariant& the_variant, TVisitor& visitor)
2630 {
2631 switch (the_variant.index())
2632 {
2633 case 0:
2634 {
2635 visitor(etl::get<0>(the_variant));
2636 break;
2637 }
2638 case 1:
2639 {
2640 visitor(etl::get<1>(the_variant));
2641 break;
2642 }
2643 case 2:
2644 {
2645 visitor(etl::get<2>(the_variant));
2646 break;
2647 }
2648 case 3:
2649 {
2650 visitor(etl::get<3>(the_variant));
2651 break;
2652 }
2653 case 4:
2654 {
2655 visitor(etl::get<4>(the_variant));
2656 break;
2657 }
2658 case 5:
2659 {
2660 visitor(etl::get<5>(the_variant));
2661 break;
2662 }
2663 case 6:
2664 {
2665 visitor(etl::get<6>(the_variant));
2666 break;
2667 }
2668 case 7:
2669 {
2670 visitor(etl::get<7>(the_variant));
2671 break;
2672 }
2673 case 8:
2674 {
2675 visitor(etl::get<8>(the_variant));
2676 break;
2677 }
2678 case 9:
2679 {
2680 visitor(etl::get<9>(the_variant));
2681 break;
2682 }
2683 case 10:
2684 {
2685 visitor(etl::get<10>(the_variant));
2686 break;
2687 }
2688 case 11:
2689 {
2690 visitor(etl::get<11>(the_variant));
2691 break;
2692 }
2693 case 12:
2694 {
2695 visitor(etl::get<12>(the_variant));
2696 break;
2697 }
2698 case 13:
2699 {
2700 visitor(etl::get<13>(the_variant));
2701 break;
2702 }
2703 case 14:
2704 {
2705 visitor(etl::get<14>(the_variant));
2706 break;
2707 }
2708 case 15:
2709 {
2710 visitor(etl::get<15>(the_variant));
2711 break;
2712 }
2713 case 16:
2714 {
2715 visitor(etl::get<16>(the_variant));
2716 break;
2717 }
2718 case 17:
2719 {
2720 visitor(etl::get<17>(the_variant));
2721 break;
2722 }
2723 case 18:
2724 {
2725 visitor(etl::get<18>(the_variant));
2726 break;
2727 }
2728 case 19:
2729 {
2730 visitor(etl::get<19>(the_variant));
2731 break;
2732 }
2733 case 20:
2734 {
2735 visitor(etl::get<20>(the_variant));
2736 break;
2737 }
2738 case 21:
2739 {
2740 visitor(etl::get<21>(the_variant));
2741 break;
2742 }
2743 case 22:
2744 {
2745 visitor(etl::get<22>(the_variant));
2746 break;
2747 }
2748 case 23:
2749 {
2750 visitor(etl::get<23>(the_variant));
2751 break;
2752 }
2753 case 24:
2754 {
2755 visitor(etl::get<24>(the_variant));
2756 break;
2757 }
2758 case 25:
2759 {
2760 visitor(etl::get<25>(the_variant));
2761 break;
2762 }
2763 case 26:
2764 {
2765 visitor(etl::get<26>(the_variant));
2766 break;
2767 }
2768 case 27:
2769 {
2770 visitor(etl::get<27>(the_variant));
2771 break;
2772 }
2773 case 28:
2774 {
2775 visitor(etl::get<28>(the_variant));
2776 break;
2777 }
2778 case 29:
2779 {
2780 visitor(etl::get<29>(the_variant));
2781 break;
2782 }
2783 default: break;
2784 }
2785 }
2786 };
2787
2788 //***************************************************************************
2789 template <>
2790 struct select_do_operator<31>
2791 {
2792 template <typename TVariant, typename TVisitor>
2793 static void do_operator(TVariant& the_variant, TVisitor& visitor)
2794 {
2795 switch (the_variant.index())
2796 {
2797 case 0:
2798 {
2799 visitor(etl::get<0>(the_variant));
2800 break;
2801 }
2802 case 1:
2803 {
2804 visitor(etl::get<1>(the_variant));
2805 break;
2806 }
2807 case 2:
2808 {
2809 visitor(etl::get<2>(the_variant));
2810 break;
2811 }
2812 case 3:
2813 {
2814 visitor(etl::get<3>(the_variant));
2815 break;
2816 }
2817 case 4:
2818 {
2819 visitor(etl::get<4>(the_variant));
2820 break;
2821 }
2822 case 5:
2823 {
2824 visitor(etl::get<5>(the_variant));
2825 break;
2826 }
2827 case 6:
2828 {
2829 visitor(etl::get<6>(the_variant));
2830 break;
2831 }
2832 case 7:
2833 {
2834 visitor(etl::get<7>(the_variant));
2835 break;
2836 }
2837 case 8:
2838 {
2839 visitor(etl::get<8>(the_variant));
2840 break;
2841 }
2842 case 9:
2843 {
2844 visitor(etl::get<9>(the_variant));
2845 break;
2846 }
2847 case 10:
2848 {
2849 visitor(etl::get<10>(the_variant));
2850 break;
2851 }
2852 case 11:
2853 {
2854 visitor(etl::get<11>(the_variant));
2855 break;
2856 }
2857 case 12:
2858 {
2859 visitor(etl::get<12>(the_variant));
2860 break;
2861 }
2862 case 13:
2863 {
2864 visitor(etl::get<13>(the_variant));
2865 break;
2866 }
2867 case 14:
2868 {
2869 visitor(etl::get<14>(the_variant));
2870 break;
2871 }
2872 case 15:
2873 {
2874 visitor(etl::get<15>(the_variant));
2875 break;
2876 }
2877 case 16:
2878 {
2879 visitor(etl::get<16>(the_variant));
2880 break;
2881 }
2882 case 17:
2883 {
2884 visitor(etl::get<17>(the_variant));
2885 break;
2886 }
2887 case 18:
2888 {
2889 visitor(etl::get<18>(the_variant));
2890 break;
2891 }
2892 case 19:
2893 {
2894 visitor(etl::get<19>(the_variant));
2895 break;
2896 }
2897 case 20:
2898 {
2899 visitor(etl::get<20>(the_variant));
2900 break;
2901 }
2902 case 21:
2903 {
2904 visitor(etl::get<21>(the_variant));
2905 break;
2906 }
2907 case 22:
2908 {
2909 visitor(etl::get<22>(the_variant));
2910 break;
2911 }
2912 case 23:
2913 {
2914 visitor(etl::get<23>(the_variant));
2915 break;
2916 }
2917 case 24:
2918 {
2919 visitor(etl::get<24>(the_variant));
2920 break;
2921 }
2922 case 25:
2923 {
2924 visitor(etl::get<25>(the_variant));
2925 break;
2926 }
2927 case 26:
2928 {
2929 visitor(etl::get<26>(the_variant));
2930 break;
2931 }
2932 case 27:
2933 {
2934 visitor(etl::get<27>(the_variant));
2935 break;
2936 }
2937 case 28:
2938 {
2939 visitor(etl::get<28>(the_variant));
2940 break;
2941 }
2942 case 29:
2943 {
2944 visitor(etl::get<29>(the_variant));
2945 break;
2946 }
2947 case 30:
2948 {
2949 visitor(etl::get<30>(the_variant));
2950 break;
2951 }
2952 default: break;
2953 }
2954 }
2955 };
2956
2957 //***************************************************************************
2958 template <>
2959 struct select_do_operator<32>
2960 {
2961 template <typename TVariant, typename TVisitor>
2962 static void do_operator(TVariant& the_variant, TVisitor& visitor)
2963 {
2964 switch (the_variant.index())
2965 {
2966 case 0:
2967 {
2968 visitor(etl::get<0>(the_variant));
2969 break;
2970 }
2971 case 1:
2972 {
2973 visitor(etl::get<1>(the_variant));
2974 break;
2975 }
2976 case 2:
2977 {
2978 visitor(etl::get<2>(the_variant));
2979 break;
2980 }
2981 case 3:
2982 {
2983 visitor(etl::get<3>(the_variant));
2984 break;
2985 }
2986 case 4:
2987 {
2988 visitor(etl::get<4>(the_variant));
2989 break;
2990 }
2991 case 5:
2992 {
2993 visitor(etl::get<5>(the_variant));
2994 break;
2995 }
2996 case 6:
2997 {
2998 visitor(etl::get<6>(the_variant));
2999 break;
3000 }
3001 case 7:
3002 {
3003 visitor(etl::get<7>(the_variant));
3004 break;
3005 }
3006 case 8:
3007 {
3008 visitor(etl::get<8>(the_variant));
3009 break;
3010 }
3011 case 9:
3012 {
3013 visitor(etl::get<9>(the_variant));
3014 break;
3015 }
3016 case 10:
3017 {
3018 visitor(etl::get<10>(the_variant));
3019 break;
3020 }
3021 case 11:
3022 {
3023 visitor(etl::get<11>(the_variant));
3024 break;
3025 }
3026 case 12:
3027 {
3028 visitor(etl::get<12>(the_variant));
3029 break;
3030 }
3031 case 13:
3032 {
3033 visitor(etl::get<13>(the_variant));
3034 break;
3035 }
3036 case 14:
3037 {
3038 visitor(etl::get<14>(the_variant));
3039 break;
3040 }
3041 case 15:
3042 {
3043 visitor(etl::get<15>(the_variant));
3044 break;
3045 }
3046 case 16:
3047 {
3048 visitor(etl::get<16>(the_variant));
3049 break;
3050 }
3051 case 17:
3052 {
3053 visitor(etl::get<17>(the_variant));
3054 break;
3055 }
3056 case 18:
3057 {
3058 visitor(etl::get<18>(the_variant));
3059 break;
3060 }
3061 case 19:
3062 {
3063 visitor(etl::get<19>(the_variant));
3064 break;
3065 }
3066 case 20:
3067 {
3068 visitor(etl::get<20>(the_variant));
3069 break;
3070 }
3071 case 21:
3072 {
3073 visitor(etl::get<21>(the_variant));
3074 break;
3075 }
3076 case 22:
3077 {
3078 visitor(etl::get<22>(the_variant));
3079 break;
3080 }
3081 case 23:
3082 {
3083 visitor(etl::get<23>(the_variant));
3084 break;
3085 }
3086 case 24:
3087 {
3088 visitor(etl::get<24>(the_variant));
3089 break;
3090 }
3091 case 25:
3092 {
3093 visitor(etl::get<25>(the_variant));
3094 break;
3095 }
3096 case 26:
3097 {
3098 visitor(etl::get<26>(the_variant));
3099 break;
3100 }
3101 case 27:
3102 {
3103 visitor(etl::get<27>(the_variant));
3104 break;
3105 }
3106 case 28:
3107 {
3108 visitor(etl::get<28>(the_variant));
3109 break;
3110 }
3111 case 29:
3112 {
3113 visitor(etl::get<29>(the_variant));
3114 break;
3115 }
3116 case 30:
3117 {
3118 visitor(etl::get<30>(the_variant));
3119 break;
3120 }
3121 case 31:
3122 {
3123 visitor(etl::get<31>(the_variant));
3124 break;
3125 }
3126 default: break;
3127 }
3128 }
3129 };
3130 #endif
3131 #endif
3132#endif
3133} // namespace private_variant
etl::get
T & get(array< T, Size > &a)
Definition array.h:1161
private_variant::select_do_operator
Definition variant_select_do_operator.h:41