X-Boost  2.3.8
invoker.h
Go to the documentation of this file.
1 /******************************************************************************
2 * sprint::invoker
3 *
4 * Copyright (C) 2005-2011 Paolo Medici <www.pmx.it>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 *******************************************************************************/
21 
22 #ifndef _SPRINT_invoker_H
23 #define _SPRINT_invoker_H
24 
25 // $generated on Oct 30 2011 10:49:02$
26 
31 #include "tuple.h"
32 
33 namespace sprint {
34  namespace detail {
35 
36 /* ptr function invoker */
37 
39 template<class R>
40 struct ptr_fun_0 {
41  typedef R (*CallbackType)();
42  typedef tuple1<CallbackType> ParamType;
43  static R run(const ParamType & p)
44  {
45  return (*p.p1)();
46  }
47 };
48 template<>
49 struct ptr_fun_0<void> {
50  typedef void (*CallbackType)();
51  typedef tuple1<CallbackType> ParamType;
52  static void run(const ParamType & p)
53  {
54  (*p.p1)();
55  }
56 };
58 template<class R, class P1>
59 struct ptr_fun_1 {
60  typedef R (*CallbackType)(P1);
61  typedef tuple2<CallbackType, P1> ParamType;
62  static R run(const ParamType & p)
63  {
64  return (*p.p1)(p.p2);
65  }
66 };
67 template<class P1>
68 struct ptr_fun_1<void, P1> {
69  typedef void (*CallbackType)(P1);
70  typedef tuple2<CallbackType, P1> ParamType;
71  static void run(const ParamType & p)
72  {
73  (*p.p1)(p.p2);
74  }
75 };
77 template<class R, class P1, class P2>
78 struct ptr_fun_2 {
79  typedef R (*CallbackType)(P1, P2);
80  typedef tuple3<CallbackType, P1, P2> ParamType;
81  static R run(const ParamType & p)
82  {
83  return (*p.p1)(p.p2, p.p3);
84  }
85 };
86 template<class P1, class P2>
87 struct ptr_fun_2<void, P1, P2> {
88  typedef void (*CallbackType)(P1, P2);
89  typedef tuple3<CallbackType, P1, P2> ParamType;
90  static void run(const ParamType & p)
91  {
92  (*p.p1)(p.p2, p.p3);
93  }
94 };
96 template<class R, class P1, class P2, class P3>
97 struct ptr_fun_3 {
98  typedef R (*CallbackType)(P1, P2, P3);
99  typedef tuple4<CallbackType, P1, P2, P3> ParamType;
100  static R run(const ParamType & p)
101  {
102  return (*p.p1)(p.p2, p.p3, p.p4);
103  }
104 };
105 template<class P1, class P2, class P3>
106 struct ptr_fun_3<void, P1, P2, P3> {
107  typedef void (*CallbackType)(P1, P2, P3);
108  typedef tuple4<CallbackType, P1, P2, P3> ParamType;
109  static void run(const ParamType & p)
110  {
111  (*p.p1)(p.p2, p.p3, p.p4);
112  }
113 };
115 template<class R, class P1, class P2, class P3, class P4>
116 struct ptr_fun_4 {
117  typedef R (*CallbackType)(P1, P2, P3, P4);
118  typedef tuple5<CallbackType, P1, P2, P3, P4> ParamType;
119  static R run(const ParamType & p)
120  {
121  return (*p.p1)(p.p2, p.p3, p.p4, p.p5);
122  }
123 };
124 template<class P1, class P2, class P3, class P4>
125 struct ptr_fun_4<void, P1, P2, P3, P4> {
126  typedef void (*CallbackType)(P1, P2, P3, P4);
127  typedef tuple5<CallbackType, P1, P2, P3, P4> ParamType;
128  static void run(const ParamType & p)
129  {
130  (*p.p1)(p.p2, p.p3, p.p4, p.p5);
131  }
132 };
134 template<class R, class P1, class P2, class P3, class P4, class P5>
135 struct ptr_fun_5 {
136  typedef R (*CallbackType)(P1, P2, P3, P4, P5);
137  typedef tuple6<CallbackType, P1, P2, P3, P4, P5> ParamType;
138  static R run(const ParamType & p)
139  {
140  return (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6);
141  }
142 };
143 template<class P1, class P2, class P3, class P4, class P5>
144 struct ptr_fun_5<void, P1, P2, P3, P4, P5> {
145  typedef void (*CallbackType)(P1, P2, P3, P4, P5);
146  typedef tuple6<CallbackType, P1, P2, P3, P4, P5> ParamType;
147  static void run(const ParamType & p)
148  {
149  (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6);
150  }
151 };
153 template<class R, class P1, class P2, class P3, class P4, class P5, class P6>
154 struct ptr_fun_6 {
155  typedef R (*CallbackType)(P1, P2, P3, P4, P5, P6);
156  typedef tuple7<CallbackType, P1, P2, P3, P4, P5, P6> ParamType;
157  static R run(const ParamType & p)
158  {
159  return (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7);
160  }
161 };
162 template<class P1, class P2, class P3, class P4, class P5, class P6>
163 struct ptr_fun_6<void, P1, P2, P3, P4, P5, P6> {
164  typedef void (*CallbackType)(P1, P2, P3, P4, P5, P6);
165  typedef tuple7<CallbackType, P1, P2, P3, P4, P5, P6> ParamType;
166  static void run(const ParamType & p)
167  {
168  (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7);
169  }
170 };
172 template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
173 struct ptr_fun_7 {
174  typedef R (*CallbackType)(P1, P2, P3, P4, P5, P6, P7);
175  typedef tuple8<CallbackType, P1, P2, P3, P4, P5, P6, P7> ParamType;
176  static R run(const ParamType & p)
177  {
178  return (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8);
179  }
180 };
181 template<class P1, class P2, class P3, class P4, class P5, class P6, class P7>
182 struct ptr_fun_7<void, P1, P2, P3, P4, P5, P6, P7> {
183  typedef void (*CallbackType)(P1, P2, P3, P4, P5, P6, P7);
184  typedef tuple8<CallbackType, P1, P2, P3, P4, P5, P6, P7> ParamType;
185  static void run(const ParamType & p)
186  {
187  (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8);
188  }
189 };
191 template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
192 struct ptr_fun_8 {
193  typedef R (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8);
194  typedef tuple9<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8> ParamType;
195  static R run(const ParamType & p)
196  {
197  return (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9);
198  }
199 };
200 template<class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
201 struct ptr_fun_8<void, P1, P2, P3, P4, P5, P6, P7, P8> {
202  typedef void (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8);
203  typedef tuple9<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8> ParamType;
204  static void run(const ParamType & p)
205  {
206  (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9);
207  }
208 };
210 template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
211 struct ptr_fun_9 {
212  typedef R (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9);
213  typedef tuple10<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8, P9> ParamType;
214  static R run(const ParamType & p)
215  {
216  return (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10);
217  }
218 };
219 template<class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
220 struct ptr_fun_9<void, P1, P2, P3, P4, P5, P6, P7, P8, P9> {
221  typedef void (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9);
222  typedef tuple10<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8, P9> ParamType;
223  static void run(const ParamType & p)
224  {
225  (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10);
226  }
227 };
229 template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
230 struct ptr_fun_10 {
231  typedef R (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
232  typedef tuple11<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> ParamType;
233  static R run(const ParamType & p)
234  {
235  return (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11);
236  }
237 };
238 template<class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
239 struct ptr_fun_10<void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> {
240  typedef void (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
241  typedef tuple11<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> ParamType;
242  static void run(const ParamType & p)
243  {
244  (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11);
245  }
246 };
248 template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11>
249 struct ptr_fun_11 {
250  typedef R (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
251  typedef tuple12<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> ParamType;
252  static R run(const ParamType & p)
253  {
254  return (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12);
255  }
256 };
257 template<class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11>
258 struct ptr_fun_11<void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> {
259  typedef void (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
260  typedef tuple12<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> ParamType;
261  static void run(const ParamType & p)
262  {
263  (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12);
264  }
265 };
267 template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11, class P12>
268 struct ptr_fun_12 {
269  typedef R (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
270  typedef tuple13<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> ParamType;
271  static R run(const ParamType & p)
272  {
273  return (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12, p.p13);
274  }
275 };
276 template<class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11, class P12>
277 struct ptr_fun_12<void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> {
278  typedef void (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
279  typedef tuple13<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> ParamType;
280  static void run(const ParamType & p)
281  {
282  (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12, p.p13);
283  }
284 };
286 template<class R, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11, class P12, class P13>
287 struct ptr_fun_13 {
288  typedef R (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
289  typedef tuple14<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> ParamType;
290  static R run(const ParamType & p)
291  {
292  return (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12, p.p13, p.p14);
293  }
294 };
295 template<class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11, class P12, class P13>
296 struct ptr_fun_13<void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> {
297  typedef void (*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
298  typedef tuple14<CallbackType, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> ParamType;
299  static void run(const ParamType & p)
300  {
301  (*p.p1)(p.p2, p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12, p.p13, p.p14);
302  }
303 };
304 /* member function invoker */
305 
307 template<class R, class T>
308 struct mem_fun_0 {
309  typedef R (T::*CallbackType)();
310  typedef tuple2<CallbackType, T*> ParamType;
311  static R run(const ParamType & p)
312  {
313  return (p.p2->*p.p1)();
314  }
315 };
316 template<class T>
317 struct mem_fun_0<void, T> {
318  typedef void (T::*CallbackType)();
319  typedef tuple2<CallbackType, T*> ParamType;
320  static void run(const ParamType & p)
321  {
322  (p.p2->*p.p1)();
323  }
324 };
326 template<class R, class T, class P1>
327 struct mem_fun_1 {
328  typedef R (T::*CallbackType)(P1);
329  typedef tuple3<CallbackType, T*, P1> ParamType;
330  static R run(const ParamType & p)
331  {
332  return (p.p2->*p.p1)(p.p3);
333  }
334 };
335 template<class T, class P1>
336 struct mem_fun_1<void, T, P1> {
337  typedef void (T::*CallbackType)(P1);
338  typedef tuple3<CallbackType, T*, P1> ParamType;
339  static void run(const ParamType & p)
340  {
341  (p.p2->*p.p1)(p.p3);
342  }
343 };
345 template<class R, class T, class P1, class P2>
346 struct mem_fun_2 {
347  typedef R (T::*CallbackType)(P1, P2);
348  typedef tuple4<CallbackType, T*, P1, P2> ParamType;
349  static R run(const ParamType & p)
350  {
351  return (p.p2->*p.p1)(p.p3, p.p4);
352  }
353 };
354 template<class T, class P1, class P2>
355 struct mem_fun_2<void, T, P1, P2> {
356  typedef void (T::*CallbackType)(P1, P2);
357  typedef tuple4<CallbackType, T*, P1, P2> ParamType;
358  static void run(const ParamType & p)
359  {
360  (p.p2->*p.p1)(p.p3, p.p4);
361  }
362 };
364 template<class R, class T, class P1, class P2, class P3>
365 struct mem_fun_3 {
366  typedef R (T::*CallbackType)(P1, P2, P3);
367  typedef tuple5<CallbackType, T*, P1, P2, P3> ParamType;
368  static R run(const ParamType & p)
369  {
370  return (p.p2->*p.p1)(p.p3, p.p4, p.p5);
371  }
372 };
373 template<class T, class P1, class P2, class P3>
374 struct mem_fun_3<void, T, P1, P2, P3> {
375  typedef void (T::*CallbackType)(P1, P2, P3);
376  typedef tuple5<CallbackType, T*, P1, P2, P3> ParamType;
377  static void run(const ParamType & p)
378  {
379  (p.p2->*p.p1)(p.p3, p.p4, p.p5);
380  }
381 };
383 template<class R, class T, class P1, class P2, class P3, class P4>
384 struct mem_fun_4 {
385  typedef R (T::*CallbackType)(P1, P2, P3, P4);
386  typedef tuple6<CallbackType, T*, P1, P2, P3, P4> ParamType;
387  static R run(const ParamType & p)
388  {
389  return (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6);
390  }
391 };
392 template<class T, class P1, class P2, class P3, class P4>
393 struct mem_fun_4<void, T, P1, P2, P3, P4> {
394  typedef void (T::*CallbackType)(P1, P2, P3, P4);
395  typedef tuple6<CallbackType, T*, P1, P2, P3, P4> ParamType;
396  static void run(const ParamType & p)
397  {
398  (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6);
399  }
400 };
402 template<class R, class T, class P1, class P2, class P3, class P4, class P5>
403 struct mem_fun_5 {
404  typedef R (T::*CallbackType)(P1, P2, P3, P4, P5);
405  typedef tuple7<CallbackType, T*, P1, P2, P3, P4, P5> ParamType;
406  static R run(const ParamType & p)
407  {
408  return (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7);
409  }
410 };
411 template<class T, class P1, class P2, class P3, class P4, class P5>
412 struct mem_fun_5<void, T, P1, P2, P3, P4, P5> {
413  typedef void (T::*CallbackType)(P1, P2, P3, P4, P5);
414  typedef tuple7<CallbackType, T*, P1, P2, P3, P4, P5> ParamType;
415  static void run(const ParamType & p)
416  {
417  (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7);
418  }
419 };
421 template<class R, class T, class P1, class P2, class P3, class P4, class P5, class P6>
422 struct mem_fun_6 {
423  typedef R (T::*CallbackType)(P1, P2, P3, P4, P5, P6);
424  typedef tuple8<CallbackType, T*, P1, P2, P3, P4, P5, P6> ParamType;
425  static R run(const ParamType & p)
426  {
427  return (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8);
428  }
429 };
430 template<class T, class P1, class P2, class P3, class P4, class P5, class P6>
431 struct mem_fun_6<void, T, P1, P2, P3, P4, P5, P6> {
432  typedef void (T::*CallbackType)(P1, P2, P3, P4, P5, P6);
433  typedef tuple8<CallbackType, T*, P1, P2, P3, P4, P5, P6> ParamType;
434  static void run(const ParamType & p)
435  {
436  (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8);
437  }
438 };
440 template<class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
441 struct mem_fun_7 {
442  typedef R (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7);
443  typedef tuple9<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7> ParamType;
444  static R run(const ParamType & p)
445  {
446  return (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9);
447  }
448 };
449 template<class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
450 struct mem_fun_7<void, T, P1, P2, P3, P4, P5, P6, P7> {
451  typedef void (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7);
452  typedef tuple9<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7> ParamType;
453  static void run(const ParamType & p)
454  {
455  (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9);
456  }
457 };
459 template<class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
460 struct mem_fun_8 {
461  typedef R (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8);
462  typedef tuple10<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7, P8> ParamType;
463  static R run(const ParamType & p)
464  {
465  return (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10);
466  }
467 };
468 template<class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
469 struct mem_fun_8<void, T, P1, P2, P3, P4, P5, P6, P7, P8> {
470  typedef void (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8);
471  typedef tuple10<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7, P8> ParamType;
472  static void run(const ParamType & p)
473  {
474  (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10);
475  }
476 };
478 template<class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
479 struct mem_fun_9 {
480  typedef R (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9);
481  typedef tuple11<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7, P8, P9> ParamType;
482  static R run(const ParamType & p)
483  {
484  return (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11);
485  }
486 };
487 template<class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
488 struct mem_fun_9<void, T, P1, P2, P3, P4, P5, P6, P7, P8, P9> {
489  typedef void (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9);
490  typedef tuple11<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7, P8, P9> ParamType;
491  static void run(const ParamType & p)
492  {
493  (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11);
494  }
495 };
497 template<class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
498 struct mem_fun_10 {
499  typedef R (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
500  typedef tuple12<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> ParamType;
501  static R run(const ParamType & p)
502  {
503  return (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12);
504  }
505 };
506 template<class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
507 struct mem_fun_10<void, T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> {
508  typedef void (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
509  typedef tuple12<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> ParamType;
510  static void run(const ParamType & p)
511  {
512  (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12);
513  }
514 };
516 template<class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11>
517 struct mem_fun_11 {
518  typedef R (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
519  typedef tuple13<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> ParamType;
520  static R run(const ParamType & p)
521  {
522  return (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12, p.p13);
523  }
524 };
525 template<class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11>
526 struct mem_fun_11<void, T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> {
527  typedef void (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
528  typedef tuple13<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> ParamType;
529  static void run(const ParamType & p)
530  {
531  (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12, p.p13);
532  }
533 };
535 template<class R, class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11, class P12>
536 struct mem_fun_12 {
537  typedef R (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
538  typedef tuple14<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> ParamType;
539  static R run(const ParamType & p)
540  {
541  return (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12, p.p13, p.p14);
542  }
543 };
544 template<class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11, class P12>
545 struct mem_fun_12<void, T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> {
546  typedef void (T::*CallbackType)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
547  typedef tuple14<CallbackType, T*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> ParamType;
548  static void run(const ParamType & p)
549  {
550  (p.p2->*p.p1)(p.p3, p.p4, p.p5, p.p6, p.p7, p.p8, p.p9, p.p10, p.p11, p.p12, p.p13, p.p14);
551  }
552 };
553 
554  } // detail
555 } // sprint
556 
557 #endif
558 
sprint::detail::ptr_fun_9
ptr fun with 9 parameters invoker
Definition: invoker.h:211
sprint::detail::mem_fun_11
member function with 11 parameters invoker
Definition: invoker.h:517
sprint::detail::mem_fun_2
member function with 2 parameters invoker
Definition: invoker.h:346
sprint::detail::ptr_fun_0
ptr fun with 0 parameters invoker
Definition: invoker.h:40
sprint::tuple9
a tuple, representing 9 ordered elements
Definition: tuple.h:191
sprint::detail::mem_fun_7
member function with 7 parameters invoker
Definition: invoker.h:441
sprint::detail::ptr_fun_5
ptr fun with 5 parameters invoker
Definition: invoker.h:135
sprint::detail::ptr_fun_10
ptr fun with 10 parameters invoker
Definition: invoker.h:230
sprint::detail::mem_fun_12
member function with 12 parameters invoker
Definition: invoker.h:536
sprint::tuple5
a tuple, representing 5 ordered elements
Definition: tuple.h:89
sprint::detail::mem_fun_3
member function with 3 parameters invoker
Definition: invoker.h:365
sprint::detail::ptr_fun_1
ptr fun with 1 parameters invoker
Definition: invoker.h:59
sprint::tuple14
a tuple, representing 14 ordered elements
Definition: tuple.h:386
sprint::detail::mem_fun_8
member function with 8 parameters invoker
Definition: invoker.h:460
sprint::detail::ptr_fun_6
ptr fun with 6 parameters invoker
Definition: invoker.h:154
sprint::tuple1
a tuple, representing 1 ordered elements
Definition: tuple.h:35
sprint::tuple12
a tuple, representing 12 ordered elements
Definition: tuple.h:299
sprint::tuple6
a tuple, representing 6 ordered elements
Definition: tuple.h:110
sprint::detail::mem_fun_4
member function with 4 parameters invoker
Definition: invoker.h:384
sprint::detail::ptr_fun_2
ptr fun with 2 parameters invoker
Definition: invoker.h:78
sprint::tuple13
a tuple, representing 13 ordered elements
Definition: tuple.h:341
sprint::detail::ptr_fun_11
ptr fun with 11 parameters invoker
Definition: invoker.h:249
sprint::detail::ptr_fun_13
ptr fun with 13 parameters invoker
Definition: invoker.h:287
sprint::tuple7
a tuple, representing 7 ordered elements
Definition: tuple.h:134
sprint::detail::mem_fun_9
member function with 9 parameters invoker
Definition: invoker.h:479
sprint::detail::ptr_fun_7
ptr fun with 7 parameters invoker
Definition: invoker.h:173
sprint::tuple2
a tuple, representing 2 ordered elements
Definition: tuple.h:44
sprint::detail::mem_fun_0
member function with 0 parameters invoker
Definition: invoker.h:308
sprint::detail::mem_fun_10
member function with 10 parameters invoker
Definition: invoker.h:498
sprint::tuple11
a tuple, representing 11 ordered elements
Definition: tuple.h:260
sprint::tuple3
a tuple, representing 3 ordered elements
Definition: tuple.h:56
sprint::detail::mem_fun_5
member function with 5 parameters invoker
Definition: invoker.h:403
sprint::detail::ptr_fun_3
ptr fun with 3 parameters invoker
Definition: invoker.h:97
tuple.h
an extension of std::pair to multiple dimensions
sprint::detail::ptr_fun_12
ptr fun with 12 parameters invoker
Definition: invoker.h:268
sprint::tuple8
a tuple, representing 8 ordered elements
Definition: tuple.h:161
sprint::detail::ptr_fun_8
ptr fun with 8 parameters invoker
Definition: invoker.h:192
sprint::detail::mem_fun_1
member function with 1 parameters invoker
Definition: invoker.h:327
sprint::tuple10
a tuple, representing 10 ordered elements
Definition: tuple.h:224
sprint::tuple4
a tuple, representing 4 ordered elements
Definition: tuple.h:71
sprint::detail::mem_fun_6
member function with 6 parameters invoker
Definition: invoker.h:422
sprint::detail::ptr_fun_4
ptr fun with 4 parameters invoker
Definition: invoker.h:116
Generated on Wed Jul 30 2014 18:01:12 for X-Boost by   doxygen 1.8.7