cgv
method_interface_impl.h
1 #pragma once
2 
3 #include <cgv/reflect/reflection_handler.h>
4 #include <cgv/type/variant.h>
5 
6 namespace cgv {
7  namespace reflect {
8 
9 template <typename M>
10 struct method_interface_impl;
11 
12 
13 
14 template <typename X, typename R>
15 struct method_interface_impl<R (X::*)()> : public method_interface
16 {
17  typedef R (X::*M)();
18  M m;
19  method_interface_impl(M _m) : m(_m) {}
20  void call_void(void* instance,
21  const std::vector<abst_reflection_traits*>& param_value_traits,
22  const std::vector<const void*>& param_value_ptrs,
23  const std::vector<std::string>& param_type_names,
24  const abst_reflection_traits* result_traits,
25  void* result_value_ptr,
26  const std::string& result_type_name)
27  {
28  cgv::type::set_variant((((X*)instance)->*m)(
29  ), result_type_name, result_value_ptr);
30  }
31 };
32 
33 
34 template <typename X, typename R>
35 struct method_interface_impl<R (X::*)() const> : public method_interface
36 {
37  typedef R (X::*M)() const;
38  M m;
39  method_interface_impl(M _m) : m(_m) {}
40  void call_void(void* instance,
41  const std::vector<abst_reflection_traits*>& param_value_traits,
42  const std::vector<const void*>& param_value_ptrs,
43  const std::vector<std::string>& param_type_names,
44  const abst_reflection_traits* result_traits,
45  void* result_value_ptr,
46  const std::string& result_type_name)
47  {
48  cgv::type::set_variant((((X*)instance)->*m)(
49  ), result_type_name, result_value_ptr);
50  }
51 };
52 
53 
54 template <typename X>
55 struct method_interface_impl<void (X::*)()> : public method_interface
56 {
57  typedef void (X::*M)();
58  M m;
59  method_interface_impl(M _m) : m(_m) {}
60  void call_void(void* instance,
61  const std::vector<abst_reflection_traits*>& param_value_traits,
62  const std::vector<const void*>& param_value_ptrs,
63  const std::vector<std::string>& param_type_names,
64  const abst_reflection_traits* result_traits,
65  void* result_value_ptr,
66  const std::string& result_type_name)
67  {
68  (((X*)instance)->*m)(
69  );
70  }
71 };
72 
73 template <typename X>
74 struct method_interface_impl<void (X::*)() const> : public method_interface
75 {
76  typedef void (X::*M)() const;
77  M m;
78  method_interface_impl(M _m) : m(_m) {}
79  void call_void(void* instance,
80  const std::vector<abst_reflection_traits*>& param_value_traits,
81  const std::vector<const void*>& param_value_ptrs,
82  const std::vector<std::string>& param_type_names,
83  const abst_reflection_traits* result_traits,
84  void* result_value_ptr,
85  const std::string& result_type_name)
86  {
87  (((X*)instance)->*m)(
88  );
89  }
90 };
91 
92 
93 
94 template <typename X, typename R, typename T1>
95 struct method_interface_impl<R (X::*)(T1)> : public method_interface
96 {
97  typedef R (X::*M)(T1);
98  M m;
99  method_interface_impl(M _m) : m(_m) {}
100  void call_void(void* instance,
101  const std::vector<abst_reflection_traits*>& param_value_traits,
102  const std::vector<const void*>& param_value_ptrs,
103  const std::vector<std::string>& param_type_names,
104  const abst_reflection_traits* result_traits,
105  void* result_value_ptr,
106  const std::string& result_type_name)
107  {
108  cgv::type::set_variant((((X*)instance)->*m)(
109  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0])
110  ), result_type_name, result_value_ptr);
111  }
112 };
113 
114 
115 template <typename X, typename R, typename T1>
116 struct method_interface_impl<R (X::*)(T1) const> : public method_interface
117 {
118  typedef R (X::*M)(T1) const;
119  M m;
120  method_interface_impl(M _m) : m(_m) {}
121  void call_void(void* instance,
122  const std::vector<abst_reflection_traits*>& param_value_traits,
123  const std::vector<const void*>& param_value_ptrs,
124  const std::vector<std::string>& param_type_names,
125  const abst_reflection_traits* result_traits,
126  void* result_value_ptr,
127  const std::string& result_type_name)
128  {
129  cgv::type::set_variant((((X*)instance)->*m)(
130  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0])
131  ), result_type_name, result_value_ptr);
132  }
133 };
134 
135 
136 template <typename X, typename T1>
137 struct method_interface_impl<void (X::*)(T1)> : public method_interface
138 {
139  typedef void (X::*M)(T1);
140  M m;
141  method_interface_impl(M _m) : m(_m) {}
142  void call_void(void* instance,
143  const std::vector<abst_reflection_traits*>& param_value_traits,
144  const std::vector<const void*>& param_value_ptrs,
145  const std::vector<std::string>& param_type_names,
146  const abst_reflection_traits* result_traits,
147  void* result_value_ptr,
148  const std::string& result_type_name)
149  {
150  (((X*)instance)->*m)(
151  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0])
152  );
153  }
154 };
155 
156 template <typename X, typename T1>
157 struct method_interface_impl<void (X::*)(T1) const> : public method_interface
158 {
159  typedef void (X::*M)(T1) const;
160  M m;
161  method_interface_impl(M _m) : m(_m) {}
162  void call_void(void* instance,
163  const std::vector<abst_reflection_traits*>& param_value_traits,
164  const std::vector<const void*>& param_value_ptrs,
165  const std::vector<std::string>& param_type_names,
166  const abst_reflection_traits* result_traits,
167  void* result_value_ptr,
168  const std::string& result_type_name)
169  {
170  (((X*)instance)->*m)(
171  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0])
172  );
173  }
174 };
175 
176 
177 
178 template <typename X, typename R, typename T1, typename T2>
179 struct method_interface_impl<R (X::*)(T1,T2)> : public method_interface
180 {
181  typedef R (X::*M)(T1,T2);
182  M m;
183  method_interface_impl(M _m) : m(_m) {}
184  void call_void(void* instance,
185  const std::vector<abst_reflection_traits*>& param_value_traits,
186  const std::vector<const void*>& param_value_ptrs,
187  const std::vector<std::string>& param_type_names,
188  const abst_reflection_traits* result_traits,
189  void* result_value_ptr,
190  const std::string& result_type_name)
191  {
192  cgv::type::set_variant((((X*)instance)->*m)(
193  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
194  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1])
195  ), result_type_name, result_value_ptr);
196  }
197 };
198 
199 
200 template <typename X, typename R, typename T1, typename T2>
201 struct method_interface_impl<R (X::*)(T1,T2) const> : public method_interface
202 {
203  typedef R (X::*M)(T1,T2) const;
204  M m;
205  method_interface_impl(M _m) : m(_m) {}
206  void call_void(void* instance,
207  const std::vector<abst_reflection_traits*>& param_value_traits,
208  const std::vector<const void*>& param_value_ptrs,
209  const std::vector<std::string>& param_type_names,
210  const abst_reflection_traits* result_traits,
211  void* result_value_ptr,
212  const std::string& result_type_name)
213  {
214  cgv::type::set_variant((((X*)instance)->*m)(
215  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
216  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1])
217  ), result_type_name, result_value_ptr);
218  }
219 };
220 
221 
222 template <typename X, typename T1, typename T2>
223 struct method_interface_impl<void (X::*)(T1,T2)> : public method_interface
224 {
225  typedef void (X::*M)(T1,T2);
226  M m;
227  method_interface_impl(M _m) : m(_m) {}
228  void call_void(void* instance,
229  const std::vector<abst_reflection_traits*>& param_value_traits,
230  const std::vector<const void*>& param_value_ptrs,
231  const std::vector<std::string>& param_type_names,
232  const abst_reflection_traits* result_traits,
233  void* result_value_ptr,
234  const std::string& result_type_name)
235  {
236  (((X*)instance)->*m)(
237  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
238  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1])
239  );
240  }
241 };
242 
243 template <typename X, typename T1, typename T2>
244 struct method_interface_impl<void (X::*)(T1,T2) const> : public method_interface
245 {
246  typedef void (X::*M)(T1,T2) const;
247  M m;
248  method_interface_impl(M _m) : m(_m) {}
249  void call_void(void* instance,
250  const std::vector<abst_reflection_traits*>& param_value_traits,
251  const std::vector<const void*>& param_value_ptrs,
252  const std::vector<std::string>& param_type_names,
253  const abst_reflection_traits* result_traits,
254  void* result_value_ptr,
255  const std::string& result_type_name)
256  {
257  (((X*)instance)->*m)(
258  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
259  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1])
260  );
261  }
262 };
263 
264 
265 
266 template <typename X, typename R, typename T1, typename T2, typename T3>
267 struct method_interface_impl<R (X::*)(T1,T2,T3)> : public method_interface
268 {
269  typedef R (X::*M)(T1,T2,T3);
270  M m;
271  method_interface_impl(M _m) : m(_m) {}
272  void call_void(void* instance,
273  const std::vector<abst_reflection_traits*>& param_value_traits,
274  const std::vector<const void*>& param_value_ptrs,
275  const std::vector<std::string>& param_type_names,
276  const abst_reflection_traits* result_traits,
277  void* result_value_ptr,
278  const std::string& result_type_name)
279  {
280  cgv::type::set_variant((((X*)instance)->*m)(
281  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
282  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
283  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2])
284  ), result_type_name, result_value_ptr);
285  }
286 };
287 
288 
289 template <typename X, typename R, typename T1, typename T2, typename T3>
290 struct method_interface_impl<R (X::*)(T1,T2,T3) const> : public method_interface
291 {
292  typedef R (X::*M)(T1,T2,T3) const;
293  M m;
294  method_interface_impl(M _m) : m(_m) {}
295  void call_void(void* instance,
296  const std::vector<abst_reflection_traits*>& param_value_traits,
297  const std::vector<const void*>& param_value_ptrs,
298  const std::vector<std::string>& param_type_names,
299  const abst_reflection_traits* result_traits,
300  void* result_value_ptr,
301  const std::string& result_type_name)
302  {
303  cgv::type::set_variant((((X*)instance)->*m)(
304  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
305  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
306  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2])
307  ), result_type_name, result_value_ptr);
308  }
309 };
310 
311 
312 template <typename X, typename T1, typename T2, typename T3>
313 struct method_interface_impl<void (X::*)(T1,T2,T3)> : public method_interface
314 {
315  typedef void (X::*M)(T1,T2,T3);
316  M m;
317  method_interface_impl(M _m) : m(_m) {}
318  void call_void(void* instance,
319  const std::vector<abst_reflection_traits*>& param_value_traits,
320  const std::vector<const void*>& param_value_ptrs,
321  const std::vector<std::string>& param_type_names,
322  const abst_reflection_traits* result_traits,
323  void* result_value_ptr,
324  const std::string& result_type_name)
325  {
326  (((X*)instance)->*m)(
327  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
328  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
329  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2])
330  );
331  }
332 };
333 
334 template <typename X, typename T1, typename T2, typename T3>
335 struct method_interface_impl<void (X::*)(T1,T2,T3) const> : public method_interface
336 {
337  typedef void (X::*M)(T1,T2,T3) const;
338  M m;
339  method_interface_impl(M _m) : m(_m) {}
340  void call_void(void* instance,
341  const std::vector<abst_reflection_traits*>& param_value_traits,
342  const std::vector<const void*>& param_value_ptrs,
343  const std::vector<std::string>& param_type_names,
344  const abst_reflection_traits* result_traits,
345  void* result_value_ptr,
346  const std::string& result_type_name)
347  {
348  (((X*)instance)->*m)(
349  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
350  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
351  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2])
352  );
353  }
354 };
355 
356 
357 
358 template <typename X, typename R, typename T1, typename T2, typename T3, typename T4>
359 struct method_interface_impl<R (X::*)(T1,T2,T3,T4)> : public method_interface
360 {
361  typedef R (X::*M)(T1,T2,T3,T4);
362  M m;
363  method_interface_impl(M _m) : m(_m) {}
364  void call_void(void* instance,
365  const std::vector<abst_reflection_traits*>& param_value_traits,
366  const std::vector<const void*>& param_value_ptrs,
367  const std::vector<std::string>& param_type_names,
368  const abst_reflection_traits* result_traits,
369  void* result_value_ptr,
370  const std::string& result_type_name)
371  {
372  cgv::type::set_variant((((X*)instance)->*m)(
373  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
374  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
375  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
376  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3])
377  ), result_type_name, result_value_ptr);
378  }
379 };
380 
381 
382 template <typename X, typename R, typename T1, typename T2, typename T3, typename T4>
383 struct method_interface_impl<R (X::*)(T1,T2,T3,T4) const> : public method_interface
384 {
385  typedef R (X::*M)(T1,T2,T3,T4) const;
386  M m;
387  method_interface_impl(M _m) : m(_m) {}
388  void call_void(void* instance,
389  const std::vector<abst_reflection_traits*>& param_value_traits,
390  const std::vector<const void*>& param_value_ptrs,
391  const std::vector<std::string>& param_type_names,
392  const abst_reflection_traits* result_traits,
393  void* result_value_ptr,
394  const std::string& result_type_name)
395  {
396  cgv::type::set_variant((((X*)instance)->*m)(
397  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
398  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
399  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
400  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3])
401  ), result_type_name, result_value_ptr);
402  }
403 };
404 
405 
406 template <typename X, typename T1, typename T2, typename T3, typename T4>
407 struct method_interface_impl<void (X::*)(T1,T2,T3,T4)> : public method_interface
408 {
409  typedef void (X::*M)(T1,T2,T3,T4);
410  M m;
411  method_interface_impl(M _m) : m(_m) {}
412  void call_void(void* instance,
413  const std::vector<abst_reflection_traits*>& param_value_traits,
414  const std::vector<const void*>& param_value_ptrs,
415  const std::vector<std::string>& param_type_names,
416  const abst_reflection_traits* result_traits,
417  void* result_value_ptr,
418  const std::string& result_type_name)
419  {
420  (((X*)instance)->*m)(
421  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
422  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
423  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
424  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3])
425  );
426  }
427 };
428 
429 template <typename X, typename T1, typename T2, typename T3, typename T4>
430 struct method_interface_impl<void (X::*)(T1,T2,T3,T4) const> : public method_interface
431 {
432  typedef void (X::*M)(T1,T2,T3,T4) const;
433  M m;
434  method_interface_impl(M _m) : m(_m) {}
435  void call_void(void* instance,
436  const std::vector<abst_reflection_traits*>& param_value_traits,
437  const std::vector<const void*>& param_value_ptrs,
438  const std::vector<std::string>& param_type_names,
439  const abst_reflection_traits* result_traits,
440  void* result_value_ptr,
441  const std::string& result_type_name)
442  {
443  (((X*)instance)->*m)(
444  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
445  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
446  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
447  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3])
448  );
449  }
450 };
451 
452 
453 
454 template <typename X, typename R, typename T1, typename T2, typename T3, typename T4, typename T5>
455 struct method_interface_impl<R (X::*)(T1,T2,T3,T4,T5)> : public method_interface
456 {
457  typedef R (X::*M)(T1,T2,T3,T4,T5);
458  M m;
459  method_interface_impl(M _m) : m(_m) {}
460  void call_void(void* instance,
461  const std::vector<abst_reflection_traits*>& param_value_traits,
462  const std::vector<const void*>& param_value_ptrs,
463  const std::vector<std::string>& param_type_names,
464  const abst_reflection_traits* result_traits,
465  void* result_value_ptr,
466  const std::string& result_type_name)
467  {
468  cgv::type::set_variant((((X*)instance)->*m)(
469  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
470  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
471  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
472  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
473  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4])
474  ), result_type_name, result_value_ptr);
475  }
476 };
477 
478 
479 template <typename X, typename R, typename T1, typename T2, typename T3, typename T4, typename T5>
480 struct method_interface_impl<R (X::*)(T1,T2,T3,T4,T5) const> : public method_interface
481 {
482  typedef R (X::*M)(T1,T2,T3,T4,T5) const;
483  M m;
484  method_interface_impl(M _m) : m(_m) {}
485  void call_void(void* instance,
486  const std::vector<abst_reflection_traits*>& param_value_traits,
487  const std::vector<const void*>& param_value_ptrs,
488  const std::vector<std::string>& param_type_names,
489  const abst_reflection_traits* result_traits,
490  void* result_value_ptr,
491  const std::string& result_type_name)
492  {
493  cgv::type::set_variant((((X*)instance)->*m)(
494  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
495  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
496  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
497  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
498  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4])
499  ), result_type_name, result_value_ptr);
500  }
501 };
502 
503 
504 template <typename X, typename T1, typename T2, typename T3, typename T4, typename T5>
505 struct method_interface_impl<void (X::*)(T1,T2,T3,T4,T5)> : public method_interface
506 {
507  typedef void (X::*M)(T1,T2,T3,T4,T5);
508  M m;
509  method_interface_impl(M _m) : m(_m) {}
510  void call_void(void* instance,
511  const std::vector<abst_reflection_traits*>& param_value_traits,
512  const std::vector<const void*>& param_value_ptrs,
513  const std::vector<std::string>& param_type_names,
514  const abst_reflection_traits* result_traits,
515  void* result_value_ptr,
516  const std::string& result_type_name)
517  {
518  (((X*)instance)->*m)(
519  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
520  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
521  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
522  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
523  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4])
524  );
525  }
526 };
527 
528 template <typename X, typename T1, typename T2, typename T3, typename T4, typename T5>
529 struct method_interface_impl<void (X::*)(T1,T2,T3,T4,T5) const> : public method_interface
530 {
531  typedef void (X::*M)(T1,T2,T3,T4,T5) const;
532  M m;
533  method_interface_impl(M _m) : m(_m) {}
534  void call_void(void* instance,
535  const std::vector<abst_reflection_traits*>& param_value_traits,
536  const std::vector<const void*>& param_value_ptrs,
537  const std::vector<std::string>& param_type_names,
538  const abst_reflection_traits* result_traits,
539  void* result_value_ptr,
540  const std::string& result_type_name)
541  {
542  (((X*)instance)->*m)(
543  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
544  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
545  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
546  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
547  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4])
548  );
549  }
550 };
551 
552 
553 
554 template <typename X, typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
555 struct method_interface_impl<R (X::*)(T1,T2,T3,T4,T5,T6)> : public method_interface
556 {
557  typedef R (X::*M)(T1,T2,T3,T4,T5,T6);
558  M m;
559  method_interface_impl(M _m) : m(_m) {}
560  void call_void(void* instance,
561  const std::vector<abst_reflection_traits*>& param_value_traits,
562  const std::vector<const void*>& param_value_ptrs,
563  const std::vector<std::string>& param_type_names,
564  const abst_reflection_traits* result_traits,
565  void* result_value_ptr,
566  const std::string& result_type_name)
567  {
568  cgv::type::set_variant((((X*)instance)->*m)(
569  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
570  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
571  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
572  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
573  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
574  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5])
575  ), result_type_name, result_value_ptr);
576  }
577 };
578 
579 
580 template <typename X, typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
581 struct method_interface_impl<R (X::*)(T1,T2,T3,T4,T5,T6) const> : public method_interface
582 {
583  typedef R (X::*M)(T1,T2,T3,T4,T5,T6) const;
584  M m;
585  method_interface_impl(M _m) : m(_m) {}
586  void call_void(void* instance,
587  const std::vector<abst_reflection_traits*>& param_value_traits,
588  const std::vector<const void*>& param_value_ptrs,
589  const std::vector<std::string>& param_type_names,
590  const abst_reflection_traits* result_traits,
591  void* result_value_ptr,
592  const std::string& result_type_name)
593  {
594  cgv::type::set_variant((((X*)instance)->*m)(
595  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
596  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
597  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
598  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
599  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
600  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5])
601  ), result_type_name, result_value_ptr);
602  }
603 };
604 
605 
606 template <typename X, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
607 struct method_interface_impl<void (X::*)(T1,T2,T3,T4,T5,T6)> : public method_interface
608 {
609  typedef void (X::*M)(T1,T2,T3,T4,T5,T6);
610  M m;
611  method_interface_impl(M _m) : m(_m) {}
612  void call_void(void* instance,
613  const std::vector<abst_reflection_traits*>& param_value_traits,
614  const std::vector<const void*>& param_value_ptrs,
615  const std::vector<std::string>& param_type_names,
616  const abst_reflection_traits* result_traits,
617  void* result_value_ptr,
618  const std::string& result_type_name)
619  {
620  (((X*)instance)->*m)(
621  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
622  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
623  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
624  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
625  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
626  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5])
627  );
628  }
629 };
630 
631 template <typename X, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
632 struct method_interface_impl<void (X::*)(T1,T2,T3,T4,T5,T6) const> : public method_interface
633 {
634  typedef void (X::*M)(T1,T2,T3,T4,T5,T6) const;
635  M m;
636  method_interface_impl(M _m) : m(_m) {}
637  void call_void(void* instance,
638  const std::vector<abst_reflection_traits*>& param_value_traits,
639  const std::vector<const void*>& param_value_ptrs,
640  const std::vector<std::string>& param_type_names,
641  const abst_reflection_traits* result_traits,
642  void* result_value_ptr,
643  const std::string& result_type_name)
644  {
645  (((X*)instance)->*m)(
646  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
647  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
648  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
649  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
650  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
651  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5])
652  );
653  }
654 };
655 
656 
657 
658 template <typename X, typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
659 struct method_interface_impl<R (X::*)(T1,T2,T3,T4,T5,T6,T7)> : public method_interface
660 {
661  typedef R (X::*M)(T1,T2,T3,T4,T5,T6,T7);
662  M m;
663  method_interface_impl(M _m) : m(_m) {}
664  void call_void(void* instance,
665  const std::vector<abst_reflection_traits*>& param_value_traits,
666  const std::vector<const void*>& param_value_ptrs,
667  const std::vector<std::string>& param_type_names,
668  const abst_reflection_traits* result_traits,
669  void* result_value_ptr,
670  const std::string& result_type_name)
671  {
672  cgv::type::set_variant((((X*)instance)->*m)(
673  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
674  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
675  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
676  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
677  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
678  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5]),
679  cgv::type::variant<T7>::get(param_type_names[6],param_value_ptrs[6])
680  ), result_type_name, result_value_ptr);
681  }
682 };
683 
684 
685 template <typename X, typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
686 struct method_interface_impl<R (X::*)(T1,T2,T3,T4,T5,T6,T7) const> : public method_interface
687 {
688  typedef R (X::*M)(T1,T2,T3,T4,T5,T6,T7) const;
689  M m;
690  method_interface_impl(M _m) : m(_m) {}
691  void call_void(void* instance,
692  const std::vector<abst_reflection_traits*>& param_value_traits,
693  const std::vector<const void*>& param_value_ptrs,
694  const std::vector<std::string>& param_type_names,
695  const abst_reflection_traits* result_traits,
696  void* result_value_ptr,
697  const std::string& result_type_name)
698  {
699  cgv::type::set_variant((((X*)instance)->*m)(
700  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
701  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
702  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
703  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
704  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
705  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5]),
706  cgv::type::variant<T7>::get(param_type_names[6],param_value_ptrs[6])
707  ), result_type_name, result_value_ptr);
708  }
709 };
710 
711 
712 template <typename X, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
713 struct method_interface_impl<void (X::*)(T1,T2,T3,T4,T5,T6,T7)> : public method_interface
714 {
715  typedef void (X::*M)(T1,T2,T3,T4,T5,T6,T7);
716  M m;
717  method_interface_impl(M _m) : m(_m) {}
718  void call_void(void* instance,
719  const std::vector<abst_reflection_traits*>& param_value_traits,
720  const std::vector<const void*>& param_value_ptrs,
721  const std::vector<std::string>& param_type_names,
722  const abst_reflection_traits* result_traits,
723  void* result_value_ptr,
724  const std::string& result_type_name)
725  {
726  (((X*)instance)->*m)(
727  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
728  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
729  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
730  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
731  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
732  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5]),
733  cgv::type::variant<T7>::get(param_type_names[6],param_value_ptrs[6])
734  );
735  }
736 };
737 
738 template <typename X, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
739 struct method_interface_impl<void (X::*)(T1,T2,T3,T4,T5,T6,T7) const> : public method_interface
740 {
741  typedef void (X::*M)(T1,T2,T3,T4,T5,T6,T7) const;
742  M m;
743  method_interface_impl(M _m) : m(_m) {}
744  void call_void(void* instance,
745  const std::vector<abst_reflection_traits*>& param_value_traits,
746  const std::vector<const void*>& param_value_ptrs,
747  const std::vector<std::string>& param_type_names,
748  const abst_reflection_traits* result_traits,
749  void* result_value_ptr,
750  const std::string& result_type_name)
751  {
752  (((X*)instance)->*m)(
753  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
754  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
755  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
756  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
757  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
758  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5]),
759  cgv::type::variant<T7>::get(param_type_names[6],param_value_ptrs[6])
760  );
761  }
762 };
763 
764 
765 
766 template <typename X, typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
767 struct method_interface_impl<R (X::*)(T1,T2,T3,T4,T5,T6,T7,T8)> : public method_interface
768 {
769  typedef R (X::*M)(T1,T2,T3,T4,T5,T6,T7,T8);
770  M m;
771  method_interface_impl(M _m) : m(_m) {}
772  void call_void(void* instance,
773  const std::vector<abst_reflection_traits*>& param_value_traits,
774  const std::vector<const void*>& param_value_ptrs,
775  const std::vector<std::string>& param_type_names,
776  const abst_reflection_traits* result_traits,
777  void* result_value_ptr,
778  const std::string& result_type_name)
779  {
780  cgv::type::set_variant((((X*)instance)->*m)(
781  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
782  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
783  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
784  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
785  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
786  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5]),
787  cgv::type::variant<T7>::get(param_type_names[6],param_value_ptrs[6]),
788  cgv::type::variant<T8>::get(param_type_names[7],param_value_ptrs[7])
789  ), result_type_name, result_value_ptr);
790  }
791 };
792 
793 
794 template <typename X, typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
795 struct method_interface_impl<R (X::*)(T1,T2,T3,T4,T5,T6,T7,T8) const> : public method_interface
796 {
797  typedef R (X::*M)(T1,T2,T3,T4,T5,T6,T7,T8) const;
798  M m;
799  method_interface_impl(M _m) : m(_m) {}
800  void call_void(void* instance,
801  const std::vector<abst_reflection_traits*>& param_value_traits,
802  const std::vector<const void*>& param_value_ptrs,
803  const std::vector<std::string>& param_type_names,
804  const abst_reflection_traits* result_traits,
805  void* result_value_ptr,
806  const std::string& result_type_name)
807  {
808  cgv::type::set_variant((((X*)instance)->*m)(
809  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
810  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
811  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
812  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
813  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
814  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5]),
815  cgv::type::variant<T7>::get(param_type_names[6],param_value_ptrs[6]),
816  cgv::type::variant<T8>::get(param_type_names[7],param_value_ptrs[7])
817  ), result_type_name, result_value_ptr);
818  }
819 };
820 
821 
822 template <typename X, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
823 struct method_interface_impl<void (X::*)(T1,T2,T3,T4,T5,T6,T7,T8)> : public method_interface
824 {
825  typedef void (X::*M)(T1,T2,T3,T4,T5,T6,T7,T8);
826  M m;
827  method_interface_impl(M _m) : m(_m) {}
828  void call_void(void* instance,
829  const std::vector<abst_reflection_traits*>& param_value_traits,
830  const std::vector<const void*>& param_value_ptrs,
831  const std::vector<std::string>& param_type_names,
832  const abst_reflection_traits* result_traits,
833  void* result_value_ptr,
834  const std::string& result_type_name)
835  {
836  (((X*)instance)->*m)(
837  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
838  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
839  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
840  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
841  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
842  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5]),
843  cgv::type::variant<T7>::get(param_type_names[6],param_value_ptrs[6]),
844  cgv::type::variant<T8>::get(param_type_names[7],param_value_ptrs[7])
845  );
846  }
847 };
848 
849 template <typename X, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
850 struct method_interface_impl<void (X::*)(T1,T2,T3,T4,T5,T6,T7,T8) const> : public method_interface
851 {
852  typedef void (X::*M)(T1,T2,T3,T4,T5,T6,T7,T8) const;
853  M m;
854  method_interface_impl(M _m) : m(_m) {}
855  void call_void(void* instance,
856  const std::vector<abst_reflection_traits*>& param_value_traits,
857  const std::vector<const void*>& param_value_ptrs,
858  const std::vector<std::string>& param_type_names,
859  const abst_reflection_traits* result_traits,
860  void* result_value_ptr,
861  const std::string& result_type_name)
862  {
863  (((X*)instance)->*m)(
864  cgv::type::variant<T1>::get(param_type_names[0],param_value_ptrs[0]),
865  cgv::type::variant<T2>::get(param_type_names[1],param_value_ptrs[1]),
866  cgv::type::variant<T3>::get(param_type_names[2],param_value_ptrs[2]),
867  cgv::type::variant<T4>::get(param_type_names[3],param_value_ptrs[3]),
868  cgv::type::variant<T5>::get(param_type_names[4],param_value_ptrs[4]),
869  cgv::type::variant<T6>::get(param_type_names[5],param_value_ptrs[5]),
870  cgv::type::variant<T7>::get(param_type_names[6],param_value_ptrs[6]),
871  cgv::type::variant<T8>::get(param_type_names[7],param_value_ptrs[7])
872  );
873  }
874 };
875 
876 
877 
878  }
879 }
cgv::reflect::abst_reflection_traits
abstract interface for type reflection with basic type management and optional string conversion
Definition: reflection_traits.h:24
cgv::reflect::method_interface
Definition: reflection_handler.h:24
cgv::type::variant::get
static T get(const std::string &value_type, const void *value_ptr)
convert the value pointed to by value_ptr of type value_type to type T and return it
Definition: variant.h:23
cgv::math::reflect
vec< T > reflect(const vec< T > &v, const vec< T > &n)
calculates the reflected direction of v; n is the normal of the reflecting surface
Definition: vec.h:822
cgv::reflect::method_interface_impl
forward declaration of method_interface_impl which is implemented in <cgv/reflect/method_interface_im...
Definition: method_interface_impl.h:10
cgv::type::variant
Definition: variant.h:21
cgv
the cgv namespace
Definition: vr_calib.cxx:9