passenger 5.0.24 → 5.0.25

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/array_deleter.hpp

@@ -1,124 +0,0 @@
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP
-
-#include <boost/smart_ptr/detail/array_utility.hpp>
-#include <boost/smart_ptr/detail/sp_forward.hpp>
-
-namespace boost {
-    namespace detail {
-        template<typename T>
-        class array_deleter;
-        template<typename T>
-        class array_deleter<T[]> {
-        public:
-            array_deleter(std::size_t size_)
-                : size(size_),
-                  object(0) {
-            }
-            ~array_deleter() {
-                if (object) {
-                    array_destroy(object, size);
-                }
-            }
-            void init(T* memory) {
-                array_init(memory, size);
-                object = memory;
-            }
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-            void init(T* memory, T&& value) {
-                array_init_value(memory, size, sp_forward<T>(value));
-                object = memory;                
-            }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-            template<typename... Args>
-            void init(T* memory, Args&&... args) {
-                array_init_args(memory, size, sp_forward<Args>(args)...);
-                object = memory;
-            }
-#endif
-#endif
-            void init_list(T* memory, const T* list) {
-                array_init_list(memory, size, list);
-                object = memory;
-            }
-            template<std::size_t M>
-            void init_list(T* memory, const T* list) {
-                array_init_list<T, M>(memory, size, list);
-                object = memory;
-            }
-            void noinit(T* memory) {
-                array_noinit(memory, size);
-                object = memory;
-            }
-            void operator()(const void*) {
-                if (object) {
-                    array_destroy(object, size);
-                    object = 0;
-                }
-            }
-        private:
-            std::size_t size;
-            T* object;
-        };
-        template<typename T, std::size_t N>
-        class array_deleter<T[N]> {
-        public:
-            array_deleter()
-                : object(0) {
-            }
-            ~array_deleter() {
-                if (object) {
-                    array_destroy(object, N);
-                }
-            }
-            void init(T* memory) {
-                array_init(memory, N);
-                object = memory;
-            }
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-            void init(T* memory, T&& value) {
-                array_init_value(memory, N, sp_forward<T>(value));
-                object = memory;                
-            }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-            template<typename... Args>
-            void init(T* memory, Args&&... args) {
-                array_init_args(memory, N, sp_forward<Args>(args)...);
-                object = memory;
-            }
-#endif
-#endif
-            void init_list(T* memory, const T* list) {
-                array_init_list(memory, N, list);
-                object = memory;
-            }
-            template<std::size_t M>
-            void init_list(T* memory, const T* list) {
-                array_init_list<T, M>(memory, N, list);
-                object = memory;
-            }
-            void noinit(T* memory) {
-                array_noinit(memory, N);
-                object = memory;
-            }
-            void operator()(const void*) {
-                if (object) {
-                    array_destroy(object, N);
-                    object = 0;
-                }
-            }
-        private:
-            T* object;
-        };
-    }
-}
-
-#endif

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/make_array_helper.hpp

@@ -1,157 +0,0 @@
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_MAKE_ARRAY_HELPER_HPP
-#define BOOST_SMART_PTR_DETAIL_MAKE_ARRAY_HELPER_HPP
-
-#include <boost/type_traits/alignment_of.hpp>
-
-namespace boost {
-    namespace detail {
-        template<typename T, typename Y = char>
-        class make_array_helper;
-        template<typename T, typename Y>
-        class make_array_helper<T[], Y> {
-            template<typename T2, typename Y2>
-            friend class make_array_helper;
-        public:
-            typedef Y           value_type;
-            typedef Y*          pointer;
-            typedef const Y*    const_pointer;
-            typedef Y&          reference;
-            typedef const Y&    const_reference;
-            typedef std::size_t size_type;
-            typedef ptrdiff_t   difference_type;
-            template<typename U>
-            struct rebind {
-                typedef make_array_helper<T[], U> other;
-            };
-            make_array_helper(std::size_t size_, T** data_)
-                : size(sizeof(T) * size_),
-                  data(data_) {
-            }
-            template<class U>
-            make_array_helper(const make_array_helper<T[], U>& other) 
-                : size(other.size),
-                  data(other.data) {
-            }
-            pointer address(reference value) const {
-                return &value;
-            }
-            const_pointer address(const_reference value) const {
-                return &value;
-            }
-            size_type max_size() const {
-                return static_cast<std::size_t>(-1) / sizeof(Y);
-            }
-            pointer allocate(size_type count, const void* = 0) {
-                std::size_t a1 = boost::alignment_of<T>::value;
-                std::size_t n1 = count * sizeof(Y) + a1 - 1;
-                void*  p1 = ::operator new(n1 + size);
-                char*  p2 = static_cast<char*>(p1) + n1;
-                while (std::size_t(p2) % a1 != 0) {
-                    p2--;
-                }
-                *data = reinterpret_cast<T*>(p2);
-                return  reinterpret_cast<Y*>(p1);
-            }
-            void deallocate(pointer memory, size_type) {
-                void* p1 = memory;
-                ::operator delete(p1);
-            }
-            void construct(pointer memory, const Y& value) {
-                void* p1 = memory;
-                ::new(p1) Y(value);
-            }
-            void destroy(pointer memory) {
-                memory->~Y();
-            }
-            template<typename U>
-            bool operator==(const make_array_helper<T[], U>&) const {
-                return true;
-            }
-            template<typename U>
-            bool operator!=(const make_array_helper<T[], U>& other) const {
-                return !(*this == other); 
-            }
-        private:
-            std::size_t size;
-            T** data;
-        };
-        template<typename T, std::size_t N, typename Y>
-        class make_array_helper<T[N], Y> {
-            template<typename T2, typename Y2>
-            friend class make_array_helper;
-        public:
-            typedef Y           value_type;
-            typedef Y*          pointer;
-            typedef const Y*    const_pointer;
-            typedef Y&          reference;
-            typedef const Y&    const_reference;
-            typedef std::size_t size_type;
-            typedef ptrdiff_t   difference_type;
-            template<typename U>
-            struct rebind {
-                typedef make_array_helper<T[N], U> other;
-            };
-            make_array_helper(T** data_)
-                : data(data_) {
-            }
-            template<class U>
-            make_array_helper(const make_array_helper<T[N], U>& other) 
-                : data(other.data) {
-            }
-            pointer address(reference value) const {
-                return &value;
-            }
-            const_pointer address(const_reference value) const {
-                return &value;
-            }
-            size_type max_size() const {
-                return static_cast<std::size_t>(-1) / sizeof(Y);
-            }
-            pointer allocate(size_type count, const void* = 0) {
-                std::size_t a1 = boost::alignment_of<T>::value;
-                std::size_t n1 = count * sizeof(Y) + a1 - 1;
-                void*  p1 = ::operator new(n1 + N1);
-                char*  p2 = static_cast<char*>(p1) + n1;
-                while (std::size_t(p2) % a1 != 0) {
-                    p2--;
-                }
-                *data = reinterpret_cast<T*>(p2);
-                return  reinterpret_cast<Y*>(p1);
-            }
-            void deallocate(pointer memory, size_type) {
-                void* p1 = memory;
-                ::operator delete(p1);
-            }
-            void construct(pointer memory, const Y& value) {
-                void* p1 = memory;
-                ::new(p1) Y(value);
-            }
-            void destroy(pointer memory) {
-                memory->~Y();
-            }
-            template<typename U>
-            bool operator==(const make_array_helper<T[N], U>&) const {
-                return true;
-            }
-            template<typename U>
-            bool operator!=(const make_array_helper<T[N], U>& other) const {
-                return !(*this == other); 
-            }
-        private:
-            enum {
-                N1 = N * sizeof(T)
-            };
-            T** data;
-        };
-    }
-}
-
-#endif

data/src/cxx_supportlib/vendor-modified/boost/thread/detail/async_func.hpp

@@ -1,571 +0,0 @@
-// Copyright (C) 2012 Vicente J. Botet Escriba
-//
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// 2013/04 Vicente J. Botet Escriba
-//    Provide implementation up to 9 parameters when BOOST_NO_CXX11_VARIADIC_TEMPLATES is defined.
-//    Make use of Boost.Move
-//    Make use of Boost.Tuple (movable)
-// 2012/11 Vicente J. Botet Escriba
-//    Adapt to boost libc++ implementation
-
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-// The async_func code is based on the one from libcxx.
-//===----------------------------------------------------------------------===//
-
-#ifndef BOOST_THREAD_DETAIL_ASYNC_FUNCT_HPP
-#define BOOST_THREAD_DETAIL_ASYNC_FUNCT_HPP
-
-#include <boost/config.hpp>
-
-#include <boost/utility/result_of.hpp>
-#include <boost/thread/detail/move.hpp>
-#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>
-#else
-#include <boost/tuple/tuple.hpp>
-#endif
-
-namespace boost
-{
-  namespace detail
-  {
-
-#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
-    ! defined(BOOST_NO_CXX11_HDR_TUPLE)
-
-    template <class Fp, class ... Args>
-    class async_func
-    {
-      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_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 async_func;
-
-    template <class Fp,
-    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>
-    {
-      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>
-    {
-      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>
-    {
-      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>
-    {
-      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>
-    {
-      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>
-    {
-      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>
-    {
-      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>
-    {
-      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>
-    {
-      Fp fp_;
-      T0 v0_;
-    public:
-      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
-      )
-      : 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 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)
-      : 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
-
-  }
-}
-
-#endif // header