[Boost-commit] svn:boost r84098 - trunk/boost/thread/detail

Subject: [Boost-commit] svn:boost r84098 - trunk/boost/thread/detail
From: vicente.botet_at_[hidden]
Date: 2013-05-01 05:19:19

Author: viboes
Date: 2013-05-01 05:19:18 EDT (Wed, 01 May 2013)
New Revision: 84098
URL: http://svn.boost.org/trac/boost/changeset/84098

Log:
Thread: replace boost:tuple in async_func.hpp as not movable until the patch is applied.
Text files modified: 
   trunk/boost/thread/detail/async_func.hpp |   943 +++++++++++++++++++-------------------- 
   1 files changed, 465 insertions(+), 478 deletions(-)

Modified: trunk/boost/thread/detail/async_func.hpp
==============================================================================
--- trunk/boost/thread/detail/async_func.hpp	(original)
+++ trunk/boost/thread/detail/async_func.hpp	2013-05-01 05:19:18 EDT (Wed, 01 May 2013)
@@ -30,7 +30,6 @@
 #include <boost/thread/detail/invoke.hpp>
 #include <boost/thread/detail/make_tuple_indices.hpp>
 
-
 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
     ! defined(BOOST_NO_CXX11_HDR_TUPLE)
 #include <tuple>
@@ -46,537 +45,525 @@
 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
     ! defined(BOOST_NO_CXX11_HDR_TUPLE)
 
-    template <class Fp, class... Args>
+    template <class Fp, class ... Args>
     class async_func
     {
-        std::tuple<Fp, Args...> f_;
+      std::tuple<Fp, Args...> f_;
 
     public:
-        BOOST_THREAD_MOVABLE_ONLY(async_func)
-        //typedef typename invoke_of<_Fp, _Args...>::type Rp;
-        typedef typename result_of<Fp(Args...)>::type result_type;
-
-        BOOST_SYMBOL_VISIBLE
-        explicit async_func(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args)... args)
-            : f_(boost::move(f), boost::move(args)...) {}
-
-        BOOST_SYMBOL_VISIBLE
-        async_func(BOOST_THREAD_RV_REF(async_func) f) : f_(boost::move(f.f_)) {}
-
-        result_type operator()()
-        {
-            typedef typename make_tuple_indices<1+sizeof...(Args), 1>::type Index;
-            return execute(Index());
-        }
-    private:
-        template <size_t ...Indices>
-        result_type
-        execute(tuple_indices<Indices...>)
-        {
-            return invoke(boost::move(std::get<0>(f_)), boost::move(std::get<Indices>(f_))...);
-        }
+      BOOST_THREAD_MOVABLE_ONLY( async_func)
+      //typedef typename invoke_of<_Fp, _Args...>::type Rp;
+      typedef typename result_of<Fp(Args...)>::type result_type;
+
+      BOOST_SYMBOL_VISIBLE
+      explicit async_func(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args)... args)
+      : f_(boost::move(f), boost::move(args)...)
+      {}
+
+      BOOST_SYMBOL_VISIBLE
+      async_func(BOOST_THREAD_RV_REF(async_func) f) : f_(boost::move(f.f_))
+      {}
+
+      result_type operator()()
+      {
+        typedef typename make_tuple_indices<1+sizeof...(Args), 1>::type Index;
+        return execute(Index());
+      }
+    private:
+      template <size_t ...Indices>
+      result_type
+      execute(tuple_indices<Indices...>)
+      {
+        return invoke(boost::move(std::get<0>(f_)), boost::move(std::get<Indices>(f_))...);
+      }
     };
     //BOOST_THREAD_DCL_MOVABLE_BEG(X) async_func<Fp> BOOST_THREAD_DCL_MOVABLE_END
 #else
     template <class Fp,
-      class T0 = tuples::null_type, class T1 = tuples::null_type, class T2 = tuples::null_type,
-      class T3 = tuples::null_type, class T4 = tuples::null_type, class T5 = tuples::null_type,
-      class T6 = tuples::null_type, class T7 = tuples::null_type, class T8 = tuples::null_type
-      ,  class T9 = tuples::null_type>
+    class T0 = tuples::null_type, class T1 = tuples::null_type, class T2 = tuples::null_type,
+    class T3 = tuples::null_type, class T4 = tuples::null_type, class T5 = tuples::null_type,
+    class T6 = tuples::null_type, class T7 = tuples::null_type, class T8 = tuples::null_type
+    , class T9 = tuples::null_type
+    >
     class async_func;
 
     template <class Fp,
-      class T0 , class T1 , class T2 ,
-      class T3 , class T4 , class T5 ,
-      class T6 , class T7 , class T8 >
+    class T0 , class T1 , class T2 ,
+    class T3 , class T4 , class T5 ,
+    class T6 , class T7 , class T8 >
     class async_func<Fp, T0, T1, T2, T3, T4, T5, T6, T7, T8>
     {
-        ::boost::tuple<Fp, T0, T1, T2, T3, T4, T5, T6, T7, T8> f_;
-
-    public:
-        BOOST_THREAD_MOVABLE_ONLY(async_func)
-        typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6, T7, T8)>::type result_type;
-
-        BOOST_SYMBOL_VISIBLE
-        explicit async_func(BOOST_THREAD_RV_REF(Fp) f
-            , BOOST_THREAD_RV_REF(T0) a0
-            , BOOST_THREAD_RV_REF(T1) a1
-            , BOOST_THREAD_RV_REF(T2) a2
-            , BOOST_THREAD_RV_REF(T3) a3
-            , BOOST_THREAD_RV_REF(T4) a4
-            , BOOST_THREAD_RV_REF(T5) a5
-            , BOOST_THREAD_RV_REF(T6) a6
-            , BOOST_THREAD_RV_REF(T7) a7
-            , BOOST_THREAD_RV_REF(T8) a8
-            )
-            : f_(boost::move(f)
-        , boost::move(a0)
-        , boost::move(a1)
-        , boost::move(a2)
-        , boost::move(a3)
-        , boost::move(a4)
-        , boost::move(a5)
-        , boost::move(a6)
-        , boost::move(a7)
-        , boost::move(a8)
-        ) {}
-
-        BOOST_SYMBOL_VISIBLE
-        async_func(BOOST_THREAD_RV_REF(async_func) f) : f_(boost::move(f.f_)) {}
-
-        result_type operator()()
-        {
-            typedef typename make_tuple_indices<10, 1>::type Index;
-            return execute(Index());
-        }
-    private:
-        template <
-        std::size_t I0, std::size_t I1, std::size_t I2,
-        std::size_t I3, std::size_t I4, std::size_t I5,
-        std::size_t I6, std::size_t I7, std::size_t I8
-        >
-        result_type
-        execute(tuple_indices<I0, I1, I2, I3, I4, I5, I6, I7, I8>)
-        {
-            return invoke(boost::move(boost::get<0>(f_))
-            , boost::move(boost::get<I0>(f_))
-            , boost::move(boost::get<I1>(f_))
-            , boost::move(boost::get<I2>(f_))
-            , boost::move(boost::get<I3>(f_))
-            , boost::move(boost::get<I4>(f_))
-            , boost::move(boost::get<I5>(f_))
-            , boost::move(boost::get<I6>(f_))
-            , boost::move(boost::get<I7>(f_))
-            , boost::move(boost::get<I8>(f_))
-                );
-        }
+      Fp fp_;
+      T0 v0_;
+      T1 v1_;
+      T2 v2_;
+      T3 v3_;
+      T4 v4_;
+      T5 v5_;
+      T6 v6_;
+      T7 v7_;
+      T8 v8_;
+      //::boost::tuple<Fp, T0, T1, T2, T3, T4, T5, T6, T7, T8> f_;
+
+    public:
+      BOOST_THREAD_MOVABLE_ONLY(async_func)
+      typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6, T7, T8)>::type result_type;
+
+      BOOST_SYMBOL_VISIBLE
+      explicit async_func(BOOST_THREAD_RV_REF(Fp) f
+          , BOOST_THREAD_RV_REF(T0) a0
+          , BOOST_THREAD_RV_REF(T1) a1
+          , BOOST_THREAD_RV_REF(T2) a2
+          , BOOST_THREAD_RV_REF(T3) a3
+          , BOOST_THREAD_RV_REF(T4) a4
+          , BOOST_THREAD_RV_REF(T5) a5
+          , BOOST_THREAD_RV_REF(T6) a6
+          , BOOST_THREAD_RV_REF(T7) a7
+          , BOOST_THREAD_RV_REF(T8) a8
+      )
+      : fp_(boost::move(f))
+      , v0_(boost::move(a0))
+      , v1_(boost::move(a1))
+      , v2_(boost::move(a2))
+      , v3_(boost::move(a3))
+      , v4_(boost::move(a4))
+      , v5_(boost::move(a5))
+      , v6_(boost::move(a6))
+      , v7_(boost::move(a7))
+      , v8_(boost::move(a8))
+      {}
+
+      BOOST_SYMBOL_VISIBLE
+      async_func(BOOST_THREAD_RV_REF(async_func) f)
+      : fp_(boost::move(f.fp))
+      , v0_(boost::move(f.a0))
+      , v1_(boost::move(f.a1))
+      , v2_(boost::move(f.a2))
+      , v3_(boost::move(f.a3))
+      , v4_(boost::move(f.a4))
+      , v5_(boost::move(f.a5))
+      , v6_(boost::move(f.a6))
+      , v7_(boost::move(f.a7))
+      , v8_(boost::move(f.a8))
+      {}
+
+      result_type operator()()
+      {
+        return invoke(boost::move(fp_)
+            , boost::move(v0_)
+            , boost::move(v1_)
+            , boost::move(v2_)
+            , boost::move(v3_)
+            , boost::move(v4_)
+            , boost::move(v5_)
+            , boost::move(v6_)
+            , boost::move(v7_)
+            , boost::move(v8_)
+        );
+      }
     };
     template <class Fp, class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7 >
     class async_func<Fp, T0, T1, T2, T3, T4, T5, T6, T7>
     {
-        ::boost::tuple<Fp, T0, T1, T2, T3, T4, T5, T6, T7> f_;
-    public:
-        BOOST_THREAD_MOVABLE_ONLY(async_func)
-        typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6, T7)>::type result_type;
-
-        BOOST_SYMBOL_VISIBLE
-        explicit async_func(BOOST_THREAD_RV_REF(Fp) f
-            , BOOST_THREAD_RV_REF(T0) a0
-            , BOOST_THREAD_RV_REF(T1) a1
-            , BOOST_THREAD_RV_REF(T2) a2
-            , BOOST_THREAD_RV_REF(T3) a3
-            , BOOST_THREAD_RV_REF(T4) a4
-            , BOOST_THREAD_RV_REF(T5) a5
-            , BOOST_THREAD_RV_REF(T6) a6
-            , BOOST_THREAD_RV_REF(T7) a7
-            )
-            : f_(boost::move(f)
-        , boost::move(a0)
-        , boost::move(a1)
-        , boost::move(a2)
-        , boost::move(a3)
-        , boost::move(a4)
-        , boost::move(a5)
-        , boost::move(a6)
-        , boost::move(a7)
-        ) {}
-
-        BOOST_SYMBOL_VISIBLE
-        async_func(BOOST_THREAD_RV_REF(async_func) f) : f_(boost::move(f.f_)) {}
-
-        result_type operator()()
-        {
-            typedef typename make_tuple_indices<9, 1>::type Index;
-            return execute(Index());
-        }
-    private:
-        template <
-        std::size_t I0, std::size_t I1, std::size_t I2,
-        std::size_t I3, std::size_t I4, std::size_t I5,
-        std::size_t I6, std::size_t I7
-        >
-        result_type
-        execute(tuple_indices<I0, I1, I2, I3, I4, I5, I6, I7>)
-        {
-            return invoke(boost::move(boost::get<0>(f_))
-            , boost::move(boost::get<I0>(f_))
-            , boost::move(boost::get<I1>(f_))
-            , boost::move(boost::get<I2>(f_))
-            , boost::move(boost::get<I3>(f_))
-            , boost::move(boost::get<I4>(f_))
-            , boost::move(boost::get<I5>(f_))
-            , boost::move(boost::get<I6>(f_))
-            , boost::move(boost::get<I7>(f_))
-                );
-        }
+      Fp fp_;
+      T0 v0_;
+      T1 v1_;
+      T2 v2_;
+      T3 v3_;
+      T4 v4_;
+      T5 v5_;
+      T6 v6_;
+      T7 v7_;
+    public:
+      BOOST_THREAD_MOVABLE_ONLY(async_func)
+      typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6, T7)>::type result_type;
+
+      BOOST_SYMBOL_VISIBLE
+      explicit async_func(BOOST_THREAD_RV_REF(Fp) f
+          , BOOST_THREAD_RV_REF(T0) a0
+          , BOOST_THREAD_RV_REF(T1) a1
+          , BOOST_THREAD_RV_REF(T2) a2
+          , BOOST_THREAD_RV_REF(T3) a3
+          , BOOST_THREAD_RV_REF(T4) a4
+          , BOOST_THREAD_RV_REF(T5) a5
+          , BOOST_THREAD_RV_REF(T6) a6
+          , BOOST_THREAD_RV_REF(T7) a7
+      )
+      : fp_(boost::move(f))
+      , v0_(boost::move(a0))
+      , v1_(boost::move(a1))
+      , v2_(boost::move(a2))
+      , v3_(boost::move(a3))
+      , v4_(boost::move(a4))
+      , v5_(boost::move(a5))
+      , v6_(boost::move(a6))
+      , v7_(boost::move(a7))
+      {}
+
+      BOOST_SYMBOL_VISIBLE
+      async_func(BOOST_THREAD_RV_REF(async_func) f)
+      : fp_(boost::move(f.fp))
+      , v0_(boost::move(f.a0))
+      , v1_(boost::move(f.a1))
+      , v2_(boost::move(f.a2))
+      , v3_(boost::move(f.a3))
+      , v4_(boost::move(f.a4))
+      , v5_(boost::move(f.a5))
+      , v6_(boost::move(f.a6))
+      , v7_(boost::move(f.a7))
+      {}
+
+      result_type operator()()
+      {
+        return invoke(boost::move(fp_)
+            , boost::move(v0_)
+            , boost::move(v1_)
+            , boost::move(v2_)
+            , boost::move(v3_)
+            , boost::move(v4_)
+            , boost::move(v5_)
+            , boost::move(v6_)
+            , boost::move(v7_)
+        );
+      }
     };
     template <class Fp, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
     class async_func<Fp, T0, T1, T2, T3, T4, T5, T6>
     {
-        ::boost::tuple<Fp, T0, T1, T2, T3, T4, T5, T6> f_;
-    public:
-        BOOST_THREAD_MOVABLE_ONLY(async_func)
-        typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6)>::type result_type;
-
-        BOOST_SYMBOL_VISIBLE
-        explicit async_func(BOOST_THREAD_RV_REF(Fp) f
-            , BOOST_THREAD_RV_REF(T0) a0
-            , BOOST_THREAD_RV_REF(T1) a1
-            , BOOST_THREAD_RV_REF(T2) a2
-            , BOOST_THREAD_RV_REF(T3) a3
-            , BOOST_THREAD_RV_REF(T4) a4
-            , BOOST_THREAD_RV_REF(T5) a5
-            , BOOST_THREAD_RV_REF(T6) a6
-            )
-            : f_(boost::move(f)
-        , boost::move(a0)
-        , boost::move(a1)
-        , boost::move(a2)
-        , boost::move(a3)
-        , boost::move(a4)
-        , boost::move(a5)
-        , boost::move(a6)
-        ) {}
-
-        BOOST_SYMBOL_VISIBLE
-        async_func(BOOST_THREAD_RV_REF(async_func) f) : f_(boost::move(f.f_)) {}
-
-        result_type operator()()
-        {
-            typedef typename make_tuple_indices<8, 1>::type Index;
-            return execute(Index());
-        }
-    private:
-        template <
-        std::size_t I0, std::size_t I1, std::size_t I2, std::size_t I3, std::size_t I4, std::size_t I5, std::size_t I6
-        >
-        result_type
-        execute(tuple_indices<I0, I1, I2, I3, I4, I5, I6>)
-        {
-            return invoke(boost::move(boost::get<0>(f_))
-            , boost::move(boost::get<I0>(f_))
-            , boost::move(boost::get<I1>(f_))
-            , boost::move(boost::get<I2>(f_))
-            , boost::move(boost::get<I3>(f_))
-            , boost::move(boost::get<I4>(f_))
-            , boost::move(boost::get<I5>(f_))
-            , boost::move(boost::get<I6>(f_))
-                );
-        }
+      Fp fp_;
+      T0 v0_;
+      T1 v1_;
+      T2 v2_;
+      T3 v3_;
+      T4 v4_;
+      T5 v5_;
+      T6 v6_;
+    public:
+      BOOST_THREAD_MOVABLE_ONLY(async_func)
+      typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6)>::type result_type;
+
+      BOOST_SYMBOL_VISIBLE
+      explicit async_func(BOOST_THREAD_RV_REF(Fp) f
+          , BOOST_THREAD_RV_REF(T0) a0
+          , BOOST_THREAD_RV_REF(T1) a1
+          , BOOST_THREAD_RV_REF(T2) a2
+          , BOOST_THREAD_RV_REF(T3) a3
+          , BOOST_THREAD_RV_REF(T4) a4
+          , BOOST_THREAD_RV_REF(T5) a5
+          , BOOST_THREAD_RV_REF(T6) a6
+      )
+      : fp_(boost::move(f))
+      , v0_(boost::move(a0))
+      , v1_(boost::move(a1))
+      , v2_(boost::move(a2))
+      , v3_(boost::move(a3))
+      , v4_(boost::move(a4))
+      , v5_(boost::move(a5))
+      , v6_(boost::move(a6))
+      {}
+
+      BOOST_SYMBOL_VISIBLE
+      async_func(BOOST_THREAD_RV_REF(async_func) f)
+      : fp_(boost::move(f.fp))
+      , v0_(boost::move(f.a0))
+      , v1_(boost::move(f.a1))
+      , v2_(boost::move(f.a2))
+      , v3_(boost::move(f.a3))
+      , v4_(boost::move(f.a4))
+      , v5_(boost::move(f.a5))
+      , v6_(boost::move(f.a6))
+      {}
+
+      result_type operator()()
+      {
+        return invoke(boost::move(fp_)
+            , boost::move(v0_)
+            , boost::move(v1_)
+            , boost::move(v2_)
+            , boost::move(v3_)
+            , boost::move(v4_)
+            , boost::move(v5_)
+            , boost::move(v6_)
+        );
+      }
     };
     template <class Fp, class T0, class T1, class T2, class T3, class T4, class T5>
     class async_func<Fp, T0, T1, T2, T3, T4, T5>
     {
-        ::boost::tuple<Fp, T0, T1, T2, T3, T4, T5> f_;
-    public:
-        BOOST_THREAD_MOVABLE_ONLY(async_func)
-        typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5)>::type result_type;
-
-        BOOST_SYMBOL_VISIBLE
-        explicit async_func(BOOST_THREAD_RV_REF(Fp) f
-            , BOOST_THREAD_RV_REF(T0) a0
-            , BOOST_THREAD_RV_REF(T1) a1
-            , BOOST_THREAD_RV_REF(T2) a2
-            , BOOST_THREAD_RV_REF(T3) a3
-            , BOOST_THREAD_RV_REF(T4) a4
-            , BOOST_THREAD_RV_REF(T5) a5
-            )
-            : f_(boost::move(f)
-        , boost::move(a0)
-        , boost::move(a1)
-        , boost::move(a2)
-        , boost::move(a3)
-        , boost::move(a4)
-        , boost::move(a5)
-        ) {}
-
-        BOOST_SYMBOL_VISIBLE
-        async_func(BOOST_THREAD_RV_REF(async_func) f) : f_(boost::move(f.f_)) {}
-
-        result_type operator()()
-        {
-            typedef typename make_tuple_indices<7, 1>::type Index;
-            return execute(Index());
-        }
-    private:
-        template <
-        std::size_t I0, std::size_t I1, std::size_t I2, std::size_t I3, std::size_t I4, std::size_t I5
-        >
-        result_type
-        execute(tuple_indices<I0, I1, I2, I3, I4, I5>)
-        {
-            return invoke(boost::move(boost::get<0>(f_))
-            , boost::move(boost::get<I0>(f_))
-            , boost::move(boost::get<I1>(f_))
-            , boost::move(boost::get<I2>(f_))
-            , boost::move(boost::get<I3>(f_))
-            , boost::move(boost::get<I4>(f_))
-            , boost::move(boost::get<I5>(f_))
-                );
-        }
+      Fp fp_;
+      T0 v0_;
+      T1 v1_;
+      T2 v2_;
+      T3 v3_;
+      T4 v4_;
+      T5 v5_;
+    public:
+      BOOST_THREAD_MOVABLE_ONLY(async_func)
+      typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5)>::type result_type;
+
+      BOOST_SYMBOL_VISIBLE
+      explicit async_func(BOOST_THREAD_RV_REF(Fp) f
+          , BOOST_THREAD_RV_REF(T0) a0
+          , BOOST_THREAD_RV_REF(T1) a1
+          , BOOST_THREAD_RV_REF(T2) a2
+          , BOOST_THREAD_RV_REF(T3) a3
+          , BOOST_THREAD_RV_REF(T4) a4
+          , BOOST_THREAD_RV_REF(T5) a5
+      )
+      : fp_(boost::move(f))
+      , v0_(boost::move(a0))
+      , v1_(boost::move(a1))
+      , v2_(boost::move(a2))
+      , v3_(boost::move(a3))
+      , v4_(boost::move(a4))
+      , v5_(boost::move(a5))
+      {}
+
+      BOOST_SYMBOL_VISIBLE
+      async_func(BOOST_THREAD_RV_REF(async_func) f)
+      : fp_(boost::move(f.fp))
+      , v0_(boost::move(f.a0))
+      , v1_(boost::move(f.a1))
+      , v2_(boost::move(f.a2))
+      , v3_(boost::move(f.a3))
+      , v4_(boost::move(f.a4))
+      , v5_(boost::move(f.a5))
+      {}
+
+      result_type operator()()
+      {
+        return invoke(boost::move(fp_)
+            , boost::move(v0_)
+            , boost::move(v1_)
+            , boost::move(v2_)
+            , boost::move(v3_)
+            , boost::move(v4_)
+            , boost::move(v5_)
+        );
+      }
     };
     template <class Fp, class T0, class T1, class T2, class T3, class T4>
     class async_func<Fp, T0, T1, T2, T3, T4>
     {
-        ::boost::tuple<Fp, T0, T1, T2, T3, T4> f_;
-    public:
-        BOOST_THREAD_MOVABLE_ONLY(async_func)
-        typedef typename result_of<Fp(T0, T1, T2, T3, T4)>::type result_type;
-
-        BOOST_SYMBOL_VISIBLE
-        explicit async_func(BOOST_THREAD_RV_REF(Fp) f
-            , BOOST_THREAD_RV_REF(T0) a0
-            , BOOST_THREAD_RV_REF(T1) a1
-            , BOOST_THREAD_RV_REF(T2) a2
-            , BOOST_THREAD_RV_REF(T3) a3
-            , BOOST_THREAD_RV_REF(T4) a4
-            )
-            : f_(boost::move(f)
-        , boost::move(a0)
-        , boost::move(a1)
-        , boost::move(a2)
-        , boost::move(a3)
-        , boost::move(a4)
-        ) {}
-
-        BOOST_SYMBOL_VISIBLE
-        async_func(BOOST_THREAD_RV_REF(async_func) f) : f_(boost::move(f.f_)) {}
-
-        result_type operator()()
-        {
-            typedef typename make_tuple_indices<6, 1>::type Index;
-            return execute(Index());
-        }
-    private:
-        template <
-        std::size_t I0, std::size_t I1, std::size_t I2, std::size_t I3, std::size_t I4
-        >
-        result_type
-        execute(tuple_indices<I0, I1, I2, I3, I4>)
-        {
-            return invoke(boost::move(boost::get<0>(f_))
-            , boost::move(boost::get<I0>(f_))
-            , boost::move(boost::get<I1>(f_))
-            , boost::move(boost::get<I2>(f_))
-            , boost::move(boost::get<I3>(f_))
-            , boost::move(boost::get<I4>(f_))
-                );
-        }
+      Fp fp_;
+      T0 v0_;
+      T1 v1_;
+      T2 v2_;
+      T3 v3_;
+      T4 v4_;
+    public:
+      BOOST_THREAD_MOVABLE_ONLY(async_func)
+      typedef typename result_of<Fp(T0, T1, T2, T3, T4)>::type result_type;
+
+      BOOST_SYMBOL_VISIBLE
+      explicit async_func(BOOST_THREAD_RV_REF(Fp) f
+          , BOOST_THREAD_RV_REF(T0) a0
+          , BOOST_THREAD_RV_REF(T1) a1
+          , BOOST_THREAD_RV_REF(T2) a2
+          , BOOST_THREAD_RV_REF(T3) a3
+          , BOOST_THREAD_RV_REF(T4) a4
+      )
+      : fp_(boost::move(f))
+      , v0_(boost::move(a0))
+      , v1_(boost::move(a1))
+      , v2_(boost::move(a2))
+      , v3_(boost::move(a3))
+      , v4_(boost::move(a4))
+      {}
+
+      BOOST_SYMBOL_VISIBLE
+      async_func(BOOST_THREAD_RV_REF(async_func) f)
+      : fp_(boost::move(f.fp))
+      , v0_(boost::move(f.a0))
+      , v1_(boost::move(f.a1))
+      , v2_(boost::move(f.a2))
+      , v3_(boost::move(f.a3))
+      , v4_(boost::move(f.a4))
+      {}
+
+      result_type operator()()
+      {
+        return invoke(boost::move(fp_)
+            , boost::move(v0_)
+            , boost::move(v1_)
+            , boost::move(v2_)
+            , boost::move(v3_)
+            , boost::move(v4_)
+        );
+      }
     };
     template <class Fp, class T0, class T1, class T2, class T3>
     class async_func<Fp, T0, T1, T2, T3>
     {
-        ::boost::tuple<Fp, T0, T1, T2, T3> f_;
-    public:
-        BOOST_THREAD_MOVABLE_ONLY(async_func)
-        typedef typename result_of<Fp(T0, T1, T2, T3)>::type result_type;
-
-        BOOST_SYMBOL_VISIBLE
-        explicit async_func(BOOST_THREAD_RV_REF(Fp) f
-            , BOOST_THREAD_RV_REF(T0) a0
-            , BOOST_THREAD_RV_REF(T1) a1
-            , BOOST_THREAD_RV_REF(T2) a2
-            , BOOST_THREAD_RV_REF(T3) a3
-            )
-            : f_(boost::move(f)
-        , boost::move(a0)
-        , boost::move(a1)
-        , boost::move(a2)
-        , boost::move(a3)
-        ) {}
-
-        BOOST_SYMBOL_VISIBLE
-        async_func(BOOST_THREAD_RV_REF(async_func) f) : f_(boost::move(f.f_)) {}
-
-        result_type operator()()
-        {
-            typedef typename make_tuple_indices<5, 1>::type Index;
-            return execute(Index());
-        }
-    private:
-        template <
-        std::size_t I0, std::size_t I1, std::size_t I2, std::size_t I3
-        >
-        result_type
-        execute(tuple_indices<I0, I1, I2, I3>)
-        {
-            return invoke(boost::move(boost::get<0>(f_))
-            , boost::move(boost::get<I0>(f_))
-            , boost::move(boost::get<I1>(f_))
-            , boost::move(boost::get<I2>(f_))
-            , boost::move(boost::get<I3>(f_))
-                );
-        }
+      Fp fp_;
+      T0 v0_;
+      T1 v1_;
+      T2 v2_;
+      T3 v3_;
+    public:
+      BOOST_THREAD_MOVABLE_ONLY(async_func)
+      typedef typename result_of<Fp(T0, T1, T2, T3)>::type result_type;
+
+      BOOST_SYMBOL_VISIBLE
+      explicit async_func(BOOST_THREAD_RV_REF(Fp) f
+          , BOOST_THREAD_RV_REF(T0) a0
+          , BOOST_THREAD_RV_REF(T1) a1
+          , BOOST_THREAD_RV_REF(T2) a2
+          , BOOST_THREAD_RV_REF(T3) a3
+      )
+      : fp_(boost::move(f))
+      , v0_(boost::move(a0))
+      , v1_(boost::move(a1))
+      , v2_(boost::move(a2))
+      , v3_(boost::move(a3))
+      {}
+
+      BOOST_SYMBOL_VISIBLE
+      async_func(BOOST_THREAD_RV_REF(async_func) f)
+      : fp_(boost::move(f.fp))
+      , v0_(boost::move(f.a0))
+      , v1_(boost::move(f.a1))
+      , v2_(boost::move(f.a2))
+      , v3_(boost::move(f.a3))
+      {}
+
+      result_type operator()()
+      {
+        return invoke(boost::move(fp_)
+            , boost::move(v0_)
+            , boost::move(v1_)
+            , boost::move(v2_)
+            , boost::move(v3_)
+        );
+      }
     };
     template <class Fp, class T0, class T1, class T2>
     class async_func<Fp, T0, T1, T2>
     {
-        ::boost::tuple<Fp, T0, T1, T2> f_;
-    public:
-        BOOST_THREAD_MOVABLE_ONLY(async_func)
-        typedef typename result_of<Fp(T0, T1, T2)>::type result_type;
-
-        BOOST_SYMBOL_VISIBLE
-        explicit async_func(BOOST_THREAD_RV_REF(Fp) f
-            , BOOST_THREAD_RV_REF(T0) a0
-            , BOOST_THREAD_RV_REF(T1) a1
-            , BOOST_THREAD_RV_REF(T2) a2
-            )
-            : f_(boost::move(f)
-        , boost::move(a0)
-        , boost::move(a1)
-        , boost::move(a2)
-        ) {}
-
-        BOOST_SYMBOL_VISIBLE
-        async_func(BOOST_THREAD_RV_REF(async_func) f) : f_(boost::move(f.f_)) {}
-
-        result_type operator()()
-        {
-            typedef typename make_tuple_indices<4, 1>::type Index;
-            return execute(Index());
-        }
-    private:
-        template <
-        std::size_t I0, std::size_t I1, std::size_t I2
-        >
-        result_type
-        execute(tuple_indices<I0, I1, I2>)
-        {
-            return invoke(boost::move(boost::get<0>(f_))
-            , boost::move(boost::get<I0>(f_))
-            , boost::move(boost::get<I1>(f_))
-            , boost::move(boost::get<I2>(f_))
-                );
-        }
+      Fp fp_;
+      T0 v0_;
+      T1 v1_;
+      T2 v2_;
+    public:
+      BOOST_THREAD_MOVABLE_ONLY(async_func)
+      typedef typename result_of<Fp(T0, T1, T2)>::type result_type;
+
+      BOOST_SYMBOL_VISIBLE
+      explicit async_func(BOOST_THREAD_RV_REF(Fp) f
+          , BOOST_THREAD_RV_REF(T0) a0
+          , BOOST_THREAD_RV_REF(T1) a1
+          , BOOST_THREAD_RV_REF(T2) a2
+      )
+      : fp_(boost::move(f))
+      , v0_(boost::move(a0))
+      , v1_(boost::move(a1))
+      , v2_(boost::move(a2))
+      {}
+
+      BOOST_SYMBOL_VISIBLE
+      async_func(BOOST_THREAD_RV_REF(async_func) f)
+      : fp_(boost::move(f.fp))
+      , v0_(boost::move(f.a0))
+      , v1_(boost::move(f.a1))
+      , v2_(boost::move(f.a2))
+      {}
+
+      result_type operator()()
+      {
+        return invoke(boost::move(fp_)
+            , boost::move(v0_)
+            , boost::move(v1_)
+            , boost::move(v2_)
+        );
+      }
     };
     template <class Fp, class T0, class T1>
     class async_func<Fp, T0, T1>
     {
-        ::boost::tuple<Fp, T0, T1> f_;
-    public:
-        BOOST_THREAD_MOVABLE_ONLY(async_func)
-        typedef typename result_of<Fp(T0, T1)>::type result_type;
-
-        BOOST_SYMBOL_VISIBLE
-        explicit async_func(BOOST_THREAD_RV_REF(Fp) f
-            , BOOST_THREAD_RV_REF(T0) a0
-            , BOOST_THREAD_RV_REF(T1) a1
-            )
-            : f_(boost::move(f)
-        , boost::move(a0)
-        , boost::move(a1)
-        ) {}
-
-        BOOST_SYMBOL_VISIBLE
-        async_func(BOOST_THREAD_RV_REF(async_func) f) : f_(boost::move(f.f_)) {}
-
-        result_type operator()()
-        {
-            typedef typename make_tuple_indices<3, 1>::type Index;
-            return execute(Index());
-        }
-    private:
-        template <
-        std::size_t I0, std::size_t I1
-        >
-        result_type
-        execute(tuple_indices<I0, I1>)
-        {
-            return invoke(boost::move(boost::get<0>(f_))
-            , boost::move(boost::get<I0>(f_))
-            , boost::move(boost::get<I1>(f_))
-                );
-        }
+      Fp fp_;
+      T0 v0_;
+      T1 v1_;
+    public:
+      BOOST_THREAD_MOVABLE_ONLY(async_func)
+      typedef typename result_of<Fp(T0, T1)>::type result_type;
+
+      BOOST_SYMBOL_VISIBLE
+      explicit async_func(BOOST_THREAD_RV_REF(Fp) f
+          , BOOST_THREAD_RV_REF(T0) a0
+          , BOOST_THREAD_RV_REF(T1) a1
+      )
+      : fp_(boost::move(f))
+      , v0_(boost::move(a0))
+      , v1_(boost::move(a1))
+      {}
+
+      BOOST_SYMBOL_VISIBLE
+      async_func(BOOST_THREAD_RV_REF(async_func) f)
+      : fp_(boost::move(f.fp))
+      , v0_(boost::move(f.a0))
+      , v1_(boost::move(f.a1))
+      {}
+
+      result_type operator()()
+      {
+        return invoke(boost::move(fp_)
+            , boost::move(v0_)
+            , boost::move(v1_)
+        );
+      }
     };
     template <class Fp, class T0>
     class async_func<Fp, T0>
     {
-        ::boost::tuple<Fp, T0> f_;
+      Fp fp_;
+      T0 v0_;
     public:
-        BOOST_THREAD_MOVABLE_ONLY(async_func)
-        typedef typename result_of<Fp(T0)>::type result_type;
+      BOOST_THREAD_MOVABLE_ONLY(async_func)
+      typedef typename result_of<Fp(T0)>::type result_type;
 
-        BOOST_SYMBOL_VISIBLE
-        explicit async_func(BOOST_THREAD_RV_REF(Fp) f
-            , BOOST_THREAD_RV_REF(T0) a0
-            )
-            : f_(boost::move(f)
-        , boost::move(a0)
-        ) {}
-
-        BOOST_SYMBOL_VISIBLE
-        async_func(BOOST_THREAD_RV_REF(async_func) f) : f_(boost::move(f.f_)) {}
-
-        result_type operator()()
-        {
-            typedef typename make_tuple_indices<2, 1>::type Index;
-            return execute(Index());
-        }
-    private:
-        template <
-        std::size_t I0
-        >
-        result_type
-        execute(tuple_indices<I0>)
-        {
-            return invoke(boost::move(boost::get<0>(f_))
-            , boost::move(boost::get<I0>(f_))
-                );
-        }
+      BOOST_SYMBOL_VISIBLE
+      explicit async_func(BOOST_THREAD_RV_REF(Fp) f
+          , BOOST_THREAD_RV_REF(T0) a0
+      )
+      : fp_(boost::move(f))
+      , v0_(boost::move(a0))
+      {}
+
+      BOOST_SYMBOL_VISIBLE
+      async_func(BOOST_THREAD_RV_REF(async_func) f)
+      : fp_(boost::move(f.fp))
+      , v0_(boost::move(f.a0))
+      {}
+
+      result_type operator()()
+      {
+        return invoke(boost::move(fp_)
+            , boost::move(v0_)
+        );
+      }
     };
     template <class Fp>
     class async_func<Fp>
     {
-        Fp f_;
+      Fp fp_;
     public:
-        BOOST_THREAD_COPYABLE_AND_MOVABLE(async_func)
-        typedef typename result_of<Fp()>::type result_type;
-        BOOST_SYMBOL_VISIBLE
-        explicit async_func(BOOST_THREAD_FWD_REF(Fp) f)
-            : f_(boost::move(f)) {}
-
-        BOOST_SYMBOL_VISIBLE
-        async_func(BOOST_THREAD_FWD_REF(async_func) f) : f_(boost::move(f.f_)) {}
-        result_type operator()()
-        {
-            return execute();
-        }
-    private:
-        result_type
-        execute()
-        {
-            return f_();
-        }
+      BOOST_THREAD_COPYABLE_AND_MOVABLE(async_func)
+      typedef typename result_of<Fp()>::type result_type;
+      BOOST_SYMBOL_VISIBLE
+      explicit async_func(BOOST_THREAD_FWD_REF(Fp) f)
+      : fp_(boost::move(f))
+      {}
+
+      BOOST_SYMBOL_VISIBLE
+      async_func(BOOST_THREAD_FWD_REF(async_func) f)
+      : fp_(boost::move(f.fp_))
+      {}
+      result_type operator()()
+      {
+        return fp_();
+      }
     };
 #endif
-//#else
-//    template <class Fp>
-//    class async_func
-//    {
-//        Fp f_;
-//    public:
-//        BOOST_THREAD_COPYABLE_AND_MOVABLE(async_func)
-//        typedef typename result_of<Fp()>::type result_type;
-//        BOOST_SYMBOL_VISIBLE
-//        explicit async_func(BOOST_THREAD_FWD_REF(Fp) f)
-//            : f_(boost::move(f)) {}
-//
-//        BOOST_SYMBOL_VISIBLE
-//        async_func(BOOST_THREAD_FWD_REF(async_func) f) : f_(boost::move(f.f_)) {}
-//        result_type operator()()
-//        {
-//            return execute();
-//        }
-//    private:
-//        result_type
-//        execute()
-//        {
-//            return f_();
-//        }
-//    };
-//    //BOOST_THREAD_DCL_MOVABLE_BEG(Fp) async_func<Fp> BOOST_THREAD_DCL_MOVABLE_END
-//#endif
 
   }
 }