Classdesc 3.44
functiondb5.h
1#ifndef CLASSDESC_FUNCTIONDB5
2#define CLASSDESC_FUNCTIONDB5
3template <class R, class A1, class A2, class A3, class A4, class A5>
4struct Arg<R (*)(A1,A2,A3,A4,A5), 1>
5{
6 typedef A1 T;
7 typedef T type;
8};
9
10template <class C, class R, class A1, class A2, class A3, class A4, class A5>
11struct Arg<R (C::*)(A1,A2,A3,A4,A5), 1>
12{
13 typedef A1 T;
14 typedef T type;
15};
16
17template <class C, class R, class A1, class A2, class A3, class A4, class A5>
18struct Arg<R (C::*)(A1,A2,A3,A4,A5) const, 1>
19{
20 typedef A1 T;
21 typedef T type;
22};
23
24#if defined(__cplusplus) && __cplusplus>=201703L
25// noexcept methods
26template <class R, class A1, class A2, class A3, class A4, class A5>
27struct Arg<R (*)(A1,A2,A3,A4,A5) noexcept, 1>
28{
29 typedef A1 T;
30 typedef T type;
31};
32
33template <class C, class R, class A1, class A2, class A3, class A4, class A5>
34struct Arg<R (C::*)(A1,A2,A3,A4,A5) noexcept, 1>
35{
36 typedef A1 T;
37 typedef T type;
38};
39
40template <class C, class R, class A1, class A2, class A3, class A4, class A5>
41struct Arg<R (C::*)(A1,A2,A3,A4,A5) const noexcept, 1>
42{
43 typedef A1 T;
44 typedef T type;
45};
46#endif
47template <class R, class A1, class A2, class A3, class A4, class A5>
48struct Arg<R (*)(A1,A2,A3,A4,A5), 2>
49{
50 typedef A2 T;
51 typedef T type;
52};
53
54template <class C, class R, class A1, class A2, class A3, class A4, class A5>
55struct Arg<R (C::*)(A1,A2,A3,A4,A5), 2>
56{
57 typedef A2 T;
58 typedef T type;
59};
60
61template <class C, class R, class A1, class A2, class A3, class A4, class A5>
62struct Arg<R (C::*)(A1,A2,A3,A4,A5) const, 2>
63{
64 typedef A2 T;
65 typedef T type;
66};
67
68#if defined(__cplusplus) && __cplusplus>=201703L
69// noexcept methods
70template <class R, class A1, class A2, class A3, class A4, class A5>
71struct Arg<R (*)(A1,A2,A3,A4,A5) noexcept, 2>
72{
73 typedef A2 T;
74 typedef T type;
75};
76
77template <class C, class R, class A1, class A2, class A3, class A4, class A5>
78struct Arg<R (C::*)(A1,A2,A3,A4,A5) noexcept, 2>
79{
80 typedef A2 T;
81 typedef T type;
82};
83
84template <class C, class R, class A1, class A2, class A3, class A4, class A5>
85struct Arg<R (C::*)(A1,A2,A3,A4,A5) const noexcept, 2>
86{
87 typedef A2 T;
88 typedef T type;
89};
90#endif
91template <class R, class A1, class A2, class A3, class A4, class A5>
92struct Arg<R (*)(A1,A2,A3,A4,A5), 3>
93{
94 typedef A3 T;
95 typedef T type;
96};
97
98template <class C, class R, class A1, class A2, class A3, class A4, class A5>
99struct Arg<R (C::*)(A1,A2,A3,A4,A5), 3>
100{
101 typedef A3 T;
102 typedef T type;
103};
104
105template <class C, class R, class A1, class A2, class A3, class A4, class A5>
106struct Arg<R (C::*)(A1,A2,A3,A4,A5) const, 3>
107{
108 typedef A3 T;
109 typedef T type;
110};
111
112#if defined(__cplusplus) && __cplusplus>=201703L
113// noexcept methods
114template <class R, class A1, class A2, class A3, class A4, class A5>
115struct Arg<R (*)(A1,A2,A3,A4,A5) noexcept, 3>
116{
117 typedef A3 T;
118 typedef T type;
119};
120
121template <class C, class R, class A1, class A2, class A3, class A4, class A5>
122struct Arg<R (C::*)(A1,A2,A3,A4,A5) noexcept, 3>
123{
124 typedef A3 T;
125 typedef T type;
126};
127
128template <class C, class R, class A1, class A2, class A3, class A4, class A5>
129struct Arg<R (C::*)(A1,A2,A3,A4,A5) const noexcept, 3>
130{
131 typedef A3 T;
132 typedef T type;
133};
134#endif
135template <class R, class A1, class A2, class A3, class A4, class A5>
136struct Arg<R (*)(A1,A2,A3,A4,A5), 4>
137{
138 typedef A4 T;
139 typedef T type;
140};
141
142template <class C, class R, class A1, class A2, class A3, class A4, class A5>
143struct Arg<R (C::*)(A1,A2,A3,A4,A5), 4>
144{
145 typedef A4 T;
146 typedef T type;
147};
148
149template <class C, class R, class A1, class A2, class A3, class A4, class A5>
150struct Arg<R (C::*)(A1,A2,A3,A4,A5) const, 4>
151{
152 typedef A4 T;
153 typedef T type;
154};
155
156#if defined(__cplusplus) && __cplusplus>=201703L
157// noexcept methods
158template <class R, class A1, class A2, class A3, class A4, class A5>
159struct Arg<R (*)(A1,A2,A3,A4,A5) noexcept, 4>
160{
161 typedef A4 T;
162 typedef T type;
163};
164
165template <class C, class R, class A1, class A2, class A3, class A4, class A5>
166struct Arg<R (C::*)(A1,A2,A3,A4,A5) noexcept, 4>
167{
168 typedef A4 T;
169 typedef T type;
170};
171
172template <class C, class R, class A1, class A2, class A3, class A4, class A5>
173struct Arg<R (C::*)(A1,A2,A3,A4,A5) const noexcept, 4>
174{
175 typedef A4 T;
176 typedef T type;
177};
178#endif
179template <class R, class A1, class A2, class A3, class A4, class A5>
180struct Arg<R (*)(A1,A2,A3,A4,A5), 5>
181{
182 typedef A5 T;
183 typedef T type;
184};
185
186template <class C, class R, class A1, class A2, class A3, class A4, class A5>
187struct Arg<R (C::*)(A1,A2,A3,A4,A5), 5>
188{
189 typedef A5 T;
190 typedef T type;
191};
192
193template <class C, class R, class A1, class A2, class A3, class A4, class A5>
194struct Arg<R (C::*)(A1,A2,A3,A4,A5) const, 5>
195{
196 typedef A5 T;
197 typedef T type;
198};
199
200#if defined(__cplusplus) && __cplusplus>=201703L
201// noexcept methods
202template <class R, class A1, class A2, class A3, class A4, class A5>
203struct Arg<R (*)(A1,A2,A3,A4,A5) noexcept, 5>
204{
205 typedef A5 T;
206 typedef T type;
207};
208
209template <class C, class R, class A1, class A2, class A3, class A4, class A5>
210struct Arg<R (C::*)(A1,A2,A3,A4,A5) noexcept, 5>
211{
212 typedef A5 T;
213 typedef T type;
214};
215
216template <class C, class R, class A1, class A2, class A3, class A4, class A5>
217struct Arg<R (C::*)(A1,A2,A3,A4,A5) const noexcept, 5>
218{
219 typedef A5 T;
220 typedef T type;
221};
222#endif
223template <class F, template<class> class P>
224struct AllArgs<F,P,5>
225{
226 static const bool value=true && P<typename Arg<F,1>::T>::value && P<typename Arg<F,2>::T>::value && P<typename Arg<F,3>::T>::value && P<typename Arg<F,4>::T>::value && P<typename Arg<F,5>::T>::value;
227};
228
229
230template <class R, class A1, class A2, class A3, class A4, class A5>
231struct Arity<R (*)(A1,A2,A3,A4,A5)>
232{
233 static const int V=5;
234 static const int value=5;
235};
236
237template <class R, class A1, class A2, class A3, class A4, class A5>
238struct Return<R (*)(A1,A2,A3,A4,A5)>
239{
240 typedef R T;
241 typedef R type;
242};
243
244template <class C,class R, class A1, class A2, class A3, class A4, class A5>
245struct Arity<R (* C::*)(A1,A2,A3,A4,A5)>
246{
247 static const int V=5;
248 static const int value=5;
249};
250
251template <class C,class R, class A1, class A2, class A3, class A4, class A5>
252struct Return<R (* C::*)(A1,A2,A3,A4,A5)>
253{
254 typedef R T;
255 typedef R type;
256};
257
258template <class C, class R, class A1, class A2, class A3, class A4, class A5>
259struct Arity<R (C::*)(A1,A2,A3,A4,A5)>
260{
261 static const int V=5;
262 static const int value=5;
263};
264
265template <class C, class R, class A1, class A2, class A3, class A4, class A5>
266struct Return<R (C::*)(A1,A2,A3,A4,A5)>
267{
268 typedef R T;
269 typedef R type;
270};
271
272template <class C, class R, class A1, class A2, class A3, class A4, class A5>
273struct Arity<R (C::*)(A1,A2,A3,A4,A5) const>
274{
275 static const int V=5;
276 static const int value=5;
277};
278
279template <class C, class R, class A1, class A2, class A3, class A4, class A5>
280struct Return<R (C::*)(A1,A2,A3,A4,A5) const>
281{
282 typedef R T;
283 typedef R type;
284};
285
286template <class C, class R, class A1, class A2, class A3, class A4, class A5>
287struct ClassOf<R (C::*)(A1,A2,A3,A4,A5)>
288{
289 typedef C T;
290 typedef C type;
291};
292
293template <class C, class R, class A1, class A2, class A3, class A4, class A5>
294struct ClassOf<R (*C::*)(A1,A2,A3,A4,A5)>
295{
296 typedef C T;
297 typedef C type;
298};
299
300template <class C, class R, class A1, class A2, class A3, class A4, class A5>
301struct ClassOf<R (C::*)(A1,A2,A3,A4,A5) const>
302{
303 typedef C T;
304 typedef C type;
305};
306
307template <class C, class R, class A1, class A2, class A3, class A4, class A5>
308struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5)>
309{
310 static const bool value=true;
311};
312
313template <class C, class R, class A1, class A2, class A3, class A4, class A5>
314struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5) const>
315{
316 static const bool value=true;
317};
318
319template <class C, class R, class A1, class A2, class A3, class A4, class A5>
320struct is_const_method<R (C::*)(A1,A2,A3,A4,A5) const>
321{
322 static const bool value=true;
323};
324
325template <class R, class A1, class A2, class A3, class A4, class A5>
326struct is_nonmember_function_ptr<R (*)(A1,A2,A3,A4,A5)>
327{
328 static const bool value=true;
329};
330
331template <class C, class R, class A1, class A2, class A3, class A4, class A5>
332struct is_nonmember_function_ptr<R (*C::*)(A1,A2,A3,A4,A5)>
333{
334 static const bool value=true;
335};
336
337template <class C, class D, class R, class A1, class A2, class A3, class A4, class A5>
338class bound_method<C, R (D::*)(A1,A2,A3,A4,A5)>
339{
340 typedef R (D::*M)(A1,A2,A3,A4,A5);
341 C* obj;
342 M method;
343 public:
344 static const int arity=5;
345 typedef R Ret;
346 template <int i> struct Arg: public functional::Arg<M,i> {};
347 bound_method(C& obj, M method): obj(&obj), method(method) {}
348 typename enable_if<Not<classdesc::is_const<C> >, R>::T
349 operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) const {return (obj->*method)(a1,a2,a3,a4,a5);}
350 void rebind(C& newObj) {obj=&newObj;}
351 static const bool is_const=false;
352};
353
354template <class C, class D, class R, class A1, class A2, class A3, class A4, class A5>
355class bound_method<const C, R (D::*)(A1,A2,A3,A4,A5)>
356{
357 typedef R (D::*M)(A1,A2,A3,A4,A5);
358 const C* obj;
359 M method;
360 public:
361 static const int arity=5;
362 typedef R Ret;
363 template <int i> struct Arg: public functional::Arg<M,i> {};
364 bound_method(const C& obj, M method): obj(&obj), method(method) {}
365 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) const {
366 throw std::runtime_error("cannot call method, inappropriate argument type");
367 }
368 void rebind(C& newObj) {obj=&newObj;}
369 static const bool is_const=false;
370};
371
372template <class C, class D, class R, class A1, class A2, class A3, class A4, class A5>
373class bound_method<C, R (D::*)(A1,A2,A3,A4,A5) const>
374{
375 typedef R (D::*M)(A1,A2,A3,A4,A5) const;
376 C& obj;
377 M method;
378 public:
379 static const int arity=5;
380 typedef R Ret;
381 template <int i> struct Arg: public functional::Arg<M,i> {};
382 bound_method(C& obj, M method): obj(obj), method(method) {}
383 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) const {return (obj.*method)(a1,a2,a3,a4,a5);}
384 static const bool is_const=true;
385};
386
387#if defined(__cplusplus) && __cplusplus>=201703L
388// noexcept methods
389
390template <class R, class A1, class A2, class A3, class A4, class A5>
391struct Arity<R (*)(A1,A2,A3,A4,A5) noexcept>
392{
393 static const int V=5;
394 static const int value=5;
395};
396
397template <class R, class A1, class A2, class A3, class A4, class A5>
398struct Return<R (*)(A1,A2,A3,A4,A5) noexcept>
399{
400 typedef R T;
401 typedef R type;
402};
403
404template <class C,class R, class A1, class A2, class A3, class A4, class A5>
405struct Arity<R (* C::*)(A1,A2,A3,A4,A5) noexcept>
406{
407 static const int V=5;
408 static const int value=5;
409};
410
411template <class C,class R, class A1, class A2, class A3, class A4, class A5>
412struct Return<R (* C::*)(A1,A2,A3,A4,A5) noexcept>
413{
414 typedef R T;
415 typedef R type;
416};
417
418template <class C, class R, class A1, class A2, class A3, class A4, class A5>
419struct Arity<R (C::*)(A1,A2,A3,A4,A5) noexcept>
420{
421 static const int V=5;
422 static const int value=5;
423};
424
425template <class C, class R, class A1, class A2, class A3, class A4, class A5>
426struct Return<R (C::*)(A1,A2,A3,A4,A5) noexcept>
427{
428 typedef R T;
429 typedef R type;
430};
431
432template <class C, class R, class A1, class A2, class A3, class A4, class A5>
433struct Arity<R (C::*)(A1,A2,A3,A4,A5) const noexcept>
434{
435 static const int V=5;
436 static const int value=5;
437};
438
439template <class C, class R, class A1, class A2, class A3, class A4, class A5>
440struct Return<R (C::*)(A1,A2,A3,A4,A5) const noexcept>
441{
442 typedef R T;
443 typedef R type;
444};
445
446template <class C, class R, class A1, class A2, class A3, class A4, class A5>
447struct ClassOf<R (C::*)(A1,A2,A3,A4,A5) noexcept>
448{
449 typedef C T;
450 typedef C type;
451};
452
453template <class C, class R, class A1, class A2, class A3, class A4, class A5>
454struct ClassOf<R (*C::*)(A1,A2,A3,A4,A5) noexcept>
455{
456 typedef C T;
457 typedef C type;
458};
459
460template <class C, class R, class A1, class A2, class A3, class A4, class A5>
461struct ClassOf<R (C::*)(A1,A2,A3,A4,A5) const noexcept>
462{
463 typedef C T;
464 typedef C type;
465};
466
467template <class C, class R, class A1, class A2, class A3, class A4, class A5>
468struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5) noexcept>
469{
470 static const bool value=true;
471};
472
473template <class C, class R, class A1, class A2, class A3, class A4, class A5>
474struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4,A5) const noexcept>
475{
476 static const bool value=true;
477};
478
479template <class C, class R, class A1, class A2, class A3, class A4, class A5>
480struct is_const_method<R (C::*)(A1,A2,A3,A4,A5) const noexcept>
481{
482 static const bool value=true;
483};
484
485template <class R, class A1, class A2, class A3, class A4, class A5>
486struct is_nonmember_function_ptr<R (*)(A1,A2,A3,A4,A5) noexcept>
487{
488 static const bool value=true;
489};
490
491template <class C, class R, class A1, class A2, class A3, class A4, class A5>
492struct is_nonmember_function_ptr<R (*C::*)(A1,A2,A3,A4,A5) noexcept>
493{
494 static const bool value=true;
495};
496
497template <class C, class D, class R, class A1, class A2, class A3, class A4, class A5>
498class bound_method<C, R (D::*)(A1,A2,A3,A4,A5) noexcept>
499{
500 typedef R (D::*M)(A1,A2,A3,A4,A5);
501 C* obj;
502 M method;
503 public:
504 static const int arity=5;
505 typedef R Ret;
506 template <int i> struct Arg: public functional::Arg<M,i> {};
507 bound_method(C& obj, M method): obj(&obj), method(method) {}
508 typename enable_if<Not<classdesc::is_const<C> >, R>::T
509 operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) const {return (obj->*method)(a1,a2,a3,a4,a5);}
510 void rebind(C& newObj) {obj=&newObj;}
511 static const bool is_const=false;
512};
513
514template <class C, class D, class A1, class A2, class A3, class A4, class A5>
515class bound_method<C, void (D::*)(A1,A2,A3,A4,A5) noexcept>
516{
517 typedef void (D::*M)(A1,A2,A3,A4,A5);
518 C* obj;
519 M method;
520 public:
521 static const int arity=5;
522 typedef void Ret;
523 template <int i> struct Arg: public functional::Arg<M,i> {};
524 bound_method(C& obj, M method): obj(&obj), method(method) {}
525 typename enable_if<Not<classdesc::is_const<C> > >::T
526 operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) const {(obj->*method)(a1,a2,a3,a4,a5);}
527 void rebind(C& newObj) {obj=&newObj;}
528 static const bool is_const=false;
529};
530
531template <class C, class D, class R, class A1, class A2, class A3, class A4, class A5>
532class bound_method<const C, R (D::*)(A1,A2,A3,A4,A5) noexcept>
533{
534 typedef R (D::*M)(A1,A2,A3,A4,A5);
535 const C* obj;
536 M method;
537 public:
538 static const int arity=5;
539 typedef R Ret;
540 template <int i> struct Arg: public functional::Arg<M,i> {};
541 bound_method(const C& obj, M method): obj(&obj), method(method) {}
542 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) const {
543 throw std::runtime_error("cannot call method, inappropriate argument type");
544 }
545 void rebind(C& newObj) {obj=&newObj;}
546 static const bool is_const=false;
547};
548
549template <class C, class D, class A1, class A2, class A3, class A4, class A5>
550class bound_method<const C, void (D::*)(A1,A2,A3,A4,A5) noexcept>
551{
552 typedef void (D::*M)(A1,A2,A3,A4,A5);
553 const C* obj;
554 M method;
555 public:
556 static const int arity=5;
557 typedef void Ret;
558 template <int i> struct Arg: public functional::Arg<M,i> {};
559 bound_method(const C& obj, M method): obj(&obj), method(method) {}
560 typename enable_if<Not<classdesc::is_const<C> > >::T
561 operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) const {
562 throw std::runtime_error("cannot call method, inappropriate argument type");
563 }
564 void rebind(C& newObj) {obj=&newObj;}
565 static const bool is_const=false;
566};
567
568template <class C, class D, class R, class A1, class A2, class A3, class A4, class A5>
569class bound_method<C, R (D::*)(A1,A2,A3,A4,A5) const noexcept>
570{
571 typedef R (D::*M)(A1,A2,A3,A4,A5) const;
572 C& obj;
573 M method;
574 public:
575 static const int arity=5;
576 typedef R Ret;
577 template <int i> struct Arg: public functional::Arg<M,i> {};
578 bound_method(C& obj, M method): obj(obj), method(method) {}
579 R operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) const {return (obj.*method)(a1,a2,a3,a4,a5);}
580 static const bool is_const=true;
581};
582
583template <class C, class D, class A1, class A2, class A3, class A4, class A5>
584class bound_method<C, void (D::*)(A1,A2,A3,A4,A5) const noexcept>
585{
586 typedef void (D::*M)(A1,A2,A3,A4,A5) const;
587 C& obj;
588 M method;
589 public:
590 static const int arity=5;
591 typedef void Ret;
592 template <int i> struct Arg: public functional::Arg<M,i> {};
593 bound_method(C& obj, M method): obj(obj), method(method) {}
594 void operator()(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5) const {(obj.*method)(a1,a2,a3,a4,a5);}
595 static const bool is_const=true;
596};
597#endif
598
599template <class F, class Args>
600typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 5> >,
601 typename Return<F>::T>::T
602apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
603{
604 return f(a[0],a[1],a[2],a[3],a[4]);
605}
606
607/*
608 TODO: if any of the arguments to f are lvalues, we need to construct temporaries,
609 which require C++-11 ability to test for the existence of a copy constructor.
610 If the return type is not copy constructable, the user must arrange for the return value to be discarded
611*/
612
613template <class F, class Args>
614typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 5> >,
615 void>::T
616apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
617{
618 f(a[0],a[1],a[2],a[3],a[4]);
619}
620
621template <class Buffer, class F>
622typename enable_if<Eq<Arity<F>::value, 5>, typename Return<F>::T>::T
623callOnBuffer(Buffer& buffer, F f)
624{
625 typename remove_const<typename remove_reference<typename Arg<F,1>::T>::type>::type a1;
626 buffer>>a1;
627 typename remove_const<typename remove_reference<typename Arg<F,2>::T>::type>::type a2;
628 buffer>>a2;
629 typename remove_const<typename remove_reference<typename Arg<F,3>::T>::type>::type a3;
630 buffer>>a3;
631 typename remove_const<typename remove_reference<typename Arg<F,4>::T>::type>::type a4;
632 buffer>>a4;
633 typename remove_const<typename remove_reference<typename Arg<F,5>::T>::type>::type a5;
634 buffer>>a5;
635 return f(
636a1
637,
638a2
639,
640a3
641,
642a4
643,
644a5
645 );
646}
647#endif
bound_method< C, R(D::*)(A1, A2, A3, A4, A5) const >::Arg
Definition functiondb5.h:381
bound_method< C, R(D::*)(A1, A2, A3, A4, A5)>::Arg
Definition functiondb5.h:346
bound_method< const C, R(D::*)(A1, A2, A3, A4, A5)>::Arg
Definition functiondb5.h:363