Embedded Template Library 1.0
Loading...
Searching...
No Matches
variant_select_do_visitor.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_visitor inplementation that is configured for the number of types.
38 //***************************************************************************
39 template <size_t NTypes>
40 struct select_do_visitor;
41
42 //***************************************************************************
43 template <>
44 struct select_do_visitor<1>
45 {
46 template <typename TVariant, typename TVisitor>
47 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
48 {
49 switch (the_variant.index())
50 {
51 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
52 default: break;
53 }
54 }
55 };
56
57 //***************************************************************************
58 template <>
59 struct select_do_visitor<2>
60 {
61 template <typename TVariant, typename TVisitor>
62 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
63 {
64 switch (the_variant.index())
65 {
66 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
67 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
68 default: break;
69 }
70 }
71 };
72
73 //***************************************************************************
74 template <>
75 struct select_do_visitor<3>
76 {
77 template <typename TVariant, typename TVisitor>
78 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
79 {
80 switch (the_variant.index())
81 {
82 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
83 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
84 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
85 default: break;
86 }
87 };
88 };
89
90 //***************************************************************************
91 template <>
92 struct select_do_visitor<4>
93 {
94 template <typename TVariant, typename TVisitor>
95 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
96 {
97 switch (the_variant.index())
98 {
99 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
100 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
101 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
102 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
103 default: break;
104 }
105 };
106 };
107
108 //***************************************************************************
109 template <>
110 struct select_do_visitor<5>
111 {
112 template <typename TVariant, typename TVisitor>
113 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
114 {
115 switch (the_variant.index())
116 {
117 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
118 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
119 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
120 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
121 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
122 default: break;
123 }
124 };
125 };
126
127 //***************************************************************************
128 template <>
129 struct select_do_visitor<6>
130 {
131 template <typename TVariant, typename TVisitor>
132 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
133 {
134 switch (the_variant.index())
135 {
136 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
137 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
138 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
139 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
140 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
141 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
142 default: break;
143 }
144 };
145 };
146
147 //***************************************************************************
148 template <>
149 struct select_do_visitor<7>
150 {
151 template <typename TVariant, typename TVisitor>
152 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
153 {
154 switch (the_variant.index())
155 {
156 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
157 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
158 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
159 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
160 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
161 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
162 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
163 default: break;
164 }
165 };
166 };
167
168 //***************************************************************************
169 template <>
170 struct select_do_visitor<8>
171 {
172 template <typename TVariant, typename TVisitor>
173 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
174 {
175 switch (the_variant.index())
176 {
177 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
178 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
179 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
180 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
181 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
182 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
183 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
184 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
185 default: break;
186 }
187 };
188 };
189#if !defined(ETL_VARIANT_CPP11_MAX_8_TYPES)
190 //***************************************************************************
191 template <>
192 struct select_do_visitor<9>
193 {
194 template <typename TVariant, typename TVisitor>
195 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
196 {
197 switch (the_variant.index())
198 {
199 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
200 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
201 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
202 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
203 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
204 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
205 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
206 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
207 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
208 default: break;
209 }
210 };
211 };
212
213 //***************************************************************************
214 template <>
215 struct select_do_visitor<10>
216 {
217 template <typename TVariant, typename TVisitor>
218 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
219 {
220 switch (the_variant.index())
221 {
222 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
223 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
224 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
225 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
226 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
227 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
228 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
229 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
230 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
231 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
232 default: break;
233 }
234 };
235 };
236
237 //***************************************************************************
238 template <>
239 struct select_do_visitor<11>
240 {
241 template <typename TVariant, typename TVisitor>
242 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
243 {
244 switch (the_variant.index())
245 {
246 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
247 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
248 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
249 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
250 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
251 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
252 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
253 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
254 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
255 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
256 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
257 default: break;
258 }
259 };
260 };
261
262 //***************************************************************************
263 template <>
264 struct select_do_visitor<12>
265 {
266 template <typename TVariant, typename TVisitor>
267 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
268 {
269 switch (the_variant.index())
270 {
271 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
272 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
273 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
274 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
275 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
276 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
277 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
278 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
279 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
280 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
281 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
282 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
283 default: break;
284 }
285 };
286 };
287
288 //***************************************************************************
289 template <>
290 struct select_do_visitor<13>
291 {
292 template <typename TVariant, typename TVisitor>
293 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
294 {
295 switch (the_variant.index())
296 {
297 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
298 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
299 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
300 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
301 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
302 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
303 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
304 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
305 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
306 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
307 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
308 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
309 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
310 default: break;
311 }
312 };
313 };
314
315 //***************************************************************************
316 template <>
317 struct select_do_visitor<14>
318 {
319 template <typename TVariant, typename TVisitor>
320 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
321 {
322 switch (the_variant.index())
323 {
324 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
325 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
326 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
327 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
328 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
329 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
330 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
331 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
332 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
333 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
334 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
335 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
336 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
337 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
338 default: break;
339 }
340 };
341 };
342
343 //***************************************************************************
344 template <>
345 struct select_do_visitor<15>
346 {
347 template <typename TVariant, typename TVisitor>
348 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
349 {
350 switch (the_variant.index())
351 {
352 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
353 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
354 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
355 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
356 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
357 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
358 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
359 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
360 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
361 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
362 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
363 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
364 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
365 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
366 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
367 default: break;
368 }
369 };
370 };
371
372 //***************************************************************************
373 template <>
374 struct select_do_visitor<16>
375 {
376 template <typename TVariant, typename TVisitor>
377 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
378 {
379 switch (the_variant.index())
380 {
381 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
382 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
383 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
384 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
385 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
386 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
387 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
388 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
389 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
390 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
391 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
392 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
393 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
394 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
395 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
396 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
397 default: break;
398 }
399 };
400 };
401#if !defined(ETL_VARIANT_CPP11_MAX_16_TYPES)
402 //***************************************************************************
403 template <>
404 struct select_do_visitor<17>
405 {
406 template <typename TVariant, typename TVisitor>
407 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
408 {
409 switch (the_variant.index())
410 {
411 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
412 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
413 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
414 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
415 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
416 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
417 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
418 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
419 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
420 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
421 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
422 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
423 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
424 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
425 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
426 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
427 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
428 default: break;
429 }
430 };
431 };
432
433 //***************************************************************************
434 template <>
435 struct select_do_visitor<18>
436 {
437 template <typename TVariant, typename TVisitor>
438 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
439 {
440 switch (the_variant.index())
441 {
442 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
443 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
444 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
445 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
446 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
447 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
448 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
449 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
450 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
451 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
452 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
453 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
454 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
455 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
456 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
457 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
458 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
459 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
460 default: break;
461 }
462 };
463 };
464
465 //***************************************************************************
466 template <>
467 struct select_do_visitor<19>
468 {
469 template <typename TVariant, typename TVisitor>
470 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
471 {
472 switch (the_variant.index())
473 {
474 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
475 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
476 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
477 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
478 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
479 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
480 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
481 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
482 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
483 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
484 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
485 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
486 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
487 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
488 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
489 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
490 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
491 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
492 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
493 default: break;
494 }
495 };
496 };
497
498 //***************************************************************************
499 template <>
500 struct select_do_visitor<20>
501 {
502 template <typename TVariant, typename TVisitor>
503 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
504 {
505 switch (the_variant.index())
506 {
507 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
508 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
509 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
510 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
511 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
512 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
513 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
514 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
515 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
516 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
517 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
518 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
519 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
520 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
521 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
522 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
523 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
524 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
525 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
526 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
527 default: break;
528 }
529 };
530 };
531
532 //***************************************************************************
533 template <>
534 struct select_do_visitor<21>
535 {
536 template <typename TVariant, typename TVisitor>
537 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
538 {
539 switch (the_variant.index())
540 {
541 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
542 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
543 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
544 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
545 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
546 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
547 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
548 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
549 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
550 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
551 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
552 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
553 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
554 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
555 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
556 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
557 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
558 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
559 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
560 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
561 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
562 default: break;
563 }
564 };
565 };
566
567 //***************************************************************************
568 template <>
569 struct select_do_visitor<22>
570 {
571 template <typename TVariant, typename TVisitor>
572 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
573 {
574 switch (the_variant.index())
575 {
576 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
577 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
578 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
579 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
580 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
581 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
582 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
583 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
584 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
585 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
586 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
587 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
588 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
589 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
590 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
591 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
592 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
593 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
594 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
595 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
596 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
597 case 21: { visitor.visit(etl::get<21>(the_variant)); break; }
598 default: break;
599 }
600 };
601 };
602
603 //***************************************************************************
604 template <>
605 struct select_do_visitor<23>
606 {
607 template <typename TVariant, typename TVisitor>
608 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
609 {
610 switch (the_variant.index())
611 {
612 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
613 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
614 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
615 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
616 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
617 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
618 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
619 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
620 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
621 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
622 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
623 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
624 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
625 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
626 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
627 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
628 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
629 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
630 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
631 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
632 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
633 case 21: { visitor.visit(etl::get<21>(the_variant)); break; }
634 case 22: { visitor.visit(etl::get<22>(the_variant)); break; }
635 default: break;
636 }
637 };
638 };
639
640 //***************************************************************************
641 template <>
642 struct select_do_visitor<24>
643 {
644 template <typename TVariant, typename TVisitor>
645 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
646 {
647 switch (the_variant.index())
648 {
649 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
650 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
651 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
652 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
653 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
654 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
655 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
656 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
657 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
658 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
659 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
660 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
661 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
662 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
663 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
664 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
665 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
666 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
667 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
668 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
669 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
670 case 21: { visitor.visit(etl::get<21>(the_variant)); break; }
671 case 22: { visitor.visit(etl::get<22>(the_variant)); break; }
672 case 23: { visitor.visit(etl::get<23>(the_variant)); break; }
673 default: break;
674 }
675 };
676 };
677#if !defined(ETL_VARIANT_CPP11_MAX_24_TYPES)
678 //***************************************************************************
679 template <>
680 struct select_do_visitor<25>
681 {
682 template <typename TVariant, typename TVisitor>
683 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
684 {
685 switch (the_variant.index())
686 {
687 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
688 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
689 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
690 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
691 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
692 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
693 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
694 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
695 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
696 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
697 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
698 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
699 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
700 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
701 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
702 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
703 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
704 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
705 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
706 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
707 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
708 case 21: { visitor.visit(etl::get<21>(the_variant)); break; }
709 case 22: { visitor.visit(etl::get<22>(the_variant)); break; }
710 case 23: { visitor.visit(etl::get<23>(the_variant)); break; }
711 case 24: { visitor.visit(etl::get<24>(the_variant)); break; }
712 default: break;
713 }
714 };
715 };
716
717 //***************************************************************************
718 template <>
719 struct select_do_visitor<26>
720 {
721 template <typename TVariant, typename TVisitor>
722 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
723 {
724 switch (the_variant.index())
725 {
726 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
727 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
728 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
729 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
730 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
731 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
732 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
733 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
734 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
735 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
736 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
737 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
738 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
739 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
740 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
741 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
742 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
743 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
744 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
745 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
746 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
747 case 21: { visitor.visit(etl::get<21>(the_variant)); break; }
748 case 22: { visitor.visit(etl::get<22>(the_variant)); break; }
749 case 23: { visitor.visit(etl::get<23>(the_variant)); break; }
750 case 24: { visitor.visit(etl::get<24>(the_variant)); break; }
751 case 25: { visitor.visit(etl::get<25>(the_variant)); break; }
752 default: break;
753 }
754 };
755 };
756
757 //***************************************************************************
758 template <>
759 struct select_do_visitor<27>
760 {
761 template <typename TVariant, typename TVisitor>
762 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
763 {
764 switch (the_variant.index())
765 {
766 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
767 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
768 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
769 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
770 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
771 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
772 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
773 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
774 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
775 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
776 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
777 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
778 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
779 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
780 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
781 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
782 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
783 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
784 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
785 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
786 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
787 case 21: { visitor.visit(etl::get<21>(the_variant)); break; }
788 case 22: { visitor.visit(etl::get<22>(the_variant)); break; }
789 case 23: { visitor.visit(etl::get<23>(the_variant)); break; }
790 case 24: { visitor.visit(etl::get<24>(the_variant)); break; }
791 case 25: { visitor.visit(etl::get<25>(the_variant)); break; }
792 case 26: { visitor.visit(etl::get<26>(the_variant)); break; }
793 default: break;
794 }
795 };
796 };
797
798 //***************************************************************************
799 template <>
800 struct select_do_visitor<28>
801 {
802 template <typename TVariant, typename TVisitor>
803 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
804 {
805 switch (the_variant.index())
806 {
807 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
808 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
809 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
810 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
811 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
812 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
813 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
814 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
815 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
816 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
817 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
818 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
819 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
820 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
821 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
822 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
823 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
824 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
825 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
826 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
827 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
828 case 21: { visitor.visit(etl::get<21>(the_variant)); break; }
829 case 22: { visitor.visit(etl::get<22>(the_variant)); break; }
830 case 23: { visitor.visit(etl::get<23>(the_variant)); break; }
831 case 24: { visitor.visit(etl::get<24>(the_variant)); break; }
832 case 25: { visitor.visit(etl::get<25>(the_variant)); break; }
833 case 26: { visitor.visit(etl::get<26>(the_variant)); break; }
834 case 27: { visitor.visit(etl::get<27>(the_variant)); break; }
835 default: break;
836 }
837 };
838 };
839
840 //***************************************************************************
841 template <>
842 struct select_do_visitor<29>
843 {
844 template <typename TVariant, typename TVisitor>
845 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
846 {
847 switch (the_variant.index())
848 {
849 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
850 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
851 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
852 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
853 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
854 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
855 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
856 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
857 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
858 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
859 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
860 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
861 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
862 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
863 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
864 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
865 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
866 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
867 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
868 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
869 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
870 case 21: { visitor.visit(etl::get<21>(the_variant)); break; }
871 case 22: { visitor.visit(etl::get<22>(the_variant)); break; }
872 case 23: { visitor.visit(etl::get<23>(the_variant)); break; }
873 case 24: { visitor.visit(etl::get<24>(the_variant)); break; }
874 case 25: { visitor.visit(etl::get<25>(the_variant)); break; }
875 case 26: { visitor.visit(etl::get<26>(the_variant)); break; }
876 case 27: { visitor.visit(etl::get<27>(the_variant)); break; }
877 case 28: { visitor.visit(etl::get<28>(the_variant)); break; }
878 default: break;
879 }
880 };
881 };
882
883 //***************************************************************************
884 template <>
885 struct select_do_visitor<30>
886 {
887 template <typename TVariant, typename TVisitor>
888 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
889 {
890 switch (the_variant.index())
891 {
892 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
893 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
894 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
895 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
896 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
897 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
898 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
899 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
900 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
901 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
902 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
903 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
904 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
905 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
906 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
907 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
908 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
909 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
910 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
911 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
912 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
913 case 21: { visitor.visit(etl::get<21>(the_variant)); break; }
914 case 22: { visitor.visit(etl::get<22>(the_variant)); break; }
915 case 23: { visitor.visit(etl::get<23>(the_variant)); break; }
916 case 24: { visitor.visit(etl::get<24>(the_variant)); break; }
917 case 25: { visitor.visit(etl::get<25>(the_variant)); break; }
918 case 26: { visitor.visit(etl::get<26>(the_variant)); break; }
919 case 27: { visitor.visit(etl::get<27>(the_variant)); break; }
920 case 28: { visitor.visit(etl::get<28>(the_variant)); break; }
921 case 29: { visitor.visit(etl::get<29>(the_variant)); break; }
922 default: break;
923 }
924 };
925 };
926
927 //***************************************************************************
928 template <>
929 struct select_do_visitor<31>
930 {
931 template <typename TVariant, typename TVisitor>
932 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
933 {
934 switch (the_variant.index())
935 {
936 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
937 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
938 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
939 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
940 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
941 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
942 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
943 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
944 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
945 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
946 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
947 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
948 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
949 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
950 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
951 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
952 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
953 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
954 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
955 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
956 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
957 case 21: { visitor.visit(etl::get<21>(the_variant)); break; }
958 case 22: { visitor.visit(etl::get<22>(the_variant)); break; }
959 case 23: { visitor.visit(etl::get<23>(the_variant)); break; }
960 case 24: { visitor.visit(etl::get<24>(the_variant)); break; }
961 case 25: { visitor.visit(etl::get<25>(the_variant)); break; }
962 case 26: { visitor.visit(etl::get<26>(the_variant)); break; }
963 case 27: { visitor.visit(etl::get<27>(the_variant)); break; }
964 case 28: { visitor.visit(etl::get<28>(the_variant)); break; }
965 case 29: { visitor.visit(etl::get<29>(the_variant)); break; }
966 case 30: { visitor.visit(etl::get<30>(the_variant)); break; }
967 default: break;
968 }
969 };
970 };
971
972 //***************************************************************************
973 template <>
974 struct select_do_visitor<32>
975 {
976 template <typename TVariant, typename TVisitor>
977 static void do_visitor(TVariant& the_variant, TVisitor& visitor)
978 {
979 switch (the_variant.index())
980 {
981 case 0: { visitor.visit(etl::get<0>(the_variant)); break; }
982 case 1: { visitor.visit(etl::get<1>(the_variant)); break; }
983 case 2: { visitor.visit(etl::get<2>(the_variant)); break; }
984 case 3: { visitor.visit(etl::get<3>(the_variant)); break; }
985 case 4: { visitor.visit(etl::get<4>(the_variant)); break; }
986 case 5: { visitor.visit(etl::get<5>(the_variant)); break; }
987 case 6: { visitor.visit(etl::get<6>(the_variant)); break; }
988 case 7: { visitor.visit(etl::get<7>(the_variant)); break; }
989 case 8: { visitor.visit(etl::get<8>(the_variant)); break; }
990 case 9: { visitor.visit(etl::get<9>(the_variant)); break; }
991 case 10: { visitor.visit(etl::get<10>(the_variant)); break; }
992 case 11: { visitor.visit(etl::get<11>(the_variant)); break; }
993 case 12: { visitor.visit(etl::get<12>(the_variant)); break; }
994 case 13: { visitor.visit(etl::get<13>(the_variant)); break; }
995 case 14: { visitor.visit(etl::get<14>(the_variant)); break; }
996 case 15: { visitor.visit(etl::get<15>(the_variant)); break; }
997 case 16: { visitor.visit(etl::get<16>(the_variant)); break; }
998 case 17: { visitor.visit(etl::get<17>(the_variant)); break; }
999 case 18: { visitor.visit(etl::get<18>(the_variant)); break; }
1000 case 19: { visitor.visit(etl::get<19>(the_variant)); break; }
1001 case 20: { visitor.visit(etl::get<20>(the_variant)); break; }
1002 case 21: { visitor.visit(etl::get<21>(the_variant)); break; }
1003 case 22: { visitor.visit(etl::get<22>(the_variant)); break; }
1004 case 23: { visitor.visit(etl::get<23>(the_variant)); break; }
1005 case 24: { visitor.visit(etl::get<24>(the_variant)); break; }
1006 case 25: { visitor.visit(etl::get<25>(the_variant)); break; }
1007 case 26: { visitor.visit(etl::get<26>(the_variant)); break; }
1008 case 27: { visitor.visit(etl::get<27>(the_variant)); break; }
1009 case 28: { visitor.visit(etl::get<28>(the_variant)); break; }
1010 case 29: { visitor.visit(etl::get<29>(the_variant)); break; }
1011 case 30: { visitor.visit(etl::get<30>(the_variant)); break; }
1012 case 31: { visitor.visit(etl::get<31>(the_variant)); break; }
1013 default: break;
1014 }
1015 };
1016 };
1017#endif
1018#endif
1019#endif
1020}
etl::get
T & get(array< T, Size > &a)
Definition array.h:1216
private_variant::select_do_visitor
Definition variant_select_do_visitor.h:40