1// Copyright (C) 2012 Vicente J. Botet Escriba
2//
3// Distributed under the Boost Software License, Version 1.0. (See accompanying
4// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5
6// 2013/04 Vicente J. Botet Escriba
7// Provide implementation up to 9 parameters when BOOST_NO_CXX11_VARIADIC_TEMPLATES is defined.
8// Make use of Boost.Move
9// Make use of Boost.Tuple (movable)
10// 2012/11 Vicente J. Botet Escriba
11// Adapt to boost libc++ implementation
12
13//===----------------------------------------------------------------------===//
14//
15// The LLVM Compiler Infrastructure
16//
17// This file is dual licensed under the MIT and the University of Illinois Open
18// Source Licenses. See LICENSE.TXT for details.
19//
20// The invoker code is based on the one from libcxx.
21//===----------------------------------------------------------------------===//
22
23#ifndef BOOST_THREAD_DETAIL_INVOKER_HPP
24#define BOOST_THREAD_DETAIL_INVOKER_HPP
25
26#include <boost/config.hpp>
27
28#include <boost/utility/result_of.hpp>
29#include <boost/thread/detail/move.hpp>
30#include <boost/thread/detail/invoke.hpp>
31#include <boost/thread/detail/make_tuple_indices.hpp>
32#include <boost/thread/csbl/tuple.hpp>
33#include <boost/tuple/tuple.hpp>
34
35#include <boost/thread/detail/variadic_header.hpp>
36
37namespace boost
38{
39 namespace detail
40 {
41
42#if defined(BOOST_THREAD_PROVIDES_INVOKE) && ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ! defined(BOOST_NO_CXX11_HDR_TUPLE)
43
44 template <class Fp, class ... Args>
45 class invoker
46 {
47 //typedef typename decay<Fp>::type Fpd;
48 //typedef tuple<typename decay<Args>::type...> Argsd;
49
50 //csbl::tuple<Fpd, Argsd...> f_;
51 csbl::tuple<Fp, Args...> f_;
52
53 public:
54 BOOST_THREAD_COPYABLE_AND_MOVABLE( invoker)
55 //typedef typename invoke_of<_Fp, _Args...>::type Rp;
56 typedef typename result_of<Fp(Args...)>::type result_type;
57
58 template <class F, class ... As>
59 BOOST_SYMBOL_VISIBLE
60 explicit invoker(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(As)... args)
61 : f_(boost::forward<F>(f), boost::forward<As>(args)...)
62 {}
63
64 BOOST_SYMBOL_VISIBLE
65 invoker(BOOST_THREAD_RV_REF(invoker) f) : f_(boost::move(BOOST_THREAD_RV(f).f_))
66 {}
67
68 BOOST_SYMBOL_VISIBLE
69 invoker( const invoker& f) : f_(f.f_)
70 {}
71
72 BOOST_SYMBOL_VISIBLE
73 invoker& operator=(BOOST_THREAD_RV_REF(invoker) f)
74 {
75 if (this != &f)
76 {
77 f_ = boost::move(BOOST_THREAD_RV(f).f_);
78 }
79 return *this;
80 }
81
82 BOOST_SYMBOL_VISIBLE
83 invoker& operator=( BOOST_THREAD_COPY_ASSIGN_REF(invoker) f)
84 {
85 if (this != &f)
86 {
87 f_ = f.f_;
88 }
89 return *this;
90 }
91
92 result_type operator()()
93 {
94 typedef typename make_tuple_indices<1+sizeof...(Args), 1>::type Index;
95 return execute(Index());
96 }
97 private:
98 template <size_t ...Indices>
99 result_type
100 execute(tuple_indices<Indices...>)
101 {
102 return detail::invoke(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
103 }
104 };
105
106 template <class R, class Fp, class ... Args>
107 class invoker_ret
108 {
109 //typedef typename decay<Fp>::type Fpd;
110 //typedef tuple<typename decay<Args>::type...> Argsd;
111
112 //csbl::tuple<Fpd, Argsd...> f_;
113 csbl::tuple<Fp, Args...> f_;
114
115 public:
116 BOOST_THREAD_COPYABLE_AND_MOVABLE( invoker_ret)
117 typedef R result_type;
118
119 template <class F, class ... As>
120 BOOST_SYMBOL_VISIBLE
121 explicit invoker_ret(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(As)... args)
122 : f_(boost::forward<F>(f), boost::forward<As>(args)...)
123 {}
124
125 BOOST_SYMBOL_VISIBLE
126 invoker_ret(BOOST_THREAD_RV_REF(invoker_ret) f) : f_(boost::move(BOOST_THREAD_RV(f).f_))
127 {}
128
129 result_type operator()()
130 {
131 typedef typename make_tuple_indices<1+sizeof...(Args), 1>::type Index;
132 return execute(Index());
133 }
134 private:
135 template <size_t ...Indices>
136 result_type
137 execute(tuple_indices<Indices...>)
138 {
139 return detail::invoke<R>(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
140 }
141 };
142 //BOOST_THREAD_DCL_MOVABLE_BEG(X) invoker<Fp> BOOST_THREAD_DCL_MOVABLE_END
143#else
144
145#if ! defined BOOST_MSVC && defined(BOOST_THREAD_PROVIDES_INVOKE)
146
147#define BOOST_THREAD_RV_REF_ARG_T(z, n, unused) BOOST_PP_COMMA_IF(n) BOOST_THREAD_RV_REF(Arg##n)
148#define BOOST_THREAD_RV_REF_A_T(z, n, unused) BOOST_PP_COMMA_IF(n) BOOST_THREAD_RV_REF(A##n)
149#define BOOST_THREAD_RV_REF_ARG(z, n, unused) , BOOST_THREAD_RV_REF(Arg##n) arg##n
150#define BOOST_THREAD_FWD_REF_A(z, n, unused) , BOOST_THREAD_FWD_REF(A##n) arg##n
151#define BOOST_THREAD_FWD_REF_ARG(z, n, unused) , BOOST_THREAD_FWD_REF(Arg##n) arg##n
152#define BOOST_THREAD_FWD_PARAM(z, n, unused) , boost::forward<Arg##n>(arg##n)
153#define BOOST_THREAD_FWD_PARAM_A(z, n, unused) , boost::forward<A##n>(arg##n)
154#define BOOST_THREAD_DCL(z, n, unused) Arg##n v##n;
155#define BOOST_THREAD_MOVE_PARAM(z, n, unused) , v##n(boost::move(arg##n))
156#define BOOST_THREAD_FORWARD_PARAM_A(z, n, unused) , v##n(boost::forward<A##n>(arg##n))
157#define BOOST_THREAD_MOVE_RHS_PARAM(z, n, unused) , v##n(boost::move(x.v##n))
158#define BOOST_THREAD_MOVE_DCL(z, n, unused) , boost::move(v##n)
159#define BOOST_THREAD_MOVE_DCL_T(z, n, unused) BOOST_PP_COMMA_IF(n) boost::move(v##n)
160#define BOOST_THREAD_ARG_DEF(z, n, unused) , class Arg##n = tuples::null_type
161
162 template <class Fp, class Arg = tuples::null_type
163 BOOST_PP_REPEAT(BOOST_THREAD_MAX_ARGS, BOOST_THREAD_ARG_DEF, ~)
164 >
165 class invoker;
166
167#define BOOST_THREAD_ASYNC_FUNCT(z, n, unused) \
168 template <class Fp BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class Arg) > \
169 class invoker<Fp BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Arg)> \
170 { \
171 Fp fp_; \
172 BOOST_PP_REPEAT(n, BOOST_THREAD_DCL, ~) \
173 public: \
174 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker) \
175 typedef typename result_of<Fp(BOOST_PP_ENUM_PARAMS(n, Arg))>::type result_type; \
176 \
177 template <class F BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A) > \
178 BOOST_SYMBOL_VISIBLE \
179 explicit invoker(BOOST_THREAD_FWD_REF(F) f \
180 BOOST_PP_REPEAT(n, BOOST_THREAD_FWD_REF_A, ~) \
181 ) \
182 : fp_(boost::forward<F>(f)) \
183 BOOST_PP_REPEAT(n, BOOST_THREAD_FORWARD_PARAM_A, ~) \
184 {} \
185 \
186 BOOST_SYMBOL_VISIBLE \
187 invoker(BOOST_THREAD_RV_REF(invoker) x) \
188 : fp_(boost::move(x.fp_)) \
189 BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_RHS_PARAM, ~) \
190 {} \
191 \
192 result_type operator()() { \
193 return detail::invoke(boost::move(fp_) \
194 BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_DCL, ~) \
195 ); \
196 } \
197 }; \
198 \
199 template <class R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class Arg) > \
200 class invoker<R(*)(BOOST_PP_REPEAT(n, BOOST_THREAD_RV_REF_ARG_T, ~)) BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Arg)> \
201 { \
202 typedef R(*Fp)(BOOST_PP_REPEAT(n, BOOST_THREAD_RV_REF_ARG_T, ~)); \
203 Fp fp_; \
204 BOOST_PP_REPEAT(n, BOOST_THREAD_DCL, ~) \
205 public: \
206 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker) \
207 typedef typename result_of<Fp(BOOST_PP_ENUM_PARAMS(n, Arg))>::type result_type; \
208 \
209 template <class R2 BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A) > \
210 BOOST_SYMBOL_VISIBLE \
211 explicit invoker(R2(*f)(BOOST_PP_REPEAT(n, BOOST_THREAD_RV_REF_A_T, ~)) \
212 BOOST_PP_REPEAT(n, BOOST_THREAD_FWD_REF_A, ~) \
213 ) \
214 : fp_(f) \
215 BOOST_PP_REPEAT(n, BOOST_THREAD_FORWARD_PARAM_A, ~) \
216 {} \
217 \
218 BOOST_SYMBOL_VISIBLE \
219 invoker(BOOST_THREAD_RV_REF(invoker) x) \
220 : fp_(x.fp_) \
221 BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_RHS_PARAM, ~) \
222 {} \
223 \
224 result_type operator()() { \
225 return fp_( \
226 BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_DCL_T, ~) \
227 ); \
228 } \
229 };
230
231 BOOST_PP_REPEAT(BOOST_THREAD_MAX_ARGS, BOOST_THREAD_ASYNC_FUNCT, ~)
232
233 #undef BOOST_THREAD_RV_REF_ARG_T
234 #undef BOOST_THREAD_RV_REF_ARG
235 #undef BOOST_THREAD_FWD_REF_ARG
236 #undef BOOST_THREAD_FWD_REF_A
237 #undef BOOST_THREAD_FWD_PARAM
238 #undef BOOST_THREAD_FWD_PARAM_A
239 #undef BOOST_THREAD_DCL
240 #undef BOOST_THREAD_MOVE_PARAM
241 #undef BOOST_THREAD_MOVE_RHS_PARAM
242 #undef BOOST_THREAD_MOVE_DCL
243 #undef BOOST_THREAD_ARG_DEF
244 #undef BOOST_THREAD_ASYNC_FUNCT
245
246#else
247
248 template <class Fp,
249 class T0 = tuples::null_type, class T1 = tuples::null_type, class T2 = tuples::null_type,
250 class T3 = tuples::null_type, class T4 = tuples::null_type, class T5 = tuples::null_type,
251 class T6 = tuples::null_type, class T7 = tuples::null_type, class T8 = tuples::null_type
252 , class T9 = tuples::null_type
253 >
254 class invoker;
255
256 template <class Fp,
257 class T0 , class T1 , class T2 ,
258 class T3 , class T4 , class T5 ,
259 class T6 , class T7 , class T8 >
260 class invoker<Fp, T0, T1, T2, T3, T4, T5, T6, T7, T8>
261 {
262 Fp fp_;
263 T0 v0_;
264 T1 v1_;
265 T2 v2_;
266 T3 v3_;
267 T4 v4_;
268 T5 v5_;
269 T6 v6_;
270 T7 v7_;
271 T8 v8_;
272 //::boost::tuple<Fp, T0, T1, T2, T3, T4, T5, T6, T7, T8> f_;
273
274 public:
275 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
276 typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6, T7, T8)>::type result_type;
277
278 BOOST_SYMBOL_VISIBLE
279 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f
280 , BOOST_THREAD_RV_REF(T0) a0
281 , BOOST_THREAD_RV_REF(T1) a1
282 , BOOST_THREAD_RV_REF(T2) a2
283 , BOOST_THREAD_RV_REF(T3) a3
284 , BOOST_THREAD_RV_REF(T4) a4
285 , BOOST_THREAD_RV_REF(T5) a5
286 , BOOST_THREAD_RV_REF(T6) a6
287 , BOOST_THREAD_RV_REF(T7) a7
288 , BOOST_THREAD_RV_REF(T8) a8
289 )
290 : fp_(boost::move(f))
291 , v0_(boost::move(a0))
292 , v1_(boost::move(a1))
293 , v2_(boost::move(a2))
294 , v3_(boost::move(a3))
295 , v4_(boost::move(a4))
296 , v5_(boost::move(a5))
297 , v6_(boost::move(a6))
298 , v7_(boost::move(a7))
299 , v8_(boost::move(a8))
300 {}
301
302 BOOST_SYMBOL_VISIBLE
303 invoker(BOOST_THREAD_RV_REF(invoker) f)
304 : fp_(boost::move(BOOST_THREAD_RV(f).fp))
305 , v0_(boost::move(BOOST_THREAD_RV(f).v0_))
306 , v1_(boost::move(BOOST_THREAD_RV(f).v1_))
307 , v2_(boost::move(BOOST_THREAD_RV(f).v2_))
308 , v3_(boost::move(BOOST_THREAD_RV(f).v3_))
309 , v4_(boost::move(BOOST_THREAD_RV(f).v4_))
310 , v5_(boost::move(BOOST_THREAD_RV(f).v5_))
311 , v6_(boost::move(BOOST_THREAD_RV(f).v6_))
312 , v7_(boost::move(BOOST_THREAD_RV(f).v7_))
313 , v8_(boost::move(BOOST_THREAD_RV(f).v8_))
314 {}
315
316 result_type operator()()
317 {
318 return detail::invoke(boost::move(fp_)
319 , boost::move(v0_)
320 , boost::move(v1_)
321 , boost::move(v2_)
322 , boost::move(v3_)
323 , boost::move(v4_)
324 , boost::move(v5_)
325 , boost::move(v6_)
326 , boost::move(v7_)
327 , boost::move(v8_)
328 );
329 }
330 };
331 template <class Fp, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 >
332 class invoker<Fp, T0, T1, T2, T3, T4, T5, T6, T7>
333 {
334 Fp fp_;
335 T0 v0_;
336 T1 v1_;
337 T2 v2_;
338 T3 v3_;
339 T4 v4_;
340 T5 v5_;
341 T6 v6_;
342 T7 v7_;
343 public:
344 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
345 typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6, T7)>::type result_type;
346
347 BOOST_SYMBOL_VISIBLE
348 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f
349 , BOOST_THREAD_RV_REF(T0) a0
350 , BOOST_THREAD_RV_REF(T1) a1
351 , BOOST_THREAD_RV_REF(T2) a2
352 , BOOST_THREAD_RV_REF(T3) a3
353 , BOOST_THREAD_RV_REF(T4) a4
354 , BOOST_THREAD_RV_REF(T5) a5
355 , BOOST_THREAD_RV_REF(T6) a6
356 , BOOST_THREAD_RV_REF(T7) a7
357 )
358 : fp_(boost::move(f))
359 , v0_(boost::move(a0))
360 , v1_(boost::move(a1))
361 , v2_(boost::move(a2))
362 , v3_(boost::move(a3))
363 , v4_(boost::move(a4))
364 , v5_(boost::move(a5))
365 , v6_(boost::move(a6))
366 , v7_(boost::move(a7))
367 {}
368
369 BOOST_SYMBOL_VISIBLE
370 invoker(BOOST_THREAD_RV_REF(invoker) f)
371 : fp_(boost::move(BOOST_THREAD_RV(f).fp))
372 , v0_(boost::move(BOOST_THREAD_RV(f).v0_))
373 , v1_(boost::move(BOOST_THREAD_RV(f).v1_))
374 , v2_(boost::move(BOOST_THREAD_RV(f).v2_))
375 , v3_(boost::move(BOOST_THREAD_RV(f).v3_))
376 , v4_(boost::move(BOOST_THREAD_RV(f).v4_))
377 , v5_(boost::move(BOOST_THREAD_RV(f).v5_))
378 , v6_(boost::move(BOOST_THREAD_RV(f).v6_))
379 , v7_(boost::move(BOOST_THREAD_RV(f).v7_))
380 {}
381
382 result_type operator()()
383 {
384 return detail::invoke(boost::move(fp_)
385 , boost::move(v0_)
386 , boost::move(v1_)
387 , boost::move(v2_)
388 , boost::move(v3_)
389 , boost::move(v4_)
390 , boost::move(v5_)
391 , boost::move(v6_)
392 , boost::move(v7_)
393 );
394 }
395 };
396 template <class Fp, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
397 class invoker<Fp, T0, T1, T2, T3, T4, T5, T6>
398 {
399 Fp fp_;
400 T0 v0_;
401 T1 v1_;
402 T2 v2_;
403 T3 v3_;
404 T4 v4_;
405 T5 v5_;
406 T6 v6_;
407 public:
408 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
409 typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6)>::type result_type;
410
411 BOOST_SYMBOL_VISIBLE
412 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f
413 , BOOST_THREAD_RV_REF(T0) a0
414 , BOOST_THREAD_RV_REF(T1) a1
415 , BOOST_THREAD_RV_REF(T2) a2
416 , BOOST_THREAD_RV_REF(T3) a3
417 , BOOST_THREAD_RV_REF(T4) a4
418 , BOOST_THREAD_RV_REF(T5) a5
419 , BOOST_THREAD_RV_REF(T6) a6
420 )
421 : fp_(boost::move(f))
422 , v0_(boost::move(a0))
423 , v1_(boost::move(a1))
424 , v2_(boost::move(a2))
425 , v3_(boost::move(a3))
426 , v4_(boost::move(a4))
427 , v5_(boost::move(a5))
428 , v6_(boost::move(a6))
429 {}
430
431 BOOST_SYMBOL_VISIBLE
432 invoker(BOOST_THREAD_RV_REF(invoker) f)
433 : fp_(boost::move(BOOST_THREAD_RV(f).fp))
434 , v0_(boost::move(BOOST_THREAD_RV(f).v0_))
435 , v1_(boost::move(BOOST_THREAD_RV(f).v1_))
436 , v2_(boost::move(BOOST_THREAD_RV(f).v2_))
437 , v3_(boost::move(BOOST_THREAD_RV(f).v3_))
438 , v4_(boost::move(BOOST_THREAD_RV(f).v4_))
439 , v5_(boost::move(BOOST_THREAD_RV(f).v5_))
440 , v6_(boost::move(BOOST_THREAD_RV(f).v6_))
441 {}
442
443 result_type operator()()
444 {
445 return detail::invoke(boost::move(fp_)
446 , boost::move(v0_)
447 , boost::move(v1_)
448 , boost::move(v2_)
449 , boost::move(v3_)
450 , boost::move(v4_)
451 , boost::move(v5_)
452 , boost::move(v6_)
453 );
454 }
455 };
456 template <class Fp, class T0, class T1, class T2, class T3, class T4, class T5>
457 class invoker<Fp, T0, T1, T2, T3, T4, T5>
458 {
459 Fp fp_;
460 T0 v0_;
461 T1 v1_;
462 T2 v2_;
463 T3 v3_;
464 T4 v4_;
465 T5 v5_;
466 public:
467 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
468 typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5)>::type result_type;
469
470 BOOST_SYMBOL_VISIBLE
471 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f
472 , BOOST_THREAD_RV_REF(T0) a0
473 , BOOST_THREAD_RV_REF(T1) a1
474 , BOOST_THREAD_RV_REF(T2) a2
475 , BOOST_THREAD_RV_REF(T3) a3
476 , BOOST_THREAD_RV_REF(T4) a4
477 , BOOST_THREAD_RV_REF(T5) a5
478 )
479 : fp_(boost::move(f))
480 , v0_(boost::move(a0))
481 , v1_(boost::move(a1))
482 , v2_(boost::move(a2))
483 , v3_(boost::move(a3))
484 , v4_(boost::move(a4))
485 , v5_(boost::move(a5))
486 {}
487
488 BOOST_SYMBOL_VISIBLE
489 invoker(BOOST_THREAD_RV_REF(invoker) f)
490 : fp_(boost::move(BOOST_THREAD_RV(f).fp))
491 , v0_(boost::move(BOOST_THREAD_RV(f).v0_))
492 , v1_(boost::move(BOOST_THREAD_RV(f).v1_))
493 , v2_(boost::move(BOOST_THREAD_RV(f).v2_))
494 , v3_(boost::move(BOOST_THREAD_RV(f).v3_))
495 , v4_(boost::move(BOOST_THREAD_RV(f).v4_))
496 , v5_(boost::move(BOOST_THREAD_RV(f).v5_))
497 {}
498
499 result_type operator()()
500 {
501 return detail::invoke(boost::move(fp_)
502 , boost::move(v0_)
503 , boost::move(v1_)
504 , boost::move(v2_)
505 , boost::move(v3_)
506 , boost::move(v4_)
507 , boost::move(v5_)
508 );
509 }
510 };
511 template <class Fp, class T0, class T1, class T2, class T3, class T4>
512 class invoker<Fp, T0, T1, T2, T3, T4>
513 {
514 Fp fp_;
515 T0 v0_;
516 T1 v1_;
517 T2 v2_;
518 T3 v3_;
519 T4 v4_;
520 public:
521 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
522 typedef typename result_of<Fp(T0, T1, T2, T3, T4)>::type result_type;
523
524 BOOST_SYMBOL_VISIBLE
525 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f
526 , BOOST_THREAD_RV_REF(T0) a0
527 , BOOST_THREAD_RV_REF(T1) a1
528 , BOOST_THREAD_RV_REF(T2) a2
529 , BOOST_THREAD_RV_REF(T3) a3
530 , BOOST_THREAD_RV_REF(T4) a4
531 )
532 : fp_(boost::move(f))
533 , v0_(boost::move(a0))
534 , v1_(boost::move(a1))
535 , v2_(boost::move(a2))
536 , v3_(boost::move(a3))
537 , v4_(boost::move(a4))
538 {}
539
540 BOOST_SYMBOL_VISIBLE
541 invoker(BOOST_THREAD_RV_REF(invoker) f)
542 : fp_(boost::move(BOOST_THREAD_RV(f).fp))
543 , v0_(boost::move(BOOST_THREAD_RV(f).v0_))
544 , v1_(boost::move(BOOST_THREAD_RV(f).v1_))
545 , v2_(boost::move(BOOST_THREAD_RV(f).v2_))
546 , v3_(boost::move(BOOST_THREAD_RV(f).v3_))
547 , v4_(boost::move(BOOST_THREAD_RV(f).v4_))
548 {}
549
550 result_type operator()()
551 {
552 return detail::invoke(boost::move(fp_)
553 , boost::move(v0_)
554 , boost::move(v1_)
555 , boost::move(v2_)
556 , boost::move(v3_)
557 , boost::move(v4_)
558 );
559 }
560 };
561 template <class Fp, class T0, class T1, class T2, class T3>
562 class invoker<Fp, T0, T1, T2, T3>
563 {
564 Fp fp_;
565 T0 v0_;
566 T1 v1_;
567 T2 v2_;
568 T3 v3_;
569 public:
570 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
571 typedef typename result_of<Fp(T0, T1, T2, T3)>::type result_type;
572
573 BOOST_SYMBOL_VISIBLE
574 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f
575 , BOOST_THREAD_RV_REF(T0) a0
576 , BOOST_THREAD_RV_REF(T1) a1
577 , BOOST_THREAD_RV_REF(T2) a2
578 , BOOST_THREAD_RV_REF(T3) a3
579 )
580 : fp_(boost::move(f))
581 , v0_(boost::move(a0))
582 , v1_(boost::move(a1))
583 , v2_(boost::move(a2))
584 , v3_(boost::move(a3))
585 {}
586
587 BOOST_SYMBOL_VISIBLE
588 invoker(BOOST_THREAD_RV_REF(invoker) f)
589 : fp_(boost::move(BOOST_THREAD_RV(f).fp))
590 , v0_(boost::move(BOOST_THREAD_RV(f).v0_))
591 , v1_(boost::move(BOOST_THREAD_RV(f).v1_))
592 , v2_(boost::move(BOOST_THREAD_RV(f).v2_))
593 , v3_(boost::move(BOOST_THREAD_RV(f).v3_))
594 {}
595
596 result_type operator()()
597 {
598 return detail::invoke(boost::move(fp_)
599 , boost::move(v0_)
600 , boost::move(v1_)
601 , boost::move(v2_)
602 , boost::move(v3_)
603 );
604 }
605 };
606 template <class Fp, class T0, class T1, class T2>
607 class invoker<Fp, T0, T1, T2>
608 {
609 Fp fp_;
610 T0 v0_;
611 T1 v1_;
612 T2 v2_;
613 public:
614 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
615 typedef typename result_of<Fp(T0, T1, T2)>::type result_type;
616
617 BOOST_SYMBOL_VISIBLE
618 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f
619 , BOOST_THREAD_RV_REF(T0) a0
620 , BOOST_THREAD_RV_REF(T1) a1
621 , BOOST_THREAD_RV_REF(T2) a2
622 )
623 : fp_(boost::move(f))
624 , v0_(boost::move(a0))
625 , v1_(boost::move(a1))
626 , v2_(boost::move(a2))
627 {}
628
629 BOOST_SYMBOL_VISIBLE
630 invoker(BOOST_THREAD_RV_REF(invoker) f)
631 : fp_(boost::move(BOOST_THREAD_RV(f).fp))
632 , v0_(boost::move(BOOST_THREAD_RV(f).v0_))
633 , v1_(boost::move(BOOST_THREAD_RV(f).v1_))
634 , v2_(boost::move(BOOST_THREAD_RV(f).v2_))
635 {}
636
637 result_type operator()()
638 {
639 return detail::invoke(boost::move(fp_)
640 , boost::move(v0_)
641 , boost::move(v1_)
642 , boost::move(v2_)
643 );
644 }
645 };
646 template <class Fp, class T0, class T1>
647 class invoker<Fp, T0, T1>
648 {
649 Fp fp_;
650 T0 v0_;
651 T1 v1_;
652 public:
653 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
654 typedef typename result_of<Fp(T0, T1)>::type result_type;
655
656 BOOST_SYMBOL_VISIBLE
657 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f
658 , BOOST_THREAD_RV_REF(T0) a0
659 , BOOST_THREAD_RV_REF(T1) a1
660 )
661 : fp_(boost::move(f))
662 , v0_(boost::move(a0))
663 , v1_(boost::move(a1))
664 {}
665
666 BOOST_SYMBOL_VISIBLE
667 invoker(BOOST_THREAD_RV_REF(invoker) f)
668 : fp_(boost::move(BOOST_THREAD_RV(f).fp))
669 , v0_(boost::move(BOOST_THREAD_RV(f).v0_))
670 , v1_(boost::move(BOOST_THREAD_RV(f).v1_))
671 {}
672
673 result_type operator()()
674 {
675 return detail::invoke(boost::move(fp_)
676 , boost::move(v0_)
677 , boost::move(v1_)
678 );
679 }
680 };
681 template <class Fp, class T0>
682 class invoker<Fp, T0>
683 {
684 Fp fp_;
685 T0 v0_;
686 public:
687 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
688 typedef typename result_of<Fp(T0)>::type result_type;
689
690 BOOST_SYMBOL_VISIBLE
691 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f
692 , BOOST_THREAD_RV_REF(T0) a0
693 )
694 : fp_(boost::move(f))
695 , v0_(boost::move(a0))
696 {}
697
698 BOOST_SYMBOL_VISIBLE
699 invoker(BOOST_THREAD_RV_REF(invoker) f)
700 : fp_(boost::move(BOOST_THREAD_RV(f).fp))
701 , v0_(boost::move(BOOST_THREAD_RV(f).v0_))
702 {}
703
704 result_type operator()()
705 {
706 return detail::invoke(boost::move(fp_)
707 , boost::move(v0_)
708 );
709 }
710 };
711 template <class Fp>
712 class invoker<Fp>
713 {
714 Fp fp_;
715 public:
716 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
717 typedef typename result_of<Fp()>::type result_type;
718 BOOST_SYMBOL_VISIBLE
719 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f)
720 : fp_(boost::move(f))
721 {}
722
723 BOOST_SYMBOL_VISIBLE
724 invoker(BOOST_THREAD_RV_REF(invoker) f)
725 : fp_(boost::move(f.fp_))
726 {}
727 result_type operator()()
728 {
729 return fp_();
730 }
731 };
732 template <class R>
733 class invoker<R(*)()>
734 {
735 typedef R(*Fp)();
736 Fp fp_;
737 public:
738 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
739 typedef typename result_of<Fp()>::type result_type;
740 BOOST_SYMBOL_VISIBLE
741 explicit invoker(Fp f)
742 : fp_(f)
743 {}
744
745 BOOST_SYMBOL_VISIBLE
746 invoker(BOOST_THREAD_RV_REF(invoker) f)
747 : fp_(f.fp_)
748 {}
749 result_type operator()()
750 {
751 return fp_();
752 }
753 };
754#endif
755#endif
756
757 }
758}
759
760#include <boost/thread/detail/variadic_footer.hpp>
761
762#endif // header
763