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