ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/callback.h
(Generate patch)

Comparing rxvt-unicode/src/callback.h (file contents):
Revision 1.7 by root, Sat Jan 14 11:21:08 2006 UTC vs.
Revision 1.8 by root, Wed May 31 00:32:56 2006 UTC

… …
24*/ 24*/
25 25
26#ifndef CALLBACK_H__ 26#ifndef CALLBACK_H__
27#define CALLBACK_H__ 27#define CALLBACK_H__
28 28
29#define CALLBACK_H_VERSION 2
30
31template<class signature>
32struct callback_funtype_trait;
33
34template<int arity, class signature>
35struct callback_get_impl;
36
29template<class R> 37template<class R>
30class callback0 { 38class callback0
39{
31 struct object { }; 40 struct object { };
41
42 typedef R (object::*ptr_type)();
32 43
33 void *obj; 44 void *obj;
34 R (object::*meth)(); 45 R (object::*meth)();
35 46
36 /* a proxy is a kind of recipe on how to call a specific class method */ 47 /* a proxy is a kind of recipe on how to call a specific class method */
… …
67 { 78 {
68 return call (); 79 return call ();
69 } 80 }
70}; 81};
71 82
83template<class R>
84struct callback_funtype_trait0
85{
86 static const int arity = 0;
87 typedef R type (void);
88 typedef R result_type;
89
90};
91
92template<class R>
93struct callback_funtype_trait<R ()> : callback_funtype_trait0<R>
94{
95};
96
97template<class signature>
98struct callback_get_impl<0, signature>
99{
100 typedef callback_funtype_trait<signature> T;
101 typedef callback0<typename T::result_type> type;
102};
103
72template<class R, class A1> 104template<class R, class A1>
73class callback1 { 105class callback1
106{
74 struct object { }; 107 struct object { };
108
109 typedef R (object::*ptr_type)(A1);
75 110
76 void *obj; 111 void *obj;
77 R (object::*meth)(A1); 112 R (object::*meth)(A1);
78 113
79 /* a proxy is a kind of recipe on how to call a specific class method */ 114 /* a proxy is a kind of recipe on how to call a specific class method */
… …
110 { 145 {
111 return call (a1); 146 return call (a1);
112 } 147 }
113}; 148};
114 149
150template<class R, class A1>
151struct callback_funtype_trait1
152{
153 static const int arity = 1;
154 typedef R type (A1);
155 typedef R result_type;
156 typedef A1 arg1_type;
157};
158
159template<class R, class A1>
160struct callback_funtype_trait<R (A1)> : callback_funtype_trait1<R, A1>
161{
162};
163
164template<class signature>
165struct callback_get_impl<1, signature>
166{
167 typedef callback_funtype_trait<signature> T;
168 typedef callback1<typename T::result_type, typename T::arg1_type> type;
169};
170
115template<class R, class A1, class A2> 171template<class R, class A1, class A2>
116class callback2 { 172class callback2
173{
117 struct object { }; 174 struct object { };
175
176 typedef R (object::*ptr_type)(A1, A2);
118 177
119 void *obj; 178 void *obj;
120 R (object::*meth)(A1, A2); 179 R (object::*meth)(A1, A2);
121 180
122 /* a proxy is a kind of recipe on how to call a specific class method */ 181 /* a proxy is a kind of recipe on how to call a specific class method */
… …
153 { 212 {
154 return call (a1, a2); 213 return call (a1, a2);
155 } 214 }
156}; 215};
157 216
217template<class R, class A1, class A2>
218struct callback_funtype_trait2
219{
220 static const int arity = 2;
221 typedef R type (A1, A2);
222 typedef R result_type;
223 typedef A1 arg1_type; typedef A2 arg2_type;
224};
225
226template<class R, class A1, class A2>
227struct callback_funtype_trait<R (A1, A2)> : callback_funtype_trait2<R, A1, A2>
228{
229};
230
231template<class signature>
232struct callback_get_impl<2, signature>
233{
234 typedef callback_funtype_trait<signature> T;
235 typedef callback2<typename T::result_type, typename T::arg1_type, typename T::arg2_type> type;
236};
237
158template<class R, class A1, class A2, class A3> 238template<class R, class A1, class A2, class A3>
159class callback3 { 239class callback3
240{
160 struct object { }; 241 struct object { };
242
243 typedef R (object::*ptr_type)(A1, A2, A3);
161 244
162 void *obj; 245 void *obj;
163 R (object::*meth)(A1, A2, A3); 246 R (object::*meth)(A1, A2, A3);
164 247
165 /* a proxy is a kind of recipe on how to call a specific class method */ 248 /* a proxy is a kind of recipe on how to call a specific class method */
… …
196 { 279 {
197 return call (a1, a2, a3); 280 return call (a1, a2, a3);
198 } 281 }
199}; 282};
200 283
284template<class R, class A1, class A2, class A3>
285struct callback_funtype_trait3
286{
287 static const int arity = 3;
288 typedef R type (A1, A2, A3);
289 typedef R result_type;
290 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type;
291};
292
293template<class R, class A1, class A2, class A3>
294struct callback_funtype_trait<R (A1, A2, A3)> : callback_funtype_trait3<R, A1, A2, A3>
295{
296};
297
298template<class signature>
299struct callback_get_impl<3, signature>
300{
301 typedef callback_funtype_trait<signature> T;
302 typedef callback3<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type> type;
303};
304
201template<class R, class A1, class A2, class A3, class A4> 305template<class R, class A1, class A2, class A3, class A4>
202class callback4 { 306class callback4
307{
203 struct object { }; 308 struct object { };
309
310 typedef R (object::*ptr_type)(A1, A2, A3, A4);
204 311
205 void *obj; 312 void *obj;
206 R (object::*meth)(A1, A2, A3, A4); 313 R (object::*meth)(A1, A2, A3, A4);
207 314
208 /* a proxy is a kind of recipe on how to call a specific class method */ 315 /* a proxy is a kind of recipe on how to call a specific class method */
… …
239 { 346 {
240 return call (a1, a2, a3, a4); 347 return call (a1, a2, a3, a4);
241 } 348 }
242}; 349};
243 350
351template<class R, class A1, class A2, class A3, class A4>
352struct callback_funtype_trait4
353{
354 static const int arity = 4;
355 typedef R type (A1, A2, A3, A4);
356 typedef R result_type;
357 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type;
358};
359
360template<class R, class A1, class A2, class A3, class A4>
361struct callback_funtype_trait<R (A1, A2, A3, A4)> : callback_funtype_trait4<R, A1, A2, A3, A4>
362{
363};
364
365template<class signature>
366struct callback_get_impl<4, signature>
367{
368 typedef callback_funtype_trait<signature> T;
369 typedef callback4<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type> type;
370};
371
244template<class R, class A1, class A2, class A3, class A4, class A5> 372template<class R, class A1, class A2, class A3, class A4, class A5>
245class callback5 { 373class callback5
374{
246 struct object { }; 375 struct object { };
376
377 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5);
247 378
248 void *obj; 379 void *obj;
249 R (object::*meth)(A1, A2, A3, A4, A5); 380 R (object::*meth)(A1, A2, A3, A4, A5);
250 381
251 /* a proxy is a kind of recipe on how to call a specific class method */ 382 /* a proxy is a kind of recipe on how to call a specific class method */
… …
282 { 413 {
283 return call (a1, a2, a3, a4, a5); 414 return call (a1, a2, a3, a4, a5);
284 } 415 }
285}; 416};
286 417
418template<class R, class A1, class A2, class A3, class A4, class A5>
419struct callback_funtype_trait5
420{
421 static const int arity = 5;
422 typedef R type (A1, A2, A3, A4, A5);
423 typedef R result_type;
424 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type;
425};
426
427template<class R, class A1, class A2, class A3, class A4, class A5>
428struct callback_funtype_trait<R (A1, A2, A3, A4, A5)> : callback_funtype_trait5<R, A1, A2, A3, A4, A5>
429{
430};
431
432template<class signature>
433struct callback_get_impl<5, signature>
434{
435 typedef callback_funtype_trait<signature> T;
436 typedef callback5<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type> type;
437};
438
287template<class R, class A1, class A2, class A3, class A4, class A5, class A6> 439template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
288class callback6 { 440class callback6
441{
289 struct object { }; 442 struct object { };
443
444 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6);
290 445
291 void *obj; 446 void *obj;
292 R (object::*meth)(A1, A2, A3, A4, A5, A6); 447 R (object::*meth)(A1, A2, A3, A4, A5, A6);
293 448
294 /* a proxy is a kind of recipe on how to call a specific class method */ 449 /* a proxy is a kind of recipe on how to call a specific class method */
… …
325 { 480 {
326 return call (a1, a2, a3, a4, a5, a6); 481 return call (a1, a2, a3, a4, a5, a6);
327 } 482 }
328}; 483};
329 484
485template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
486struct callback_funtype_trait6
487{
488 static const int arity = 6;
489 typedef R type (A1, A2, A3, A4, A5, A6);
490 typedef R result_type;
491 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type; typedef A6 arg6_type;
492};
493
494template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
495struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6)> : callback_funtype_trait6<R, A1, A2, A3, A4, A5, A6>
496{
497};
498
499template<class signature>
500struct callback_get_impl<6, signature>
501{
502 typedef callback_funtype_trait<signature> T;
503 typedef callback6<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type, typename T::arg6_type> type;
504};
505
330template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 506template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
331class callback7 { 507class callback7
508{
332 struct object { }; 509 struct object { };
510
511 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7);
333 512
334 void *obj; 513 void *obj;
335 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7); 514 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7);
336 515
337 /* a proxy is a kind of recipe on how to call a specific class method */ 516 /* a proxy is a kind of recipe on how to call a specific class method */
… …
368 { 547 {
369 return call (a1, a2, a3, a4, a5, a6, a7); 548 return call (a1, a2, a3, a4, a5, a6, a7);
370 } 549 }
371}; 550};
372 551
552template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
553struct callback_funtype_trait7
554{
555 static const int arity = 7;
556 typedef R type (A1, A2, A3, A4, A5, A6, A7);
557 typedef R result_type;
558 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type; typedef A6 arg6_type; typedef A7 arg7_type;
559};
560
561template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
562struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6, A7)> : callback_funtype_trait7<R, A1, A2, A3, A4, A5, A6, A7>
563{
564};
565
566template<class signature>
567struct callback_get_impl<7, signature>
568{
569 typedef callback_funtype_trait<signature> T;
570 typedef callback7<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type, typename T::arg6_type, typename T::arg7_type> type;
571};
572
573template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
574class callback8
575{
576 struct object { };
577
578 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8);
579
580 void *obj;
581 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8);
582
583 /* a proxy is a kind of recipe on how to call a specific class method */
584 struct proxy_base {
585 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const = 0;
586 };
587 template<class O1, class O2>
588 struct proxy : proxy_base {
589 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
590 {
591 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7, A8)>(meth)))
592 (a1, a2, a3, a4, a5, a6, a7, a8);
593 }
594 };
595
596 proxy_base *prxy;
597
598public:
599 template<class O1, class O2>
600 explicit callback8 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8))
601 {
602 static proxy<O1,O2> p;
603 obj = reinterpret_cast<void *>(object);
604 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7, A8)>(method);
605 prxy = &p;
606 }
607
608 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
609 {
610 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8);
611 }
612
613 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
614 {
615 return call (a1, a2, a3, a4, a5, a6, a7, a8);
616 }
617};
618
619template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
620struct callback_funtype_trait8
621{
622 static const int arity = 8;
623 typedef R type (A1, A2, A3, A4, A5, A6, A7, A8);
624 typedef R result_type;
625 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type; typedef A6 arg6_type; typedef A7 arg7_type; typedef A8 arg8_type;
626};
627
628template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
629struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6, A7, A8)> : callback_funtype_trait8<R, A1, A2, A3, A4, A5, A6, A7, A8>
630{
631};
632
633template<class signature>
634struct callback_get_impl<8, signature>
635{
636 typedef callback_funtype_trait<signature> T;
637 typedef callback8<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type, typename T::arg6_type, typename T::arg7_type, typename T::arg8_type> type;
638};
639
640template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
641class callback9
642{
643 struct object { };
644
645 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
646
647 void *obj;
648 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
649
650 /* a proxy is a kind of recipe on how to call a specific class method */
651 struct proxy_base {
652 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const = 0;
653 };
654 template<class O1, class O2>
655 struct proxy : proxy_base {
656 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
657 {
658 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>(meth)))
659 (a1, a2, a3, a4, a5, a6, a7, a8, a9);
660 }
661 };
662
663 proxy_base *prxy;
664
665public:
666 template<class O1, class O2>
667 explicit callback9 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9))
668 {
669 static proxy<O1,O2> p;
670 obj = reinterpret_cast<void *>(object);
671 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>(method);
672 prxy = &p;
673 }
674
675 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
676 {
677 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8, a9);
678 }
679
680 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) const
681 {
682 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9);
683 }
684};
685
686template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
687struct callback_funtype_trait9
688{
689 static const int arity = 9;
690 typedef R type (A1, A2, A3, A4, A5, A6, A7, A8, A9);
691 typedef R result_type;
692 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type; typedef A6 arg6_type; typedef A7 arg7_type; typedef A8 arg8_type; typedef A9 arg9_type;
693};
694
695template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
696struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6, A7, A8, A9)> : callback_funtype_trait9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>
697{
698};
699
700template<class signature>
701struct callback_get_impl<9, signature>
702{
703 typedef callback_funtype_trait<signature> T;
704 typedef callback9<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type, typename T::arg6_type, typename T::arg7_type, typename T::arg8_type, typename T::arg9_type> type;
705};
706
707template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
708class callback10
709{
710 struct object { };
711
712 typedef R (object::*ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
713
714 void *obj;
715 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
716
717 /* a proxy is a kind of recipe on how to call a specific class method */
718 struct proxy_base {
719 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const = 0;
720 };
721 template<class O1, class O2>
722 struct proxy : proxy_base {
723 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
724 {
725 return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>(meth)))
726 (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
727 }
728 };
729
730 proxy_base *prxy;
731
732public:
733 template<class O1, class O2>
734 explicit callback10 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
735 {
736 static proxy<O1,O2> p;
737 obj = reinterpret_cast<void *>(object);
738 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>(method);
739 prxy = &p;
740 }
741
742 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
743 {
744 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
745 }
746
747 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) const
748 {
749 return call (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
750 }
751};
752
753template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
754struct callback_funtype_trait10
755{
756 static const int arity = 10;
757 typedef R type (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
758 typedef R result_type;
759 typedef A1 arg1_type; typedef A2 arg2_type; typedef A3 arg3_type; typedef A4 arg4_type; typedef A5 arg5_type; typedef A6 arg6_type; typedef A7 arg7_type; typedef A8 arg8_type; typedef A9 arg9_type; typedef A10 arg10_type;
760};
761
762template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
763struct callback_funtype_trait<R (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> : callback_funtype_trait10<R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>
764{
765};
766
767template<class signature>
768struct callback_get_impl<10, signature>
769{
770 typedef callback_funtype_trait<signature> T;
771 typedef callback10<typename T::result_type, typename T::arg1_type, typename T::arg2_type, typename T::arg3_type, typename T::arg4_type, typename T::arg5_type, typename T::arg6_type, typename T::arg7_type, typename T::arg8_type, typename T::arg9_type, typename T::arg10_type> type;
772};
773
774
775template<class signature>
776struct callback : callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type
777{
778 typedef typename callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type base_type;
779
780 template<class O, class M>
781 explicit callback (O object, M method)
782 : base_type (object, method)
783 {
784 }
785};
786
373#endif 787#endif

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines