X-Boost  2.3.8
bind.h
Go to the documentation of this file.
1 /******************************************************************************
2 * sprint::bind
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_THREAD_bind_H
23 #define _SPRINT_THREAD_bind_H
24 
25 // $generated on Oct 31 2011 15:01:05$
26 
32 #include "invoker.h"
33 #include "function.h"
34 
35 namespace sprint {
36 
46  template<typename T, typename R, R (T::*F)(void)>
47  inline thread_function thread_bind(T * obj)
48  {
49  return thread_function( sprint::detail::embedded_mem_fun<R,T,F>, reinterpret_cast<void *>(obj));
50  }
51 
52 /* ptr function invoker */
53 
55 template<class R>
56 inline thread_function thread_bind(R (*Proc)())
57  {
58  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_0<R> >, reinterpret_cast<void *>( new_tuple(Proc) ));
59  }
60 
61 template<>
62 inline thread_function thread_bind(void (*Proc)())
63  {
64  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_0<void> >, reinterpret_cast<void *>( new_tuple(Proc) ));
65  }
66 
68 template<class R, class A1, class P1>
69 inline thread_function thread_bind(R (*Proc)(A1), P1 p1)
70  {
71  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_1<R, P1> >, reinterpret_cast<void *>( new_tuple(Proc, p1) ));
72  }
73 
74 template<class A1, class P1>
75 inline thread_function thread_bind(void (*Proc)(A1), P1 p1)
76  {
77  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_1<void, P1> >, reinterpret_cast<void *>( new_tuple(Proc, p1) ));
78  }
79 
81 template<class R, class A1, class A2, class P1, class P2>
82 inline thread_function thread_bind(R (*Proc)(A1, A2), P1 p1, P2 p2)
83  {
84  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_2<R, P1, P2> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2) ));
85  }
86 
87 template<class A1, class A2, class P1, class P2>
88 inline thread_function thread_bind(void (*Proc)(A1, A2), P1 p1, P2 p2)
89  {
90  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_2<void, P1, P2> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2) ));
91  }
92 
94 template<class R, class A1, class A2, class A3, class P1, class P2, class P3>
95 inline thread_function thread_bind(R (*Proc)(A1, A2, A3), P1 p1, P2 p2, P3 p3)
96  {
97  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_3<R, P1, P2, P3> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3) ));
98  }
99 
100 template<class A1, class A2, class A3, class P1, class P2, class P3>
101 inline thread_function thread_bind(void (*Proc)(A1, A2, A3), P1 p1, P2 p2, P3 p3)
102  {
103  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_3<void, P1, P2, P3> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3) ));
104  }
105 
107 template<class R, class A1, class A2, class A3, class A4, class P1, class P2, class P3, class P4>
108 inline thread_function thread_bind(R (*Proc)(A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4)
109  {
110  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_4<R, P1, P2, P3, P4> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4) ));
111  }
112 
113 template<class A1, class A2, class A3, class A4, class P1, class P2, class P3, class P4>
114 inline thread_function thread_bind(void (*Proc)(A1, A2, A3, A4), P1 p1, P2 p2, P3 p3, P4 p4)
115  {
116  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_4<void, P1, P2, P3, P4> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4) ));
117  }
118 
120 template<class R, class A1, class A2, class A3, class A4, class A5,
121  class P1, class P2, class P3, class P4, class P5>
122 inline thread_function thread_bind(R (*Proc)(A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
123  {
124  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_5<R, P1, P2, P3, P4, P5> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5) ));
125  }
126 
127 template<class A1, class A2, class A3, class A4, class A5, class P1, class P2, class P3, class P4, class P5>
128 inline thread_function thread_bind(void (*Proc)(A1, A2, A3, A4, A5), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
129  {
130  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_5<void, P1, P2, P3, P4, P5> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5) ));
131  }
132 
134 template<class R, class A1, class A2, class A3, class A4, class A5, class A6,
135  class P1, class P2, class P3, class P4, class P5, class P6>
136 inline thread_function thread_bind(R (*Proc)(A1, A2, A3, A4, A5, A6), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
137  {
138  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_6<R, P1, P2, P3, P4, P5, P6> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6) ));
139  }
140 
141 template<class A1, class A2, class A3, class A4, class A5, class A6, class P1, class P2, class P3, class P4, class P5, class P6>
142 inline thread_function thread_bind(void (*Proc)(A1, A2, A3, A4, A5, A6), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
143  {
144  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_6<void, P1, P2, P3, P4, P5, P6> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6) ));
145  }
146 
148 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7,
149  class P1, class P2, class P3, class P4, class P5, class P6, class P7>
150 inline thread_function thread_bind(R (*Proc)(A1, A2, A3, A4, A5, A6, A7), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
151  {
152  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_7<R, P1, P2, P3, P4, P5, P6, P7> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7) ));
153  }
154 
155 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
156 inline thread_function thread_bind(void (*Proc)(A1, A2, A3, A4, A5, A6, A7), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
157  {
158  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_7<void, P1, P2, P3, P4, P5, P6, P7> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7) ));
159  }
160 
162 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8,
163  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
164 inline thread_function thread_bind(R (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
165  {
166  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_8<R, P1, P2, P3, P4, P5, P6, P7, P8> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8) ));
167  }
168 
169 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
170 inline thread_function thread_bind(void (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
171  {
172  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_8<void, P1, P2, P3, P4, P5, P6, P7, P8> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8) ));
173  }
174 
176 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9,
177  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
178 inline thread_function thread_bind(R (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9)
179  {
180  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8, p9) ));
181  }
182 
183 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
184 inline thread_function thread_bind(void (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9)
185  {
186  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_9<void, P1, P2, P3, P4, P5, P6, P7, P8, P9> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8, p9) ));
187  }
188 
190 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10,
191  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
192 inline thread_function thread_bind(R (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10)
193  {
194  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) ));
195  }
196 
197 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
198 inline thread_function thread_bind(void (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10)
199  {
200  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_10<void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) ));
201  }
202 
204 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11,
205  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11>
206 inline thread_function thread_bind(R (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11)
207  {
208  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) ));
209  }
210 
211 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11>
212 inline thread_function thread_bind(void (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11)
213  {
214  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_11<void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) ));
215  }
216 
218 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12,
219  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11, class P12>
220 inline thread_function thread_bind(R (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12)
221  {
222  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) ));
223  }
224 
225 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11, class P12>
226 inline thread_function thread_bind(void (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12)
227  {
228  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_12<void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) ));
229  }
230 
232 template<class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13,
233  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>
234 inline thread_function thread_bind(R (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13)
235  {
236  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) ));
237  }
238 
239 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, 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>
240 inline thread_function thread_bind(void (*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13), P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13)
241  {
242  return thread_function( sprint::detail::thread_fun< sprint::detail::ptr_fun_13<void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >, reinterpret_cast<void *>( new_tuple(Proc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) ));
243  }
244 
245 
246 /* mem function invoker */
247 
249 template<class T, class R>
250 inline thread_function thread_bind(R (T::*Proc)(), T *_this)
251  {
252  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_0<R, T> > , reinterpret_cast<void *>(new_tuple(Proc, _this) ));
253  }
254 template<class T, class R>
255 inline thread_function thread_bind(R (T::*Proc)() const, T *_this)
256  {
257  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_0<R, T> > , reinterpret_cast<void *>(new_tuple(Proc, _this) ));
258  }
259 
261 template<class T, class R, class A1, class P1>
262 inline thread_function thread_bind(R (T::*Proc)(A1), T *_this, P1 p1)
263  {
264  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_1<R, T, P1> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1) ));
265  }
266 template<class T, class R, class A1, class P1>
267 inline thread_function thread_bind(R (T::*Proc)(A1) const, T *_this, P1 p1)
268  {
269  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_1<R, T, P1> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1) ));
270  }
271 
273 template<class T, class R, class A1, class A2, class P1, class P2>
274 inline thread_function thread_bind(R (T::*Proc)(A1, A2), T *_this, P1 p1, P2 p2)
275  {
276  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_2<R, T, P1, P2> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2) ));
277  }
278 template<class T, class R, class A1, class A2, class P1, class P2>
279 inline thread_function thread_bind(R (T::*Proc)(A1, A2) const, T *_this, P1 p1, P2 p2)
280  {
281  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_2<R, T, P1, P2> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2) ));
282  }
283 
285 template<class T, class R, class A1, class A2, class A3, class P1, class P2, class P3>
286 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3), T *_this, P1 p1, P2 p2, P3 p3)
287  {
288  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_3<R, T, P1, P2, P3> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3) ));
289  }
290 template<class T, class R, class A1, class A2, class A3, class P1, class P2, class P3>
291 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3) const, T *_this, P1 p1, P2 p2, P3 p3)
292  {
293  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_3<R, T, P1, P2, P3> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3) ));
294  }
295 
297 template<class T, class R, class A1, class A2, class A3, class A4, class P1, class P2, class P3, class P4>
298 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4), T *_this, P1 p1, P2 p2, P3 p3, P4 p4)
299  {
300  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_4<R, T, P1, P2, P3, P4> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4) ));
301  }
302 template<class T, class R, class A1, class A2, class A3, class A4, class P1, class P2, class P3, class P4>
303 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4) const, T *_this, P1 p1, P2 p2, P3 p3, P4 p4)
304  {
305  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_4<R, T, P1, P2, P3, P4> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4) ));
306  }
307 
309 template<class T, class R, class A1, class A2, class A3, class A4, class A5,
310  class P1, class P2, class P3, class P4, class P5>
311 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5), T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
312  {
313  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_5<R, T, P1, P2, P3, P4, P5> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5) ));
314  }
315 template<class T, class R, class A1, class A2, class A3, class A4, class A5,
316  class P1, class P2, class P3, class P4, class P5>
317 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5) const, T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
318  {
319  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_5<R, T, P1, P2, P3, P4, P5> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5) ));
320  }
321 
323 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6,
324  class P1, class P2, class P3, class P4, class P5, class P6>
325 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6), T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
326  {
327  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_6<R, T, P1, P2, P3, P4, P5, P6> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6) ));
328  }
329 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6,
330  class P1, class P2, class P3, class P4, class P5, class P6>
331 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6) const, T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
332  {
333  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_6<R, T, P1, P2, P3, P4, P5, P6> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6) ));
334  }
335 
337 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7,
338  class P1, class P2, class P3, class P4, class P5, class P6, class P7>
339 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6, A7), T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
340  {
341  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_7<R, T, P1, P2, P3, P4, P5, P6, P7> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6, p7) ));
342  }
343 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7,
344  class P1, class P2, class P3, class P4, class P5, class P6, class P7>
345 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6, A7) const, T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
346  {
347  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_7<R, T, P1, P2, P3, P4, P5, P6, P7> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6, p7) ));
348  }
349 
351 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8,
352  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
353 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6, A7, A8), T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
354  {
355  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_8<R, T, P1, P2, P3, P4, P5, P6, P7, P8> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6, p7, p8) ));
356  }
357 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8,
358  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
359 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6, A7, A8) const, T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
360  {
361  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_8<R, T, P1, P2, P3, P4, P5, P6, P7, P8> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6, p7, p8) ));
362  }
363 
365 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9,
366  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
367 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9), T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9)
368  {
369  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_9<R, T, P1, P2, P3, P4, P5, P6, P7, P8, P9> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6, p7, p8, p9) ));
370  }
371 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9,
372  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>
373 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9)
374  {
375  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_9<R, T, P1, P2, P3, P4, P5, P6, P7, P8, P9> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6, p7, p8, p9) ));
376  }
377 
379 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10,
380  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
381 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10)
382  {
383  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_10<R, T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) ));
384  }
385 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10,
386  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>
387 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10)
388  {
389  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_10<R, T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) ));
390  }
391 
393 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11,
394  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11>
395 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11)
396  {
397  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_11<R, T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) ));
398  }
399 template<class T, class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11,
400  class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11>
401 inline thread_function thread_bind(R (T::*Proc)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const, T *_this, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11)
402  {
403  return thread_function( sprint::detail::thread_fun< sprint::detail::mem_fun_11<R, T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> > , reinterpret_cast<void *>(new_tuple(Proc, _this, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) ));
404  }
405 
406 
407 } //sprint
408 
409 #endif
410 
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::detail::ptr_fun_4< void, P1, P2, P3, P4 >
Definition: invoker.h:125
sprint::detail::ptr_fun_12< void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 >
Definition: invoker.h:277
sprint::detail::mem_fun_7
member function with 7 parameters invoker
Definition: invoker.h:441
sprint::detail::ptr_fun_0< void >
Definition: invoker.h:49
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::ptr_fun_6< void, P1, P2, P3, P4, P5, P6 >
Definition: invoker.h:163
sprint::detail::ptr_fun_9< void, P1, P2, P3, P4, P5, P6, P7, P8, P9 >
Definition: invoker.h:220
sprint::detail::ptr_fun_11< void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 >
Definition: invoker.h:258
sprint::detail::mem_fun_3
member function with 3 parameters invoker
Definition: invoker.h:365
sprint::detail::ptr_fun_13< void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 >
Definition: invoker.h:296
sprint::detail::ptr_fun_1
ptr fun with 1 parameters invoker
Definition: invoker.h:59
sprint::detail::ptr_fun_7< void, P1, P2, P3, P4, P5, P6, P7 >
Definition: invoker.h:182
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::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::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::detail::ptr_fun_8< void, P1, P2, P3, P4, P5, P6, P7, P8 >
Definition: invoker.h:201
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::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::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
sprint::detail::ptr_fun_12
ptr fun with 12 parameters invoker
Definition: invoker.h:268
sprint::detail::ptr_fun_2< void, P1, P2 >
Definition: invoker.h:87
sprint::detail::ptr_fun_8
ptr fun with 8 parameters invoker
Definition: invoker.h:192
sprint::detail::ptr_fun_3< void, P1, P2, P3 >
Definition: invoker.h:106
sprint::detail::mem_fun_1
member function with 1 parameters invoker
Definition: invoker.h:327
sprint::detail::ptr_fun_5< void, P1, P2, P3, P4, P5 >
Definition: invoker.h:144
sprint::detail::ptr_fun_1< void, P1 >
Definition: invoker.h:68
sprint::detail::ptr_fun_10< void, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 >
Definition: invoker.h:239
invoker.h
methods used to wrap function calls
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