ceph/src/boost/libs/thread/include/boost/thread/detail/invoker.hpp

   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
  37 namespace 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