thread/detail/invoke.hpp

0001 // Copyright (C) 2012-2013 Vicente J. Botet Escriba
0002 //
0003 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
0004 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0005
0006 // 2013/04 Vicente J. Botet Escriba
0007 //    Provide implementation up to 9 parameters when BOOST_NO_CXX11_VARIADIC_TEMPLATES is defined.
0008 //    Make use of Boost.Move
0009 //    Make use of Boost.Tuple (movable)
0010 // 2012 Vicente J. Botet Escriba
0011 //    Provide implementation _RET using bind when BOOST_NO_CXX11_HDR_FUNCTIONAL and BOOST_NO_SFINAE_EXPR are not defined
0012 // 2012 Vicente J. Botet Escriba
0013 //    Adapt to boost libc++ implementation
0014
0015 //===----------------------------------------------------------------------===//
0016 //
0017 //                     The LLVM Compiler Infrastructure
0018 //
0019 // This file is dual licensed under the MIT and the University of Illinois Open
0020 // Source Licenses. See LICENSE.TXT for details.
0021 //
0022 // The invoke code is based on the one from libcxx.
0023 //===----------------------------------------------------------------------===//
0024
0025 #ifndef BOOST_THREAD_DETAIL_INVOKE_HPP
0026 #define BOOST_THREAD_DETAIL_INVOKE_HPP
0027
0028 #include <boost/config.hpp>
0029 #include <boost/static_assert.hpp>
0030 #include <boost/thread/detail/move.hpp>
0031 #include <boost/core/enable_if.hpp>
0032 #include <boost/type_traits/is_base_of.hpp>
0033 #include <boost/type_traits/is_pointer.hpp>
0034 #include <boost/type_traits/is_member_function_pointer.hpp>
0035 #include <boost/type_traits/is_member_object_pointer.hpp>
0036 #include <boost/type_traits/remove_reference.hpp>
0037 #ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
0038 #include <functional>
0039 #endif
0040
0041 namespace boost
0042 {
0043   namespace detail
0044   {
0045
0046
0047 #if ! defined(BOOST_NO_SFINAE_EXPR) && \
0048     ! defined(BOOST_NO_CXX11_DECLTYPE) && \
0049     ! defined(BOOST_NO_CXX11_DECLTYPE_N3276) && \
0050     ! defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES)
0051
0052 #define BOOST_THREAD_PROVIDES_INVOKE
0053
0054 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
0055     // bullets 1 and 2
0056
0057     template <class Fp, class A0, class ...Args>
0058     inline auto
0059     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0060         -> decltype((boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...))
0061     {
0062         return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...);
0063     }
0064     template <class R, class Fp, class A0, class ...Args>
0065     inline auto
0066     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0067         -> decltype((boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...))
0068     {
0069         return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...);
0070     }
0071
0072     template <class Fp, class A0, class ...Args>
0073     inline auto
0074     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0075         -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...))
0076     {
0077         return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...);
0078     }
0079     template <class R, class Fp, class A0, class ...Args>
0080     inline auto
0081     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0082         -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...))
0083     {
0084         return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...);
0085     }
0086
0087     // bullets 3 and 4
0088
0089     // enable_if avoids
0090     //
0091     // ./boost/thread/detail/invoke.hpp:101:43: internal compiler error: in gimplify_expr, at gimplify.c:12039
0092     // https://sourceforge.net/p/mingw-w64/bugs/694/
0093     // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83756
0094
0095     template <class Fp, class A0, class En = typename boost::enable_if<boost::is_member_object_pointer<Fp> >::type>
0096     inline auto
0097     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0098         -> decltype(boost::forward<A0>(a0).*f)
0099     {
0100         return boost::forward<A0>(a0).*f;
0101     }
0102
0103     template <class Fp, class A0, class En = typename boost::enable_if<boost::is_member_object_pointer<Fp> >::type>
0104     inline auto
0105     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0106         -> decltype((*boost::forward<A0>(a0)).*f)
0107     {
0108         return (*boost::forward<A0>(a0)).*f;
0109     }
0110
0111     template <class R, class Fp, class A0, class En = typename boost::enable_if<boost::is_member_object_pointer<Fp> >::type>
0112     inline auto
0113     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0114         -> decltype(boost::forward<A0>(a0).*f)
0115     {
0116         return boost::forward<A0>(a0).*f;
0117     }
0118
0119     template <class R, class Fp, class A0, class En = typename boost::enable_if<boost::is_member_object_pointer<Fp> >::type>
0120     inline auto
0121     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0122         -> decltype((*boost::forward<A0>(a0)).*f)
0123     {
0124         return (*boost::forward<A0>(a0)).*f;
0125     }
0126
0127
0128     // bullet 5
0129
0130     template <class R, class Fp, class ...Args>
0131     inline auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args)
0132     -> decltype(boost::forward<Fp>(f)(boost::forward<Args>(args)...))
0133     {
0134       return boost::forward<Fp>(f)(boost::forward<Args>(args)...);
0135     }
0136     template <class Fp, class ...Args>
0137     inline auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args)
0138     -> decltype(boost::forward<Fp>(f)(boost::forward<Args>(args)...))
0139     {
0140       return boost::forward<Fp>(f)(boost::forward<Args>(args)...);
0141     }
0142
0143 #else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
0144
0145     // bullets 1 and 2
0146
0147     template <class Fp, class A0>
0148     inline
0149     auto
0150     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0151         -> decltype((boost::forward<A0>(a0).*f)())
0152     {
0153         return (boost::forward<A0>(a0).*f)();
0154     }
0155     template <class R, class Fp, class A0>
0156     inline
0157     auto
0158     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0159         -> decltype((boost::forward<A0>(a0).*f)())
0160     {
0161         return (boost::forward<A0>(a0).*f)();
0162     }
0163     template <class Fp, class A0, class A1>
0164     inline
0165     auto
0166     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1)
0167         -> decltype((boost::forward<A0>(a0).*f)(boost::forward<A1>(a1)))
0168     {
0169         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1));
0170     }
0171     template <class R, class Fp, class A0, class A1>
0172     inline
0173     auto
0174     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1)
0175         -> decltype((boost::forward<A0>(a0).*f)(boost::forward<A1>(a1)))
0176     {
0177         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1));
0178     }
0179     template <class Fp, class A0, class A1, class A2>
0180     inline
0181     auto
0182     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
0183         -> decltype((boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)))
0184     {
0185         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
0186     }
0187     template <class R, class Fp, class A0, class A1, class A2>
0188     inline
0189     auto
0190     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
0191         -> decltype((boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)))
0192     {
0193         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
0194     }
0195
0196     template <class Fp, class A0>
0197     inline
0198     auto
0199     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0200         -> decltype(((*boost::forward<A0>(a0)).*f)())
0201     {
0202         return ((*boost::forward<A0>(a0)).*f)();
0203     }
0204     template <class R, class Fp, class A0>
0205     inline
0206     auto
0207     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0208         -> decltype(((*boost::forward<A0>(a0)).*f)())
0209     {
0210         return ((*boost::forward<A0>(a0)).*f)();
0211     }
0212     template <class Fp, class A0, class A1>
0213     inline
0214     auto
0215     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1)
0216         -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1)))
0217     {
0218         return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1));
0219     }
0220     template <class R, class Fp, class A0, class A1>
0221     inline
0222     auto
0223     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1)
0224         -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1)))
0225     {
0226         return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1));
0227     }
0228     template <class Fp, class A0, class A1, class A2>
0229     inline
0230     auto
0231     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
0232         -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)))
0233     {
0234         return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
0235     }
0236     template <class R, class Fp, class A0, class A1, class A2>
0237     inline
0238     auto
0239     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
0240         -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)))
0241     {
0242         return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
0243     }
0244
0245     // bullets 3 and 4
0246
0247     template <class Fp, class A0>
0248     inline
0249     auto
0250     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0251         -> decltype(boost::forward<A0>(a0).*f)
0252     {
0253         return boost::forward<A0>(a0).*f;
0254     }
0255     template <class R, class Fp, class A0>
0256     inline
0257     auto
0258     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0259         -> decltype(boost::forward<A0>(a0).*f)
0260     {
0261         return boost::forward<A0>(a0).*f;
0262     }
0263
0264     template <class Fp, class A0>
0265     inline
0266     auto
0267     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0268         -> decltype((*boost::forward<A0>(a0)).*f)
0269     {
0270         return (*boost::forward<A0>(a0)).*f;
0271     }
0272     template <class R, class Fp, class A0>
0273     inline
0274     auto
0275     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0)
0276         -> decltype((*boost::forward<A0>(a0)).*f)
0277     {
0278         return (*boost::forward<A0>(a0)).*f;
0279     }
0280
0281     // bullet 5
0282
0283     template <class Fp>
0284     inline
0285     auto invoke(BOOST_THREAD_RV_REF(Fp) f)
0286     -> decltype(boost::forward<Fp>(f)())
0287     {
0288       return boost::forward<Fp>(f)();
0289     }
0290     template <class Fp, class A1>
0291     inline
0292     auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1)
0293     -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1)))
0294     {
0295       return boost::forward<Fp>(f)(boost::forward<A1>(a1));
0296     }    template <class Fp, class A1, class A2>
0297     inline
0298     auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
0299     -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2)))
0300     {
0301       return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
0302     }
0303     template <class Fp, class A1, class A2, class A3>
0304     inline
0305     auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
0306     -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)))
0307     {
0308       return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
0309     }
0310
0311
0312     template <class R, class Fp>
0313     inline
0314     auto invoke(BOOST_THREAD_RV_REF(Fp) f)
0315     -> decltype(boost::forward<Fp>(f)())
0316     {
0317       return boost::forward<Fp>(f)();
0318     }
0319     template <class R, class Fp, class A1>
0320     inline
0321     auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1)
0322     -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1)))
0323     {
0324       return boost::forward<Fp>(f)(boost::forward<A1>(a1));
0325     }
0326     template <class R, class Fp, class A1, class A2>
0327     inline
0328     auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
0329     -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2)))
0330     {
0331       return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
0332     }
0333     template <class R, class Fp, class A1, class A2, class A3>
0334     inline
0335     auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
0336     -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)))
0337     {
0338       return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
0339     }
0340
0341 #endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
0342
0343 #elif ! defined(BOOST_NO_SFINAE_EXPR) && \
0344     ! defined BOOST_NO_CXX11_HDR_FUNCTIONAL && \
0345     defined  BOOST_MSVC
0346
0347     template <class Ret, class Fp>
0348     inline
0349     Ret invoke(BOOST_THREAD_RV_REF(Fp) f)
0350     {
0351       return f();
0352     }
0353     template <class Ret, class Fp, class A1>
0354     inline
0355     Ret invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1)
0356     {
0357       return std::bind(boost::forward<Fp>(f), boost::forward<A1>(a1))();
0358     }
0359     template <class Ret, class Fp, class A1, class A2>
0360     inline
0361     Ret invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
0362     {
0363       return std::bind(boost::forward<Fp>(f), boost::forward<A1>(a1), boost::forward<A2>(a2))();
0364     }
0365     template <class Ret, class Fp, class A1, class A2, class A3>
0366     inline
0367     Ret invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
0368     {
0369       return std::bind(boost::forward<Fp>(f), boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3))();
0370     }
0371
0372 #define BOOST_THREAD_PROVIDES_INVOKE_RET
0373
0374 #elif ! defined  BOOST_MSVC
0375 //!!!!!  WARNING !!!!! THIS DOESN'T WORKS YET
0376 #define BOOST_THREAD_PROVIDES_INVOKE_RET
0377
0378 #if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
0379
0380     // bullet 1
0381     // (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is an object of
0382     // type T or a reference to an object of type T or a reference to an object of a type derived from T
0383     template <class Ret, class A, class A0, class ...Args>
0384     inline
0385     typename enable_if_c
0386     <
0387         is_base_of<A, typename remove_reference<A0>::type>::value,
0388         Ret
0389     >::type
0390     invoke(Ret (A::*f)(Args...), BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0391     {
0392         return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...);
0393     }
0394
0395     template <class Ret, class A, class A0, class ...Args>
0396     inline
0397     typename enable_if_c
0398     <
0399         is_base_of<A, typename remove_reference<A0>::type>::value,
0400         Ret
0401     >::type
0402     invoke(Ret (A::*f)(Args...) const, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0403     {
0404         return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...);
0405     }
0406
0407     template <class Ret, class A, class A0, class ...Args>
0408     inline
0409     typename enable_if_c
0410     <
0411         is_base_of<A, typename remove_reference<A0>::type>::value,
0412         Ret
0413     >::type
0414     invoke(Ret (A::*f)(Args...) volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0415     {
0416         return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...);
0417     }
0418
0419     template <class Ret, class A, class A0, class ...Args>
0420     inline
0421     typename enable_if_c
0422     <
0423         is_base_of<A, typename remove_reference<A0>::type>::value,
0424         Ret
0425     >::type
0426     invoke(Ret (A::*f)(Args...) const volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0427     {
0428         return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...);
0429     }
0430
0431     // bullet 2
0432     // ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is not one of
0433     // the types described in the previous item;
0434     template <class Ret, class A, class A0, class ...Args>
0435     inline
0436     typename enable_if_c
0437     <
0438         ! is_base_of<A, typename remove_reference<A0>::type>::value,
0439         Ret
0440     >::type
0441     invoke(Ret (A::*f)(Args...), BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0442     {
0443       return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...);
0444     }
0445
0446     template <class Ret, class A, class A0, class ...Args>
0447     inline
0448     typename enable_if_c
0449     <
0450         ! is_base_of<A, typename remove_reference<A0>::type>::value,
0451         Ret
0452     >::type
0453     invoke(Ret (A::*f)(Args...) const, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0454     {
0455       return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...);
0456     }
0457
0458     template <class Ret, class A, class A0, class ...Args>
0459     inline
0460     typename enable_if_c
0461     <
0462         ! is_base_of<A, typename remove_reference<A0>::type>::value,
0463         Ret
0464     >::type
0465     invoke(Ret (A::*f)(Args...) volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0466     {
0467       return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...);
0468     }
0469
0470     template <class Ret, class A, class A0, class ...Args>
0471     inline
0472     typename enable_if_c
0473     <
0474         ! is_base_of<A, typename remove_reference<A0>::type>::value,
0475         Ret
0476     >::type
0477     invoke(Ret (A::*f)(Args...) const volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args)
0478     {
0479       return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...);
0480     }
0481
0482     // bullet 3
0483     // t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is an object of type T or a
0484     // reference to an object of type T or a reference to an object of a type derived from T;
0485 //    template <class Ret, class A, class A0>
0486 //    inline
0487 //    typename enable_if_c
0488 //    <
0489 //        is_base_of<A, typename remove_reference<A0>::type>::value,
0490 //        typename detail::apply_cv<A0, A>::type&
0491 //    >::type
0492 //    invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0)
0493 //    {
0494 //        return boost::forward<A0>(a0).*f;
0495 //    }
0496
0497     // bullet 4
0498     // (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1 is not one of the types
0499     //described in the previous item;
0500
0501 //    template <class A0, class Ret, bool>
0502 //    struct d4th_helper
0503 //    {
0504 //    };
0505 //
0506 //    template <class A0, class Ret>
0507 //    struct d4th_helper<A0, Ret, true>
0508 //    {
0509 //        typedef typename apply_cv<decltype(*declval<A0>()), Ret>::type type;
0510 //    };
0511 //
0512 //    template <class Ret, class A, class A0>
0513 //    inline
0514 //    typename detail::4th_helper<A, Ret,
0515 //                          !is_base_of<A,
0516 //                                      typename remove_reference<A0>::type
0517 //                                     >::value
0518 //                         >::type&
0519 //    invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0)
0520 //    {
0521 //        return (*boost::forward<A0>(a0)).*f;
0522 //    }
0523
0524 //    template <class Ret, class A, class A0>
0525 //    inline
0526 //    typename enable_if_c
0527 //    <
0528 //        !is_base_of<A, typename remove_reference<A0>::type>::value,
0529 //        typename detail::ref_return1<Ret A::*, A0>::type
0530 //    >::type
0531 //    invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0)
0532 //    {
0533 //        return (*boost::forward<A0>(a0)).*f;
0534 //    }
0535
0536     // bullet 5
0537     // f(t1, t2, ..., tN) in all other cases.
0538
0539     template <class Ret, class Fp, class ...Args>
0540     inline Ret do_invoke(boost::false_type, BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args)
0541     {
0542       return boost::forward<Fp>(f)(boost::forward<Args>(args)...);
0543     }
0544
0545     template <class Ret, class Fp, class ...Args>
0546     inline Ret do_invoke(boost::true_type, BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args)
0547     {
0548       return f(boost::forward<Args>(args)...);
0549     }
0550
0551     template <class Ret, class Fp, class ...Args>
0552     inline
0553     typename disable_if_c
0554     <
0555         is_member_function_pointer<Fp>::value,
0556         Ret
0557     >::type
0558     invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args)
0559     {
0560       return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), boost::forward<Args>(args)...);
0561     }
0562 #else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
0563     // bullet 1
0564     // (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is an object of
0565     // type T or a reference to an object of type T or a reference to an object of a type derived from T
0566
0567     template <class Ret, class A, class A0>
0568     inline
0569     typename enable_if_c
0570     <
0571         is_base_of<A, typename remove_reference<A0>::type>::value,
0572         Ret
0573     >::type
0574     invoke(Ret (A::*f)(), A0& a0)
0575     {
0576         return (a0.*f)();
0577     }
0578     template <class Ret, class A, class A0>
0579     inline
0580     typename enable_if_c
0581     <
0582         is_base_of<A, typename remove_reference<A0>::type>::value,
0583         Ret
0584     >::type
0585     invoke(Ret (A::*f)(), A0* a0)
0586     {
0587         return ((*a0).*f)();
0588     }
0589
0590     template <class Ret, class A, class A0, class A1>
0591     inline
0592     typename enable_if_c
0593     <
0594         is_base_of<A, typename remove_reference<A0>::type>::value,
0595         Ret
0596     >::type
0597     invoke(Ret (A::*f)(A1),
0598         A0& a0, BOOST_THREAD_RV_REF(A1) a1
0599         )
0600     {
0601         return (a0.*f)(boost::forward<A1>(a1));
0602     }
0603     template <class Ret, class A, class A0, class A1>
0604     inline
0605     typename enable_if_c
0606     <
0607         is_base_of<A, typename remove_reference<A0>::type>::value,
0608         Ret
0609     >::type
0610     invoke(Ret (A::*f)(A1), A0& a0, A1 a1)
0611     {
0612         return (a0.*f)(a1);
0613     }
0614     template <class Ret, class A, class A0, class A1>
0615     inline
0616     typename enable_if_c
0617     <
0618         is_base_of<A, typename remove_reference<A0>::type>::value,
0619         Ret
0620     >::type
0621     invoke(Ret (A::*f)(A1), A0* a0, BOOST_THREAD_RV_REF(A1) a1
0622         )
0623     {
0624         return (*(a0).*f)(boost::forward<A1>(a1));
0625     }
0626     template <class Ret, class A, class A0, class A1>
0627     inline
0628     typename enable_if_c
0629     <
0630         is_base_of<A, typename remove_reference<A0>::type>::value,
0631         Ret
0632     >::type
0633     invoke(Ret (A::*f)(A1), A0* a0, A1 a1)
0634     {
0635         return (*a0.*f)(a1);
0636     }
0637     template <class Ret, class A, class A0, class A1, class A2>
0638     inline
0639     typename enable_if_c
0640     <
0641         is_base_of<A, typename remove_reference<A0>::type>::value,
0642         Ret
0643     >::type
0644     invoke(Ret (A::*f)(A1, A2),
0645         A0& a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2
0646         )
0647     {
0648         return (a0.*f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
0649     }
0650     template <class Ret, class A, class A0, class A1, class A2>
0651     inline
0652     typename enable_if_c
0653     <
0654         is_base_of<A, typename remove_reference<A0>::type>::value,
0655         Ret
0656     >::type
0657     invoke(Ret (A::*f)(A1, A2), A0* a0, A1 a1, A2 a2)
0658     {
0659         return ((*a0).*f)(a1, a2);
0660     }
0661     template <class Ret, class A, class A0, class A1, class A2, class A3>
0662     inline
0663     typename enable_if_c
0664     <
0665         is_base_of<A, typename remove_reference<A0>::type>::value,
0666         Ret
0667     >::type
0668     invoke(Ret (A::*f)(A1, A2, A3),
0669         A0& a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
0670     {
0671         return (a0.*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
0672     }
0673     template <class Ret, class A, class A0, class A1, class A2, class A3>
0674     inline
0675     typename enable_if_c
0676     <
0677         is_base_of<A, typename remove_reference<A0>::type>::value,
0678         Ret
0679     >::type
0680     invoke(Ret (A::*f)(A1, A2, A3), A0* a0, A1 a1, A2 a2, A3 a3)
0681     {
0682         return ((*a0).*f)(a1, a2, a3);
0683     }
0684
0685 ///
0686     template <class Ret, class A, class A0>
0687     inline
0688     typename enable_if_c
0689     <
0690         is_base_of<A, typename remove_reference<A0>::type>::value,
0691         Ret
0692     >::type
0693     invoke(Ret (A::*f)() const, A0 const& a0)
0694     {
0695         return (a0.*f)();
0696     }
0697     template <class Ret, class A, class A0>
0698     inline
0699     typename enable_if_c
0700     <
0701         is_base_of<A, typename remove_reference<A0>::type>::value,
0702         Ret
0703     >::type
0704     invoke(Ret (A::*f)() const, A0 const* a0)
0705     {
0706         return ((*a0).*f)();
0707     }
0708     template <class Ret, class A, class A0, class A1>
0709     inline
0710     typename enable_if_c
0711     <
0712         is_base_of<A, typename remove_reference<A0>::type>::value,
0713         Ret
0714     >::type
0715     invoke(Ret (A::*f)(A1) const, A0 const& a0, BOOST_THREAD_RV_REF(A1) a1)
0716     {
0717         return (a0.*f)(boost::forward<A1>(a1));
0718     }
0719     template <class Ret, class A, class A0, class A1>
0720     inline
0721     typename enable_if_c
0722     <
0723         is_base_of<A, typename remove_reference<A0>::type>::value,
0724         Ret
0725     >::type
0726     invoke(Ret (A::*f)(A1) const, A0 const* a0, BOOST_THREAD_RV_REF(A1) a1)
0727     {
0728         return ((*a0).*f)(boost::forward<A1>(a1));
0729     }
0730
0731     template <class Ret, class A, class A0, class A1>
0732     inline
0733     typename enable_if_c
0734     <
0735         is_base_of<A, typename remove_reference<A0>::type>::value,
0736         Ret
0737     >::type
0738     invoke(Ret (A::*f)(A1) const, A0 const& a0, A1 a1)
0739     {
0740         return (a0.*f)(a1);
0741     }
0742     template <class Ret, class A, class A0, class A1, class A2>
0743     inline
0744     typename enable_if_c
0745     <
0746         is_base_of<A, typename remove_reference<A0>::type>::value,
0747         Ret
0748     >::type
0749     invoke(Ret (A::*f)(A1, A2) const,
0750         A0 const& a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2
0751         )
0752     {
0753         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)
0754             );
0755     }
0756     template <class Ret, class A, class A0, class A1, class A2>
0757     inline
0758     typename enable_if_c
0759     <
0760         is_base_of<A, typename remove_reference<A0>::type>::value,
0761         Ret
0762     >::type
0763     invoke(Ret (A::*f)(A1, A2) const, A0 const& a0, A1 a1, A2 a2)
0764     {
0765         return (a0.*f)(a1, a2);
0766     }
0767     template <class Ret, class A, class A0, class A1, class A2, class A3>
0768     inline
0769     typename enable_if_c
0770     <
0771         is_base_of<A, typename remove_reference<A0>::type>::value,
0772         Ret
0773     >::type
0774     invoke(Ret (A::*f)(A1, A2, A3) const,
0775         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3
0776         )
0777     {
0778         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
0779     }
0780     template <class Ret, class A, class A0, class A1, class A2, class A3>
0781     inline
0782     typename enable_if_c
0783     <
0784         is_base_of<A, typename remove_reference<A0>::type>::value,
0785         Ret
0786     >::type
0787     invoke(Ret (A::*f)(A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3)
0788     {
0789         return (a0.*f)(a1, a2, a3);
0790     }
0791     ///
0792     template <class Ret, class A, class A0>
0793     inline
0794     typename enable_if_c
0795     <
0796         is_base_of<A, typename remove_reference<A0>::type>::value,
0797         Ret
0798     >::type
0799     invoke(Ret (A::*f)() volatile, BOOST_THREAD_RV_REF(A0) a0)
0800     {
0801         return (boost::forward<A0>(a0).*f)();
0802     }
0803     template <class Ret, class A, class A0, class A1>
0804     inline
0805     typename enable_if_c
0806     <
0807         is_base_of<A, typename remove_reference<A0>::type>::value,
0808         Ret
0809     >::type
0810     invoke(Ret (A::*f)(A1) volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1)
0811     {
0812         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1));
0813     }
0814     template <class Ret, class A, class A0, class A1>
0815     inline
0816     typename enable_if_c
0817     <
0818         is_base_of<A, typename remove_reference<A0>::type>::value,
0819         Ret
0820     >::type
0821     invoke(Ret (A::*f)(A1) volatile, A0 a0, A1 a1)
0822     {
0823         return (a0.*f)(a1);
0824     }
0825     template <class Ret, class A, class A0, class A1, class A2>
0826     inline
0827     typename enable_if_c
0828     <
0829         is_base_of<A, typename remove_reference<A0>::type>::value,
0830         Ret
0831     >::type
0832     invoke(Ret (A::*f)(A1, A2) volatile,
0833         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
0834     {
0835         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
0836     }
0837     template <class Ret, class A, class A0, class A1, class A2>
0838     inline
0839     typename enable_if_c
0840     <
0841         is_base_of<A, typename remove_reference<A0>::type>::value,
0842         Ret
0843     >::type
0844     invoke(Ret (A::*f)(A1, A2) volatile, A0 a0, A1 a1, A2 a2 )
0845     {
0846         return (a0.*f)(a1, a2);
0847     }
0848     template <class Ret, class A, class A0, class A1, class A2, class A3>
0849     inline
0850     typename enable_if_c
0851     <
0852         is_base_of<A, typename remove_reference<A0>::type>::value,
0853         Ret
0854     >::type
0855     invoke(Ret (A::*f)(A1, A2, A3) volatile,
0856         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3
0857         )
0858     {
0859         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
0860     }
0861     template <class Ret, class A, class A0, class A1, class A2, class A3>
0862     inline
0863     typename enable_if_c
0864     <
0865         is_base_of<A, typename remove_reference<A0>::type>::value,
0866         Ret
0867     >::type
0868     invoke(Ret (A::*f)(A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3)
0869     {
0870         return (a0.*f)(a1, a2, a3);
0871     }
0872     ///
0873     template <class Ret, class A, class A0>
0874     inline
0875     typename enable_if_c
0876     <
0877         is_base_of<A, typename remove_reference<A0>::type>::value,
0878         Ret
0879     >::type
0880     invoke(Ret (A::*f)() const volatile, BOOST_THREAD_RV_REF(A0) a0)
0881     {
0882         return (boost::forward<A0>(a0).*f)();
0883     }
0884     template <class Ret, class A, class A0, class A1>
0885     inline
0886     typename enable_if_c
0887     <
0888         is_base_of<A, typename remove_reference<A0>::type>::value,
0889         Ret
0890     >::type
0891     invoke(Ret (A::*f)(A1) const volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1)
0892     {
0893         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1));
0894     }
0895     template <class Ret, class A, class A0, class A1>
0896     inline
0897     typename enable_if_c
0898     <
0899         is_base_of<A, typename remove_reference<A0>::type>::value,
0900         Ret
0901     >::type
0902     invoke(Ret (A::*f)(A1) const volatile, A0 a0, A1 a1)
0903     {
0904         return (a0.*f)(a1);
0905     }
0906     template <class Ret, class A, class A0, class A1, class A2>
0907     inline
0908     typename enable_if_c
0909     <
0910         is_base_of<A, typename remove_reference<A0>::type>::value,
0911         Ret
0912     >::type
0913     invoke(Ret (A::*f)(A1, A2) const volatile,
0914         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2
0915         )
0916     {
0917         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
0918     }
0919     template <class Ret, class A, class A0, class A1, class A2>
0920     inline
0921     typename enable_if_c
0922     <
0923         is_base_of<A, typename remove_reference<A0>::type>::value,
0924         Ret
0925     >::type
0926     invoke(Ret (A::*f)(A1, A2) const volatile,
0927         A0 a0, A1 a1, A2 a2
0928         )
0929     {
0930         return (a0.*f)(a1, a2);
0931     }
0932     template <class Ret, class A, class A0, class A1, class A2, class A3>
0933     inline
0934     typename enable_if_c
0935     <
0936         is_base_of<A, typename remove_reference<A0>::type>::value,
0937         Ret
0938     >::type
0939     invoke(Ret (A::*f)(A1, A2, A3) const volatile,
0940         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3
0941         )
0942     {
0943         return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
0944     }
0945     template <class Ret, class A, class A0, class A1, class A2, class A3>
0946     inline
0947     typename enable_if_c
0948     <
0949         is_base_of<A, typename remove_reference<A0>::type>::value,
0950         Ret
0951     >::type
0952     invoke(Ret (A::*f)(A1, A2, A3) const volatile,
0953         A0 a0, A1 a1, A2 a2, A3 a3
0954         )
0955     {
0956         return (a0.*f)(a1, a2, a3);
0957     }
0958
0959     // bullet 2
0960     // ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is not one of
0961     // the types described in the previous item;
0962     template <class Ret, class A, class A0>
0963     inline
0964     typename enable_if_c
0965     <
0966         ! is_base_of<A, typename remove_reference<A0>::type>::value,
0967         Ret
0968     >::type
0969     invoke(Ret (A::*f)(), BOOST_THREAD_RV_REF(A0) a0)
0970     {
0971       return ((*boost::forward<A0>(a0)).*f)();
0972     }
0973     template <class Ret, class A, class A0, class A1>
0974     inline
0975     typename enable_if_c
0976     <
0977         ! is_base_of<A, typename remove_reference<A0>::type>::value,
0978         Ret
0979     >::type
0980     invoke(Ret (A::*f)(A1), BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1)
0981     {
0982       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1));
0983     }
0984     template <class Ret, class A, class A0, class A1>
0985     inline
0986     typename enable_if_c
0987     <
0988         ! is_base_of<A, typename remove_reference<A0>::type>::value,
0989         Ret
0990     >::type
0991     invoke(Ret (A::*f)(A1), A0 a0, A1 a1)
0992     {
0993       return ((*a0).*f)(a1);
0994     }
0995     template <class Ret, class A, class A0, class A1, class A2>
0996     inline
0997     typename enable_if_c
0998     <
0999         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1000         Ret
1001     >::type
1002     invoke(Ret (A::*f)(A1, BOOST_THREAD_RV_REF(A2)),
1003         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
1004     {
1005       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
1006     }
1007     template <class Ret, class A, class A0, class A1, class A2>
1008     inline
1009     typename enable_if_c
1010     <
1011         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1012         Ret
1013     >::type
1014     invoke(Ret (A::*f)(A1, A2), A0 a0, A1 a1, A2 a2)
1015     {
1016       return ((*a0).*f)(a1, a2);
1017     }
1018     template <class Ret, class A, class A0, class A1, class A2, class A3>
1019     inline
1020     typename enable_if_c
1021     <
1022         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1023         Ret
1024     >::type
1025     invoke(Ret (A::*f)(A1, BOOST_THREAD_RV_REF(A2), BOOST_THREAD_RV_REF(A3)),
1026         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
1027     {
1028       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)
1029           );
1030     }
1031     template <class Ret, class A, class A0, class A1, class A2, class A3>
1032     inline
1033     typename enable_if_c
1034     <
1035         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1036         Ret
1037     >::type
1038     invoke(Ret (A::*f)(A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3)
1039     {
1040       return ((*a0).*f)(a1, a2, a3);
1041     }
1042
1043 ///
1044     template <class Ret, class A, class A0>
1045     inline
1046     typename enable_if_c
1047     <
1048         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1049         Ret
1050     >::type
1051     invoke(Ret (A::*f)() const, BOOST_THREAD_RV_REF(A0) a0)
1052     {
1053       return ((*boost::forward<A0>(a0)).*f)();
1054     }
1055     template <class Ret, class A, class A0, class A1>
1056     inline
1057     typename enable_if_c
1058     <
1059         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1060         Ret
1061     >::type
1062     invoke(Ret (A::*f)(A1) const,
1063         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1)
1064     {
1065       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1));
1066     }
1067     template <class Ret, class A, class A0, class A1>
1068     inline
1069     typename enable_if_c
1070     <
1071         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1072         Ret
1073     >::type
1074     invoke(Ret (A::*f)(A1) const, BOOST_THREAD_RV_REF(A0) a0, A1 a1)
1075     {
1076       return ((*boost::forward<A0>(a0)).*f)(a1);
1077     }
1078     template <class Ret, class A, class A0, class A1>
1079     inline
1080     typename enable_if_c
1081     <
1082         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1083         Ret
1084     >::type
1085     invoke(Ret (A::*f)(A1) const, A0 a0, A1 a1)
1086     {
1087       return ((*a0).*f)(a1);
1088     }
1089     template <class Ret, class A, class A0, class A1, class A2>
1090     inline
1091     typename enable_if_c
1092     <
1093         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1094         Ret
1095     >::type
1096     invoke(Ret (A::*f)(A1, A2) const,
1097         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
1098     {
1099       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
1100     }
1101     template <class Ret, class A, class A0, class A1, class A2>
1102     inline
1103     typename enable_if_c
1104     <
1105         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1106         Ret
1107     >::type
1108     invoke(Ret (A::*f)(A1, A2) const, A0 a0, A1 a1, A2 a2)
1109     {
1110       return ((*a0).*f)(a1, a2);
1111     }
1112     template <class Ret, class A, class A0, class A1, class A2, class A3>
1113     inline
1114     typename enable_if_c
1115     <
1116         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1117         Ret
1118     >::type
1119     invoke(Ret (A::*f)(A1, A2, A3) const,
1120         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
1121     {
1122       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
1123     }
1124     template <class Ret, class A, class A0, class A1, class A2, class A3>
1125     inline
1126     typename enable_if_c
1127     <
1128         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1129         Ret
1130     >::type
1131     invoke(Ret (A::*f)(A1, A2, A3) const,
1132         A0 a0, A1 a1, A2 a2, A3 a3)
1133     {
1134       return ((*a0).*f)(a1, a2, a3);
1135     }
1136     ///
1137     template <class Ret, class A, class A0>
1138     inline
1139     typename enable_if_c
1140     <
1141         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1142         Ret
1143     >::type
1144     invoke(Ret (A::*f)() volatile, BOOST_THREAD_RV_REF(A0) a0)
1145     {
1146       return ((*boost::forward<A0>(a0)).*f)();
1147     }
1148     template <class Ret, class A, class A0, class A1>
1149     inline
1150     typename enable_if_c
1151     <
1152         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1153         Ret
1154     >::type
1155     invoke(Ret (A::*f)(A1) volatile,
1156         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1)
1157     {
1158       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1));
1159     }
1160     template <class Ret, class A, class A0, class A1>
1161     inline
1162     typename enable_if_c
1163     <
1164         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1165         Ret
1166     >::type
1167     invoke(Ret (A::*f)(A1) volatile, A0 a0, A1 a1)
1168     {
1169       return ((*a0).*f)(a1);
1170     }
1171     template <class Ret, class A, class A0, class A1, class A2>
1172     inline
1173     typename enable_if_c
1174     <
1175         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1176         Ret
1177     >::type
1178     invoke(Ret (A::*f)(A1, A2) volatile,
1179         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
1180     {
1181       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
1182     }
1183     template <class Ret, class A, class A0, class A1, class A2>
1184     inline
1185     typename enable_if_c
1186     <
1187         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1188         Ret
1189     >::type
1190     invoke(Ret (A::*f)(A1, A2) volatile, A0 a0, A1 a1, A2 a2)
1191     {
1192       return ((*a0).*f)(a1, a2);
1193     }
1194     template <class Ret, class A, class A0, class A1, class A2, class A3>
1195     inline
1196     typename enable_if_c
1197     <
1198         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1199         Ret
1200     >::type
1201     invoke(Ret (A::*f)(A1, A2, A3) volatile,
1202         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
1203     {
1204       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
1205     }
1206     template <class Ret, class A, class A0, class A1, class A2, class A3>
1207     inline
1208     typename enable_if_c
1209     <
1210         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1211         Ret
1212     >::type
1213     invoke(Ret (A::*f)(A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3)
1214     {
1215       return ((*a0).*f)(a1, a2, a3);
1216     }
1217     ///
1218     template <class Ret, class A, class A0>
1219     inline
1220     typename enable_if_c
1221     <
1222         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1223         Ret
1224     >::type
1225     invoke(Ret (A::*f)() const volatile, BOOST_THREAD_RV_REF(A0) a0)
1226     {
1227       return ((*boost::forward<A0>(a0)).*f)();
1228     }
1229     template <class Ret, class A, class A0>
1230     inline
1231     typename enable_if_c
1232     <
1233         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1234         Ret
1235     >::type
1236     invoke(Ret (A::*f)() const volatile, A0 a0)
1237     {
1238       return ((*a0).*f)();
1239     }
1240     template <class Ret, class A, class A0, class A1>
1241     inline
1242     typename enable_if_c
1243     <
1244         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1245         Ret
1246     >::type
1247     invoke(Ret (A::*f)(A1) const volatile,
1248         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1)
1249     {
1250       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1));
1251     }
1252     template <class Ret, class A, class A0, class A1>
1253     inline
1254     typename enable_if_c
1255     <
1256         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1257         Ret
1258     >::type
1259     invoke(Ret (A::*f)(A1) const volatile, A0 a0, A1 a1)
1260     {
1261       return ((*a0).*f)(a1);
1262     }
1263     template <class Ret, class A, class A0, class A1, class A2>
1264     inline
1265     typename enable_if_c
1266     <
1267         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1268         Ret
1269     >::type
1270     invoke(Ret (A::*f)(A1, A2) const volatile,
1271         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
1272     {
1273       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
1274     }
1275     template <class Ret, class A, class A0, class A1, class A2>
1276     inline
1277     typename enable_if_c
1278     <
1279         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1280         Ret
1281     >::type
1282     invoke(Ret (A::*f)(A1, A2) const volatile,
1283         A0 a0, A1 a1, A2 a2)
1284     {
1285       return ((*a0).*f)(a1, a2);
1286     }
1287     template <class Ret, class A, class A0, class A1, class A2, class A3>
1288     inline
1289     typename enable_if_c
1290     <
1291         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1292         Ret
1293     >::type
1294     invoke(Ret (A::*f)(A1, A2, A3) const volatile,
1295         BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
1296     {
1297       return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
1298     }
1299     template <class Ret, class A, class A0, class A1, class A2, class A3>
1300     inline
1301     typename enable_if_c
1302     <
1303         ! is_base_of<A, typename remove_reference<A0>::type>::value,
1304         Ret
1305     >::type
1306     invoke(Ret (A::*f)(A1, A2, A3) const volatile,
1307         A0 a0, A1 a1, A2 a2, A3 a3)
1308     {
1309       return ((*a0).*f)(a1, a2, a3);
1310     }
1311     // bullet 3
1312     // t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is an object of type T or a
1313     // reference to an object of type T or a reference to an object of a type derived from T;
1314 //    template <class Ret, class A, class A0>
1315 //    inline
1316 //    typename enable_if_c
1317 //    <
1318 //        is_base_of<A, typename remove_reference<A0>::type>::value,
1319 //        typename detail::apply_cv<A0, A>::type&
1320 //    >::type
1321 //    invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0)
1322 //    {
1323 //        return boost::forward<A0>(a0).*f;
1324 //    }
1325
1326     // bullet 4
1327     // (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1 is not one of the types
1328     //described in the previous item;
1329
1330 //    template <class A0, class Ret, bool>
1331 //    struct d4th_helper
1332 //    {
1333 //    };
1334 //
1335 //    template <class A0, class Ret>
1336 //    struct d4th_helper<A0, Ret, true>
1337 //    {
1338 //        typedef typename apply_cv<decltype(*declval<A0>()), Ret>::type type;
1339 //    };
1340 //
1341 //    template <class Ret, class A, class A0>
1342 //    inline
1343 //    typename detail::4th_helper<A, Ret,
1344 //                          !is_base_of<A,
1345 //                                      typename remove_reference<A0>::type
1346 //                                     >::value
1347 //                         >::type&
1348 //    invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0)
1349 //    {
1350 //        return (*boost::forward<A0>(a0)).*f;
1351 //    }
1352
1353 //    template <class Ret, class A, class A0>
1354 //    inline
1355 //    typename enable_if_c
1356 //    <
1357 //        !is_base_of<A, typename remove_reference<A0>::type>::value,
1358 //        typename detail::ref_return1<Ret A::*, A0>::type
1359 //    >::type
1360 //    invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0)
1361 //    {
1362 //        return (*boost::forward<A0>(a0)).*f;
1363 //    }
1364
1365     // bullet 5
1366     // f(t1, t2, ..., tN) in all other cases.
1367
1368     template <class Ret, class Fp>
1369     inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f)
1370     {
1371       return boost::forward<Fp>(f)();
1372     }
1373     template <class Ret, class Fp>
1374     inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f)
1375     {
1376       return f();
1377     }
1378     template <class Ret, class Fp>
1379     inline
1380     typename disable_if_c
1381     <
1382         is_member_function_pointer<Fp>::value,
1383         Ret
1384     >::type
1385     invoke(BOOST_THREAD_FWD_REF(Fp) f)
1386     {
1387       return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f));
1388     }
1389
1390     template <class Ret, class Fp, class A1>
1391     inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1)
1392     {
1393       return boost::forward<Fp>(f)(boost::forward<A1>(a1));
1394     }
1395     template <class Ret, class Fp, class A1>
1396     inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1)
1397     {
1398       return f(boost::forward<A1>(a1));
1399     }
1400     template <class Ret, class Fp, class A1>
1401     inline
1402     typename disable_if_c
1403     <
1404         is_member_function_pointer<Fp>::value,
1405         Ret
1406     >::type
1407     invoke(BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1)
1408     {
1409       return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), boost::forward<A1>(a1));
1410     }
1411
1412     template <class Ret, class Fp, class A1, class A2>
1413     inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
1414     {
1415       return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2));
1416     }
1417     template <class Ret, class Fp, class A1, class A2>
1418     inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
1419     {
1420       return f(boost::forward<A1>(a1), boost::forward<A2>(a2));
1421     }
1422     template <class Ret, class Fp, class A1, class A2>
1423     inline
1424     typename disable_if_c
1425     <
1426         is_member_function_pointer<Fp>::value,
1427         Ret
1428     >::type
1429     invoke(BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
1430     {
1431       return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), boost::forward<A1>(a1), boost::forward<A2>(a2));
1432     }
1433
1434     template <class Ret, class Fp, class A1, class A2, class A3>
1435     inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
1436     {
1437       return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
1438     }
1439     template <class Ret, class Fp, class A1, class A2, class A3>
1440     inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
1441     {
1442       return f(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
1443     }
1444     template <class Ret, class Fp, class A1, class A2, class A3>
1445     inline
1446     typename disable_if_c
1447     <
1448         is_member_function_pointer<Fp>::value,
1449         Ret
1450     >::type
1451     invoke(BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
1452     {
1453       return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
1454     }
1455
1456
1457     template <class Ret, class Fp, class A1>
1458     inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1)
1459     {
1460       return boost::forward<Fp>(f)(a1);
1461     }
1462     template <class Ret, class Fp, class A1>
1463     inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1)
1464     {
1465       return f(a1);
1466     }
1467     template <class Ret, class Fp, class A1>
1468     inline
1469     typename disable_if_c
1470     <
1471         is_member_function_pointer<Fp>::value,
1472         Ret
1473     >::type
1474     invoke(BOOST_THREAD_FWD_REF(Fp) f, A1 a1)
1475     {
1476       return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), a1);
1477     }
1478
1479     template <class Ret, class Fp, class A1, class A2>
1480     inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2)
1481     {
1482       return boost::forward<Fp>(f)(a1, a2);
1483     }
1484     template <class Ret, class Fp, class A1, class A2>
1485     inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2)
1486     {
1487       return f(a1, a2);
1488     }
1489     template <class Ret, class Fp, class A1, class A2>
1490     inline
1491     typename disable_if_c
1492     <
1493         is_member_function_pointer<Fp>::value,
1494         Ret
1495     >::type
1496     invoke(BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2)
1497     {
1498       return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), a1, a2);
1499     }
1500
1501     template <class Ret, class Fp, class A1, class A2, class A3>
1502     inline Ret do_invoke(boost::false_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2, A3 a3)
1503     {
1504       return boost::forward<Fp>(f)(a1, a2, a3);
1505     }
1506     template <class Ret, class Fp, class A1, class A2, class A3>
1507     inline Ret do_invoke(boost::true_type, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2, A3 a3)
1508     {
1509       return f(a1, a2, a3);
1510     }
1511     template <class Ret, class Fp, class A1, class A2, class A3>
1512     inline
1513     typename disable_if_c
1514     <
1515         is_member_function_pointer<Fp>::value,
1516         Ret
1517     >::type
1518     invoke(BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2, A3 a3)
1519     {
1520       return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), a1, a2, a3);
1521     }
1522
1523
1524     ///
1525     template <class Ret, class Fp>
1526     inline
1527     typename disable_if_c
1528     <
1529         is_member_function_pointer<Fp>::value,
1530         Ret
1531     >::type
1532     invoke(Fp &f)
1533     {
1534       return f();
1535     }
1536     template <class Ret, class Fp, class A1>
1537     inline
1538     typename disable_if_c
1539     <
1540         is_member_function_pointer<Fp>::value,
1541         Ret
1542     >::type
1543     invoke(Fp &f, BOOST_THREAD_RV_REF(A1) a1)
1544     {
1545       return f(boost::forward<A1>(a1));
1546     }
1547     template <class Ret, class Fp, class A1>
1548     inline
1549     typename disable_if_c
1550     <
1551         is_member_function_pointer<Fp>::value,
1552         Ret
1553     >::type
1554     invoke(Fp &f, A1 a1)
1555     {
1556       return f(a1);
1557     }
1558     template <class Ret, class Fp, class A1, class A2>
1559     inline
1560     typename disable_if_c
1561     <
1562         is_member_function_pointer<Fp>::value,
1563         Ret
1564     >::type
1565     invoke(Fp &f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2)
1566     {
1567       return f(boost::forward<A1>(a1), boost::forward<A2>(a2));
1568     }
1569     template <class Ret, class Fp, class A1, class A2>
1570     inline
1571     typename disable_if_c
1572     <
1573         is_member_function_pointer<Fp>::value,
1574         Ret
1575     >::type
1576     invoke(Fp &f, A1 a1, A2 a2)
1577     {
1578       return f(a1, a2);
1579     }
1580     template <class Ret, class Fp, class A1, class A2, class A3>
1581     inline
1582     typename disable_if_c
1583     <
1584         is_member_function_pointer<Fp>::value,
1585         Ret
1586     >::type
1587     invoke(Fp &f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3)
1588     {
1589       return f(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3));
1590     }
1591     template <class Ret, class Fp, class A1, class A2, class A3>
1592     inline
1593     typename disable_if_c
1594     <
1595         is_member_function_pointer<Fp>::value,
1596         Ret
1597     >::type
1598     invoke(Fp &f, A1 a1, A2 a2, A3 a3)
1599     {
1600       return f(a1, a2, a3);
1601     }
1602     ///
1603
1604 #endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES
1605
1606 #endif  // all
1607       }
1608     }
1609
1610 #endif // header