1 // Copyright (C) 2012 Vicente J. Botet Escriba
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)
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
13 //===----------------------------------------------------------------------===//
15 // The LLVM Compiler Infrastructure
17 // This file is dual licensed under the MIT and the University of Illinois Open
18 // Source Licenses. See LICENSE.TXT for details.
20 // The invoker code is based on the one from libcxx.
21 //===----------------------------------------------------------------------===//
23 #ifndef BOOST_THREAD_DETAIL_INVOKER_HPP
24 #define BOOST_THREAD_DETAIL_INVOKER_HPP
26 #include <boost/config.hpp>
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>
35 #include <boost/thread/detail/variadic_header.hpp>
42 #if defined(BOOST_THREAD_PROVIDES_INVOKE) && ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ! defined(BOOST_NO_CXX11_HDR_TUPLE)
44 template <class Fp, class ... Args>
47 //typedef typename decay<Fp>::type Fpd;
48 //typedef tuple<typename decay<Args>::type...> Argsd;
50 //csbl::tuple<Fpd, Argsd...> f_;
51 csbl::tuple<Fp, Args...> f_;
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;
58 template <class F, class ... As>
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)...)
65 invoker(BOOST_THREAD_RV_REF(invoker) f) : f_(boost::move(BOOST_THREAD_RV(f).f_))
69 invoker( const invoker& f) : f_(f.f_)
73 invoker& operator=(BOOST_THREAD_RV_REF(invoker) f)
77 f_ = boost::move(BOOST_THREAD_RV(f).f_);
83 invoker& operator=( BOOST_THREAD_COPY_ASSIGN_REF(invoker) f)
92 result_type operator()()
94 typedef typename make_tuple_indices<1+sizeof...(Args), 1>::type Index;
95 return execute(Index());
98 template <size_t ...Indices>
100 execute(tuple_indices<Indices...>)
102 return detail::invoke(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
106 template <class R, class Fp, class ... Args>
109 //typedef typename decay<Fp>::type Fpd;
110 //typedef tuple<typename decay<Args>::type...> Argsd;
112 //csbl::tuple<Fpd, Argsd...> f_;
113 csbl::tuple<Fp, Args...> f_;
116 BOOST_THREAD_COPYABLE_AND_MOVABLE( invoker_ret)
117 typedef R result_type;
119 template <class F, class ... As>
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)...)
126 invoker_ret(BOOST_THREAD_RV_REF(invoker_ret) f) : f_(boost::move(BOOST_THREAD_RV(f).f_))
129 result_type operator()()
131 typedef typename make_tuple_indices<1+sizeof...(Args), 1>::type Index;
132 return execute(Index());
135 template <size_t ...Indices>
137 execute(tuple_indices<Indices...>)
139 return detail::invoke<R>(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...);
142 //BOOST_THREAD_DCL_MOVABLE_BEG(X) invoker<Fp> BOOST_THREAD_DCL_MOVABLE_END
145 #if ! defined BOOST_MSVC && defined(BOOST_THREAD_PROVIDES_INVOKE)
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
162 template <class Fp, class Arg = tuples::null_type
163 BOOST_PP_REPEAT(BOOST_THREAD_MAX_ARGS, BOOST_THREAD_ARG_DEF, ~)
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)> \
172 BOOST_PP_REPEAT(n, BOOST_THREAD_DCL, ~) \
174 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker) \
175 typedef typename result_of<Fp(BOOST_PP_ENUM_PARAMS(n, Arg))>::type result_type; \
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, ~) \
182 : fp_(boost::forward<F>(f)) \
183 BOOST_PP_REPEAT(n, BOOST_THREAD_FORWARD_PARAM_A, ~) \
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, ~) \
192 result_type operator()() { \
193 return detail::invoke(boost::move(fp_) \
194 BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_DCL, ~) \
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)> \
202 typedef R(*Fp)(BOOST_PP_REPEAT(n, BOOST_THREAD_RV_REF_ARG_T, ~)); \
204 BOOST_PP_REPEAT(n, BOOST_THREAD_DCL, ~) \
206 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker) \
207 typedef typename result_of<Fp(BOOST_PP_ENUM_PARAMS(n, Arg))>::type result_type; \
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, ~) \
215 BOOST_PP_REPEAT(n, BOOST_THREAD_FORWARD_PARAM_A, ~) \
218 BOOST_SYMBOL_VISIBLE \
219 invoker(BOOST_THREAD_RV_REF(invoker) x) \
221 BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_RHS_PARAM, ~) \
224 result_type operator()() { \
226 BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_DCL_T, ~) \
231 BOOST_PP_REPEAT(BOOST_THREAD_MAX_ARGS, BOOST_THREAD_ASYNC_FUNCT, ~)
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
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
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>
272 //::boost::tuple<Fp, T0, T1, T2, T3, T4, T5, T6, T7, T8> f_;
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;
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
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))
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_))
316 result_type operator()()
318 return detail::invoke(boost::move(fp_)
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>
344 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
345 typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6, T7)>::type result_type;
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
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))
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_))
382 result_type operator()()
384 return detail::invoke(boost::move(fp_)
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>
408 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
409 typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6)>::type result_type;
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
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))
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_))
443 result_type operator()()
445 return detail::invoke(boost::move(fp_)
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>
467 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
468 typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5)>::type result_type;
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
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))
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_))
499 result_type operator()()
501 return detail::invoke(boost::move(fp_)
511 template <class Fp, class T0, class T1, class T2, class T3, class T4>
512 class invoker<Fp, T0, T1, T2, T3, T4>
521 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
522 typedef typename result_of<Fp(T0, T1, T2, T3, T4)>::type result_type;
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
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))
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_))
550 result_type operator()()
552 return detail::invoke(boost::move(fp_)
561 template <class Fp, class T0, class T1, class T2, class T3>
562 class invoker<Fp, T0, T1, T2, T3>
570 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
571 typedef typename result_of<Fp(T0, T1, T2, T3)>::type result_type;
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
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))
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_))
596 result_type operator()()
598 return detail::invoke(boost::move(fp_)
606 template <class Fp, class T0, class T1, class T2>
607 class invoker<Fp, T0, T1, T2>
614 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
615 typedef typename result_of<Fp(T0, T1, T2)>::type result_type;
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
623 : fp_(boost::move(f))
624 , v0_(boost::move(a0))
625 , v1_(boost::move(a1))
626 , v2_(boost::move(a2))
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_))
637 result_type operator()()
639 return detail::invoke(boost::move(fp_)
646 template <class Fp, class T0, class T1>
647 class invoker<Fp, T0, T1>
653 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
654 typedef typename result_of<Fp(T0, T1)>::type result_type;
657 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f
658 , BOOST_THREAD_RV_REF(T0) a0
659 , BOOST_THREAD_RV_REF(T1) a1
661 : fp_(boost::move(f))
662 , v0_(boost::move(a0))
663 , v1_(boost::move(a1))
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_))
673 result_type operator()()
675 return detail::invoke(boost::move(fp_)
681 template <class Fp, class T0>
682 class invoker<Fp, T0>
687 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
688 typedef typename result_of<Fp(T0)>::type result_type;
691 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f
692 , BOOST_THREAD_RV_REF(T0) a0
694 : fp_(boost::move(f))
695 , v0_(boost::move(a0))
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_))
704 result_type operator()()
706 return detail::invoke(boost::move(fp_)
716 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
717 typedef typename result_of<Fp()>::type result_type;
719 explicit invoker(BOOST_THREAD_FWD_REF(Fp) f)
720 : fp_(boost::move(f))
724 invoker(BOOST_THREAD_RV_REF(invoker) f)
725 : fp_(boost::move(f.fp_))
727 result_type operator()()
733 class invoker<R(*)()>
738 BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker)
739 typedef typename result_of<Fp()>::type result_type;
741 explicit invoker(Fp f)
746 invoker(BOOST_THREAD_RV_REF(invoker) f)
749 result_type operator()()
760 #include <boost/thread/detail/variadic_footer.hpp>