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.4 by root, Tue Apr 26 00:35:00 2005 UTC vs.
Revision 1.5 by root, Tue Nov 29 19:22:02 2005 UTC

1// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it 1// THIS IS A GENERATED FILE: RUN callback.pl to regenerate it
2// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it 2// THIS IS A GENERATED FILE: callback.pl is part of the GVPE
3// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it 3// THIS IS A GENERATED FILE: distribution.
4// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
5// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
6// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
7 4
8/* 5/*
9 callback.h -- C++ callback mechanism 6 callback.h -- C++ callback mechanism
10 Copyright (C) 2003 Marc Lehmann <pcg@goof.com> 7 Copyright (C) 2003-2005 Marc Lehmann <pcg@goof.com>
11 8
9 This file is part of GVPE.
10
12 This program is free software; you can redistribute it and/or modify 11 GVPE is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by 12 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or 13 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version. 14 (at your option) any later version.
16 15
17 This program is distributed in the hope that it will be useful, 16 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details. 19 GNU General Public License for more details.
21 20
22 You should have received a copy of the GNU General Public License 21 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 22 along with gvpe; if not, write to the Free Software
24 Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 23 Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25*/ 24*/
26 25
27#ifndef CALLBACK_H__ 26#ifndef CALLBACK_H__
28#define CALLBACK_H__ 27#define CALLBACK_H__
… …
30template<class R> 29template<class R>
31class callback0 { 30class callback0 {
32 struct object { }; 31 struct object { };
33 32
34 void *obj; 33 void *obj;
35 R (object::*meth) (); 34 R (object::*meth)();
36 35
37 /* a proxy is a kind of recipe on how to call a specific class method */ 36 /* a proxy is a kind of recipe on how to call a specific class method */
38 struct proxy_base { 37 struct proxy_base {
39 virtual R call (void *obj, R (object::*meth) ()) = 0; 38 virtual R call (void *obj, R (object::*meth)()) = 0;
40 }; 39 };
41 template<class O1, class O2> 40 template<class O1, class O2>
42 struct proxy : proxy_base { 41 struct proxy : proxy_base {
43 virtual R call (void *obj, R (object::*meth) ()) 42 virtual R call (void *obj, R (object::*meth)())
44 { 43 {
45 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) ()> (meth))) 44 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth)))
46 (); 45 ();
47 } 46 }
48 }; 47 };
49 48
50 proxy_base *prxy; 49 proxy_base *prxy;
51 50
52public: 51public:
53 template<class O1, class O2> 52 template<class O1, class O2>
54 callback0 (O1 *object, R (O2::*method) ()) 53 callback0 (O1 *object, R (O2::*method)())
55 { 54 {
56 static proxy<O1,O2> p; 55 static proxy<O1,O2> p;
57 obj = reinterpret_cast<void *> (object); 56 obj = reinterpret_cast<void *>(object);
58 meth = reinterpret_cast<R (object::*) ()> (method); 57 meth = reinterpret_cast<R (object::*)()>(method);
59 prxy = &p; 58 prxy = &p;
60 } 59 }
61 60
62 R call () const 61 R call() const
63 { 62 {
64 return prxy->call (obj, meth); 63 return prxy->call (obj, meth);
65 } 64 }
66 65
67 R operator () () const 66 R operator ()() const
68 { 67 {
69 return call (); 68 return call ();
70 } 69 }
71}; 70};
72 71
73template<class R, class A1> 72template<class R, class A1>
74class callback1 { 73class callback1 {
75 struct object { }; 74 struct object { };
76 75
77 void *obj; 76 void *obj;
78 R (object::*meth) (A1); 77 R (object::*meth)(A1);
79 78
80 /* a proxy is a kind of recipe on how to call a specific class method */ 79 /* a proxy is a kind of recipe on how to call a specific class method */
81 struct proxy_base { 80 struct proxy_base {
82 virtual R call (void *obj, R (object::*meth) (A1), A1 a1) = 0; 81 virtual R call (void *obj, R (object::*meth)(A1), A1 a1) = 0;
83 }; 82 };
84 template<class O1, class O2> 83 template<class O1, class O2>
85 struct proxy : proxy_base { 84 struct proxy : proxy_base {
86 virtual R call (void *obj, R (object::*meth) (A1), A1 a1) 85 virtual R call (void *obj, R (object::*meth)(A1), A1 a1)
87 { 86 {
88 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1)> (meth))) 87 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth)))
89 (a1); 88 (a1);
90 } 89 }
91 }; 90 };
92 91
93 proxy_base *prxy; 92 proxy_base *prxy;
94 93
95public: 94public:
96 template<class O1, class O2> 95 template<class O1, class O2>
97 callback1 (O1 *object, R (O2::*method) (A1)) 96 callback1 (O1 *object, R (O2::*method)(A1))
98 { 97 {
99 static proxy<O1,O2> p; 98 static proxy<O1,O2> p;
100 obj = reinterpret_cast<void *> (object); 99 obj = reinterpret_cast<void *>(object);
101 meth = reinterpret_cast<R (object::*) (A1)> (method); 100 meth = reinterpret_cast<R (object::*)(A1)>(method);
102 prxy = &p; 101 prxy = &p;
103 } 102 }
104 103
105 R call (A1 a1) const 104 R call(A1 a1) const
106 { 105 {
107 return prxy->call (obj, meth, a1); 106 return prxy->call (obj, meth, a1);
108 } 107 }
109 108
110 R operator () (A1 a1) const 109 R operator ()(A1 a1) const
111 { 110 {
112 return call (a1); 111 return call (a1);
113 } 112 }
114}; 113};
115 114
116template<class R, class A1, class A2> 115template<class R, class A1, class A2>
117class callback2 { 116class callback2 {
118 struct object { }; 117 struct object { };
119 118
120 void *obj; 119 void *obj;
121 R (object::*meth) (A1, A2); 120 R (object::*meth)(A1, A2);
122 121
123 /* a proxy is a kind of recipe on how to call a specific class method */ 122 /* a proxy is a kind of recipe on how to call a specific class method */
124 struct proxy_base { 123 struct proxy_base {
125 virtual R call (void *obj, R (object::*meth) (A1, A2), A1 a1, A2 a2) = 0; 124 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) = 0;
126 }; 125 };
127 template<class O1, class O2> 126 template<class O1, class O2>
128 struct proxy : proxy_base { 127 struct proxy : proxy_base {
129 virtual R call (void *obj, R (object::*meth) (A1, A2), A1 a1, A2 a2) 128 virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2)
130 { 129 {
131 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2)> (meth))) 130 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2)>(meth)))
132 (a1, a2); 131 (a1, a2);
133 } 132 }
134 }; 133 };
135 134
136 proxy_base *prxy; 135 proxy_base *prxy;
137 136
138public: 137public:
139 template<class O1, class O2> 138 template<class O1, class O2>
140 callback2 (O1 *object, R (O2::*method) (A1, A2)) 139 callback2 (O1 *object, R (O2::*method)(A1, A2))
141 { 140 {
142 static proxy<O1,O2> p; 141 static proxy<O1,O2> p;
143 obj = reinterpret_cast<void *> (object); 142 obj = reinterpret_cast<void *>(object);
144 meth = reinterpret_cast<R (object::*) (A1, A2)> (method); 143 meth = reinterpret_cast<R (object::*)(A1, A2)>(method);
145 prxy = &p; 144 prxy = &p;
146 } 145 }
147 146
148 R call (A1 a1, A2 a2) const 147 R call(A1 a1, A2 a2) const
149 { 148 {
150 return prxy->call (obj, meth, a1, a2); 149 return prxy->call (obj, meth, a1, a2);
151 } 150 }
152 151
153 R operator () (A1 a1, A2 a2) const 152 R operator ()(A1 a1, A2 a2) const
154 { 153 {
155 return call (a1, a2); 154 return call (a1, a2);
156 } 155 }
157}; 156};
158 157
159template<class R, class A1, class A2, class A3> 158template<class R, class A1, class A2, class A3>
160class callback3 { 159class callback3 {
161 struct object { }; 160 struct object { };
162 161
163 void *obj; 162 void *obj;
164 R (object::*meth) (A1, A2, A3); 163 R (object::*meth)(A1, A2, A3);
165 164
166 /* a proxy is a kind of recipe on how to call a specific class method */ 165 /* a proxy is a kind of recipe on how to call a specific class method */
167 struct proxy_base { 166 struct proxy_base {
168 virtual R call (void *obj, R (object::*meth) (A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0; 167 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0;
169 }; 168 };
170 template<class O1, class O2> 169 template<class O1, class O2>
171 struct proxy : proxy_base { 170 struct proxy : proxy_base {
172 virtual R call (void *obj, R (object::*meth) (A1, A2, A3), A1 a1, A2 a2, A3 a3) 171 virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3)
173 { 172 {
174 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3)> (meth))) 173 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth)))
175 (a1, a2, a3); 174 (a1, a2, a3);
176 } 175 }
177 }; 176 };
178 177
179 proxy_base *prxy; 178 proxy_base *prxy;
180 179
181public: 180public:
182 template<class O1, class O2> 181 template<class O1, class O2>
183 callback3 (O1 *object, R (O2::*method) (A1, A2, A3)) 182 callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
184 { 183 {
185 static proxy<O1,O2> p; 184 static proxy<O1,O2> p;
186 obj = reinterpret_cast<void *> (object); 185 obj = reinterpret_cast<void *>(object);
187 meth = reinterpret_cast<R (object::*) (A1, A2, A3)> (method); 186 meth = reinterpret_cast<R (object::*)(A1, A2, A3)>(method);
188 prxy = &p; 187 prxy = &p;
189 } 188 }
190 189
191 R call (A1 a1, A2 a2, A3 a3) const 190 R call(A1 a1, A2 a2, A3 a3) const
192 { 191 {
193 return prxy->call (obj, meth, a1, a2, a3); 192 return prxy->call (obj, meth, a1, a2, a3);
194 } 193 }
195 194
196 R operator () (A1 a1, A2 a2, A3 a3) const 195 R operator ()(A1 a1, A2 a2, A3 a3) const
197 { 196 {
198 return call (a1, a2, a3); 197 return call (a1, a2, a3);
199 } 198 }
200}; 199};
201 200
202template<class R, class A1, class A2, class A3, class A4> 201template<class R, class A1, class A2, class A3, class A4>
203class callback4 { 202class callback4 {
204 struct object { }; 203 struct object { };
205 204
206 void *obj; 205 void *obj;
207 R (object::*meth) (A1, A2, A3, A4); 206 R (object::*meth)(A1, A2, A3, A4);
208 207
209 /* a proxy is a kind of recipe on how to call a specific class method */ 208 /* a proxy is a kind of recipe on how to call a specific class method */
210 struct proxy_base { 209 struct proxy_base {
211 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0; 210 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0;
212 }; 211 };
213 template<class O1, class O2> 212 template<class O1, class O2>
214 struct proxy : proxy_base { 213 struct proxy : proxy_base {
215 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) 214 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4)
216 { 215 {
217 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4)> (meth))) 216 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth)))
218 (a1, a2, a3, a4); 217 (a1, a2, a3, a4);
219 } 218 }
220 }; 219 };
221 220
222 proxy_base *prxy; 221 proxy_base *prxy;
223 222
224public: 223public:
225 template<class O1, class O2> 224 template<class O1, class O2>
226 callback4 (O1 *object, R (O2::*method) (A1, A2, A3, A4)) 225 callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
227 { 226 {
228 static proxy<O1,O2> p; 227 static proxy<O1,O2> p;
229 obj = reinterpret_cast<void *> (object); 228 obj = reinterpret_cast<void *>(object);
230 meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4)> (method); 229 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4)>(method);
231 prxy = &p; 230 prxy = &p;
232 } 231 }
233 232
234 R call (A1 a1, A2 a2, A3 a3, A4 a4) const 233 R call(A1 a1, A2 a2, A3 a3, A4 a4) const
235 { 234 {
236 return prxy->call (obj, meth, a1, a2, a3, a4); 235 return prxy->call (obj, meth, a1, a2, a3, a4);
237 } 236 }
238 237
239 R operator () (A1 a1, A2 a2, A3 a3, A4 a4) const 238 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4) const
240 { 239 {
241 return call (a1, a2, a3, a4); 240 return call (a1, a2, a3, a4);
242 } 241 }
243}; 242};
244 243
245template<class R, class A1, class A2, class A3, class A4, class A5> 244template<class R, class A1, class A2, class A3, class A4, class A5>
246class callback5 { 245class callback5 {
247 struct object { }; 246 struct object { };
248 247
249 void *obj; 248 void *obj;
250 R (object::*meth) (A1, A2, A3, A4, A5); 249 R (object::*meth)(A1, A2, A3, A4, A5);
251 250
252 /* a proxy is a kind of recipe on how to call a specific class method */ 251 /* a proxy is a kind of recipe on how to call a specific class method */
253 struct proxy_base { 252 struct proxy_base {
254 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) = 0; 253 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) = 0;
255 }; 254 };
256 template<class O1, class O2> 255 template<class O1, class O2>
257 struct proxy : proxy_base { 256 struct proxy : proxy_base {
258 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) 257 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
259 { 258 {
260 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5)> (meth))) 259 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth)))
261 (a1, a2, a3, a4, a5); 260 (a1, a2, a3, a4, a5);
262 } 261 }
263 }; 262 };
264 263
265 proxy_base *prxy; 264 proxy_base *prxy;
266 265
267public: 266public:
268 template<class O1, class O2> 267 template<class O1, class O2>
269 callback5 (O1 *object, R (O2::*method) (A1, A2, A3, A4, A5)) 268 callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
270 { 269 {
271 static proxy<O1,O2> p; 270 static proxy<O1,O2> p;
272 obj = reinterpret_cast<void *> (object); 271 obj = reinterpret_cast<void *>(object);
273 meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5)> (method); 272 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5)>(method);
274 prxy = &p; 273 prxy = &p;
275 } 274 }
276 275
277 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const 276 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
278 { 277 {
279 return prxy->call (obj, meth, a1, a2, a3, a4, a5); 278 return prxy->call (obj, meth, a1, a2, a3, a4, a5);
280 } 279 }
281 280
282 R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const 281 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
283 { 282 {
284 return call (a1, a2, a3, a4, a5); 283 return call (a1, a2, a3, a4, a5);
285 } 284 }
286}; 285};
287 286
288template<class R, class A1, class A2, class A3, class A4, class A5, class A6> 287template<class R, class A1, class A2, class A3, class A4, class A5, class A6>
289class callback6 { 288class callback6 {
290 struct object { }; 289 struct object { };
291 290
292 void *obj; 291 void *obj;
293 R (object::*meth) (A1, A2, A3, A4, A5, A6); 292 R (object::*meth)(A1, A2, A3, A4, A5, A6);
294 293
295 /* a proxy is a kind of recipe on how to call a specific class method */ 294 /* a proxy is a kind of recipe on how to call a specific class method */
296 struct proxy_base { 295 struct proxy_base {
297 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) = 0; 296 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) = 0;
298 }; 297 };
299 template<class O1, class O2> 298 template<class O1, class O2>
300 struct proxy : proxy_base { 299 struct proxy : proxy_base {
301 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) 300 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
302 { 301 {
303 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5, A6)> (meth))) 302 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth)))
304 (a1, a2, a3, a4, a5, a6); 303 (a1, a2, a3, a4, a5, a6);
305 } 304 }
306 }; 305 };
307 306
308 proxy_base *prxy; 307 proxy_base *prxy;
309 308
310public: 309public:
311 template<class O1, class O2> 310 template<class O1, class O2>
312 callback6 (O1 *object, R (O2::*method) (A1, A2, A3, A4, A5, A6)) 311 callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
313 { 312 {
314 static proxy<O1,O2> p; 313 static proxy<O1,O2> p;
315 obj = reinterpret_cast<void *> (object); 314 obj = reinterpret_cast<void *>(object);
316 meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5, A6)> (method); 315 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6)>(method);
317 prxy = &p; 316 prxy = &p;
318 } 317 }
319 318
320 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const 319 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
321 { 320 {
322 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6); 321 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6);
323 } 322 }
324 323
325 R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const 324 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
326 { 325 {
327 return call (a1, a2, a3, a4, a5, a6); 326 return call (a1, a2, a3, a4, a5, a6);
328 } 327 }
329}; 328};
330 329
331template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7> 330template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
332class callback7 { 331class callback7 {
333 struct object { }; 332 struct object { };
334 333
335 void *obj; 334 void *obj;
336 R (object::*meth) (A1, A2, A3, A4, A5, A6, A7); 335 R (object::*meth)(A1, A2, A3, A4, A5, A6, A7);
337 336
338 /* a proxy is a kind of recipe on how to call a specific class method */ 337 /* a proxy is a kind of recipe on how to call a specific class method */
339 struct proxy_base { 338 struct proxy_base {
340 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) = 0; 339 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) = 0;
341 }; 340 };
342 template<class O1, class O2> 341 template<class O1, class O2>
343 struct proxy : proxy_base { 342 struct proxy : proxy_base {
344 virtual R call (void *obj, R (object::*meth) (A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) 343 virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
345 { 344 {
346 ((reinterpret_cast<O1 *> (obj)) ->* (reinterpret_cast<R (O2::*) (A1, A2, A3, A4, A5, A6, A7)> (meth))) 345 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth)))
347 (a1, a2, a3, a4, a5, a6, a7); 346 (a1, a2, a3, a4, a5, a6, a7);
348 } 347 }
349 }; 348 };
350 349
351 proxy_base *prxy; 350 proxy_base *prxy;
352 351
353public: 352public:
354 template<class O1, class O2> 353 template<class O1, class O2>
355 callback7 (O1 *object, R (O2::*method) (A1, A2, A3, A4, A5, A6, A7)) 354 callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
356 { 355 {
357 static proxy<O1,O2> p; 356 static proxy<O1,O2> p;
358 obj = reinterpret_cast<void *> (object); 357 obj = reinterpret_cast<void *>(object);
359 meth = reinterpret_cast<R (object::*) (A1, A2, A3, A4, A5, A6, A7)> (method); 358 meth = reinterpret_cast<R (object::*)(A1, A2, A3, A4, A5, A6, A7)>(method);
360 prxy = &p; 359 prxy = &p;
361 } 360 }
362 361
363 R call (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const 362 R call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
364 { 363 {
365 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7); 364 return prxy->call (obj, meth, a1, a2, a3, a4, a5, a6, a7);
366 } 365 }
367 366
368 R operator () (A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const 367 R operator ()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
369 { 368 {
370 return call (a1, a2, a3, a4, a5, a6, a7); 369 return call (a1, a2, a3, a4, a5, a6, a7);
371 } 370 }
372}; 371};
373 372

Diff Legend

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