Classdesc 3.44
functiondb4.h
1#ifndef CLASSDESC_FUNCTIONDB4
2#define CLASSDESC_FUNCTIONDB4
3template <class R, class A1, class A2, class A3, class A4>
4struct Arg<R (*)(A1,A2,A3,A4), 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>
11struct Arg<R (C::*)(A1,A2,A3,A4), 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>
18struct Arg<R (C::*)(A1,A2,A3,A4) 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>
27struct Arg<R (*)(A1,A2,A3,A4) 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>
34struct Arg<R (C::*)(A1,A2,A3,A4) 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>
41struct Arg<R (C::*)(A1,A2,A3,A4) 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>
48struct Arg<R (*)(A1,A2,A3,A4), 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>
55struct Arg<R (C::*)(A1,A2,A3,A4), 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>
62struct Arg<R (C::*)(A1,A2,A3,A4) 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>
71struct Arg<R (*)(A1,A2,A3,A4) 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>
78struct Arg<R (C::*)(A1,A2,A3,A4) 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>
85struct Arg<R (C::*)(A1,A2,A3,A4) 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>
92struct Arg<R (*)(A1,A2,A3,A4), 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>
99struct Arg<R (C::*)(A1,A2,A3,A4), 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>
106struct Arg<R (C::*)(A1,A2,A3,A4) 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>
115struct Arg<R (*)(A1,A2,A3,A4) 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>
122struct Arg<R (C::*)(A1,A2,A3,A4) 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>
129struct Arg<R (C::*)(A1,A2,A3,A4) 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>
136struct Arg<R (*)(A1,A2,A3,A4), 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>
143struct Arg<R (C::*)(A1,A2,A3,A4), 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>
150struct Arg<R (C::*)(A1,A2,A3,A4) 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>
159struct Arg<R (*)(A1,A2,A3,A4) 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>
166struct Arg<R (C::*)(A1,A2,A3,A4) 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>
173struct Arg<R (C::*)(A1,A2,A3,A4) const noexcept, 4>
174{
175 typedef A4 T;
176 typedef T type;
177};
178#endif
179template <class F, template<class> class P>
180struct AllArgs<F,P,4>
181{
182 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;
183};
184
185
186template <class R, class A1, class A2, class A3, class A4>
187struct Arity<R (*)(A1,A2,A3,A4)>
188{
189 static const int V=4;
190 static const int value=4;
191};
192
193template <class R, class A1, class A2, class A3, class A4>
194struct Return<R (*)(A1,A2,A3,A4)>
195{
196 typedef R T;
197 typedef R type;
198};
199
200template <class C,class R, class A1, class A2, class A3, class A4>
201struct Arity<R (* C::*)(A1,A2,A3,A4)>
202{
203 static const int V=4;
204 static const int value=4;
205};
206
207template <class C,class R, class A1, class A2, class A3, class A4>
208struct Return<R (* C::*)(A1,A2,A3,A4)>
209{
210 typedef R T;
211 typedef R type;
212};
213
214template <class C, class R, class A1, class A2, class A3, class A4>
215struct Arity<R (C::*)(A1,A2,A3,A4)>
216{
217 static const int V=4;
218 static const int value=4;
219};
220
221template <class C, class R, class A1, class A2, class A3, class A4>
222struct Return<R (C::*)(A1,A2,A3,A4)>
223{
224 typedef R T;
225 typedef R type;
226};
227
228template <class C, class R, class A1, class A2, class A3, class A4>
229struct Arity<R (C::*)(A1,A2,A3,A4) const>
230{
231 static const int V=4;
232 static const int value=4;
233};
234
235template <class C, class R, class A1, class A2, class A3, class A4>
236struct Return<R (C::*)(A1,A2,A3,A4) const>
237{
238 typedef R T;
239 typedef R type;
240};
241
242template <class C, class R, class A1, class A2, class A3, class A4>
243struct ClassOf<R (C::*)(A1,A2,A3,A4)>
244{
245 typedef C T;
246 typedef C type;
247};
248
249template <class C, class R, class A1, class A2, class A3, class A4>
250struct ClassOf<R (*C::*)(A1,A2,A3,A4)>
251{
252 typedef C T;
253 typedef C type;
254};
255
256template <class C, class R, class A1, class A2, class A3, class A4>
257struct ClassOf<R (C::*)(A1,A2,A3,A4) const>
258{
259 typedef C T;
260 typedef C type;
261};
262
263template <class C, class R, class A1, class A2, class A3, class A4>
264struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4)>
265{
266 static const bool value=true;
267};
268
269template <class C, class R, class A1, class A2, class A3, class A4>
270struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4) const>
271{
272 static const bool value=true;
273};
274
275template <class C, class R, class A1, class A2, class A3, class A4>
276struct is_const_method<R (C::*)(A1,A2,A3,A4) const>
277{
278 static const bool value=true;
279};
280
281template <class R, class A1, class A2, class A3, class A4>
282struct is_nonmember_function_ptr<R (*)(A1,A2,A3,A4)>
283{
284 static const bool value=true;
285};
286
287template <class C, class R, class A1, class A2, class A3, class A4>
288struct is_nonmember_function_ptr<R (*C::*)(A1,A2,A3,A4)>
289{
290 static const bool value=true;
291};
292
293template <class C, class D, class R, class A1, class A2, class A3, class A4>
294class bound_method<C, R (D::*)(A1,A2,A3,A4)>
295{
296 typedef R (D::*M)(A1,A2,A3,A4);
297 C* obj;
298 M method;
299 public:
300 static const int arity=4;
301 typedef R Ret;
302 template <int i> struct Arg: public functional::Arg<M,i> {};
303 bound_method(C& obj, M method): obj(&obj), method(method) {}
304 typename enable_if<Not<classdesc::is_const<C> >, R>::T
305 operator()(A1 a1,A2 a2,A3 a3,A4 a4) const {return (obj->*method)(a1,a2,a3,a4);}
306 void rebind(C& newObj) {obj=&newObj;}
307 static const bool is_const=false;
308};
309
310template <class C, class D, class R, class A1, class A2, class A3, class A4>
311class bound_method<const C, R (D::*)(A1,A2,A3,A4)>
312{
313 typedef R (D::*M)(A1,A2,A3,A4);
314 const C* obj;
315 M method;
316 public:
317 static const int arity=4;
318 typedef R Ret;
319 template <int i> struct Arg: public functional::Arg<M,i> {};
320 bound_method(const C& obj, M method): obj(&obj), method(method) {}
321 R operator()(A1 a1,A2 a2,A3 a3,A4 a4) const {
322 throw std::runtime_error("cannot call method, inappropriate argument type");
323 }
324 void rebind(C& newObj) {obj=&newObj;}
325 static const bool is_const=false;
326};
327
328template <class C, class D, class R, class A1, class A2, class A3, class A4>
329class bound_method<C, R (D::*)(A1,A2,A3,A4) const>
330{
331 typedef R (D::*M)(A1,A2,A3,A4) const;
332 C& obj;
333 M method;
334 public:
335 static const int arity=4;
336 typedef R Ret;
337 template <int i> struct Arg: public functional::Arg<M,i> {};
338 bound_method(C& obj, M method): obj(obj), method(method) {}
339 R operator()(A1 a1,A2 a2,A3 a3,A4 a4) const {return (obj.*method)(a1,a2,a3,a4);}
340 static const bool is_const=true;
341};
342
343#if defined(__cplusplus) && __cplusplus>=201703L
344// noexcept methods
345
346template <class R, class A1, class A2, class A3, class A4>
347struct Arity<R (*)(A1,A2,A3,A4) noexcept>
348{
349 static const int V=4;
350 static const int value=4;
351};
352
353template <class R, class A1, class A2, class A3, class A4>
354struct Return<R (*)(A1,A2,A3,A4) noexcept>
355{
356 typedef R T;
357 typedef R type;
358};
359
360template <class C,class R, class A1, class A2, class A3, class A4>
361struct Arity<R (* C::*)(A1,A2,A3,A4) noexcept>
362{
363 static const int V=4;
364 static const int value=4;
365};
366
367template <class C,class R, class A1, class A2, class A3, class A4>
368struct Return<R (* C::*)(A1,A2,A3,A4) noexcept>
369{
370 typedef R T;
371 typedef R type;
372};
373
374template <class C, class R, class A1, class A2, class A3, class A4>
375struct Arity<R (C::*)(A1,A2,A3,A4) noexcept>
376{
377 static const int V=4;
378 static const int value=4;
379};
380
381template <class C, class R, class A1, class A2, class A3, class A4>
382struct Return<R (C::*)(A1,A2,A3,A4) noexcept>
383{
384 typedef R T;
385 typedef R type;
386};
387
388template <class C, class R, class A1, class A2, class A3, class A4>
389struct Arity<R (C::*)(A1,A2,A3,A4) const noexcept>
390{
391 static const int V=4;
392 static const int value=4;
393};
394
395template <class C, class R, class A1, class A2, class A3, class A4>
396struct Return<R (C::*)(A1,A2,A3,A4) const noexcept>
397{
398 typedef R T;
399 typedef R type;
400};
401
402template <class C, class R, class A1, class A2, class A3, class A4>
403struct ClassOf<R (C::*)(A1,A2,A3,A4) noexcept>
404{
405 typedef C T;
406 typedef C type;
407};
408
409template <class C, class R, class A1, class A2, class A3, class A4>
410struct ClassOf<R (*C::*)(A1,A2,A3,A4) noexcept>
411{
412 typedef C T;
413 typedef C type;
414};
415
416template <class C, class R, class A1, class A2, class A3, class A4>
417struct ClassOf<R (C::*)(A1,A2,A3,A4) const noexcept>
418{
419 typedef C T;
420 typedef C type;
421};
422
423template <class C, class R, class A1, class A2, class A3, class A4>
424struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4) noexcept>
425{
426 static const bool value=true;
427};
428
429template <class C, class R, class A1, class A2, class A3, class A4>
430struct is_member_function_ptr<R (C::*)(A1,A2,A3,A4) const noexcept>
431{
432 static const bool value=true;
433};
434
435template <class C, class R, class A1, class A2, class A3, class A4>
436struct is_const_method<R (C::*)(A1,A2,A3,A4) const noexcept>
437{
438 static const bool value=true;
439};
440
441template <class R, class A1, class A2, class A3, class A4>
442struct is_nonmember_function_ptr<R (*)(A1,A2,A3,A4) noexcept>
443{
444 static const bool value=true;
445};
446
447template <class C, class R, class A1, class A2, class A3, class A4>
448struct is_nonmember_function_ptr<R (*C::*)(A1,A2,A3,A4) noexcept>
449{
450 static const bool value=true;
451};
452
453template <class C, class D, class R, class A1, class A2, class A3, class A4>
454class bound_method<C, R (D::*)(A1,A2,A3,A4) noexcept>
455{
456 typedef R (D::*M)(A1,A2,A3,A4);
457 C* obj;
458 M method;
459 public:
460 static const int arity=4;
461 typedef R Ret;
462 template <int i> struct Arg: public functional::Arg<M,i> {};
463 bound_method(C& obj, M method): obj(&obj), method(method) {}
464 typename enable_if<Not<classdesc::is_const<C> >, R>::T
465 operator()(A1 a1,A2 a2,A3 a3,A4 a4) const {return (obj->*method)(a1,a2,a3,a4);}
466 void rebind(C& newObj) {obj=&newObj;}
467 static const bool is_const=false;
468};
469
470template <class C, class D, class A1, class A2, class A3, class A4>
471class bound_method<C, void (D::*)(A1,A2,A3,A4) noexcept>
472{
473 typedef void (D::*M)(A1,A2,A3,A4);
474 C* obj;
475 M method;
476 public:
477 static const int arity=4;
478 typedef void Ret;
479 template <int i> struct Arg: public functional::Arg<M,i> {};
480 bound_method(C& obj, M method): obj(&obj), method(method) {}
481 typename enable_if<Not<classdesc::is_const<C> > >::T
482 operator()(A1 a1,A2 a2,A3 a3,A4 a4) const {(obj->*method)(a1,a2,a3,a4);}
483 void rebind(C& newObj) {obj=&newObj;}
484 static const bool is_const=false;
485};
486
487template <class C, class D, class R, class A1, class A2, class A3, class A4>
488class bound_method<const C, R (D::*)(A1,A2,A3,A4) noexcept>
489{
490 typedef R (D::*M)(A1,A2,A3,A4);
491 const C* obj;
492 M method;
493 public:
494 static const int arity=4;
495 typedef R Ret;
496 template <int i> struct Arg: public functional::Arg<M,i> {};
497 bound_method(const C& obj, M method): obj(&obj), method(method) {}
498 R operator()(A1 a1,A2 a2,A3 a3,A4 a4) const {
499 throw std::runtime_error("cannot call method, inappropriate argument type");
500 }
501 void rebind(C& newObj) {obj=&newObj;}
502 static const bool is_const=false;
503};
504
505template <class C, class D, class A1, class A2, class A3, class A4>
506class bound_method<const C, void (D::*)(A1,A2,A3,A4) noexcept>
507{
508 typedef void (D::*M)(A1,A2,A3,A4);
509 const C* obj;
510 M method;
511 public:
512 static const int arity=4;
513 typedef void Ret;
514 template <int i> struct Arg: public functional::Arg<M,i> {};
515 bound_method(const C& obj, M method): obj(&obj), method(method) {}
516 typename enable_if<Not<classdesc::is_const<C> > >::T
517 operator()(A1 a1,A2 a2,A3 a3,A4 a4) const {
518 throw std::runtime_error("cannot call method, inappropriate argument type");
519 }
520 void rebind(C& newObj) {obj=&newObj;}
521 static const bool is_const=false;
522};
523
524template <class C, class D, class R, class A1, class A2, class A3, class A4>
525class bound_method<C, R (D::*)(A1,A2,A3,A4) const noexcept>
526{
527 typedef R (D::*M)(A1,A2,A3,A4) const;
528 C& obj;
529 M method;
530 public:
531 static const int arity=4;
532 typedef R Ret;
533 template <int i> struct Arg: public functional::Arg<M,i> {};
534 bound_method(C& obj, M method): obj(obj), method(method) {}
535 R operator()(A1 a1,A2 a2,A3 a3,A4 a4) const {return (obj.*method)(a1,a2,a3,a4);}
536 static const bool is_const=true;
537};
538
539template <class C, class D, class A1, class A2, class A3, class A4>
540class bound_method<C, void (D::*)(A1,A2,A3,A4) const noexcept>
541{
542 typedef void (D::*M)(A1,A2,A3,A4) const;
543 C& obj;
544 M method;
545 public:
546 static const int arity=4;
547 typedef void Ret;
548 template <int i> struct Arg: public functional::Arg<M,i> {};
549 bound_method(C& obj, M method): obj(obj), method(method) {}
550 void operator()(A1 a1,A2 a2,A3 a3,A4 a4) const {(obj.*method)(a1,a2,a3,a4);}
551 static const bool is_const=true;
552};
553#endif
554
555template <class F, class Args>
556typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 4> >,
557 typename Return<F>::T>::T
558apply_nonvoid_fn(F f, Args& a, Fdummy<F> dum=0)
559{
560 return f(a[0],a[1],a[2],a[3]);
561}
562
563/*
564 TODO: if any of the arguments to f are lvalues, we need to construct temporaries,
565 which require C++-11 ability to test for the existence of a copy constructor.
566 If the return type is not copy constructable, the user must arrange for the return value to be discarded
567*/
568
569template <class F, class Args>
570typename enable_if<And<AllArgs<F, is_rvalue>, Eq<Arity<F>::value, 4> >,
571 void>::T
572apply_void_fn(F f, Args& a, Fdummy<F> dum=0)
573{
574 f(a[0],a[1],a[2],a[3]);
575}
576
577template <class Buffer, class F>
578typename enable_if<Eq<Arity<F>::value, 4>, typename Return<F>::T>::T
579callOnBuffer(Buffer& buffer, F f)
580{
581 typename remove_const<typename remove_reference<typename Arg<F,1>::T>::type>::type a1;
582 buffer>>a1;
583 typename remove_const<typename remove_reference<typename Arg<F,2>::T>::type>::type a2;
584 buffer>>a2;
585 typename remove_const<typename remove_reference<typename Arg<F,3>::T>::type>::type a3;
586 buffer>>a3;
587 typename remove_const<typename remove_reference<typename Arg<F,4>::T>::type>::type a4;
588 buffer>>a4;
589 return f(
590a1
591,
592a2
593,
594a3
595,
596a4
597 );
598}
599#endif
bound_method< C, R(D::*)(A1, A2, A3, A4) const >::Arg
Definition functiondb4.h:337
bound_method< C, R(D::*)(A1, A2, A3, A4)>::Arg
Definition functiondb4.h:302
bound_method< const C, R(D::*)(A1, A2, A3, A4)>::Arg
Definition functiondb4.h:319