OSSIA
Open Scenario System for Interactive Application
Loading...
Searching...
No Matches
domain_variant_impl.hpp
1struct domain_base_variant
2{
3public:
4 struct dummy_t
5 {
6 };
7 union Impl
8 {
9 ossia::domain_base<ossia::impulse> m_value0;
10
11 ossia::domain_base<bool> m_value1;
12
13 ossia::domain_base<int32_t> m_value2;
14
15 ossia::domain_base<float> m_value3;
16
17 ossia::domain_base<std::string> m_value5;
18
19 ossia::vector_domain m_value6;
20
21 ossia::vecf_domain<2> m_value7;
22
23 ossia::vecf_domain<3> m_value8;
24
25 ossia::vecf_domain<4> m_value9;
26
27 ossia::domain_base<ossia::value> m_value10;
28
29 dummy_t m_dummy;
30 Impl()
31 : m_dummy{}
32 {
33 }
34 ~Impl() { }
35 };
36
37 enum Type : int8_t
38 {
39 Type0,
40 Type1,
41 Type2,
42 Type3,
43 Type4,
44 Type5,
45 Type6,
46 Type7,
47 Type8,
48 Type9,
49 Type10,
50 Npos
51 };
52
53 void destruct_impl()
54 {
55 switch(m_type)
56 {
57 case Type::Type0:
58 m_impl.m_value0.~domain_base();
59 break;
60 case Type::Type1:
61 m_impl.m_value1.~domain_base();
62 break;
63 case Type::Type2:
64 m_impl.m_value2.~domain_base();
65 break;
66 case Type::Type3:
67 m_impl.m_value3.~domain_base();
68 break;
69 case Type::Type5:
70 m_impl.m_value5.~domain_base();
71 break;
72 case Type::Type6:
73 m_impl.m_value6.~vector_domain();
74 break;
75 case Type::Type7:
76 m_impl.m_value7.~vecf_domain();
77 break;
78 case Type::Type8:
79 m_impl.m_value8.~vecf_domain();
80 break;
81 case Type::Type9:
82 m_impl.m_value9.~vecf_domain();
83 break;
84 case Type::Type10:
85 m_impl.m_value10.~domain_base();
86 break;
87 default:
88 break;
89 }
90 }
91 Impl m_impl;
92 Type m_type;
93
94public:
95 static const constexpr auto npos = Npos;
96 int which() const { return m_type; }
97
98 operator bool() const { return m_type != npos; }
99 template <typename T>
100 const T* target() const;
101 template <typename T>
102 T* target();
103 template <typename T>
104 const T& get() const;
105 template <typename T>
106 T& get();
107
108 template <typename T>
109 static Type matching_type();
110 domain_base_variant()
111 : m_type{Npos}
112 {
113 }
114 ~domain_base_variant() { destruct_impl(); }
115 domain_base_variant(const ossia::domain_base<ossia::impulse>& v)
116 : m_type{Type0}
117 {
118 new(&m_impl.m_value0) ossia::domain_base<ossia::impulse>{v};
119 }
120 domain_base_variant(ossia::domain_base<ossia::impulse>&& v)
121 : m_type{Type0}
122 {
123 new(&m_impl.m_value0) ossia::domain_base<ossia::impulse>{std::move(v)};
124 }
125 domain_base_variant(const ossia::domain_base<bool>& v)
126 : m_type{Type1}
127 {
128 new(&m_impl.m_value1) ossia::domain_base<bool>{v};
129 }
130 domain_base_variant(ossia::domain_base<bool>&& v)
131 : m_type{Type1}
132 {
133 new(&m_impl.m_value1) ossia::domain_base<bool>{std::move(v)};
134 }
135 domain_base_variant(const ossia::domain_base<int32_t>& v)
136 : m_type{Type2}
137 {
138 new(&m_impl.m_value2) ossia::domain_base<int32_t>{v};
139 }
140 domain_base_variant(ossia::domain_base<int32_t>&& v)
141 : m_type{Type2}
142 {
143 new(&m_impl.m_value2) ossia::domain_base<int32_t>{std::move(v)};
144 }
145 domain_base_variant(const ossia::domain_base<float>& v)
146 : m_type{Type3}
147 {
148 new(&m_impl.m_value3) ossia::domain_base<float>{v};
149 }
150 domain_base_variant(ossia::domain_base<float>&& v)
151 : m_type{Type3}
152 {
153 new(&m_impl.m_value3) ossia::domain_base<float>{std::move(v)};
154 }
155 domain_base_variant(const ossia::domain_base<std::string>& v)
156 : m_type{Type5}
157 {
158 new(&m_impl.m_value5) ossia::domain_base<std::string>{v};
159 }
160 domain_base_variant(ossia::domain_base<std::string>&& v)
161 : m_type{Type5}
162 {
163 new(&m_impl.m_value5) ossia::domain_base<std::string>{std::move(v)};
164 }
165 domain_base_variant(const ossia::vector_domain& v)
166 : m_type{Type6}
167 {
168 new(&m_impl.m_value6) ossia::vector_domain{v};
169 }
170 domain_base_variant(ossia::vector_domain&& v)
171 : m_type{Type6}
172 {
173 new(&m_impl.m_value6) ossia::vector_domain{std::move(v)};
174 }
175 domain_base_variant(const ossia::vecf_domain<2>& v)
176 : m_type{Type7}
177 {
178 new(&m_impl.m_value7) ossia::vecf_domain<2>{v};
179 }
180 domain_base_variant(ossia::vecf_domain<2>&& v)
181 : m_type{Type7}
182 {
183 new(&m_impl.m_value7) ossia::vecf_domain<2>{std::move(v)};
184 }
185 domain_base_variant(const ossia::vecf_domain<3>& v)
186 : m_type{Type8}
187 {
188 new(&m_impl.m_value8) ossia::vecf_domain<3>{v};
189 }
190 domain_base_variant(ossia::vecf_domain<3>&& v)
191 : m_type{Type8}
192 {
193 new(&m_impl.m_value8) ossia::vecf_domain<3>{std::move(v)};
194 }
195 domain_base_variant(const ossia::vecf_domain<4>& v)
196 : m_type{Type9}
197 {
198 new(&m_impl.m_value9) ossia::vecf_domain<4>{v};
199 }
200 domain_base_variant(ossia::vecf_domain<4>&& v)
201 : m_type{Type9}
202 {
203 new(&m_impl.m_value9) ossia::vecf_domain<4>{std::move(v)};
204 }
205 domain_base_variant(const ossia::domain_base<ossia::value>& v)
206 : m_type{Type10}
207 {
208 new(&m_impl.m_value10) ossia::domain_base<ossia::value>{v};
209 }
210 domain_base_variant(ossia::domain_base<ossia::value>&& v)
211 : m_type{Type10}
212 {
213 new(&m_impl.m_value10) ossia::domain_base<ossia::value>{std::move(v)};
214 }
215 domain_base_variant(const domain_base_variant& other)
216 : m_type{other.m_type}
217 {
218 switch(m_type)
219 {
220 case Type::Type0:
221 new(&m_impl.m_value0) ossia::domain_base<ossia::impulse>{other.m_impl.m_value0};
222 break;
223 case Type::Type1:
224 new(&m_impl.m_value1) ossia::domain_base<bool>{other.m_impl.m_value1};
225 break;
226 case Type::Type2:
227 new(&m_impl.m_value2) ossia::domain_base<int32_t>{other.m_impl.m_value2};
228 break;
229 case Type::Type3:
230 new(&m_impl.m_value3) ossia::domain_base<float>{other.m_impl.m_value3};
231 break;
232 case Type::Type5:
233 new(&m_impl.m_value5) ossia::domain_base<std::string>{other.m_impl.m_value5};
234 break;
235 case Type::Type6:
236 new(&m_impl.m_value6) ossia::vector_domain{other.m_impl.m_value6};
237 break;
238 case Type::Type7:
239 new(&m_impl.m_value7) ossia::vecf_domain<2>{other.m_impl.m_value7};
240 break;
241 case Type::Type8:
242 new(&m_impl.m_value8) ossia::vecf_domain<3>{other.m_impl.m_value8};
243 break;
244 case Type::Type9:
245 new(&m_impl.m_value9) ossia::vecf_domain<4>{other.m_impl.m_value9};
246 break;
247 case Type::Type10:
248 new(&m_impl.m_value10) ossia::domain_base<ossia::value>{other.m_impl.m_value10};
249 break;
250 default:
251 break;
252 }
253 }
254 domain_base_variant(domain_base_variant&& other)
255 : m_type{other.m_type}
256 {
257 switch(m_type)
258 {
259 case Type::Type0:
260 new(&m_impl.m_value0)
261 ossia::domain_base<ossia::impulse>{std::move(other.m_impl.m_value0)};
262 break;
263 case Type::Type1:
264 new(&m_impl.m_value1) ossia::domain_base<bool>{std::move(other.m_impl.m_value1)};
265 break;
266 case Type::Type2:
267 new(&m_impl.m_value2)
268 ossia::domain_base<int32_t>{std::move(other.m_impl.m_value2)};
269 break;
270 case Type::Type3:
271 new(&m_impl.m_value3)
272 ossia::domain_base<float>{std::move(other.m_impl.m_value3)};
273 break;
274 case Type::Type5:
275 new(&m_impl.m_value5)
276 ossia::domain_base<std::string>{std::move(other.m_impl.m_value5)};
277 break;
278 case Type::Type6:
279 new(&m_impl.m_value6) ossia::vector_domain{std::move(other.m_impl.m_value6)};
280 break;
281 case Type::Type7:
282 new(&m_impl.m_value7) ossia::vecf_domain<2>{std::move(other.m_impl.m_value7)};
283 break;
284 case Type::Type8:
285 new(&m_impl.m_value8) ossia::vecf_domain<3>{std::move(other.m_impl.m_value8)};
286 break;
287 case Type::Type9:
288 new(&m_impl.m_value9) ossia::vecf_domain<4>{std::move(other.m_impl.m_value9)};
289 break;
290 case Type::Type10:
291 new(&m_impl.m_value10)
292 ossia::domain_base<ossia::value>{std::move(other.m_impl.m_value10)};
293 break;
294 default:
295 break;
296 }
297 }
298 domain_base_variant& operator=(const domain_base_variant& other)
299 {
300 destruct_impl();
301 m_type = other.m_type;
302 switch(m_type)
303 {
304 case Type::Type0:
305 new(&m_impl.m_value0) ossia::domain_base<ossia::impulse>{other.m_impl.m_value0};
306 break;
307 case Type::Type1:
308 new(&m_impl.m_value1) ossia::domain_base<bool>{other.m_impl.m_value1};
309 break;
310 case Type::Type2:
311 new(&m_impl.m_value2) ossia::domain_base<int32_t>{other.m_impl.m_value2};
312 break;
313 case Type::Type3:
314 new(&m_impl.m_value3) ossia::domain_base<float>{other.m_impl.m_value3};
315 break;
316 case Type::Type5:
317 new(&m_impl.m_value5) ossia::domain_base<std::string>{other.m_impl.m_value5};
318 break;
319 case Type::Type6:
320 new(&m_impl.m_value6) ossia::vector_domain{other.m_impl.m_value6};
321 break;
322 case Type::Type7:
323 new(&m_impl.m_value7) ossia::vecf_domain<2>{other.m_impl.m_value7};
324 break;
325 case Type::Type8:
326 new(&m_impl.m_value8) ossia::vecf_domain<3>{other.m_impl.m_value8};
327 break;
328 case Type::Type9:
329 new(&m_impl.m_value9) ossia::vecf_domain<4>{other.m_impl.m_value9};
330 break;
331 case Type::Type10:
332 new(&m_impl.m_value10) ossia::domain_base<ossia::value>{other.m_impl.m_value10};
333 break;
334 default:
335 break;
336 }
337 return *this;
338 }
339 domain_base_variant& operator=(domain_base_variant&& other)
340 {
341 destruct_impl();
342 m_type = other.m_type;
343 switch(m_type)
344 {
345 case Type::Type0:
346 new(&m_impl.m_value0)
347 ossia::domain_base<ossia::impulse>{std::move(other.m_impl.m_value0)};
348 break;
349 case Type::Type1:
350 new(&m_impl.m_value1) ossia::domain_base<bool>{std::move(other.m_impl.m_value1)};
351 break;
352 case Type::Type2:
353 new(&m_impl.m_value2)
354 ossia::domain_base<int32_t>{std::move(other.m_impl.m_value2)};
355 break;
356 case Type::Type3:
357 new(&m_impl.m_value3)
358 ossia::domain_base<float>{std::move(other.m_impl.m_value3)};
359 break;
360 case Type::Type5:
361 new(&m_impl.m_value5)
362 ossia::domain_base<std::string>{std::move(other.m_impl.m_value5)};
363 break;
364 case Type::Type6:
365 new(&m_impl.m_value6) ossia::vector_domain{std::move(other.m_impl.m_value6)};
366 break;
367 case Type::Type7:
368 new(&m_impl.m_value7) ossia::vecf_domain<2>{std::move(other.m_impl.m_value7)};
369 break;
370 case Type::Type8:
371 new(&m_impl.m_value8) ossia::vecf_domain<3>{std::move(other.m_impl.m_value8)};
372 break;
373 case Type::Type9:
374 new(&m_impl.m_value9) ossia::vecf_domain<4>{std::move(other.m_impl.m_value9)};
375 break;
376 case Type::Type10:
377 new(&m_impl.m_value10)
378 ossia::domain_base<ossia::value>{std::move(other.m_impl.m_value10)};
379 break;
380 default:
381 break;
382 }
383 return *this;
384 }
385};
386template <>
387inline const ossia::domain_base<ossia::impulse>* domain_base_variant::target() const
388{
389 if(m_type == Type0)
390 return &m_impl.m_value0;
391 return nullptr;
392}
393template <>
394inline const ossia::domain_base<bool>* domain_base_variant::target() const
395{
396 if(m_type == Type1)
397 return &m_impl.m_value1;
398 return nullptr;
399}
400template <>
401inline const ossia::domain_base<int32_t>* domain_base_variant::target() const
402{
403 if(m_type == Type2)
404 return &m_impl.m_value2;
405 return nullptr;
406}
407template <>
408inline const ossia::domain_base<float>* domain_base_variant::target() const
409{
410 if(m_type == Type3)
411 return &m_impl.m_value3;
412 return nullptr;
413}
414template <>
415inline const ossia::domain_base<std::string>* domain_base_variant::target() const
416{
417 if(m_type == Type5)
418 return &m_impl.m_value5;
419 return nullptr;
420}
421template <>
422inline const ossia::vector_domain* domain_base_variant::target() const
423{
424 if(m_type == Type6)
425 return &m_impl.m_value6;
426 return nullptr;
427}
428template <>
429inline const ossia::vecf_domain<2>* domain_base_variant::target() const
430{
431 if(m_type == Type7)
432 return &m_impl.m_value7;
433 return nullptr;
434}
435template <>
436inline const ossia::vecf_domain<3>* domain_base_variant::target() const
437{
438 if(m_type == Type8)
439 return &m_impl.m_value8;
440 return nullptr;
441}
442template <>
443inline const ossia::vecf_domain<4>* domain_base_variant::target() const
444{
445 if(m_type == Type9)
446 return &m_impl.m_value9;
447 return nullptr;
448}
449template <>
450inline const ossia::domain_base<ossia::value>* domain_base_variant::target() const
451{
452 if(m_type == Type10)
453 return &m_impl.m_value10;
454 return nullptr;
455}
456template <>
457inline ossia::domain_base<ossia::impulse>* domain_base_variant::target()
458{
459 if(m_type == Type0)
460 return &m_impl.m_value0;
461 return nullptr;
462}
463template <>
464inline ossia::domain_base<bool>* domain_base_variant::target()
465{
466 if(m_type == Type1)
467 return &m_impl.m_value1;
468 return nullptr;
469}
470template <>
471inline ossia::domain_base<int32_t>* domain_base_variant::target()
472{
473 if(m_type == Type2)
474 return &m_impl.m_value2;
475 return nullptr;
476}
477template <>
478inline ossia::domain_base<float>* domain_base_variant::target()
479{
480 if(m_type == Type3)
481 return &m_impl.m_value3;
482 return nullptr;
483}
484template <>
485inline ossia::domain_base<std::string>* domain_base_variant::target()
486{
487 if(m_type == Type5)
488 return &m_impl.m_value5;
489 return nullptr;
490}
491template <>
492inline ossia::vector_domain* domain_base_variant::target()
493{
494 if(m_type == Type6)
495 return &m_impl.m_value6;
496 return nullptr;
497}
498template <>
499inline ossia::vecf_domain<2>* domain_base_variant::target()
500{
501 if(m_type == Type7)
502 return &m_impl.m_value7;
503 return nullptr;
504}
505template <>
506inline ossia::vecf_domain<3>* domain_base_variant::target()
507{
508 if(m_type == Type8)
509 return &m_impl.m_value8;
510 return nullptr;
511}
512template <>
513inline ossia::vecf_domain<4>* domain_base_variant::target()
514{
515 if(m_type == Type9)
516 return &m_impl.m_value9;
517 return nullptr;
518}
519template <>
520inline ossia::domain_base<ossia::value>* domain_base_variant::target()
521{
522 if(m_type == Type10)
523 return &m_impl.m_value10;
524 return nullptr;
525}
526template <>
527inline const ossia::domain_base<ossia::impulse>& domain_base_variant::get() const
528{
529 if(m_type == Type0)
530 return m_impl.m_value0;
531 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
532}
533template <>
534inline const ossia::domain_base<bool>& domain_base_variant::get() const
535{
536 if(m_type == Type1)
537 return m_impl.m_value1;
538 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
539}
540template <>
541inline const ossia::domain_base<int32_t>& domain_base_variant::get() const
542{
543 if(m_type == Type2)
544 return m_impl.m_value2;
545 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
546}
547template <>
548inline const ossia::domain_base<float>& domain_base_variant::get() const
549{
550 if(m_type == Type3)
551 return m_impl.m_value3;
552 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
553}
554template <>
555inline const ossia::domain_base<std::string>& domain_base_variant::get() const
556{
557 if(m_type == Type5)
558 return m_impl.m_value5;
559 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
560}
561template <>
562inline const ossia::vector_domain& domain_base_variant::get() const
563{
564 if(m_type == Type6)
565 return m_impl.m_value6;
566 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
567}
568template <>
569inline const ossia::vecf_domain<2>& domain_base_variant::get() const
570{
571 if(m_type == Type7)
572 return m_impl.m_value7;
573 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
574}
575template <>
576inline const ossia::vecf_domain<3>& domain_base_variant::get() const
577{
578 if(m_type == Type8)
579 return m_impl.m_value8;
580 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
581}
582template <>
583inline const ossia::vecf_domain<4>& domain_base_variant::get() const
584{
585 if(m_type == Type9)
586 return m_impl.m_value9;
587 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
588}
589template <>
590inline const ossia::domain_base<ossia::value>& domain_base_variant::get() const
591{
592 if(m_type == Type10)
593 return m_impl.m_value10;
594 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
595}
596template <>
597inline ossia::domain_base<ossia::impulse>& domain_base_variant::get()
598{
599 if(m_type == Type0)
600 return m_impl.m_value0;
601 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
602}
603template <>
604inline ossia::domain_base<bool>& domain_base_variant::get()
605{
606 if(m_type == Type1)
607 return m_impl.m_value1;
608 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
609}
610template <>
611inline ossia::domain_base<int32_t>& domain_base_variant::get()
612{
613 if(m_type == Type2)
614 return m_impl.m_value2;
615 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
616}
617template <>
618inline ossia::domain_base<float>& domain_base_variant::get()
619{
620 if(m_type == Type3)
621 return m_impl.m_value3;
622 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
623}
624template <>
625inline ossia::domain_base<std::string>& domain_base_variant::get()
626{
627 if(m_type == Type5)
628 return m_impl.m_value5;
629 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
630}
631template <>
632inline ossia::vector_domain& domain_base_variant::get()
633{
634 if(m_type == Type6)
635 return m_impl.m_value6;
636 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
637}
638template <>
639inline ossia::vecf_domain<2>& domain_base_variant::get()
640{
641 if(m_type == Type7)
642 return m_impl.m_value7;
643 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
644}
645template <>
646inline ossia::vecf_domain<3>& domain_base_variant::get()
647{
648 if(m_type == Type8)
649 return m_impl.m_value8;
650 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
651}
652template <>
653inline ossia::vecf_domain<4>& domain_base_variant::get()
654{
655 if(m_type == Type9)
656 return m_impl.m_value9;
657 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
658}
659template <>
660inline ossia::domain_base<ossia::value>& domain_base_variant::get()
661{
662 if(m_type == Type10)
663 return m_impl.m_value10;
664 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
665}
666template <typename Visitor>
667auto apply_nonnull(Visitor&& functor, const domain_base_variant& var)
668{
669 switch(var.m_type)
670 {
671 case domain_base_variant::Type::Type0:
672 return functor(var.m_impl.m_value0);
673 case domain_base_variant::Type::Type1:
674 return functor(var.m_impl.m_value1);
675 case domain_base_variant::Type::Type2:
676 return functor(var.m_impl.m_value2);
677 case domain_base_variant::Type::Type3:
678 return functor(var.m_impl.m_value3);
679 case domain_base_variant::Type::Type5:
680 return functor(var.m_impl.m_value5);
681 case domain_base_variant::Type::Type6:
682 return functor(var.m_impl.m_value6);
683 case domain_base_variant::Type::Type7:
684 return functor(var.m_impl.m_value7);
685 case domain_base_variant::Type::Type8:
686 return functor(var.m_impl.m_value8);
687 case domain_base_variant::Type::Type9:
688 return functor(var.m_impl.m_value9);
689 case domain_base_variant::Type::Type10:
690 return functor(var.m_impl.m_value10);
691 default:
692 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
693 }
694}
695template <typename Visitor>
696auto apply_nonnull(Visitor&& functor, domain_base_variant& var)
697{
698 switch(var.m_type)
699 {
700 case domain_base_variant::Type::Type0:
701 return functor(var.m_impl.m_value0);
702 case domain_base_variant::Type::Type1:
703 return functor(var.m_impl.m_value1);
704 case domain_base_variant::Type::Type2:
705 return functor(var.m_impl.m_value2);
706 case domain_base_variant::Type::Type3:
707 return functor(var.m_impl.m_value3);
708 case domain_base_variant::Type::Type5:
709 return functor(var.m_impl.m_value5);
710 case domain_base_variant::Type::Type6:
711 return functor(var.m_impl.m_value6);
712 case domain_base_variant::Type::Type7:
713 return functor(var.m_impl.m_value7);
714 case domain_base_variant::Type::Type8:
715 return functor(var.m_impl.m_value8);
716 case domain_base_variant::Type::Type9:
717 return functor(var.m_impl.m_value9);
718 case domain_base_variant::Type::Type10:
719 return functor(var.m_impl.m_value10);
720 default:
721 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
722 }
723}
724template <typename Visitor>
725auto apply_nonnull(Visitor&& functor, domain_base_variant&& var)
726{
727 switch(var.m_type)
728 {
729 case domain_base_variant::Type::Type0:
730 return functor(std::move(var.m_impl.m_value0));
731 case domain_base_variant::Type::Type1:
732 return functor(std::move(var.m_impl.m_value1));
733 case domain_base_variant::Type::Type2:
734 return functor(std::move(var.m_impl.m_value2));
735 case domain_base_variant::Type::Type3:
736 return functor(std::move(var.m_impl.m_value3));
737 case domain_base_variant::Type::Type5:
738 return functor(std::move(var.m_impl.m_value5));
739 case domain_base_variant::Type::Type6:
740 return functor(std::move(var.m_impl.m_value6));
741 case domain_base_variant::Type::Type7:
742 return functor(std::move(var.m_impl.m_value7));
743 case domain_base_variant::Type::Type8:
744 return functor(std::move(var.m_impl.m_value8));
745 case domain_base_variant::Type::Type9:
746 return functor(std::move(var.m_impl.m_value9));
747 case domain_base_variant::Type::Type10:
748 return functor(std::move(var.m_impl.m_value10));
749 default:
750 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
751 }
752}
753template <typename Visitor>
754auto apply(Visitor&& functor, const domain_base_variant& var)
755{
756 switch(var.m_type)
757 {
758 case domain_base_variant::Type::Type0:
759 return functor(var.m_impl.m_value0);
760 case domain_base_variant::Type::Type1:
761 return functor(var.m_impl.m_value1);
762 case domain_base_variant::Type::Type2:
763 return functor(var.m_impl.m_value2);
764 case domain_base_variant::Type::Type3:
765 return functor(var.m_impl.m_value3);
766 case domain_base_variant::Type::Type5:
767 return functor(var.m_impl.m_value5);
768 case domain_base_variant::Type::Type6:
769 return functor(var.m_impl.m_value6);
770 case domain_base_variant::Type::Type7:
771 return functor(var.m_impl.m_value7);
772 case domain_base_variant::Type::Type8:
773 return functor(var.m_impl.m_value8);
774 case domain_base_variant::Type::Type9:
775 return functor(var.m_impl.m_value9);
776 case domain_base_variant::Type::Type10:
777 return functor(var.m_impl.m_value10);
778 default:
779 return functor();
780 }
781}
782template <typename Visitor>
783auto apply(Visitor&& functor, domain_base_variant& var)
784{
785 switch(var.m_type)
786 {
787 case domain_base_variant::Type::Type0:
788 return functor(var.m_impl.m_value0);
789 case domain_base_variant::Type::Type1:
790 return functor(var.m_impl.m_value1);
791 case domain_base_variant::Type::Type2:
792 return functor(var.m_impl.m_value2);
793 case domain_base_variant::Type::Type3:
794 return functor(var.m_impl.m_value3);
795 case domain_base_variant::Type::Type5:
796 return functor(var.m_impl.m_value5);
797 case domain_base_variant::Type::Type6:
798 return functor(var.m_impl.m_value6);
799 case domain_base_variant::Type::Type7:
800 return functor(var.m_impl.m_value7);
801 case domain_base_variant::Type::Type8:
802 return functor(var.m_impl.m_value8);
803 case domain_base_variant::Type::Type9:
804 return functor(var.m_impl.m_value9);
805 case domain_base_variant::Type::Type10:
806 return functor(var.m_impl.m_value10);
807 default:
808 return functor();
809 }
810}
811template <typename Visitor>
812auto apply(Visitor&& functor, domain_base_variant&& var)
813{
814 switch(var.m_type)
815 {
816 case domain_base_variant::Type::Type0:
817 return functor(std::move(var.m_impl.m_value0));
818 case domain_base_variant::Type::Type1:
819 return functor(std::move(var.m_impl.m_value1));
820 case domain_base_variant::Type::Type2:
821 return functor(std::move(var.m_impl.m_value2));
822 case domain_base_variant::Type::Type3:
823 return functor(std::move(var.m_impl.m_value3));
824 case domain_base_variant::Type::Type5:
825 return functor(std::move(var.m_impl.m_value5));
826 case domain_base_variant::Type::Type6:
827 return functor(std::move(var.m_impl.m_value6));
828 case domain_base_variant::Type::Type7:
829 return functor(std::move(var.m_impl.m_value7));
830 case domain_base_variant::Type::Type8:
831 return functor(std::move(var.m_impl.m_value8));
832 case domain_base_variant::Type::Type9:
833 return functor(std::move(var.m_impl.m_value9));
834 case domain_base_variant::Type::Type10:
835 return functor(std::move(var.m_impl.m_value10));
836 default:
837 return functor();
838 }
839}
840inline bool operator==(const domain_base_variant& lhs, const domain_base_variant& rhs)
841{
842 if(lhs.m_type == rhs.m_type)
843 {
844 switch(lhs.m_type)
845 {
846 case domain_base_variant::Type::Type0:
847 return lhs.m_impl.m_value0 == rhs.m_impl.m_value0;
848 case domain_base_variant::Type::Type1:
849 return lhs.m_impl.m_value1 == rhs.m_impl.m_value1;
850 case domain_base_variant::Type::Type2:
851 return lhs.m_impl.m_value2 == rhs.m_impl.m_value2;
852 case domain_base_variant::Type::Type3:
853 return lhs.m_impl.m_value3 == rhs.m_impl.m_value3;
854 case domain_base_variant::Type::Type5:
855 return lhs.m_impl.m_value5 == rhs.m_impl.m_value5;
856 case domain_base_variant::Type::Type6:
857 return lhs.m_impl.m_value6 == rhs.m_impl.m_value6;
858 case domain_base_variant::Type::Type7:
859 return lhs.m_impl.m_value7 == rhs.m_impl.m_value7;
860 case domain_base_variant::Type::Type8:
861 return lhs.m_impl.m_value8 == rhs.m_impl.m_value8;
862 case domain_base_variant::Type::Type9:
863 return lhs.m_impl.m_value9 == rhs.m_impl.m_value9;
864 case domain_base_variant::Type::Type10:
865 return lhs.m_impl.m_value10 == rhs.m_impl.m_value10;
866 default:
867 return true;
868 }
869 }
870 return false;
871}
872inline bool operator!=(const domain_base_variant& lhs, const domain_base_variant& rhs)
873{
874 if(lhs.m_type != rhs.m_type)
875 return true;
876 switch(lhs.m_type)
877 {
878 case domain_base_variant::Type::Type0:
879 return lhs.m_impl.m_value0 != rhs.m_impl.m_value0;
880 case domain_base_variant::Type::Type1:
881 return lhs.m_impl.m_value1 != rhs.m_impl.m_value1;
882 case domain_base_variant::Type::Type2:
883 return lhs.m_impl.m_value2 != rhs.m_impl.m_value2;
884 case domain_base_variant::Type::Type3:
885 return lhs.m_impl.m_value3 != rhs.m_impl.m_value3;
886 case domain_base_variant::Type::Type5:
887 return lhs.m_impl.m_value5 != rhs.m_impl.m_value5;
888 case domain_base_variant::Type::Type6:
889 return lhs.m_impl.m_value6 != rhs.m_impl.m_value6;
890 case domain_base_variant::Type::Type7:
891 return lhs.m_impl.m_value7 != rhs.m_impl.m_value7;
892 case domain_base_variant::Type::Type8:
893 return lhs.m_impl.m_value8 != rhs.m_impl.m_value8;
894 case domain_base_variant::Type::Type9:
895 return lhs.m_impl.m_value9 != rhs.m_impl.m_value9;
896 case domain_base_variant::Type::Type10:
897 return lhs.m_impl.m_value10 != rhs.m_impl.m_value10;
898 default:
899 return false;
900 }
901 return true;
902}
903inline bool
904operator==(const domain_base_variant& lhs, const ossia::domain_base<ossia::impulse>& rhs)
905{
906 return (lhs.m_type == domain_base_variant::Type::Type0)
907 && (lhs.m_impl.m_value0 == rhs);
908}
909inline bool
910operator==(const ossia::domain_base<ossia::impulse>& lhs, const domain_base_variant& rhs)
911{
912 return (rhs.m_type == domain_base_variant::Type::Type0)
913 && (rhs.m_impl.m_value0 == lhs);
914}
915inline bool
916operator!=(const domain_base_variant& lhs, const ossia::domain_base<ossia::impulse>& rhs)
917{
918 return (lhs.m_type != domain_base_variant::Type::Type0)
919 || (lhs.m_impl.m_value0 != rhs);
920}
921inline bool
922operator!=(const ossia::domain_base<ossia::impulse>& lhs, const domain_base_variant& rhs)
923{
924 return (rhs.m_type != domain_base_variant::Type::Type0)
925 || (rhs.m_impl.m_value0 != lhs);
926}
927inline bool
928operator==(const domain_base_variant& lhs, const ossia::domain_base<bool>& rhs)
929{
930 return (lhs.m_type == domain_base_variant::Type::Type1)
931 && (lhs.m_impl.m_value1 == rhs);
932}
933inline bool
934operator==(const ossia::domain_base<bool>& lhs, const domain_base_variant& rhs)
935{
936 return (rhs.m_type == domain_base_variant::Type::Type1)
937 && (rhs.m_impl.m_value1 == lhs);
938}
939inline bool
940operator!=(const domain_base_variant& lhs, const ossia::domain_base<bool>& rhs)
941{
942 return (lhs.m_type != domain_base_variant::Type::Type1)
943 || (lhs.m_impl.m_value1 != rhs);
944}
945inline bool
946operator!=(const ossia::domain_base<bool>& lhs, const domain_base_variant& rhs)
947{
948 return (rhs.m_type != domain_base_variant::Type::Type1)
949 || (rhs.m_impl.m_value1 != lhs);
950}
951inline bool
952operator==(const domain_base_variant& lhs, const ossia::domain_base<int32_t>& rhs)
953{
954 return (lhs.m_type == domain_base_variant::Type::Type2)
955 && (lhs.m_impl.m_value2 == rhs);
956}
957inline bool
958operator==(const ossia::domain_base<int32_t>& lhs, const domain_base_variant& rhs)
959{
960 return (rhs.m_type == domain_base_variant::Type::Type2)
961 && (rhs.m_impl.m_value2 == lhs);
962}
963inline bool
964operator!=(const domain_base_variant& lhs, const ossia::domain_base<int32_t>& rhs)
965{
966 return (lhs.m_type != domain_base_variant::Type::Type2)
967 || (lhs.m_impl.m_value2 != rhs);
968}
969inline bool
970operator!=(const ossia::domain_base<int32_t>& lhs, const domain_base_variant& rhs)
971{
972 return (rhs.m_type != domain_base_variant::Type::Type2)
973 || (rhs.m_impl.m_value2 != lhs);
974}
975inline bool
976operator==(const domain_base_variant& lhs, const ossia::domain_base<float>& rhs)
977{
978 return (lhs.m_type == domain_base_variant::Type::Type3)
979 && (lhs.m_impl.m_value3 == rhs);
980}
981inline bool
982operator==(const ossia::domain_base<float>& lhs, const domain_base_variant& rhs)
983{
984 return (rhs.m_type == domain_base_variant::Type::Type3)
985 && (rhs.m_impl.m_value3 == lhs);
986}
987inline bool
988operator!=(const domain_base_variant& lhs, const ossia::domain_base<float>& rhs)
989{
990 return (lhs.m_type != domain_base_variant::Type::Type3)
991 || (lhs.m_impl.m_value3 != rhs);
992}
993inline bool
994operator!=(const ossia::domain_base<float>& lhs, const domain_base_variant& rhs)
995{
996 return (rhs.m_type != domain_base_variant::Type::Type3)
997 || (rhs.m_impl.m_value3 != lhs);
998}
999inline bool
1000operator==(const domain_base_variant& lhs, const ossia::domain_base<std::string>& rhs)
1001{
1002 return (lhs.m_type == domain_base_variant::Type::Type5)
1003 && (lhs.m_impl.m_value5 == rhs);
1004}
1005inline bool
1006operator==(const ossia::domain_base<std::string>& lhs, const domain_base_variant& rhs)
1007{
1008 return (rhs.m_type == domain_base_variant::Type::Type5)
1009 && (rhs.m_impl.m_value5 == lhs);
1010}
1011inline bool
1012operator!=(const domain_base_variant& lhs, const ossia::domain_base<std::string>& rhs)
1013{
1014 return (lhs.m_type != domain_base_variant::Type::Type5)
1015 || (lhs.m_impl.m_value5 != rhs);
1016}
1017inline bool
1018operator!=(const ossia::domain_base<std::string>& lhs, const domain_base_variant& rhs)
1019{
1020 return (rhs.m_type != domain_base_variant::Type::Type5)
1021 || (rhs.m_impl.m_value5 != lhs);
1022}
1023inline bool operator==(const domain_base_variant& lhs, const ossia::vector_domain& rhs)
1024{
1025 return (lhs.m_type == domain_base_variant::Type::Type6)
1026 && (lhs.m_impl.m_value6 == rhs);
1027}
1028inline bool operator==(const ossia::vector_domain& lhs, const domain_base_variant& rhs)
1029{
1030 return (rhs.m_type == domain_base_variant::Type::Type6)
1031 && (rhs.m_impl.m_value6 == lhs);
1032}
1033inline bool operator!=(const domain_base_variant& lhs, const ossia::vector_domain& rhs)
1034{
1035 return (lhs.m_type != domain_base_variant::Type::Type6)
1036 || (lhs.m_impl.m_value6 != rhs);
1037}
1038inline bool operator!=(const ossia::vector_domain& lhs, const domain_base_variant& rhs)
1039{
1040 return (rhs.m_type != domain_base_variant::Type::Type6)
1041 || (rhs.m_impl.m_value6 != lhs);
1042}
1043inline bool operator==(const domain_base_variant& lhs, const ossia::vecf_domain<2>& rhs)
1044{
1045 return (lhs.m_type == domain_base_variant::Type::Type7)
1046 && (lhs.m_impl.m_value7 == rhs);
1047}
1048inline bool operator==(const ossia::vecf_domain<2>& lhs, const domain_base_variant& rhs)
1049{
1050 return (rhs.m_type == domain_base_variant::Type::Type7)
1051 && (rhs.m_impl.m_value7 == lhs);
1052}
1053inline bool operator!=(const domain_base_variant& lhs, const ossia::vecf_domain<2>& rhs)
1054{
1055 return (lhs.m_type != domain_base_variant::Type::Type7)
1056 || (lhs.m_impl.m_value7 != rhs);
1057}
1058inline bool operator!=(const ossia::vecf_domain<2>& lhs, const domain_base_variant& rhs)
1059{
1060 return (rhs.m_type != domain_base_variant::Type::Type7)
1061 || (rhs.m_impl.m_value7 != lhs);
1062}
1063inline bool operator==(const domain_base_variant& lhs, const ossia::vecf_domain<3>& rhs)
1064{
1065 return (lhs.m_type == domain_base_variant::Type::Type8)
1066 && (lhs.m_impl.m_value8 == rhs);
1067}
1068inline bool operator==(const ossia::vecf_domain<3>& lhs, const domain_base_variant& rhs)
1069{
1070 return (rhs.m_type == domain_base_variant::Type::Type8)
1071 && (rhs.m_impl.m_value8 == lhs);
1072}
1073inline bool operator!=(const domain_base_variant& lhs, const ossia::vecf_domain<3>& rhs)
1074{
1075 return (lhs.m_type != domain_base_variant::Type::Type8)
1076 || (lhs.m_impl.m_value8 != rhs);
1077}
1078inline bool operator!=(const ossia::vecf_domain<3>& lhs, const domain_base_variant& rhs)
1079{
1080 return (rhs.m_type != domain_base_variant::Type::Type8)
1081 || (rhs.m_impl.m_value8 != lhs);
1082}
1083inline bool operator==(const domain_base_variant& lhs, const ossia::vecf_domain<4>& rhs)
1084{
1085 return (lhs.m_type == domain_base_variant::Type::Type9)
1086 && (lhs.m_impl.m_value9 == rhs);
1087}
1088inline bool operator==(const ossia::vecf_domain<4>& lhs, const domain_base_variant& rhs)
1089{
1090 return (rhs.m_type == domain_base_variant::Type::Type9)
1091 && (rhs.m_impl.m_value9 == lhs);
1092}
1093inline bool operator!=(const domain_base_variant& lhs, const ossia::vecf_domain<4>& rhs)
1094{
1095 return (lhs.m_type != domain_base_variant::Type::Type9)
1096 || (lhs.m_impl.m_value9 != rhs);
1097}
1098inline bool operator!=(const ossia::vecf_domain<4>& lhs, const domain_base_variant& rhs)
1099{
1100 return (rhs.m_type != domain_base_variant::Type::Type9)
1101 || (rhs.m_impl.m_value9 != lhs);
1102}
1103inline bool
1104operator==(const domain_base_variant& lhs, const ossia::domain_base<ossia::value>& rhs)
1105{
1106 return (lhs.m_type == domain_base_variant::Type::Type10)
1107 && (lhs.m_impl.m_value10 == rhs);
1108}
1109inline bool
1110operator==(const ossia::domain_base<ossia::value>& lhs, const domain_base_variant& rhs)
1111{
1112 return (rhs.m_type == domain_base_variant::Type::Type10)
1113 && (rhs.m_impl.m_value10 == lhs);
1114}
1115inline bool
1116operator!=(const domain_base_variant& lhs, const ossia::domain_base<ossia::value>& rhs)
1117{
1118 return (lhs.m_type != domain_base_variant::Type::Type10)
1119 || (lhs.m_impl.m_value10 != rhs);
1120}
1121inline bool
1122operator!=(const ossia::domain_base<ossia::value>& lhs, const domain_base_variant& rhs)
1123{
1124 return (rhs.m_type != domain_base_variant::Type::Type10)
1125 || (rhs.m_impl.m_value10 != lhs);
1126}
1127template <typename Functor>
1128auto apply(Functor&& functor, domain_base_variant& arg0, const value_variant_type& arg1)
1129{
1130 switch(arg0.m_type)
1131 {
1132 case domain_base_variant::Type::Type0: {
1133 switch(arg1.m_type)
1134 {
1135 case value_variant_type::Type::Type0: {
1136 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value0);
1137 }
1138 case value_variant_type::Type::Type1: {
1139 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value1);
1140 }
1141 case value_variant_type::Type::Type2: {
1142 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value2);
1143 }
1144 case value_variant_type::Type::Type3: {
1145 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value3);
1146 }
1147 case value_variant_type::Type::Type4: {
1148 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value4);
1149 }
1150 case value_variant_type::Type::Type5: {
1151 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value5);
1152 }
1153 case value_variant_type::Type::Type6: {
1154 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value6);
1155 }
1156 case value_variant_type::Type::Type7: {
1157 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value7);
1158 }
1159 case value_variant_type::Type::Type8: {
1160 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value8);
1161 }
1162 case value_variant_type::Type::Type9: {
1163 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value9);
1164 }
1165 default:
1166 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1167 }
1168 }
1169 case domain_base_variant::Type::Type1: {
1170 switch(arg1.m_type)
1171 {
1172 case value_variant_type::Type::Type0: {
1173 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value0);
1174 }
1175 case value_variant_type::Type::Type1: {
1176 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value1);
1177 }
1178 case value_variant_type::Type::Type2: {
1179 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value2);
1180 }
1181 case value_variant_type::Type::Type3: {
1182 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value3);
1183 }
1184 case value_variant_type::Type::Type4: {
1185 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value4);
1186 }
1187 case value_variant_type::Type::Type5: {
1188 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value5);
1189 }
1190 case value_variant_type::Type::Type6: {
1191 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value6);
1192 }
1193 case value_variant_type::Type::Type7: {
1194 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value7);
1195 }
1196 case value_variant_type::Type::Type8: {
1197 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value8);
1198 }
1199 case value_variant_type::Type::Type9: {
1200 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value9);
1201 }
1202 default:
1203 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1204 }
1205 }
1206 case domain_base_variant::Type::Type2: {
1207 switch(arg1.m_type)
1208 {
1209 case value_variant_type::Type::Type0: {
1210 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value0);
1211 }
1212 case value_variant_type::Type::Type1: {
1213 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value1);
1214 }
1215 case value_variant_type::Type::Type2: {
1216 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value2);
1217 }
1218 case value_variant_type::Type::Type3: {
1219 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value3);
1220 }
1221 case value_variant_type::Type::Type4: {
1222 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value4);
1223 }
1224 case value_variant_type::Type::Type5: {
1225 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value5);
1226 }
1227 case value_variant_type::Type::Type6: {
1228 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value6);
1229 }
1230 case value_variant_type::Type::Type7: {
1231 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value7);
1232 }
1233 case value_variant_type::Type::Type8: {
1234 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value8);
1235 }
1236 case value_variant_type::Type::Type9: {
1237 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value9);
1238 }
1239 default:
1240 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1241 }
1242 }
1243 case domain_base_variant::Type::Type3: {
1244 switch(arg1.m_type)
1245 {
1246 case value_variant_type::Type::Type0: {
1247 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value0);
1248 }
1249 case value_variant_type::Type::Type1: {
1250 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value1);
1251 }
1252 case value_variant_type::Type::Type2: {
1253 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value2);
1254 }
1255 case value_variant_type::Type::Type3: {
1256 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value3);
1257 }
1258 case value_variant_type::Type::Type4: {
1259 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value4);
1260 }
1261 case value_variant_type::Type::Type5: {
1262 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value5);
1263 }
1264 case value_variant_type::Type::Type6: {
1265 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value6);
1266 }
1267 case value_variant_type::Type::Type7: {
1268 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value7);
1269 }
1270 case value_variant_type::Type::Type8: {
1271 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value8);
1272 }
1273 case value_variant_type::Type::Type9: {
1274 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value9);
1275 }
1276 default:
1277 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1278 }
1279 }
1280 case domain_base_variant::Type::Type5: {
1281 switch(arg1.m_type)
1282 {
1283 case value_variant_type::Type::Type0: {
1284 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value0);
1285 }
1286 case value_variant_type::Type::Type1: {
1287 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value1);
1288 }
1289 case value_variant_type::Type::Type2: {
1290 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value2);
1291 }
1292 case value_variant_type::Type::Type3: {
1293 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value3);
1294 }
1295 case value_variant_type::Type::Type4: {
1296 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value4);
1297 }
1298 case value_variant_type::Type::Type5: {
1299 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value5);
1300 }
1301 case value_variant_type::Type::Type6: {
1302 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value6);
1303 }
1304 case value_variant_type::Type::Type7: {
1305 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value7);
1306 }
1307 case value_variant_type::Type::Type8: {
1308 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value8);
1309 }
1310 case value_variant_type::Type::Type9: {
1311 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value9);
1312 }
1313 default:
1314 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1315 }
1316 }
1317 case domain_base_variant::Type::Type6: {
1318 switch(arg1.m_type)
1319 {
1320 case value_variant_type::Type::Type0: {
1321 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value0);
1322 }
1323 case value_variant_type::Type::Type1: {
1324 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value1);
1325 }
1326 case value_variant_type::Type::Type2: {
1327 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value2);
1328 }
1329 case value_variant_type::Type::Type3: {
1330 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value3);
1331 }
1332 case value_variant_type::Type::Type4: {
1333 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value4);
1334 }
1335 case value_variant_type::Type::Type5: {
1336 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value5);
1337 }
1338 case value_variant_type::Type::Type6: {
1339 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value6);
1340 }
1341 case value_variant_type::Type::Type7: {
1342 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value7);
1343 }
1344 case value_variant_type::Type::Type8: {
1345 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value8);
1346 }
1347 case value_variant_type::Type::Type9: {
1348 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value9);
1349 }
1350 default:
1351 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1352 }
1353 }
1354 case domain_base_variant::Type::Type7: {
1355 switch(arg1.m_type)
1356 {
1357 case value_variant_type::Type::Type0: {
1358 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value0);
1359 }
1360 case value_variant_type::Type::Type1: {
1361 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value1);
1362 }
1363 case value_variant_type::Type::Type2: {
1364 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value2);
1365 }
1366 case value_variant_type::Type::Type3: {
1367 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value3);
1368 }
1369 case value_variant_type::Type::Type4: {
1370 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value4);
1371 }
1372 case value_variant_type::Type::Type5: {
1373 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value5);
1374 }
1375 case value_variant_type::Type::Type6: {
1376 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value6);
1377 }
1378 case value_variant_type::Type::Type7: {
1379 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value7);
1380 }
1381 case value_variant_type::Type::Type8: {
1382 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value8);
1383 }
1384 case value_variant_type::Type::Type9: {
1385 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value9);
1386 }
1387 default:
1388 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1389 }
1390 }
1391 case domain_base_variant::Type::Type8: {
1392 switch(arg1.m_type)
1393 {
1394 case value_variant_type::Type::Type0: {
1395 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value0);
1396 }
1397 case value_variant_type::Type::Type1: {
1398 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value1);
1399 }
1400 case value_variant_type::Type::Type2: {
1401 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value2);
1402 }
1403 case value_variant_type::Type::Type3: {
1404 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value3);
1405 }
1406 case value_variant_type::Type::Type4: {
1407 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value4);
1408 }
1409 case value_variant_type::Type::Type5: {
1410 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value5);
1411 }
1412 case value_variant_type::Type::Type6: {
1413 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value6);
1414 }
1415 case value_variant_type::Type::Type7: {
1416 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value7);
1417 }
1418 case value_variant_type::Type::Type8: {
1419 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value8);
1420 }
1421 case value_variant_type::Type::Type9: {
1422 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value9);
1423 }
1424 default:
1425 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1426 }
1427 }
1428 case domain_base_variant::Type::Type9: {
1429 switch(arg1.m_type)
1430 {
1431 case value_variant_type::Type::Type0: {
1432 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value0);
1433 }
1434 case value_variant_type::Type::Type1: {
1435 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value1);
1436 }
1437 case value_variant_type::Type::Type2: {
1438 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value2);
1439 }
1440 case value_variant_type::Type::Type3: {
1441 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value3);
1442 }
1443 case value_variant_type::Type::Type4: {
1444 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value4);
1445 }
1446 case value_variant_type::Type::Type5: {
1447 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value5);
1448 }
1449 case value_variant_type::Type::Type6: {
1450 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value6);
1451 }
1452 case value_variant_type::Type::Type7: {
1453 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value7);
1454 }
1455 case value_variant_type::Type::Type8: {
1456 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value8);
1457 }
1458 case value_variant_type::Type::Type9: {
1459 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value9);
1460 }
1461 default:
1462 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1463 }
1464 }
1465 case domain_base_variant::Type::Type10: {
1466 switch(arg1.m_type)
1467 {
1468 case value_variant_type::Type::Type0: {
1469 return functor(arg0.m_impl.m_value10, arg1.m_impl.m_value0);
1470 }
1471 case value_variant_type::Type::Type1: {
1472 return functor(arg0.m_impl.m_value10, arg1.m_impl.m_value1);
1473 }
1474 case value_variant_type::Type::Type2: {
1475 return functor(arg0.m_impl.m_value10, arg1.m_impl.m_value2);
1476 }
1477 case value_variant_type::Type::Type3: {
1478 return functor(arg0.m_impl.m_value10, arg1.m_impl.m_value3);
1479 }
1480 case value_variant_type::Type::Type4: {
1481 return functor(arg0.m_impl.m_value10, arg1.m_impl.m_value4);
1482 }
1483 case value_variant_type::Type::Type5: {
1484 return functor(arg0.m_impl.m_value10, arg1.m_impl.m_value5);
1485 }
1486 case value_variant_type::Type::Type6: {
1487 return functor(arg0.m_impl.m_value10, arg1.m_impl.m_value6);
1488 }
1489 case value_variant_type::Type::Type7: {
1490 return functor(arg0.m_impl.m_value10, arg1.m_impl.m_value7);
1491 }
1492 case value_variant_type::Type::Type8: {
1493 return functor(arg0.m_impl.m_value10, arg1.m_impl.m_value8);
1494 }
1495 case value_variant_type::Type::Type9: {
1496 return functor(arg0.m_impl.m_value10, arg1.m_impl.m_value9);
1497 }
1498 default:
1499 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1500 }
1501 }
1502 default:
1503 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1504 }
1505}
1506template <typename Functor>
1507auto apply(
1508 Functor&& functor, const value_variant_type& arg0, const domain_base_variant& arg1)
1509{
1510 switch(arg0.m_type)
1511 {
1512 case value_variant_type::Type::Type0: {
1513 switch(arg1.m_type)
1514 {
1515 case domain_base_variant::Type::Type0: {
1516 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value0);
1517 }
1518 case domain_base_variant::Type::Type1: {
1519 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value1);
1520 }
1521 case domain_base_variant::Type::Type2: {
1522 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value2);
1523 }
1524 case domain_base_variant::Type::Type3: {
1525 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value3);
1526 }
1527 case domain_base_variant::Type::Type5: {
1528 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value5);
1529 }
1530 case domain_base_variant::Type::Type6: {
1531 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value6);
1532 }
1533 case domain_base_variant::Type::Type7: {
1534 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value7);
1535 }
1536 case domain_base_variant::Type::Type8: {
1537 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value8);
1538 }
1539 case domain_base_variant::Type::Type9: {
1540 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value9);
1541 }
1542 case domain_base_variant::Type::Type10: {
1543 return functor(arg0.m_impl.m_value0, arg1.m_impl.m_value10);
1544 }
1545 default:
1546 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1547 }
1548 }
1549 case value_variant_type::Type::Type1: {
1550 switch(arg1.m_type)
1551 {
1552 case domain_base_variant::Type::Type0: {
1553 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value0);
1554 }
1555 case domain_base_variant::Type::Type1: {
1556 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value1);
1557 }
1558 case domain_base_variant::Type::Type2: {
1559 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value2);
1560 }
1561 case domain_base_variant::Type::Type3: {
1562 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value3);
1563 }
1564 case domain_base_variant::Type::Type5: {
1565 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value5);
1566 }
1567 case domain_base_variant::Type::Type6: {
1568 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value6);
1569 }
1570 case domain_base_variant::Type::Type7: {
1571 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value7);
1572 }
1573 case domain_base_variant::Type::Type8: {
1574 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value8);
1575 }
1576 case domain_base_variant::Type::Type9: {
1577 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value9);
1578 }
1579 case domain_base_variant::Type::Type10: {
1580 return functor(arg0.m_impl.m_value1, arg1.m_impl.m_value10);
1581 }
1582 default:
1583 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1584 }
1585 }
1586 case value_variant_type::Type::Type2: {
1587 switch(arg1.m_type)
1588 {
1589 case domain_base_variant::Type::Type0: {
1590 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value0);
1591 }
1592 case domain_base_variant::Type::Type1: {
1593 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value1);
1594 }
1595 case domain_base_variant::Type::Type2: {
1596 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value2);
1597 }
1598 case domain_base_variant::Type::Type3: {
1599 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value3);
1600 }
1601 case domain_base_variant::Type::Type5: {
1602 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value5);
1603 }
1604 case domain_base_variant::Type::Type6: {
1605 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value6);
1606 }
1607 case domain_base_variant::Type::Type7: {
1608 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value7);
1609 }
1610 case domain_base_variant::Type::Type8: {
1611 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value8);
1612 }
1613 case domain_base_variant::Type::Type9: {
1614 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value9);
1615 }
1616 case domain_base_variant::Type::Type10: {
1617 return functor(arg0.m_impl.m_value2, arg1.m_impl.m_value10);
1618 }
1619 default:
1620 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1621 }
1622 }
1623 case value_variant_type::Type::Type3: {
1624 switch(arg1.m_type)
1625 {
1626 case domain_base_variant::Type::Type0: {
1627 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value0);
1628 }
1629 case domain_base_variant::Type::Type1: {
1630 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value1);
1631 }
1632 case domain_base_variant::Type::Type2: {
1633 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value2);
1634 }
1635 case domain_base_variant::Type::Type3: {
1636 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value3);
1637 }
1638 case domain_base_variant::Type::Type5: {
1639 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value5);
1640 }
1641 case domain_base_variant::Type::Type6: {
1642 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value6);
1643 }
1644 case domain_base_variant::Type::Type7: {
1645 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value7);
1646 }
1647 case domain_base_variant::Type::Type8: {
1648 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value8);
1649 }
1650 case domain_base_variant::Type::Type9: {
1651 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value9);
1652 }
1653 case domain_base_variant::Type::Type10: {
1654 return functor(arg0.m_impl.m_value3, arg1.m_impl.m_value10);
1655 }
1656 default:
1657 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1658 }
1659 }
1660 case value_variant_type::Type::Type4: {
1661 switch(arg1.m_type)
1662 {
1663 case domain_base_variant::Type::Type0: {
1664 return functor(arg0.m_impl.m_value4, arg1.m_impl.m_value0);
1665 }
1666 case domain_base_variant::Type::Type1: {
1667 return functor(arg0.m_impl.m_value4, arg1.m_impl.m_value1);
1668 }
1669 case domain_base_variant::Type::Type2: {
1670 return functor(arg0.m_impl.m_value4, arg1.m_impl.m_value2);
1671 }
1672 case domain_base_variant::Type::Type3: {
1673 return functor(arg0.m_impl.m_value4, arg1.m_impl.m_value3);
1674 }
1675 case domain_base_variant::Type::Type5: {
1676 return functor(arg0.m_impl.m_value4, arg1.m_impl.m_value5);
1677 }
1678 case domain_base_variant::Type::Type6: {
1679 return functor(arg0.m_impl.m_value4, arg1.m_impl.m_value6);
1680 }
1681 case domain_base_variant::Type::Type7: {
1682 return functor(arg0.m_impl.m_value4, arg1.m_impl.m_value7);
1683 }
1684 case domain_base_variant::Type::Type8: {
1685 return functor(arg0.m_impl.m_value4, arg1.m_impl.m_value8);
1686 }
1687 case domain_base_variant::Type::Type9: {
1688 return functor(arg0.m_impl.m_value4, arg1.m_impl.m_value9);
1689 }
1690 case domain_base_variant::Type::Type10: {
1691 return functor(arg0.m_impl.m_value4, arg1.m_impl.m_value10);
1692 }
1693 default:
1694 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1695 }
1696 }
1697 case value_variant_type::Type::Type5: {
1698 switch(arg1.m_type)
1699 {
1700 case domain_base_variant::Type::Type0: {
1701 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value0);
1702 }
1703 case domain_base_variant::Type::Type1: {
1704 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value1);
1705 }
1706 case domain_base_variant::Type::Type2: {
1707 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value2);
1708 }
1709 case domain_base_variant::Type::Type3: {
1710 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value3);
1711 }
1712 case domain_base_variant::Type::Type5: {
1713 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value5);
1714 }
1715 case domain_base_variant::Type::Type6: {
1716 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value6);
1717 }
1718 case domain_base_variant::Type::Type7: {
1719 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value7);
1720 }
1721 case domain_base_variant::Type::Type8: {
1722 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value8);
1723 }
1724 case domain_base_variant::Type::Type9: {
1725 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value9);
1726 }
1727 case domain_base_variant::Type::Type10: {
1728 return functor(arg0.m_impl.m_value5, arg1.m_impl.m_value10);
1729 }
1730 default:
1731 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1732 }
1733 }
1734 case value_variant_type::Type::Type6: {
1735 switch(arg1.m_type)
1736 {
1737 case domain_base_variant::Type::Type0: {
1738 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value0);
1739 }
1740 case domain_base_variant::Type::Type1: {
1741 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value1);
1742 }
1743 case domain_base_variant::Type::Type2: {
1744 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value2);
1745 }
1746 case domain_base_variant::Type::Type3: {
1747 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value3);
1748 }
1749 case domain_base_variant::Type::Type5: {
1750 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value5);
1751 }
1752 case domain_base_variant::Type::Type6: {
1753 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value6);
1754 }
1755 case domain_base_variant::Type::Type7: {
1756 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value7);
1757 }
1758 case domain_base_variant::Type::Type8: {
1759 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value8);
1760 }
1761 case domain_base_variant::Type::Type9: {
1762 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value9);
1763 }
1764 case domain_base_variant::Type::Type10: {
1765 return functor(arg0.m_impl.m_value6, arg1.m_impl.m_value10);
1766 }
1767 default:
1768 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1769 }
1770 }
1771 case value_variant_type::Type::Type7: {
1772 switch(arg1.m_type)
1773 {
1774 case domain_base_variant::Type::Type0: {
1775 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value0);
1776 }
1777 case domain_base_variant::Type::Type1: {
1778 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value1);
1779 }
1780 case domain_base_variant::Type::Type2: {
1781 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value2);
1782 }
1783 case domain_base_variant::Type::Type3: {
1784 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value3);
1785 }
1786 case domain_base_variant::Type::Type5: {
1787 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value5);
1788 }
1789 case domain_base_variant::Type::Type6: {
1790 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value6);
1791 }
1792 case domain_base_variant::Type::Type7: {
1793 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value7);
1794 }
1795 case domain_base_variant::Type::Type8: {
1796 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value8);
1797 }
1798 case domain_base_variant::Type::Type9: {
1799 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value9);
1800 }
1801 case domain_base_variant::Type::Type10: {
1802 return functor(arg0.m_impl.m_value7, arg1.m_impl.m_value10);
1803 }
1804 default:
1805 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1806 }
1807 }
1808 case value_variant_type::Type::Type8: {
1809 switch(arg1.m_type)
1810 {
1811 case domain_base_variant::Type::Type0: {
1812 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value0);
1813 }
1814 case domain_base_variant::Type::Type1: {
1815 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value1);
1816 }
1817 case domain_base_variant::Type::Type2: {
1818 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value2);
1819 }
1820 case domain_base_variant::Type::Type3: {
1821 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value3);
1822 }
1823 case domain_base_variant::Type::Type5: {
1824 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value5);
1825 }
1826 case domain_base_variant::Type::Type6: {
1827 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value6);
1828 }
1829 case domain_base_variant::Type::Type7: {
1830 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value7);
1831 }
1832 case domain_base_variant::Type::Type8: {
1833 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value8);
1834 }
1835 case domain_base_variant::Type::Type9: {
1836 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value9);
1837 }
1838 case domain_base_variant::Type::Type10: {
1839 return functor(arg0.m_impl.m_value8, arg1.m_impl.m_value10);
1840 }
1841 default:
1842 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1843 }
1844 }
1845 case value_variant_type::Type::Type9: {
1846 switch(arg1.m_type)
1847 {
1848 case domain_base_variant::Type::Type0: {
1849 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value0);
1850 }
1851 case domain_base_variant::Type::Type1: {
1852 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value1);
1853 }
1854 case domain_base_variant::Type::Type2: {
1855 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value2);
1856 }
1857 case domain_base_variant::Type::Type3: {
1858 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value3);
1859 }
1860 case domain_base_variant::Type::Type5: {
1861 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value5);
1862 }
1863 case domain_base_variant::Type::Type6: {
1864 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value6);
1865 }
1866 case domain_base_variant::Type::Type7: {
1867 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value7);
1868 }
1869 case domain_base_variant::Type::Type8: {
1870 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value8);
1871 }
1872 case domain_base_variant::Type::Type9: {
1873 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value9);
1874 }
1875 case domain_base_variant::Type::Type10: {
1876 return functor(arg0.m_impl.m_value9, arg1.m_impl.m_value10);
1877 }
1878 default:
1879 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1880 }
1881 }
1882 default:
1883 ossia_do_throw(std::runtime_error, "domain_variant_impl: bad type");
1884 }
1885}
ossia::matching_type
val_type matching_type(const unit_t &u)
underlying_type Get the implementation type of an unit
Definition dataspace_visitors.cpp:198