Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/thread/detail')
15 files changed, 3606 insertions, 233 deletions
diff --git a/3rdParty/Boost/src/boost/thread/detail/config.hpp b/3rdParty/Boost/src/boost/thread/detail/config.hpp index 87bad34..5ffe5e4 100644 --- a/3rdParty/Boost/src/boost/thread/detail/config.hpp +++ b/3rdParty/Boost/src/boost/thread/detail/config.hpp @@ -1,6 +1,6 @@ // Copyright (C) 2001-2003 // William E. Kempf -// Copyright (C) 2011-2012 Vicente J. Botet Escriba +// Copyright (C) 2011-2013 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) @@ -8,111 +8,192 @@ #ifndef BOOST_THREAD_CONFIG_WEK01032003_HPP #define BOOST_THREAD_CONFIG_WEK01032003_HPP -// Force SIG_ATOMIC_MAX to be defined -//#ifndef __STDC_LIMIT_MACROS -//#define __STDC_LIMIT_MACROS -//#endif - #include <boost/config.hpp> #include <boost/detail/workaround.hpp> +#include <boost/thread/detail/platform.hpp> + +//#define BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS +// ATTRIBUTE_MAY_ALIAS -#ifdef BOOST_NO_NOEXCEPT -# define BOOST_THREAD_NOEXCEPT_OR_THROW throw() +#if defined(__GNUC__) && !defined(__INTEL_COMPILER) + + // GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with + // regard to violation of the strict aliasing rules. + + #define BOOST_THREAD_DETAIL_USE_ATTRIBUTE_MAY_ALIAS + #define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__)) #else -# define BOOST_THREAD_NOEXCEPT_OR_THROW noexcept + #define BOOST_THREAD_ATTRIBUTE_MAY_ALIAS +#endif + + +#if defined BOOST_THREAD_THROW_IF_PRECONDITION_NOT_SATISFIED +#define BOOST_THREAD_ASSERT_PRECONDITION(EXPR, EX) \ + if (EXPR) {} else boost::throw_exception(EX) +#define BOOST_THREAD_VERIFY_PRECONDITION(EXPR, EX) \ + if (EXPR) {} else boost::throw_exception(EX) +#define BOOST_THREAD_THROW_ELSE_RETURN(EX, RET) \ + boost::throw_exception(EX) +#else +#define BOOST_THREAD_ASSERT_PRECONDITION(EXPR, EX) +#define BOOST_THREAD_VERIFY_PRECONDITION(EXPR, EX) \ + (void)(EXPR) +#define BOOST_THREAD_THROW_ELSE_RETURN(EX, RET) \ + return (RET) #endif // This compiler doesn't support Boost.Chrono -#if defined __IBMCPP__ && (__IBMCPP__ < 1100) && ! defined BOOST_THREAD_DONT_USE_CHRONO +#if defined __IBMCPP__ && (__IBMCPP__ < 1100) \ + && ! defined BOOST_THREAD_DONT_USE_CHRONO #define BOOST_THREAD_DONT_USE_CHRONO +#if ! defined BOOST_THREAD_USES_DATETIME +#define BOOST_THREAD_USES_DATETIME +#endif #endif // This compiler doesn't support Boost.Move -#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) && ! defined BOOST_THREAD_DONT_USE_MOVE +#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) \ + && ! defined BOOST_THREAD_DONT_USE_MOVE #define BOOST_THREAD_DONT_USE_MOVE #endif // This compiler doesn't support Boost.Container Allocators files -#if defined __SUNPRO_CC && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS +#if defined __SUNPRO_CC \ + && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS #define BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS #endif -#if defined _WIN32_WCE && _WIN32_WCE==0x501 && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS +#if defined _WIN32_WCE && _WIN32_WCE==0x501 \ + && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS #define BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS #endif -#if ! defined BOOST_THREAD_DONT_PROVIDE_BASIC_THREAD_ID && ! defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID + +#if defined BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX || defined BOOST_NO_CXX11_HDR_INITIALIZER_LIST +#define BOOST_THREAD_NO_CXX11_HDR_INITIALIZER_LIST +#define BOOST_THREAD_NO_MAKE_LOCK_GUARD +#define BOOST_THREAD_NO_MAKE_STRICT_LOCK +#define BOOST_THREAD_NO_MAKE_NESTED_STRICT_LOCK +#endif + +#if defined(BOOST_NO_CXX11_HDR_TUPLE) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES) +#define BOOST_THREAD_NO_MAKE_UNIQUE_LOCKS +#define BOOST_THREAD_NO_SYNCHRONIZE +#elif defined _MSC_VER && _MSC_VER <= 1600 +// C++ features supported by VC++ 10 (aka 2010) +#define BOOST_THREAD_NO_MAKE_UNIQUE_LOCKS +#define BOOST_THREAD_NO_SYNCHRONIZE +#endif + +/// BASIC_THREAD_ID +#if ! defined BOOST_THREAD_DONT_PROVIDE_BASIC_THREAD_ID \ + && ! defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID #define BOOST_THREAD_PROVIDES_BASIC_THREAD_ID #endif -// Default version is 2 +/// RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR +//#if defined BOOST_NO_CXX11_RVALUE_REFERENCES || defined BOOST_MSVC +#define BOOST_THREAD_RVALUE_REFERENCES_DONT_MATCH_FUNTION_PTR +//#endif + +// Default version #if !defined BOOST_THREAD_VERSION #define BOOST_THREAD_VERSION 2 #else -#if BOOST_THREAD_VERSION!=2 && BOOST_THREAD_VERSION!=3 -#error "BOOST_THREAD_VERSION must be 2 or 3" +#if BOOST_THREAD_VERSION!=2 && BOOST_THREAD_VERSION!=3 && BOOST_THREAD_VERSION!=4 +#error "BOOST_THREAD_VERSION must be 2, 3 or 4" #endif #endif +// CHRONO // Uses Boost.Chrono by default if not stated the opposite defining BOOST_THREAD_DONT_USE_CHRONO -#if ! defined BOOST_THREAD_DONT_USE_CHRONO && ! defined BOOST_THREAD_USES_CHRONO +#if ! defined BOOST_THREAD_DONT_USE_CHRONO \ + && ! defined BOOST_THREAD_USES_CHRONO #define BOOST_THREAD_USES_CHRONO #endif -// Don't provided by default in version 1. -#if defined BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION -#define BOOST_THREAD_EXPLICIT_LOCK_CONVERSION explicit -#else -#define BOOST_THREAD_EXPLICIT_LOCK_CONVERSION +#if ! defined BOOST_THREAD_DONT_USE_ATOMIC \ + && ! defined BOOST_THREAD_USES_ATOMIC +#define BOOST_THREAD_USES_ATOMIC +//#define BOOST_THREAD_DONT_USE_ATOMIC #endif - +#if defined BOOST_THREAD_USES_ATOMIC +// Andrey Semashev +#define BOOST_THREAD_ONCE_ATOMIC +#else +//#elif ! defined BOOST_NO_CXX11_THREAD_LOCAL && ! defined BOOST_NO_THREAD_LOCAL && ! defined BOOST_THREAD_NO_UINT32_PSEUDO_ATOMIC +// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2444.html#Appendix +#define BOOST_THREAD_ONCE_FAST_EPOCH +#endif #if BOOST_THREAD_VERSION==2 -#if ! defined BOOST_THREAD_DONT_PROVIDE_PROMISE_LAZY && ! defined BOOST_THREAD_PROMISE_LAZY -#define BOOST_THREAD_PROMISE_LAZY + +// PROVIDE_PROMISE_LAZY +#if ! defined BOOST_THREAD_DONT_PROVIDE_PROMISE_LAZY \ + && ! defined BOOST_THREAD_PROVIDES_PROMISE_LAZY +#define BOOST_THREAD_PROVIDES_PROMISE_LAZY #endif -#if ! defined BOOST_THREAD_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V3_0_0 -#define BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 + +// PROVIDE_THREAD_EQ +#if ! defined BOOST_THREAD_DONT_PROVIDE_THREAD_EQ \ + && ! defined BOOST_THREAD_PROVIDES_THREAD_EQ +#define BOOST_THREAD_PROVIDES_THREAD_EQ #endif + #endif -#if BOOST_THREAD_VERSION==3 +#if BOOST_THREAD_VERSION>=3 + +// ONCE_CXX11 +// fixme BOOST_THREAD_PROVIDES_ONCE_CXX11 doesn't works when thread.cpp is compiled BOOST_THREAD_VERSION 3 #if ! defined BOOST_THREAD_DONT_PROVIDE_ONCE_CXX11 \ && ! defined BOOST_THREAD_PROVIDES_ONCE_CXX11 -#define BOOST_THREAD_PROVIDES_ONCE_CXX11 +#define BOOST_THREAD_DONT_PROVIDE_ONCE_CXX11 #endif + +// THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE #if ! defined BOOST_THREAD_DONT_PROVIDE_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE \ && ! defined BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE #define BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE #endif + +// THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE #if ! defined BOOST_THREAD_DONT_PROVIDE_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE \ && ! defined BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE #define BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE #endif + +// PROVIDE_FUTURE #if ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE \ && ! defined BOOST_THREAD_PROVIDES_FUTURE #define BOOST_THREAD_PROVIDES_FUTURE #endif + +// FUTURE_CTOR_ALLOCATORS #if ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_CTOR_ALLOCATORS \ && ! defined BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS #define BOOST_THREAD_PROVIDES_FUTURE_CTOR_ALLOCATORS #endif + +// SHARED_MUTEX_UPWARDS_CONVERSIONS #if ! defined BOOST_THREAD_DONT_PROVIDE_SHARED_MUTEX_UPWARDS_CONVERSIONS \ && ! defined BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS #define BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS #endif + +// PROVIDE_EXPLICIT_LOCK_CONVERSION #if ! defined BOOST_THREAD_DONT_PROVIDE_EXPLICIT_LOCK_CONVERSION \ && ! defined BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION #define BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION #endif + +// GENERIC_SHARED_MUTEX_ON_WIN #if ! defined BOOST_THREAD_DONT_PROVIDE_GENERIC_SHARED_MUTEX_ON_WIN \ && ! defined BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN #define BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN #endif -#if ! defined BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 \ - && ! defined BOOST_THREAD_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V3_0_ -#define BOOST_THREAD_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V3_0_0 -#endif + +// USE_MOVE #if ! defined BOOST_THREAD_DONT_USE_MOVE \ && ! defined BOOST_THREAD_USES_MOVE #define BOOST_THREAD_USES_MOVE @@ -120,17 +201,157 @@ #endif +// deprecated since version 4 +#if BOOST_THREAD_VERSION < 4 + +// NESTED_LOCKS +#if ! defined BOOST_THREAD_PROVIDES_NESTED_LOCKS \ + && ! defined BOOST_THREAD_DONT_PROVIDE_NESTED_LOCKS +#define BOOST_THREAD_PROVIDES_NESTED_LOCKS +#endif + +// CONDITION +#if ! defined BOOST_THREAD_PROVIDES_CONDITION \ + && ! defined BOOST_THREAD_DONT_PROVIDE_CONDITION +#define BOOST_THREAD_PROVIDES_CONDITION +#endif + +// USE_DATETIME +#if ! defined BOOST_THREAD_DONT_USE_DATETIME \ + && ! defined BOOST_THREAD_USES_DATETIME +#define BOOST_THREAD_USES_DATETIME +#endif +#endif + +#if BOOST_THREAD_VERSION>=4 + +// SIGNATURE_PACKAGED_TASK +#if ! defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK \ + && ! defined BOOST_THREAD_DONT_PROVIDE_SIGNATURE_PACKAGED_TASK +#define BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK +#endif + +// VARIADIC_THREAD +#if ! defined BOOST_THREAD_PROVIDES_VARIADIC_THREAD \ + && ! defined BOOST_THREAD_DONT_PROVIDE_VARIADIC_THREAD + +#if ! defined(BOOST_NO_SFINAE_EXPR) && \ + ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \ + ! defined(BOOST_NO_CXX11_DECLTYPE) && \ + ! defined(BOOST_NO_CXX11_DECLTYPE_N3276) && \ + ! defined(BOOST_THREAD_NO_CXX11_DECLTYPE_N3276) && \ + ! defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES) && \ + ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \ + ! defined(BOOST_NO_CXX11_HDR_TUPLE) + +#define BOOST_THREAD_PROVIDES_VARIADIC_THREAD +#endif +#endif + +#if ! defined BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY \ + && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_WHEN_ALL_WHEN_ANY + +#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \ + ! defined(BOOST_NO_CXX11_HDR_TUPLE) + +#define BOOST_THREAD_PROVIDES_FUTURE_WHEN_ALL_WHEN_ANY +#endif +#endif + +// ! defined(BOOST_NO_SFINAE_EXPR) && +// ! defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && +// ! defined(BOOST_NO_CXX11_AUTO) && +// ! defined(BOOST_NO_CXX11_DECLTYPE) && +// ! defined(BOOST_NO_CXX11_DECLTYPE_N3276) && + + +// MAKE_READY_AT_THREAD_EXIT +#if ! defined BOOST_THREAD_PROVIDES_MAKE_READY_AT_THREAD_EXIT \ + && ! defined BOOST_THREAD_DONT_PROVIDE_MAKE_READY_AT_THREAD_EXIT + +//#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) +#define BOOST_THREAD_PROVIDES_MAKE_READY_AT_THREAD_EXIT +//#endif +#endif + +// FUTURE_CONTINUATION +#if ! defined BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION \ + && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_CONTINUATION +#define BOOST_THREAD_PROVIDES_FUTURE_CONTINUATION +#endif + +#if ! defined BOOST_THREAD_PROVIDES_FUTURE_UNWRAP \ + && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_UNWRAP +#define BOOST_THREAD_PROVIDES_FUTURE_UNWRAP +#endif + +// FUTURE_INVALID_AFTER_GET +#if ! defined BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET \ + && ! defined BOOST_THREAD_DONT_PROVIDE_FUTURE_INVALID_AFTER_GET +#define BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET +#endif + +// NESTED_LOCKS +#if ! defined BOOST_THREAD_PROVIDES_NESTED_LOCKS \ + && ! defined BOOST_THREAD_DONT_PROVIDE_NESTED_LOCKS +#define BOOST_THREAD_DONT_PROVIDE_NESTED_LOCKS +#endif + +// CONDITION +#if ! defined BOOST_THREAD_PROVIDES_CONDITION \ + && ! defined BOOST_THREAD_DONT_PROVIDE_CONDITION +#define BOOST_THREAD_DONT_PROVIDE_CONDITION +#endif + +#endif // BOOST_THREAD_VERSION>=4 + +// INTERRUPTIONS +#if ! defined BOOST_THREAD_PROVIDES_INTERRUPTIONS \ + && ! defined BOOST_THREAD_DONT_PROVIDE_INTERRUPTIONS +#define BOOST_THREAD_PROVIDES_INTERRUPTIONS +#endif + +// CORRELATIONS + +// EXPLICIT_LOCK_CONVERSION. +#if defined BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION +#define BOOST_THREAD_EXPLICIT_LOCK_CONVERSION explicit +#else +#define BOOST_THREAD_EXPLICIT_LOCK_CONVERSION +#endif + // BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN is defined if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS #if defined BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS \ && ! defined BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN #define BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN #endif -// BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 defined by default up to Boost 1.52 +// For C++11 call_once interface the compiler MUST support constexpr. +// Otherwise once_flag would be initialized during dynamic initialization stage, which is not thread-safe. +#if defined(BOOST_THREAD_PROVIDES_ONCE_CXX11) +#if defined(BOOST_NO_CXX11_CONSTEXPR) +#undef BOOST_THREAD_PROVIDES_ONCE_CXX11 +#endif +#endif + +#if defined(BOOST_THREAD_PLATFORM_WIN32) && defined BOOST_THREAD_DONT_USE_DATETIME +#undef BOOST_THREAD_DONT_USE_DATETIME +#define BOOST_THREAD_USES_DATETIME +#endif + +#if defined(BOOST_THREAD_PLATFORM_WIN32) && defined BOOST_THREAD_DONT_USE_CHRONO +#undef BOOST_THREAD_DONT_USE_CHRONO +#define BOOST_THREAD_USES_CHRONO +#endif + +// BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 defined by default up to Boost 1.55 // BOOST_THREAD_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V3_0_0 defined by default up to Boost 1.55 -#if ! defined BOOST_THREAD_DONT_PROVIDE_DEPRECATED_FEATURES_SINCE_V3_0_0 \ -&& ! defined BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 -#define BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 +#if defined BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 + +#if ! defined BOOST_THREAD_PROVIDES_THREAD_EQ +#define BOOST_THREAD_PROVIDES_THREAD_EQ +#endif + #endif #if BOOST_WORKAROUND(__BORLANDC__, < 0x600) @@ -142,6 +363,13 @@ #include <boost/thread/detail/platform.hpp> +#if defined(BOOST_THREAD_PLATFORM_WIN32) +#else + # if defined(BOOST_HAS_PTHREAD_DELAY_NP) || defined(BOOST_HAS_NANOSLEEP) + # define BOOST_THREAD_SLEEP_FOR_IS_STEADY + # endif +#endif + // provided for backwards compatibility, since this // macro was used for several releases by mistake. #if defined(BOOST_THREAD_DYN_DLL) && ! defined BOOST_THREAD_DYN_LINK @@ -151,7 +379,9 @@ // compatibility with the rest of Boost's auto-linking code: #if defined(BOOST_THREAD_DYN_LINK) || defined(BOOST_ALL_DYN_LINK) # undef BOOST_THREAD_USE_LIB -# define BOOST_THREAD_USE_DLL +# if !defined(BOOST_THREAD_USE_DLL) +# define BOOST_THREAD_USE_DLL +# endif #endif #if defined(BOOST_THREAD_BUILD_DLL) //Build dll @@ -160,8 +390,9 @@ #elif defined(BOOST_THREAD_USE_LIB) //Use lib #else //Use default # if defined(BOOST_THREAD_PLATFORM_WIN32) -# if defined(BOOST_MSVC) || defined(BOOST_INTEL_WIN) - //For compilers supporting auto-tss cleanup +# if defined(BOOST_MSVC) || defined(BOOST_INTEL_WIN) \ + || defined(__MINGW32__) || defined(MINGW32) || defined(BOOST_MINGW32) + //For compilers supporting auto-tss cleanup //with Boost.Threads lib, use Boost.Threads lib # define BOOST_THREAD_USE_LIB # else diff --git a/3rdParty/Boost/src/boost/thread/detail/delete.hpp b/3rdParty/Boost/src/boost/thread/detail/delete.hpp index 30e7c93..4caa340 100644 --- a/3rdParty/Boost/src/boost/thread/detail/delete.hpp +++ b/3rdParty/Boost/src/boost/thread/detail/delete.hpp @@ -15,6 +15,7 @@ * BOOST_THREAD_DELETE_COPY_ASSIGN deletes the copy assignment when the compiler supports it or * makes it private. */ + #ifndef BOOST_NO_CXX11_DELETED_FUNCTIONS #define BOOST_THREAD_DELETE_COPY_CTOR(CLASS) \ CLASS(CLASS const&) = delete; \ @@ -23,6 +24,17 @@ CLASS& operator=(CLASS const&) = delete; #else // BOOST_NO_CXX11_DELETED_FUNCTIONS +#if defined(BOOST_MSVC) && _MSC_VER >= 1600 +#define BOOST_THREAD_DELETE_COPY_CTOR(CLASS) \ + private: \ + CLASS(CLASS const&); \ + public: + +#define BOOST_THREAD_DELETE_COPY_ASSIGN(CLASS) \ + private: \ + CLASS& operator=(CLASS const&); \ + public: +#else #define BOOST_THREAD_DELETE_COPY_CTOR(CLASS) \ private: \ CLASS(CLASS&); \ @@ -32,6 +44,7 @@ private: \ CLASS& operator=(CLASS&); \ public: +#endif #endif // BOOST_NO_CXX11_DELETED_FUNCTIONS /** diff --git a/3rdParty/Boost/src/boost/thread/detail/invoke.hpp b/3rdParty/Boost/src/boost/thread/detail/invoke.hpp new file mode 100644 index 0000000..c81f50f --- /dev/null +++ b/3rdParty/Boost/src/boost/thread/detail/invoke.hpp @@ -0,0 +1,1606 @@ +// Copyright (C) 2012-2013 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 Vicente J. Botet Escriba +// Provide implementation _RET using bind when BOOST_NO_CXX11_HDR_FUNCTIONAL and BOOST_NO_SFINAE_EXPR are not defined +// 2012 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 invoke code is based on the one from libcxx. +//===----------------------------------------------------------------------===// + +#ifndef BOOST_THREAD_DETAIL_INVOKE_HPP +#define BOOST_THREAD_DETAIL_INVOKE_HPP + +#include <boost/config.hpp> +#include <boost/static_assert.hpp> +#include <boost/thread/detail/move.hpp> +#include <boost/core/enable_if.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/type_traits/is_base_of.hpp> +#include <boost/type_traits/is_pointer.hpp> +#include <boost/type_traits/is_member_function_pointer.hpp> +#include <boost/type_traits/remove_reference.hpp> +#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL +#include <functional> +#endif + +namespace boost +{ + namespace detail + { + + +#if ! defined(BOOST_NO_SFINAE_EXPR) && \ + ! defined(BOOST_NO_CXX11_DECLTYPE) && \ + ! defined(BOOST_NO_CXX11_DECLTYPE_N3276) && \ + ! defined(BOOST_THREAD_NO_CXX11_DECLTYPE_N3276) && \ + ! defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES) + +#define BOOST_THREAD_PROVIDES_INVOKE + +#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + // bullets 1 and 2 + + template <class Fp, class A0, class ...Args> + inline auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + -> decltype((boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...)) + { + return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...); + } + template <class R, class Fp, class A0, class ...Args> + inline auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + -> decltype((boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...)) + { + return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...); + } + + template <class Fp, class A0, class ...Args> + inline auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...)) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...); + } + template <class R, class Fp, class A0, class ...Args> + inline auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...)) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...); + } + + // bullets 3 and 4 + + template <class Fp, class A0> + inline auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype(boost::forward<A0>(a0).*f) + { + return boost::forward<A0>(a0).*f; + } + + template <class Fp, class A0> + inline auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype((*boost::forward<A0>(a0)).*f) + { + return (*boost::forward<A0>(a0)).*f; + } + + template <class R, class Fp, class A0> + inline auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype(boost::forward<A0>(a0).*f) + { + return boost::forward<A0>(a0).*f; + } + + template <class R, class Fp, class A0> + inline auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype((*boost::forward<A0>(a0)).*f) + { + return (*boost::forward<A0>(a0)).*f; + } + + + // bullet 5 + + template <class R, class Fp, class ...Args> + inline auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args) + -> decltype(boost::forward<Fp>(f)(boost::forward<Args>(args)...)) + { + return boost::forward<Fp>(f)(boost::forward<Args>(args)...); + } + template <class Fp, class ...Args> + inline auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args) + -> decltype(boost::forward<Fp>(f)(boost::forward<Args>(args)...)) + { + return boost::forward<Fp>(f)(boost::forward<Args>(args)...); + } + +#else // BOOST_NO_CXX11_VARIADIC_TEMPLATES + + // bullets 1 and 2 + + template <class Fp, class A0> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype((boost::forward<A0>(a0).*f)()) + { + return (boost::forward<A0>(a0).*f)(); + } + template <class R, class Fp, class A0> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype((boost::forward<A0>(a0).*f)()) + { + return (boost::forward<A0>(a0).*f)(); + } + template <class Fp, class A0, class A1> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1) + -> decltype((boost::forward<A0>(a0).*f)(boost::forward<A1>(a1))) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1)); + } + template <class R, class Fp, class A0, class A1> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1) + -> decltype((boost::forward<A0>(a0).*f)(boost::forward<A1>(a1))) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1)); + } + template <class Fp, class A0, class A1, class A2> + inline + auto + 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) + -> decltype((boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2))) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class R, class Fp, class A0, class A1, class A2> + inline + auto + 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) + -> decltype((boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2))) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + + template <class Fp, class A0> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype(((*boost::forward<A0>(a0)).*f)()) + { + return ((*boost::forward<A0>(a0)).*f)(); + } + template <class R, class Fp, class A0> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype(((*boost::forward<A0>(a0)).*f)()) + { + return ((*boost::forward<A0>(a0)).*f)(); + } + template <class Fp, class A0, class A1> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1) + -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1))) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1)); + } + template <class R, class Fp, class A0, class A1> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1) + -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1))) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1)); + } + template <class Fp, class A0, class A1, class A2> + inline + auto + 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) + -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2))) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class R, class Fp, class A0, class A1, class A2> + inline + auto + 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) + -> decltype(((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2))) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + + // bullets 3 and 4 + + template <class Fp, class A0> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype(boost::forward<A0>(a0).*f) + { + return boost::forward<A0>(a0).*f; + } + template <class R, class Fp, class A0> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype(boost::forward<A0>(a0).*f) + { + return boost::forward<A0>(a0).*f; + } + + template <class Fp, class A0> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype((*boost::forward<A0>(a0)).*f) + { + return (*boost::forward<A0>(a0)).*f; + } + template <class R, class Fp, class A0> + inline + auto + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A0) a0) + -> decltype((*boost::forward<A0>(a0)).*f) + { + return (*boost::forward<A0>(a0)).*f; + } + + // bullet 5 + + template <class Fp> + inline + auto invoke(BOOST_THREAD_RV_REF(Fp) f) + -> decltype(boost::forward<Fp>(f)()) + { + return boost::forward<Fp>(f)(); + } + template <class Fp, class A1> + inline + auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1) + -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1))) + { + return boost::forward<Fp>(f)(boost::forward<A1>(a1)); + } template <class Fp, class A1, class A2> + inline + auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2))) + { + return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class Fp, class A1, class A2, class A3> + inline + 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) + -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3))) + { + return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + + + template <class R, class Fp> + inline + auto invoke(BOOST_THREAD_RV_REF(Fp) f) + -> decltype(boost::forward<Fp>(f)()) + { + return boost::forward<Fp>(f)(); + } + template <class R, class Fp, class A1> + inline + auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1) + -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1))) + { + return boost::forward<Fp>(f)(boost::forward<A1>(a1)); + } + template <class R, class Fp, class A1, class A2> + inline + auto invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2))) + { + return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class R, class Fp, class A1, class A2, class A3> + inline + 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) + -> decltype(boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3))) + { + return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + +#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES + +#elif ! defined(BOOST_NO_SFINAE_EXPR) && \ + ! defined BOOST_NO_CXX11_HDR_FUNCTIONAL && \ + defined BOOST_MSVC + +//#error + template <class Ret, class Fp> + inline + Ret invoke(BOOST_THREAD_RV_REF(Fp) f) + { + return f(); + } + template <class Ret, class Fp, class A1> + inline + Ret invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1) + { + return std::bind(boost::forward<Fp>(f), boost::forward<A1>(a1))(); + } + template <class Ret, class Fp, class A1, class A2> + inline + Ret invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + { + return std::bind(boost::forward<Fp>(f), boost::forward<A1>(a1), boost::forward<A2>(a2))(); + } + template <class Ret, class Fp, class A1, class A2, class A3> + inline + 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) + { + return std::bind(boost::forward<Fp>(f), boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3))(); + } + +#define BOOST_THREAD_PROVIDES_INVOKE_RET + +#elif ! defined BOOST_MSVC +//!!!!! WARNING !!!!! THIS DOESN'T WORKS YET +#define BOOST_THREAD_PROVIDES_INVOKE_RET + +#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + + // bullet 1 + // (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is an object of + // type T or a reference to an object of type T or a reference to an object of a type derived from T + template <class Ret, class A, class A0, class ...Args> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(Args...), BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + { + return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...); + } + + template <class Ret, class A, class A0, class ...Args> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(Args...) const, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + { + return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...); + } + + template <class Ret, class A, class A0, class ...Args> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(Args...) volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + { + return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...); + } + + template <class Ret, class A, class A0, class ...Args> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(Args...) const volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + { + return (boost::forward<A0>(a0).*f)(boost::forward<Args>(args)...); + } + + // bullet 2 + // ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is not one of + // the types described in the previous item; + template <class Ret, class A, class A0, class ...Args> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(Args...), BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...); + } + + template <class Ret, class A, class A0, class ...Args> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(Args...) const, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...); + } + + template <class Ret, class A, class A0, class ...Args> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(Args...) volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...); + } + + template <class Ret, class A, class A0, class ...Args> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(Args...) const volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(Args) ...args) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<Args>(args)...); + } + + // bullet 3 + // 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 + // reference to an object of type T or a reference to an object of a type derived from T; +// template <class Ret, class A, class A0> +// inline +// typename enable_if_c +// < +// is_base_of<A, typename remove_reference<A0>::type>::value, +// typename detail::apply_cv<A0, A>::type& +// >::type +// invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0) +// { +// return boost::forward<A0>(a0).*f; +// } + + // bullet 4 + // (*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 + //described in the previous item; + +// template <class A0, class Ret, bool> +// struct d4th_helper +// { +// }; +// +// template <class A0, class Ret> +// struct d4th_helper<A0, Ret, true> +// { +// typedef typename apply_cv<decltype(*declval<A0>()), Ret>::type type; +// }; +// +// template <class Ret, class A, class A0> +// inline +// typename detail::4th_helper<A, Ret, +// !is_base_of<A, +// typename remove_reference<A0>::type +// >::value +// >::type& +// invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0) +// { +// return (*boost::forward<A0>(a0)).*f; +// } + +// template <class Ret, class A, class A0> +// inline +// typename enable_if_c +// < +// !is_base_of<A, typename remove_reference<A0>::type>::value, +// typename detail::ref_return1<Ret A::*, A0>::type +// >::type +// invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0) +// { +// return (*boost::forward<A0>(a0)).*f; +// } + + // bullet 5 + // f(t1, t2, ..., tN) in all other cases. + + template <class Ret, class Fp, class ...Args> + inline Ret do_invoke(mpl::false_, BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args) + { + return boost::forward<Fp>(f)(boost::forward<Args>(args)...); + } + + template <class Ret, class Fp, class ...Args> + inline Ret do_invoke(mpl::true_, BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args) + { + return f(boost::forward<Args>(args)...); + } + + template <class Ret, class Fp, class ...Args> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(BOOST_THREAD_RV_REF(Fp) f, BOOST_THREAD_RV_REF(Args) ...args) + { + return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), boost::forward<Args>(args)...); + } +#else // BOOST_NO_CXX11_VARIADIC_TEMPLATES + // bullet 1 + // (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is an object of + // type T or a reference to an object of type T or a reference to an object of a type derived from T + + template <class Ret, class A, class A0> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(), A0& a0) + { + return (a0.*f)(); + } + template <class Ret, class A, class A0> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(), A0* a0) + { + return ((*a0).*f)(); + } + + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1), + A0& a0, BOOST_THREAD_RV_REF(A1) a1 + ) + { + return (a0.*f)(boost::forward<A1>(a1)); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1), A0& a0, A1 a1) + { + return (a0.*f)(a1); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1), A0* a0, BOOST_THREAD_RV_REF(A1) a1 + ) + { + return (*(a0).*f)(boost::forward<A1>(a1)); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1), A0* a0, A1 a1) + { + return (*a0.*f)(a1); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2), + A0& a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2 + ) + { + return (a0.*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2), A0* a0, A1 a1, A2 a2) + { + return ((*a0).*f)(a1, a2); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3), + A0& a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3) + { + return (a0.*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3), A0* a0, A1 a1, A2 a2, A3 a3) + { + return ((*a0).*f)(a1, a2, a3); + } + +/// + template <class Ret, class A, class A0> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)() const, A0 const& a0) + { + return (a0.*f)(); + } + template <class Ret, class A, class A0> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)() const, A0 const* a0) + { + return ((*a0).*f)(); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) const, A0 const& a0, BOOST_THREAD_RV_REF(A1) a1) + { + return (a0.*f)(boost::forward<A1>(a1)); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) const, A0 const* a0, BOOST_THREAD_RV_REF(A1) a1) + { + return ((*a0).*f)(boost::forward<A1>(a1)); + } + + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) const, A0 const& a0, A1 a1) + { + return (a0.*f)(a1); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) const, + A0 const& a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2 + ) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2) + ); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) const, A0 const& a0, A1 a1, A2 a2) + { + return (a0.*f)(a1, a2); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) const, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3 + ) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) const, A0 a0, A1 a1, A2 a2, A3 a3) + { + return (a0.*f)(a1, a2, a3); + } + /// + template <class Ret, class A, class A0> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)() volatile, BOOST_THREAD_RV_REF(A0) a0) + { + return (boost::forward<A0>(a0).*f)(); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1)); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) volatile, A0 a0, A1 a1) + { + return (a0.*f)(a1); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) volatile, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) volatile, A0 a0, A1 a1, A2 a2 ) + { + return (a0.*f)(a1, a2); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) volatile, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3 + ) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) + { + return (a0.*f)(a1, a2, a3); + } + /// + template <class Ret, class A, class A0> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)() const volatile, BOOST_THREAD_RV_REF(A0) a0) + { + return (boost::forward<A0>(a0).*f)(); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) const volatile, BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1)); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) const volatile, A0 a0, A1 a1) + { + return (a0.*f)(a1); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) const volatile, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2 + ) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) const volatile, + A0 a0, A1 a1, A2 a2 + ) + { + return (a0.*f)(a1, a2); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) const volatile, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3 + ) + { + return (boost::forward<A0>(a0).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) const volatile, + A0 a0, A1 a1, A2 a2, A3 a3 + ) + { + return (a0.*f)(a1, a2, a3); + } + + // bullet 2 + // ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is not one of + // the types described in the previous item; + template <class Ret, class A, class A0> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(), BOOST_THREAD_RV_REF(A0) a0) + { + return ((*boost::forward<A0>(a0)).*f)(); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1), BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1)); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1), A0 a0, A1 a1) + { + return ((*a0).*f)(a1); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, BOOST_THREAD_RV_REF(A2)), + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2), A0 a0, A1 a1, A2 a2) + { + return ((*a0).*f)(a1, a2); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, BOOST_THREAD_RV_REF(A2), BOOST_THREAD_RV_REF(A3)), + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3) + ); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3), A0 a0, A1 a1, A2 a2, A3 a3) + { + return ((*a0).*f)(a1, a2, a3); + } + +/// + template <class Ret, class A, class A0> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)() const, BOOST_THREAD_RV_REF(A0) a0) + { + return ((*boost::forward<A0>(a0)).*f)(); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) const, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1)); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) const, BOOST_THREAD_RV_REF(A0) a0, A1 a1) + { + return ((*boost::forward<A0>(a0)).*f)(a1); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) const, A0 a0, A1 a1) + { + return ((*a0).*f)(a1); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) const, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) const, A0 a0, A1 a1, A2 a2) + { + return ((*a0).*f)(a1, a2); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) const, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) const, + A0 a0, A1 a1, A2 a2, A3 a3) + { + return ((*a0).*f)(a1, a2, a3); + } + /// + template <class Ret, class A, class A0> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)() volatile, BOOST_THREAD_RV_REF(A0) a0) + { + return ((*boost::forward<A0>(a0)).*f)(); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) volatile, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1)); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) volatile, A0 a0, A1 a1) + { + return ((*a0).*f)(a1); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) volatile, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) volatile, A0 a0, A1 a1, A2 a2) + { + return ((*a0).*f)(a1, a2); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) volatile, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) volatile, A0 a0, A1 a1, A2 a2, A3 a3) + { + return ((*a0).*f)(a1, a2, a3); + } + /// + template <class Ret, class A, class A0> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)() const volatile, BOOST_THREAD_RV_REF(A0) a0) + { + return ((*boost::forward<A0>(a0)).*f)(); + } + template <class Ret, class A, class A0> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)() const volatile, A0 a0) + { + return ((*a0).*f)(); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) const volatile, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1)); + } + template <class Ret, class A, class A0, class A1> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1) const volatile, A0 a0, A1 a1) + { + return ((*a0).*f)(a1); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) const volatile, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class Ret, class A, class A0, class A1, class A2> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2) const volatile, + A0 a0, A1 a1, A2 a2) + { + return ((*a0).*f)(a1, a2); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) const volatile, + BOOST_THREAD_RV_REF(A0) a0, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3) + { + return ((*boost::forward<A0>(a0)).*f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + template <class Ret, class A, class A0, class A1, class A2, class A3> + inline + typename enable_if_c + < + ! is_base_of<A, typename remove_reference<A0>::type>::value, + Ret + >::type + invoke(Ret (A::*f)(A1, A2, A3) const volatile, + A0 a0, A1 a1, A2 a2, A3 a3) + { + return ((*a0).*f)(a1, a2, a3); + } + // bullet 3 + // 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 + // reference to an object of type T or a reference to an object of a type derived from T; +// template <class Ret, class A, class A0> +// inline +// typename enable_if_c +// < +// is_base_of<A, typename remove_reference<A0>::type>::value, +// typename detail::apply_cv<A0, A>::type& +// >::type +// invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0) +// { +// return boost::forward<A0>(a0).*f; +// } + + // bullet 4 + // (*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 + //described in the previous item; + +// template <class A0, class Ret, bool> +// struct d4th_helper +// { +// }; +// +// template <class A0, class Ret> +// struct d4th_helper<A0, Ret, true> +// { +// typedef typename apply_cv<decltype(*declval<A0>()), Ret>::type type; +// }; +// +// template <class Ret, class A, class A0> +// inline +// typename detail::4th_helper<A, Ret, +// !is_base_of<A, +// typename remove_reference<A0>::type +// >::value +// >::type& +// invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0) +// { +// return (*boost::forward<A0>(a0)).*f; +// } + +// template <class Ret, class A, class A0> +// inline +// typename enable_if_c +// < +// !is_base_of<A, typename remove_reference<A0>::type>::value, +// typename detail::ref_return1<Ret A::*, A0>::type +// >::type +// invoke(Ret A::* f, BOOST_THREAD_RV_REF(A0) a0) +// { +// return (*boost::forward<A0>(a0)).*f; +// } + + // bullet 5 + // f(t1, t2, ..., tN) in all other cases. + + template <class Ret, class Fp> + inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f) + { + return boost::forward<Fp>(f)(); + } + template <class Ret, class Fp> + inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f) + { + return f(); + } + template <class Ret, class Fp> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(BOOST_THREAD_FWD_REF(Fp) f) + { + return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f)); + } + + template <class Ret, class Fp, class A1> + inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1) + { + return boost::forward<Fp>(f)(boost::forward<A1>(a1)); + } + template <class Ret, class Fp, class A1> + inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1) + { + return f(boost::forward<A1>(a1)); + } + template <class Ret, class Fp, class A1> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1) + { + return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), boost::forward<A1>(a1)); + } + + template <class Ret, class Fp, class A1, class A2> + inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + { + return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class Ret, class Fp, class A1, class A2> + inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + { + return f(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class Ret, class Fp, class A1, class A2> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + { + return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + + template <class Ret, class Fp, class A1, class A2, class A3> + inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3) + { + return boost::forward<Fp>(f)(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + template <class Ret, class Fp, class A1, class A2, class A3> + inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3) + { + return f(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + template <class Ret, class Fp, class A1, class A2, class A3> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + 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) + { + 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)); + } + + + template <class Ret, class Fp, class A1> + inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1) + { + return boost::forward<Fp>(f)(a1); + } + template <class Ret, class Fp, class A1> + inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1) + { + return f(a1); + } + template <class Ret, class Fp, class A1> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(BOOST_THREAD_FWD_REF(Fp) f, A1 a1) + { + return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), a1); + } + + template <class Ret, class Fp, class A1, class A2> + inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2) + { + return boost::forward<Fp>(f)(a1, a2); + } + template <class Ret, class Fp, class A1, class A2> + inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2) + { + return f(a1, a2); + } + template <class Ret, class Fp, class A1, class A2> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2) + { + return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), a1, a2); + } + + template <class Ret, class Fp, class A1, class A2, class A3> + inline Ret do_invoke(mpl::false_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2, A3 a3) + { + return boost::forward<Fp>(f)(a1, a2, a3); + } + template <class Ret, class Fp, class A1, class A2, class A3> + inline Ret do_invoke(mpl::true_, BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2, A3 a3) + { + return f(a1, a2, a3); + } + template <class Ret, class Fp, class A1, class A2, class A3> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(BOOST_THREAD_FWD_REF(Fp) f, A1 a1, A2 a2, A3 a3) + { + return boost::detail::do_invoke<Ret>(boost::is_pointer<Fp>(), boost::forward<Fp>(f), a1, a2, a3); + } + + + /// + template <class Ret, class Fp> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(Fp &f) + { + return f(); + } + template <class Ret, class Fp, class A1> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(Fp &f, BOOST_THREAD_RV_REF(A1) a1) + { + return f(boost::forward<A1>(a1)); + } + template <class Ret, class Fp, class A1> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(Fp &f, A1 a1) + { + return f(a1); + } + template <class Ret, class Fp, class A1, class A2> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(Fp &f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2) + { + return f(boost::forward<A1>(a1), boost::forward<A2>(a2)); + } + template <class Ret, class Fp, class A1, class A2> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(Fp &f, A1 a1, A2 a2) + { + return f(a1, a2); + } + template <class Ret, class Fp, class A1, class A2, class A3> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(Fp &f, BOOST_THREAD_RV_REF(A1) a1, BOOST_THREAD_RV_REF(A2) a2, BOOST_THREAD_RV_REF(A3) a3) + { + return f(boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)); + } + template <class Ret, class Fp, class A1, class A2, class A3> + inline + typename disable_if_c + < + is_member_function_pointer<Fp>::value, + Ret + >::type + invoke(Fp &f, A1 a1, A2 a2, A3 a3) + { + return f(a1, a2, a3); + } + /// + +#endif // BOOST_NO_CXX11_VARIADIC_TEMPLATES + +#endif // all + } + } + +#endif // header diff --git a/3rdParty/Boost/src/boost/thread/detail/invoker.hpp b/3rdParty/Boost/src/boost/thread/detail/invoker.hpp new file mode 100644 index 0000000..aeac530 --- /dev/null +++ b/3rdParty/Boost/src/boost/thread/detail/invoker.hpp @@ -0,0 +1,738 @@ +// 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 invoker 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> +#include <boost/thread/csbl/tuple.hpp> +#include <boost/tuple/tuple.hpp> + +#include <boost/thread/detail/variadic_header.hpp> + +namespace boost +{ + namespace detail + { + +#if defined(BOOST_THREAD_PROVIDES_INVOKE) && ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && ! defined(BOOST_NO_CXX11_HDR_TUPLE) + + template <class Fp, class ... Args> + class invoker + { + //typedef typename decay<Fp>::type Fpd; + //typedef tuple<typename decay<Args>::type...> Argsd; + + //csbl::tuple<Fpd, Argsd...> f_; + csbl::tuple<Fp, Args...> f_; + + public: + BOOST_THREAD_MOVABLE_ONLY( invoker) + //typedef typename invoke_of<_Fp, _Args...>::type Rp; + typedef typename result_of<Fp(Args...)>::type result_type; + + template <class F, class ... As> + BOOST_SYMBOL_VISIBLE + explicit invoker(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(As)... args) + : f_(boost::forward<F>(f), boost::forward<As>(args)...) + {} + + BOOST_SYMBOL_VISIBLE + invoker(BOOST_THREAD_RV_REF(invoker) f) : f_(boost::move(BOOST_THREAD_RV(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(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...); + } + }; + + template <class R, class Fp, class ... Args> + class invoker_ret + { + //typedef typename decay<Fp>::type Fpd; + //typedef tuple<typename decay<Args>::type...> Argsd; + + //csbl::tuple<Fpd, Argsd...> f_; + csbl::tuple<Fp, Args...> f_; + + public: + BOOST_THREAD_MOVABLE_ONLY( invoker_ret) + typedef R result_type; + + template <class F, class ... As> + BOOST_SYMBOL_VISIBLE + explicit invoker_ret(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(As)... args) + : f_(boost::forward<F>(f), boost::forward<As>(args)...) + {} + + BOOST_SYMBOL_VISIBLE + invoker_ret(BOOST_THREAD_RV_REF(invoker_ret) f) : f_(boost::move(BOOST_THREAD_RV(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<R>(boost::move(csbl::get<0>(f_)), boost::move(csbl::get<Indices>(f_))...); + } + }; + //BOOST_THREAD_DCL_MOVABLE_BEG(X) invoker<Fp> BOOST_THREAD_DCL_MOVABLE_END +#else + +#if ! defined BOOST_MSVC + +#define BOOST_THREAD_RV_REF_ARG_T(z, n, unused) BOOST_PP_COMMA_IF(n) BOOST_THREAD_RV_REF(Arg##n) +#define BOOST_THREAD_RV_REF_A_T(z, n, unused) BOOST_PP_COMMA_IF(n) BOOST_THREAD_RV_REF(A##n) +#define BOOST_THREAD_RV_REF_ARG(z, n, unused) , BOOST_THREAD_RV_REF(Arg##n) arg##n +#define BOOST_THREAD_FWD_REF_A(z, n, unused) , BOOST_THREAD_FWD_REF(A##n) arg##n +#define BOOST_THREAD_FWD_REF_ARG(z, n, unused) , BOOST_THREAD_FWD_REF(Arg##n) arg##n +#define BOOST_THREAD_FWD_PARAM(z, n, unused) , boost::forward<Arg##n>(arg##n) +#define BOOST_THREAD_FWD_PARAM_A(z, n, unused) , boost::forward<A##n>(arg##n) +#define BOOST_THREAD_DCL(z, n, unused) Arg##n v##n; +#define BOOST_THREAD_MOVE_PARAM(z, n, unused) , v##n(boost::move(arg##n)) +#define BOOST_THREAD_FORWARD_PARAM_A(z, n, unused) , v##n(boost::forward<A##n>(arg##n)) +#define BOOST_THREAD_MOVE_RHS_PARAM(z, n, unused) , v##n(boost::move(x.v##n)) +#define BOOST_THREAD_MOVE_DCL(z, n, unused) , boost::move(v##n) +#define BOOST_THREAD_MOVE_DCL_T(z, n, unused) BOOST_PP_COMMA_IF(n) boost::move(v##n) +#define BOOST_THREAD_ARG_DEF(z, n, unused) , class Arg##n = tuples::null_type + + template <class Fp, class Arg = tuples::null_type + BOOST_PP_REPEAT(BOOST_THREAD_MAX_ARGS, BOOST_THREAD_ARG_DEF, ~) + > + class invoker; + +#define BOOST_THREAD_ASYNC_FUNCT(z, n, unused) \ + template <class Fp BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class Arg) > \ + class invoker<Fp BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Arg)> \ + { \ + Fp fp_; \ + BOOST_PP_REPEAT(n, BOOST_THREAD_DCL, ~) \ + public: \ + BOOST_THREAD_MOVABLE_ONLY(invoker) \ + typedef typename result_of<Fp(BOOST_PP_ENUM_PARAMS(n, Arg))>::type result_type; \ + \ + template <class F BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A) > \ + BOOST_SYMBOL_VISIBLE \ + explicit invoker(BOOST_THREAD_FWD_REF(F) f \ + BOOST_PP_REPEAT(n, BOOST_THREAD_FWD_REF_A, ~) \ + ) \ + : fp_(boost::forward<F>(f)) \ + BOOST_PP_REPEAT(n, BOOST_THREAD_FORWARD_PARAM_A, ~) \ + {} \ + \ + BOOST_SYMBOL_VISIBLE \ + invoker(BOOST_THREAD_FWD_REF(invoker) x) \ + : fp_(boost::move(x.fp_)) \ + BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_RHS_PARAM, ~) \ + {} \ + \ + result_type operator()() { \ + return invoke(boost::move(fp_) \ + BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_DCL, ~) \ + ); \ + } \ + }; \ + \ + template <class R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class Arg) > \ + class invoker<R(*)(BOOST_PP_REPEAT(n, BOOST_THREAD_RV_REF_ARG_T, ~)) BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, Arg)> \ + { \ + typedef R(*Fp)(BOOST_PP_REPEAT(n, BOOST_THREAD_RV_REF_ARG_T, ~)); \ + Fp fp_; \ + BOOST_PP_REPEAT(n, BOOST_THREAD_DCL, ~) \ + public: \ + BOOST_THREAD_MOVABLE_ONLY(invoker) \ + typedef typename result_of<Fp(BOOST_PP_ENUM_PARAMS(n, Arg))>::type result_type; \ + \ + template <class R2 BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A) > \ + BOOST_SYMBOL_VISIBLE \ + explicit invoker(R2(*f)(BOOST_PP_REPEAT(n, BOOST_THREAD_RV_REF_A_T, ~)) \ + BOOST_PP_REPEAT(n, BOOST_THREAD_FWD_REF_A, ~) \ + ) \ + : fp_(f) \ + BOOST_PP_REPEAT(n, BOOST_THREAD_FORWARD_PARAM_A, ~) \ + {} \ + \ + BOOST_SYMBOL_VISIBLE \ + invoker(BOOST_THREAD_FWD_REF(invoker) x) \ + : fp_(x.fp_) \ + BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_RHS_PARAM, ~) \ + {} \ + \ + result_type operator()() { \ + return fp_( \ + BOOST_PP_REPEAT(n, BOOST_THREAD_MOVE_DCL_T, ~) \ + ); \ + } \ + }; + + BOOST_PP_REPEAT(BOOST_THREAD_MAX_ARGS, BOOST_THREAD_ASYNC_FUNCT, ~) + + #undef BOOST_THREAD_RV_REF_ARG_T + #undef BOOST_THREAD_RV_REF_ARG + #undef BOOST_THREAD_FWD_REF_ARG + #undef BOOST_THREAD_FWD_REF_A + #undef BOOST_THREAD_FWD_PARAM + #undef BOOST_THREAD_FWD_PARAM_A + #undef BOOST_THREAD_DCL + #undef BOOST_THREAD_MOVE_PARAM + #undef BOOST_THREAD_MOVE_RHS_PARAM + #undef BOOST_THREAD_MOVE_DCL + #undef BOOST_THREAD_ARG_DEF + #undef BOOST_THREAD_ASYNC_FUNCT + +#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 invoker; + + template <class Fp, + class T0 , class T1 , class T2 , + class T3 , class T4 , class T5 , + class T6 , class T7 , class T8 > + class invoker<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(invoker) + typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6, T7, T8)>::type result_type; + + BOOST_SYMBOL_VISIBLE + explicit invoker(BOOST_THREAD_FWD_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 + invoker(BOOST_THREAD_FWD_REF(invoker) f) + : fp_(boost::move(BOOST_THREAD_RV(f).fp)) + , v0_(boost::move(BOOST_THREAD_RV(f).v0_)) + , v1_(boost::move(BOOST_THREAD_RV(f).v1_)) + , v2_(boost::move(BOOST_THREAD_RV(f).v2_)) + , v3_(boost::move(BOOST_THREAD_RV(f).v3_)) + , v4_(boost::move(BOOST_THREAD_RV(f).v4_)) + , v5_(boost::move(BOOST_THREAD_RV(f).v5_)) + , v6_(boost::move(BOOST_THREAD_RV(f).v6_)) + , v7_(boost::move(BOOST_THREAD_RV(f).v7_)) + , v8_(boost::move(BOOST_THREAD_RV(f).v8_)) + {} + + 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 invoker<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(invoker) + typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6, T7)>::type result_type; + + BOOST_SYMBOL_VISIBLE + explicit invoker(BOOST_THREAD_FWD_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 + invoker(BOOST_THREAD_FWD_REF(invoker) f) + : fp_(boost::move(BOOST_THREAD_RV(f).fp)) + , v0_(boost::move(BOOST_THREAD_RV(f).v0_)) + , v1_(boost::move(BOOST_THREAD_RV(f).v1_)) + , v2_(boost::move(BOOST_THREAD_RV(f).v2_)) + , v3_(boost::move(BOOST_THREAD_RV(f).v3_)) + , v4_(boost::move(BOOST_THREAD_RV(f).v4_)) + , v5_(boost::move(BOOST_THREAD_RV(f).v5_)) + , v6_(boost::move(BOOST_THREAD_RV(f).v6_)) + , v7_(boost::move(BOOST_THREAD_RV(f).v7_)) + {} + + 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 invoker<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(invoker) + typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5, T6)>::type result_type; + + BOOST_SYMBOL_VISIBLE + explicit invoker(BOOST_THREAD_FWD_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 + invoker(BOOST_THREAD_FWD_REF(invoker) f) + : fp_(boost::move(BOOST_THREAD_RV(f).fp)) + , v0_(boost::move(BOOST_THREAD_RV(f).v0_)) + , v1_(boost::move(BOOST_THREAD_RV(f).v1_)) + , v2_(boost::move(BOOST_THREAD_RV(f).v2_)) + , v3_(boost::move(BOOST_THREAD_RV(f).v3_)) + , v4_(boost::move(BOOST_THREAD_RV(f).v4_)) + , v5_(boost::move(BOOST_THREAD_RV(f).v5_)) + , v6_(boost::move(BOOST_THREAD_RV(f).v6_)) + {} + + 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 invoker<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(invoker) + typedef typename result_of<Fp(T0, T1, T2, T3, T4, T5)>::type result_type; + + BOOST_SYMBOL_VISIBLE + explicit invoker(BOOST_THREAD_FWD_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 + invoker(BOOST_THREAD_FWD_REF(invoker) f) + : fp_(boost::move(BOOST_THREAD_RV(f).fp)) + , v0_(boost::move(BOOST_THREAD_RV(f).v0_)) + , v1_(boost::move(BOOST_THREAD_RV(f).v1_)) + , v2_(boost::move(BOOST_THREAD_RV(f).v2_)) + , v3_(boost::move(BOOST_THREAD_RV(f).v3_)) + , v4_(boost::move(BOOST_THREAD_RV(f).v4_)) + , v5_(boost::move(BOOST_THREAD_RV(f).v5_)) + {} + + 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 invoker<Fp, T0, T1, T2, T3, T4> + { + Fp fp_; + T0 v0_; + T1 v1_; + T2 v2_; + T3 v3_; + T4 v4_; + public: + BOOST_THREAD_MOVABLE_ONLY(invoker) + typedef typename result_of<Fp(T0, T1, T2, T3, T4)>::type result_type; + + BOOST_SYMBOL_VISIBLE + explicit invoker(BOOST_THREAD_FWD_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 + invoker(BOOST_THREAD_FWD_REF(invoker) f) + : fp_(boost::move(BOOST_THREAD_RV(f).fp)) + , v0_(boost::move(BOOST_THREAD_RV(f).v0_)) + , v1_(boost::move(BOOST_THREAD_RV(f).v1_)) + , v2_(boost::move(BOOST_THREAD_RV(f).v2_)) + , v3_(boost::move(BOOST_THREAD_RV(f).v3_)) + , v4_(boost::move(BOOST_THREAD_RV(f).v4_)) + {} + + 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 invoker<Fp, T0, T1, T2, T3> + { + Fp fp_; + T0 v0_; + T1 v1_; + T2 v2_; + T3 v3_; + public: + BOOST_THREAD_MOVABLE_ONLY(invoker) + typedef typename result_of<Fp(T0, T1, T2, T3)>::type result_type; + + BOOST_SYMBOL_VISIBLE + explicit invoker(BOOST_THREAD_FWD_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 + invoker(BOOST_THREAD_FWD_REF(invoker) f) + : fp_(boost::move(BOOST_THREAD_RV(f).fp)) + , v0_(boost::move(BOOST_THREAD_RV(f).v0_)) + , v1_(boost::move(BOOST_THREAD_RV(f).v1_)) + , v2_(boost::move(BOOST_THREAD_RV(f).v2_)) + , v3_(boost::move(BOOST_THREAD_RV(f).v3_)) + {} + + 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 invoker<Fp, T0, T1, T2> + { + Fp fp_; + T0 v0_; + T1 v1_; + T2 v2_; + public: + BOOST_THREAD_MOVABLE_ONLY(invoker) + typedef typename result_of<Fp(T0, T1, T2)>::type result_type; + + BOOST_SYMBOL_VISIBLE + explicit invoker(BOOST_THREAD_FWD_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 + invoker(BOOST_THREAD_FWD_REF(invoker) f) + : fp_(boost::move(BOOST_THREAD_RV(f).fp)) + , v0_(boost::move(BOOST_THREAD_RV(f).v0_)) + , v1_(boost::move(BOOST_THREAD_RV(f).v1_)) + , v2_(boost::move(BOOST_THREAD_RV(f).v2_)) + {} + + 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 invoker<Fp, T0, T1> + { + Fp fp_; + T0 v0_; + T1 v1_; + public: + BOOST_THREAD_MOVABLE_ONLY(invoker) + typedef typename result_of<Fp(T0, T1)>::type result_type; + + BOOST_SYMBOL_VISIBLE + explicit invoker(BOOST_THREAD_FWD_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 + invoker(BOOST_THREAD_FWD_REF(invoker) f) + : fp_(boost::move(BOOST_THREAD_RV(f).fp)) + , v0_(boost::move(BOOST_THREAD_RV(f).v0_)) + , v1_(boost::move(BOOST_THREAD_RV(f).v1_)) + {} + + result_type operator()() + { + return invoke(boost::move(fp_) + , boost::move(v0_) + , boost::move(v1_) + ); + } + }; + template <class Fp, class T0> + class invoker<Fp, T0> + { + Fp fp_; + T0 v0_; + public: + BOOST_THREAD_MOVABLE_ONLY(invoker) + typedef typename result_of<Fp(T0)>::type result_type; + + BOOST_SYMBOL_VISIBLE + explicit invoker(BOOST_THREAD_FWD_REF(Fp) f + , BOOST_THREAD_RV_REF(T0) a0 + ) + : fp_(boost::move(f)) + , v0_(boost::move(a0)) + {} + + BOOST_SYMBOL_VISIBLE + invoker(BOOST_THREAD_FWD_REF(invoker) f) + : fp_(boost::move(BOOST_THREAD_RV(f).fp)) + , v0_(boost::move(BOOST_THREAD_RV(f).v0_)) + {} + + result_type operator()() + { + return invoke(boost::move(fp_) + , boost::move(v0_) + ); + } + }; + template <class Fp> + class invoker<Fp> + { + Fp fp_; + public: + BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker) + typedef typename result_of<Fp()>::type result_type; + BOOST_SYMBOL_VISIBLE + explicit invoker(BOOST_THREAD_FWD_REF(Fp) f) + : fp_(boost::move(f)) + {} + + BOOST_SYMBOL_VISIBLE + invoker(BOOST_THREAD_FWD_REF(invoker) f) + : fp_(boost::move(f.fp_)) + {} + result_type operator()() + { + return fp_(); + } + }; + template <class R> + class invoker<R(*)()> + { + typedef R(*Fp)(); + Fp fp_; + public: + BOOST_THREAD_COPYABLE_AND_MOVABLE(invoker) + typedef typename result_of<Fp()>::type result_type; + BOOST_SYMBOL_VISIBLE + explicit invoker(Fp f) + : fp_(f) + {} + + BOOST_SYMBOL_VISIBLE + invoker(BOOST_THREAD_FWD_REF(invoker) f) + : fp_(f.fp_) + {} + result_type operator()() + { + return fp_(); + } + }; +#endif +#endif + + } +} + +#include <boost/thread/detail/variadic_footer.hpp> + +#endif // header diff --git a/3rdParty/Boost/src/boost/thread/detail/is_convertible.hpp b/3rdParty/Boost/src/boost/thread/detail/is_convertible.hpp new file mode 100644 index 0000000..b77620c --- /dev/null +++ b/3rdParty/Boost/src/boost/thread/detail/is_convertible.hpp @@ -0,0 +1,49 @@ +////////////////////////////////////////////////////////////////////////////// +// +// Copyright (C) 2011-2013 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) +// +// See http://www.boost.org/libs/thread for documentation. +// +////////////////////////////////////////////////////////////////////////////// + +#ifndef BOOST_THREAD_DETAIL_IS_CONVERTIBLE_HPP +#define BOOST_THREAD_DETAIL_IS_CONVERTIBLE_HPP + +#include <boost/type_traits/is_convertible.hpp> +#include <boost/thread/detail/move.hpp> + +namespace boost +{ + namespace thread_detail + { + template <typename T1, typename T2> + struct is_convertible : boost::is_convertible<T1,T2> {}; + +#if defined BOOST_NO_CXX11_RVALUE_REFERENCES + +#if defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION <= 1300) + +#if defined BOOST_THREAD_USES_MOVE + template <typename T1, typename T2> + struct is_convertible< + rv<T1> &, + rv<rv<T2> > & + > : false_type {}; +#endif + +#elif defined __GNUC__ && (__GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ <= 4 )) + + template <typename T1, typename T2> + struct is_convertible<T1&, T2&> : boost::is_convertible<T1, T2> {}; +#endif + +#endif + } + +} // namespace boost + + +#endif // BOOST_THREAD_DETAIL_MEMORY_HPP diff --git a/3rdParty/Boost/src/boost/thread/detail/lockable_wrapper.hpp b/3rdParty/Boost/src/boost/thread/detail/lockable_wrapper.hpp new file mode 100644 index 0000000..8dc5a6c --- /dev/null +++ b/3rdParty/Boost/src/boost/thread/detail/lockable_wrapper.hpp @@ -0,0 +1,45 @@ +// 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) +// (C) Copyright 2012 Vicente J. Botet Escriba + +#ifndef BOOST_THREAD_DETAIL_LOCKABLE_WRAPPER_HPP +#define BOOST_THREAD_DETAIL_LOCKABLE_WRAPPER_HPP + +#include <boost/thread/detail/config.hpp> + +#if ! defined BOOST_THREAD_NO_CXX11_HDR_INITIALIZER_LIST +#include <initializer_list> +#endif +#include <boost/config/abi_prefix.hpp> + +namespace boost +{ + +#if ! defined BOOST_THREAD_NO_CXX11_HDR_INITIALIZER_LIST + namespace thread_detail + { + template <typename Mutex> + struct lockable_wrapper + { + Mutex* m; + explicit lockable_wrapper(Mutex& m_) : + m(&m_) + {} + }; + template <typename Mutex> + struct lockable_adopt_wrapper + { + Mutex* m; + explicit lockable_adopt_wrapper(Mutex& m_) : + m(&m_) + {} + }; + } +#endif + +} + +#include <boost/config/abi_suffix.hpp> + +#endif // header diff --git a/3rdParty/Boost/src/boost/thread/detail/make_tuple_indices.hpp b/3rdParty/Boost/src/boost/thread/detail/make_tuple_indices.hpp new file mode 100644 index 0000000..73d54f1 --- /dev/null +++ b/3rdParty/Boost/src/boost/thread/detail/make_tuple_indices.hpp @@ -0,0 +1,224 @@ +// Copyright (C) 2012-2013 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 10 parameters when BOOST_NO_CXX11_VARIADIC_TEMPLATES is defined. +// 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 make_tuple_indices C++11 code is based on the one from libcxx. +//===----------------------------------------------------------------------===// + +#ifndef BOOST_THREAD_DETAIL_MAKE_TUPLE_INDICES_HPP +#define BOOST_THREAD_DETAIL_MAKE_TUPLE_INDICES_HPP + +#include <boost/config.hpp> +#include <boost/static_assert.hpp> + +namespace boost +{ + namespace detail + { + +#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) + // make_tuple_indices + + template <std::size_t...> struct tuple_indices + {}; + + template <std::size_t Sp, class IntTuple, std::size_t Ep> + struct make_indices_imp; + + template <std::size_t Sp, std::size_t ...Indices, std::size_t Ep> + struct make_indices_imp<Sp, tuple_indices<Indices...>, Ep> + { + typedef typename make_indices_imp<Sp+1, tuple_indices<Indices..., Sp>, Ep>::type type; + }; + + template <std::size_t Ep, std::size_t ...Indices> + struct make_indices_imp<Ep, tuple_indices<Indices...>, Ep> + { + typedef tuple_indices<Indices...> type; + }; + + template <std::size_t Ep, std::size_t Sp = 0> + struct make_tuple_indices + { + BOOST_STATIC_ASSERT_MSG(Sp <= Ep, "make_tuple_indices input error"); + typedef typename make_indices_imp<Sp, tuple_indices<>, Ep>::type type; + }; +#else + + // - tuple forward declaration ----------------------------------------------- + template < + std::size_t T0 = 0, std::size_t T1 = 0, std::size_t T2 = 0, + std::size_t T3 = 0, std::size_t T4 = 0, std::size_t T5 = 0, + std::size_t T6 = 0, std::size_t T7 = 0, std::size_t T8 = 0, + std::size_t T9 = 0> + class tuple_indices {}; + + template <std::size_t Sp, class IntTuple, std::size_t Ep> + struct make_indices_imp; + + template <std::size_t Sp, std::size_t Ep> + struct make_indices_imp<Sp, tuple_indices<>, Ep> + { + typedef typename make_indices_imp<Sp+1, tuple_indices<Sp>, Ep>::type type; + }; + template <std::size_t Sp, std::size_t I0, std::size_t Ep> + struct make_indices_imp<Sp, tuple_indices<I0>, Ep> + { + typedef typename make_indices_imp<Sp+1, tuple_indices<I0, Sp>, Ep>::type type; + }; + template <std::size_t Sp, std::size_t I0, std::size_t I1, std::size_t Ep> + struct make_indices_imp<Sp, tuple_indices<I0, I1>, Ep> + { + typedef typename make_indices_imp<Sp+1, tuple_indices<I0, I1, Sp>, Ep>::type type; + }; + template <std::size_t Sp, std::size_t I0, std::size_t I1, std::size_t I2, std::size_t Ep> + struct make_indices_imp<Sp, tuple_indices<I0, I1 , I2>, Ep> + { + typedef typename make_indices_imp<Sp+1, tuple_indices<I0, I1, I2, Sp>, Ep>::type type; + }; + template <std::size_t Sp, std::size_t I0, std::size_t I1, std::size_t I2, std::size_t I3, std::size_t Ep> + struct make_indices_imp<Sp, tuple_indices<I0, I1 , I2, I3>, Ep> + { + typedef typename make_indices_imp<Sp+1, tuple_indices<I0, I1, I2, I3, Sp>, Ep>::type type; + }; + template <std::size_t Sp, std::size_t I0, std::size_t I1, std::size_t I2, std::size_t I3, std::size_t I4, std::size_t Ep> + struct make_indices_imp<Sp, tuple_indices<I0, I1 , I2, I3, I4>, Ep> + { + typedef typename make_indices_imp<Sp+1, tuple_indices<I0, I1, I2, I3, I4, Sp>, Ep>::type type; + }; + template <std::size_t Sp, 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 Ep> + struct make_indices_imp<Sp, tuple_indices<I0, I1 , I2, I3, I4, I5>, Ep> + { + typedef typename make_indices_imp<Sp+1, tuple_indices<I0, I1, I2, I3, I4, I5, Sp>, Ep>::type type; + }; + template <std::size_t Sp, 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 Ep> + struct make_indices_imp<Sp, tuple_indices<I0, I1 , I2, I3, I4, I5, I6>, Ep> + { + typedef typename make_indices_imp<Sp+1, tuple_indices<I0, I1, I2, I3, I4, I5, I6, Sp>, Ep>::type type; + }; + template <std::size_t Sp, 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 Ep> + struct make_indices_imp<Sp, tuple_indices<I0, I1 , I2, I3, I4, I5, I6, I7>, Ep> + { + typedef typename make_indices_imp<Sp+1, tuple_indices<I0, I1, I2, I3, I4, I5, I6, I7, Sp>, Ep>::type type; + }; + template <std::size_t Sp, 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 + , std::size_t Ep> + struct make_indices_imp<Sp, tuple_indices<I0, I1 , I2, I3, I4, I5, I6, I7, I8>, Ep> + { + typedef typename make_indices_imp<Sp+1, tuple_indices<I0, I1, I2, I3, I4, I5, I6, I7, I8, Sp>, Ep>::type type; + }; +// template <std::size_t Sp, 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 +// , std::size_t I9 +// , std::size_t Ep> +// struct make_indices_imp<Sp, tuple_indices<I0, I1 , I2, I3, I4, I5, I6, I7, I8, I9>, Ep> +// { +// typedef typename make_indices_imp<Sp+1, tuple_indices<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, Sp>, Ep>::type type; +// }; + + template <std::size_t Ep> + struct make_indices_imp<Ep, tuple_indices<>, Ep> + { + typedef tuple_indices<> type; + }; + template <std::size_t Ep, std::size_t I0> + struct make_indices_imp<Ep, tuple_indices<I0>, Ep> + { + typedef tuple_indices<I0> type; + }; + template <std::size_t Ep, std::size_t I0, std::size_t I1> + struct make_indices_imp<Ep, tuple_indices<I0, I1>, Ep> + { + typedef tuple_indices<I0, I1> type; + }; + template <std::size_t Ep, std::size_t I0, std::size_t I1, std::size_t I2> + struct make_indices_imp<Ep, tuple_indices<I0, I1, I2>, Ep> + { + typedef tuple_indices<I0, I1, I2> type; + }; + template <std::size_t Ep, std::size_t I0, std::size_t I1, std::size_t I2, std::size_t I3> + struct make_indices_imp<Ep, tuple_indices<I0, I1, I2, I3>, Ep> + { + typedef tuple_indices<I0, I1, I2, I3> type; + }; + template <std::size_t Ep, std::size_t I0, std::size_t I1, std::size_t I2, std::size_t I3, std::size_t I4> + struct make_indices_imp<Ep, tuple_indices<I0, I1, I2, I3, I4>, Ep> + { + typedef tuple_indices<I0, I1, I2, I3, I4> type; + }; + template <std::size_t Ep, std::size_t I0, std::size_t I1, std::size_t I2, std::size_t I3, std::size_t I4, std::size_t I5> + struct make_indices_imp<Ep, tuple_indices<I0, I1, I2, I3, I4, I5>, Ep> + { + typedef tuple_indices<I0, I1, I2, I3, I4, I5> type; + }; + template <std::size_t Ep, 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 + > + struct make_indices_imp<Ep, tuple_indices<I0, I1, I2, I3, I4, I5, I6>, Ep> + { + typedef tuple_indices<I0, I1, I2, I3, I4, I5, I6> type; + }; + template <std::size_t Ep, 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 + > + struct make_indices_imp<Ep, tuple_indices<I0, I1, I2, I3, I4, I5, I6, I7>, Ep> + { + typedef tuple_indices<I0, I1, I2, I3, I4, I5, I6, I7> type; + }; + template <std::size_t Ep, 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 + > + struct make_indices_imp<Ep, tuple_indices<I0, I1, I2, I3, I4, I5, I6, I7, I8>, Ep> + { + typedef tuple_indices<I0, I1, I2, I3, I4, I5, I6, I7, I8> type; + }; + + template <std::size_t Ep, 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 + , std::size_t I9 + > + struct make_indices_imp<Ep, tuple_indices<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9>, Ep> + { + typedef tuple_indices<I0, I1, I2, I3, I4, I5, I6, I7, I8, I9> type; + }; + + template <std::size_t Ep, std::size_t Sp = 0> + struct make_tuple_indices + { + BOOST_STATIC_ASSERT_MSG(Sp <= Ep, "make_tuple_indices input error"); + typedef typename make_indices_imp<Sp, tuple_indices<>, Ep>::type type; + }; + +#endif + } +} + +#endif // header diff --git a/3rdParty/Boost/src/boost/thread/detail/memory.hpp b/3rdParty/Boost/src/boost/thread/detail/memory.hpp index 3c1692d..51ce84f 100644 --- a/3rdParty/Boost/src/boost/thread/detail/memory.hpp +++ b/3rdParty/Boost/src/boost/thread/detail/memory.hpp @@ -1,8 +1,9 @@ ////////////////////////////////////////////////////////////////////////////// // -// (C) Copyright 2011-2012 Vicente J. Botet Escriba -// Software License, Version 1.0. (See accompanying file -// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// Copyright (C) 2011-2013 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) // // See http://www.boost.org/libs/thread for documentation. // @@ -12,14 +13,11 @@ #define BOOST_THREAD_DETAIL_MEMORY_HPP #include <boost/config.hpp> -#include <boost/container/allocator_traits.hpp> -#include <boost/container/scoped_allocator.hpp> -#include <boost/type_traits/remove_cv.hpp> -#include <boost/type_traits/is_convertible.hpp> -#include <boost/type_traits/is_scalar.hpp> -#include <boost/type_traits/is_pointer.hpp> -#include <boost/type_traits/is_same.hpp> -#include <boost/static_assert.hpp> + +#include <boost/thread/csbl/memory/pointer_traits.hpp> +#include <boost/thread/csbl/memory/allocator_arg.hpp> +#include <boost/thread/csbl/memory/allocator_traits.hpp> +#include <boost/thread/csbl/memory/scoped_allocator.hpp> namespace boost { @@ -28,7 +26,7 @@ namespace boost template <class _Alloc> class allocator_destructor { - typedef container::allocator_traits<_Alloc> alloc_traits; + typedef csbl::allocator_traits<_Alloc> alloc_traits; public: typedef typename alloc_traits::pointer pointer; typedef typename alloc_traits::size_type size_type; @@ -46,111 +44,5 @@ namespace boost } }; } //namespace thread_detail - - typedef container::allocator_arg_t allocator_arg_t; - BOOST_CONSTEXPR_OR_CONST allocator_arg_t allocator_arg = {}; - - template <class T, class Alloc> - struct uses_allocator: public container::uses_allocator<T, Alloc> - { - }; - - template <class Ptr> - struct pointer_traits - { - typedef Ptr pointer; -// typedef <details> element_type; -// typedef <details> difference_type; - -// template <class U> using rebind = <details>; -// -// static pointer pointer_to(<details>); - }; - - template <class T> - struct pointer_traits<T*> - { - typedef T* pointer; - typedef T element_type; - typedef ptrdiff_t difference_type; - -// template <class U> using rebind = U*; -// -// static pointer pointer_to(<details>) noexcept; - }; - - - namespace thread_detail { - template <class _Ptr1, class _Ptr2, - bool = is_same<typename remove_cv<typename pointer_traits<_Ptr1>::element_type>::type, - typename remove_cv<typename pointer_traits<_Ptr2>::element_type>::type - >::value - > - struct same_or_less_cv_qualified_imp - : is_convertible<_Ptr1, _Ptr2> {}; - - template <class _Ptr1, class _Ptr2> - struct same_or_less_cv_qualified_imp<_Ptr1, _Ptr2, false> - : false_type {}; - - template <class _Ptr1, class _Ptr2, bool = is_scalar<_Ptr1>::value && - !is_pointer<_Ptr1>::value> - struct same_or_less_cv_qualified - : same_or_less_cv_qualified_imp<_Ptr1, _Ptr2> {}; - - template <class _Ptr1, class _Ptr2> - struct same_or_less_cv_qualified<_Ptr1, _Ptr2, true> - : false_type {}; - - } - template <class T> - struct BOOST_SYMBOL_VISIBLE default_delete - { - #ifndef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS - BOOST_SYMBOL_VISIBLE - BOOST_CONSTEXPR default_delete() = default; - #else - BOOST_SYMBOL_VISIBLE - BOOST_CONSTEXPR default_delete() BOOST_NOEXCEPT {} - #endif - template <class U> - BOOST_SYMBOL_VISIBLE - default_delete(const default_delete<U>&, - typename enable_if<is_convertible<U*, T*> >::type* = 0) BOOST_NOEXCEPT {} - BOOST_SYMBOL_VISIBLE - void operator() (T* ptr) const BOOST_NOEXCEPT - { - BOOST_STATIC_ASSERT_MSG(sizeof(T) > 0, "default_delete can not delete incomplete type"); - delete ptr; - } - }; - - template <class T> - struct BOOST_SYMBOL_VISIBLE default_delete<T[]> - { - public: - #ifndef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS - BOOST_SYMBOL_VISIBLE - BOOST_CONSTEXPR default_delete() = default; - #else - BOOST_SYMBOL_VISIBLE - BOOST_CONSTEXPR default_delete() BOOST_NOEXCEPT {} - #endif - template <class U> - BOOST_SYMBOL_VISIBLE - default_delete(const default_delete<U[]>&, - typename enable_if<thread_detail::same_or_less_cv_qualified<U*, T*> >::type* = 0) BOOST_NOEXCEPT {} - template <class U> - BOOST_SYMBOL_VISIBLE - void operator() (U* ptr, - typename enable_if<thread_detail::same_or_less_cv_qualified<U*, T*> >::type* = 0) const BOOST_NOEXCEPT - { - BOOST_STATIC_ASSERT_MSG(sizeof(T) > 0, "default_delete can not delete incomplete type"); - delete [] ptr; - } - }; - -} // namespace boost - - +} #endif // BOOST_THREAD_DETAIL_MEMORY_HPP diff --git a/3rdParty/Boost/src/boost/thread/detail/move.hpp b/3rdParty/Boost/src/boost/thread/detail/move.hpp index f2665e6..c3339ef 100644 --- a/3rdParty/Boost/src/boost/thread/detail/move.hpp +++ b/3rdParty/Boost/src/boost/thread/detail/move.hpp @@ -9,24 +9,34 @@ #include <boost/thread/detail/config.hpp> #ifndef BOOST_NO_SFINAE -#include <boost/utility/enable_if.hpp> +#include <boost/core/enable_if.hpp> #include <boost/type_traits/is_convertible.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/type_traits/remove_cv.hpp> #include <boost/type_traits/decay.hpp> +#include <boost/type_traits/conditional.hpp> +#include <boost/type_traits/remove_extent.hpp> +#include <boost/type_traits/is_array.hpp> +#include <boost/type_traits/is_function.hpp> +#include <boost/type_traits/remove_cv.hpp> +#include <boost/type_traits/add_pointer.hpp> +#include <boost/type_traits/decay.hpp> #endif #include <boost/thread/detail/delete.hpp> -#include <boost/move/move.hpp> +#include <boost/move/utility.hpp> +#include <boost/move/traits.hpp> #include <boost/config/abi_prefix.hpp> - +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +#include <type_traits> +#endif namespace boost { namespace detail { template <typename T> - struct has_move_emulation_enabled_aux_dummy_specialization; + struct enable_move_utility_emulation_dummy_specialization; template<typename T> struct thread_move_t { @@ -49,6 +59,7 @@ namespace boost }; } +#if !defined BOOST_THREAD_USES_MOVE #ifndef BOOST_NO_SFINAE template<typename T> @@ -63,11 +74,14 @@ namespace boost { return t; } + +#endif //#if !defined BOOST_THREAD_USES_MOVE } #if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES #define BOOST_THREAD_RV_REF(TYPE) BOOST_RV_REF(TYPE) +#define BOOST_THREAD_RV_REF_2_TEMPL_ARGS(TYPE) BOOST_RV_REF_2_TEMPL_ARGS(TYPE) #define BOOST_THREAD_RV_REF_BEG BOOST_RV_REF_BEG #define BOOST_THREAD_RV_REF_END BOOST_RV_REF_END #define BOOST_THREAD_RV(V) V @@ -77,16 +91,17 @@ namespace boost #define BOOST_THREAD_DCL_MOVABLE_BEG(T) \ namespace detail { \ template <typename T> \ - struct has_move_emulation_enabled_aux_dummy_specialization< + struct enable_move_utility_emulation_dummy_specialization< #define BOOST_THREAD_DCL_MOVABLE_END > \ - : integral_constant<bool, true> \ + : integral_constant<bool, false> \ {}; \ } #elif ! defined BOOST_NO_CXX11_RVALUE_REFERENCES && defined BOOST_MSVC #define BOOST_THREAD_RV_REF(TYPE) BOOST_RV_REF(TYPE) +#define BOOST_THREAD_RV_REF_2_TEMPL_ARGS(TYPE) BOOST_RV_REF_2_TEMPL_ARGS(TYPE) #define BOOST_THREAD_RV_REF_BEG BOOST_RV_REF_BEG #define BOOST_THREAD_RV_REF_END BOOST_RV_REF_END #define BOOST_THREAD_RV(V) V @@ -96,10 +111,10 @@ namespace boost #define BOOST_THREAD_DCL_MOVABLE_BEG(T) \ namespace detail { \ template <typename T> \ - struct has_move_emulation_enabled_aux_dummy_specialization< + struct enable_move_utility_emulation_dummy_specialization< #define BOOST_THREAD_DCL_MOVABLE_END > \ - : integral_constant<bool, true> \ + : integral_constant<bool, false> \ {}; \ } @@ -107,6 +122,7 @@ namespace boost #if defined BOOST_THREAD_USES_MOVE #define BOOST_THREAD_RV_REF(TYPE) BOOST_RV_REF(TYPE) +#define BOOST_THREAD_RV_REF_2_TEMPL_ARGS(TYPE) BOOST_RV_REF_2_TEMPL_ARGS(TYPE) #define BOOST_THREAD_RV_REF_BEG BOOST_RV_REF_BEG #define BOOST_THREAD_RV_REF_END BOOST_RV_REF_END #define BOOST_THREAD_RV(V) V @@ -115,10 +131,10 @@ namespace boost #define BOOST_THREAD_DCL_MOVABLE_BEG(T) \ namespace detail { \ template <typename T> \ - struct has_move_emulation_enabled_aux_dummy_specialization< + struct enable_move_utility_emulation_dummy_specialization< #define BOOST_THREAD_DCL_MOVABLE_END > \ - : integral_constant<bool, true> \ + : integral_constant<bool, false> \ {}; \ } @@ -132,17 +148,19 @@ namespace boost #define BOOST_THREAD_DCL_MOVABLE(TYPE) \ template <> \ -struct has_move_emulation_enabled_aux< TYPE > \ - : BOOST_MOVE_BOOST_NS::integral_constant<bool, true> \ -{}; +struct enable_move_utility_emulation< TYPE > \ +{ \ + static const bool value = false; \ +}; #define BOOST_THREAD_DCL_MOVABLE_BEG(T) \ template <typename T> \ -struct has_move_emulation_enabled_aux< +struct enable_move_utility_emulation< #define BOOST_THREAD_DCL_MOVABLE_END > \ - : BOOST_MOVE_BOOST_NS::integral_constant<bool, true> \ -{}; +{ \ + static const bool value = false; \ +}; #endif @@ -227,19 +245,69 @@ namespace detail -#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES namespace boost -{ namespace thread_detail +{ + namespace thread_detail + { +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES + template <class Tp> + struct remove_reference : boost::remove_reference<Tp> {}; + template <class Tp> + struct decay : boost::decay<Tp> {}; +#else + template <class Tp> + struct remove_reference { + typedef Tp type; + }; + template <class Tp> + struct remove_reference<Tp&> + { + typedef Tp type; + }; + template <class Tp> + struct remove_reference< rv<Tp> > { + typedef Tp type; + }; + + template <class Tp> + struct decay + { + private: + typedef typename boost::move_detail::remove_rvalue_reference<Tp>::type Up0; + typedef typename boost::remove_reference<Up0>::type Up; + public: + typedef typename conditional + < + is_array<Up>::value, + typename remove_extent<Up>::type*, + typename conditional + < + is_function<Up>::value, + typename add_pointer<Up>::type, + typename remove_cv<Up>::type + >::type + >::type type; + }; +#endif + +#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES template <class T> typename decay<T>::type decay_copy(T&& t) { return boost::forward<T>(t); } +#else + template <class T> + typename decay<T>::type + decay_copy(BOOST_THREAD_FWD_REF(T) t) + { + return boost::forward<T>(t); } -} #endif + } +} #include <boost/config/abi_suffix.hpp> diff --git a/3rdParty/Boost/src/boost/thread/detail/nullary_function.hpp b/3rdParty/Boost/src/boost/thread/detail/nullary_function.hpp new file mode 100644 index 0000000..26d1390 --- /dev/null +++ b/3rdParty/Boost/src/boost/thread/detail/nullary_function.hpp @@ -0,0 +1,213 @@ +// Copyright (C) 2013 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/09 Vicente J. Botet Escriba +// Adapt to boost from CCIA C++11 implementation +// Make use of Boost.Move + +#ifndef BOOST_THREAD_DETAIL_NULLARY_FUNCTION_HPP +#define BOOST_THREAD_DETAIL_NULLARY_FUNCTION_HPP + +#include <boost/config.hpp> +#include <boost/thread/detail/memory.hpp> +#include <boost/thread/detail/move.hpp> +#include <boost/smart_ptr/shared_ptr.hpp> +#include <boost/type_traits/decay.hpp> + +namespace boost +{ + namespace detail + { + + template <typename F> + class nullary_function; + template <> + class nullary_function<void()> + { + struct impl_base + { + virtual void call()=0; + virtual ~impl_base() + { + } + }; + shared_ptr<impl_base> impl; + template <typename F> + struct impl_type: impl_base + { + F f; +#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES + impl_type(F &f_) + : f(f_) + {} +#endif + impl_type(BOOST_THREAD_RV_REF(F) f_) + : f(boost::move(f_)) + {} + + void call() + { + f(); + } + }; + struct impl_type_ptr: impl_base + { + void (*f)(); + impl_type_ptr(void (*f_)()) + : f(f_) + {} + void call() + { + f(); + } + }; + public: + BOOST_THREAD_MOVABLE(nullary_function) + + explicit nullary_function(void (*f)()): + impl(new impl_type_ptr(f)) + {} + +#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES + template<typename F> + explicit nullary_function(F& f): + impl(new impl_type<F>(f)) + {} +#endif + template<typename F> + nullary_function(BOOST_THREAD_RV_REF(F) f): + impl(new impl_type<typename decay<F>::type>(thread_detail::decay_copy(boost::forward<F>(f)))) + {} + + nullary_function() + : impl() + { + } + nullary_function(nullary_function const& other) BOOST_NOEXCEPT : + impl(other.impl) + { + } + nullary_function(BOOST_THREAD_RV_REF(nullary_function) other) BOOST_NOEXCEPT : + impl(BOOST_THREAD_RV(other).impl) + { + BOOST_THREAD_RV(other).impl.reset(); + } + ~nullary_function() + { + } + + nullary_function& operator=(nullary_function const& other) BOOST_NOEXCEPT + { + impl=other.impl; + return *this; + } + nullary_function& operator=(BOOST_THREAD_RV_REF(nullary_function) other) BOOST_NOEXCEPT + { + impl=BOOST_THREAD_RV(other).impl; + BOOST_THREAD_RV(other).impl.reset(); + return *this; + } + + + void operator()() + { impl->call();} + + }; + + template <typename R> + class nullary_function<R()> + { + struct impl_base + { + virtual R call()=0; + virtual ~impl_base() + { + } + }; + shared_ptr<impl_base> impl; + template <typename F> + struct impl_type: impl_base + { + F f; +#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES + impl_type(F &f_) + : f(f_) + {} +#endif + impl_type(BOOST_THREAD_RV_REF(F) f_) + : f(boost::move(f_)) + {} + + R call() + { + return f(); + } + }; + struct impl_type_ptr: impl_base + { + R (*f)(); + impl_type_ptr(R (*f_)()) + : f(f_) + {} + + R call() + { + return f(); + } + }; + public: + BOOST_THREAD_MOVABLE(nullary_function) + + nullary_function(R (*f)()): + impl(new impl_type_ptr(f)) + {} +#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES + template<typename F> + nullary_function(F& f): + impl(new impl_type<F>(f)) + {} +#endif + template<typename F> + nullary_function(BOOST_THREAD_RV_REF(F) f): + impl(new impl_type<typename decay<F>::type>(thread_detail::decay_copy(boost::forward<F>(f)))) + {} + + nullary_function(nullary_function const& other) BOOST_NOEXCEPT : + impl(other.impl) + { + } + nullary_function(BOOST_THREAD_RV_REF(nullary_function) other) BOOST_NOEXCEPT : + impl(BOOST_THREAD_RV(other).impl) + { + BOOST_THREAD_RV(other).impl.reset(); + } + nullary_function() + : impl() + { + } + ~nullary_function() + { + } + + nullary_function& operator=(nullary_function const& other) BOOST_NOEXCEPT + { + impl=other.impl; + return *this; + } + nullary_function& operator=(BOOST_THREAD_RV_REF(nullary_function) other) BOOST_NOEXCEPT + { + impl=BOOST_THREAD_RV(other).impl; + BOOST_THREAD_RV(other).impl.reset(); + return *this; + } + + R operator()() + { return impl->call();} + + }; + } +} + +#endif // header diff --git a/3rdParty/Boost/src/boost/thread/detail/thread.hpp b/3rdParty/Boost/src/boost/thread/detail/thread.hpp index 2590f45..520ca26 100644 --- a/3rdParty/Boost/src/boost/thread/detail/thread.hpp +++ b/3rdParty/Boost/src/boost/thread/detail/thread.hpp @@ -3,29 +3,33 @@ // 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) -// (C) Copyright 2007-10 Anthony Williams -// (C) Copyright 20011-12 Vicente J. Botet Escriba +// (C) Copyright 2007-2010 Anthony Williams +// (C) Copyright 2011-2012 Vicente J. Botet Escriba #include <boost/thread/detail/config.hpp> + #include <boost/thread/exceptions.hpp> #ifndef BOOST_NO_IOSTREAM #include <ostream> #endif #include <boost/thread/detail/move.hpp> #include <boost/thread/mutex.hpp> +#if defined BOOST_THREAD_USES_DATETIME #include <boost/thread/xtime.hpp> +#endif #include <boost/thread/detail/thread_heap_alloc.hpp> +#include <boost/thread/detail/make_tuple_indices.hpp> +#include <boost/thread/detail/invoke.hpp> +#include <boost/thread/detail/is_convertible.hpp> #include <boost/assert.hpp> #include <list> #include <algorithm> -#include <boost/ref.hpp> +#include <boost/core/ref.hpp> #include <boost/cstdint.hpp> #include <boost/bind.hpp> #include <stdlib.h> #include <memory> -//#include <vector> -//#include <utility> -#include <boost/utility/enable_if.hpp> +#include <boost/core/enable_if.hpp> #include <boost/type_traits/remove_reference.hpp> #include <boost/io/ios_state.hpp> #include <boost/type_traits/is_same.hpp> @@ -36,6 +40,9 @@ #include <boost/chrono/ceil.hpp> #endif +#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) +#include <tuple> +#endif #include <boost/config/abi_prefix.hpp> #ifdef BOOST_MSVC @@ -48,6 +55,36 @@ namespace boost namespace detail { + +#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) + + template<typename F, class ...ArgTypes> + class thread_data: + public detail::thread_data_base + { + public: + BOOST_THREAD_NO_COPYABLE(thread_data) + thread_data(BOOST_THREAD_RV_REF(F) f_, BOOST_THREAD_RV_REF(ArgTypes)... args_): + fp(boost::forward<F>(f_), boost::forward<ArgTypes>(args_)...) + {} + template <std::size_t ...Indices> + void run2(tuple_indices<Indices...>) + { + + invoke(std::move(std::get<0>(fp)), std::move(std::get<Indices>(fp))...); + } + void run() + { + typedef typename make_tuple_indices<std::tuple_size<std::tuple<F, ArgTypes...> >::value, 1>::type index_type; + + run2(index_type()); + } + + private: + std::tuple<typename decay<F>::type, typename decay<ArgTypes>::type...> fp; + }; +#else // defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) + template<typename F> class thread_data: public detail::thread_data_base @@ -115,6 +152,7 @@ namespace boost f(); } }; +#endif } class BOOST_THREAD_DECL thread @@ -125,24 +163,55 @@ namespace boost BOOST_THREAD_MOVABLE_ONLY(thread) private: + struct dummy; + void release_handle(); detail::thread_data_ptr thread_info; - void start_thread(); - void start_thread(const attributes& attr); + private: + bool start_thread_noexcept(); + bool start_thread_noexcept(const attributes& attr); + //public: + void start_thread() + { + if (!start_thread_noexcept()) + { + boost::throw_exception(thread_resource_error()); + } + } + void start_thread(const attributes& attr) + { + if (!start_thread_noexcept(attr)) + { + boost::throw_exception(thread_resource_error()); + } + } explicit thread(detail::thread_data_ptr data); detail::thread_data_ptr get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const; #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES +#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) + template<typename F, class ...ArgTypes> + static inline detail::thread_data_ptr make_thread_info(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_RV_REF(ArgTypes)... args) + { + return detail::thread_data_ptr(detail::heap_new< + detail::thread_data<typename boost::remove_reference<F>::type, ArgTypes...> + >( + boost::forward<F>(f), boost::forward<ArgTypes>(args)... + ) + ); + } +#else template<typename F> static inline detail::thread_data_ptr make_thread_info(BOOST_THREAD_RV_REF(F) f) { return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >( boost::forward<F>(f))); } +#endif static inline detail::thread_data_ptr make_thread_info(void (*f)()) { return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >( @@ -150,7 +219,12 @@ namespace boost } #else template<typename F> - static inline detail::thread_data_ptr make_thread_info(F f) + static inline detail::thread_data_ptr make_thread_info(F f + , typename disable_if_c< + //boost::thread_detail::is_convertible<F&,BOOST_THREAD_RV_REF(F)>::value || + is_same<typename decay<F>::type, thread>::value, + dummy* >::type=0 + ) { return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f)); } @@ -161,7 +235,6 @@ namespace boost } #endif - struct dummy; public: #if 0 // This should not be needed anymore. Use instead BOOST_THREAD_MAKE_RV_REF. #if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) @@ -171,6 +244,7 @@ namespace boost thread() BOOST_NOEXCEPT; ~thread() { + #if defined BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE if (joinable()) { std::terminate(); @@ -184,7 +258,7 @@ namespace boost class F > explicit thread(BOOST_THREAD_RV_REF(F) f - , typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0 + //, typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0 ): thread_info(make_thread_info(thread_detail::decay_copy(boost::forward<F>(f)))) { @@ -193,7 +267,7 @@ namespace boost template < class F > - thread(attributes& attrs, BOOST_THREAD_RV_REF(F) f): + thread(attributes const& attrs, BOOST_THREAD_RV_REF(F) f): thread_info(make_thread_info(thread_detail::decay_copy(boost::forward<F>(f)))) { start_thread(attrs); @@ -208,7 +282,7 @@ namespace boost start_thread(); } template <class F> - thread(attributes& attrs, F f): + thread(attributes const& attrs, F f): thread_info(make_thread_info(f)) { start_thread(attrs); @@ -216,15 +290,19 @@ namespace boost #else template <class F> explicit thread(F f - // todo Disable also if Or is_same<typename decay<F>::type, thread> - , typename disable_if<boost::is_convertible<F&,BOOST_THREAD_RV_REF(F) >, dummy* >::type=0): + , typename disable_if_c< + boost::thread_detail::is_convertible<F&,BOOST_THREAD_RV_REF(F)>::value + //|| is_same<typename decay<F>::type, thread>::value + , dummy* >::type=0 + ): thread_info(make_thread_info(f)) { start_thread(); } template <class F> - thread(attributes& attrs, F f - , typename disable_if<boost::is_convertible<F&,BOOST_THREAD_RV_REF(F) >, dummy* >::type=0): + thread(attributes const& attrs, F f + , typename disable_if<boost::thread_detail::is_convertible<F&,BOOST_THREAD_RV_REF(F) >, dummy* >::type=0 + ): thread_info(make_thread_info(f)) { start_thread(attrs); @@ -234,19 +312,27 @@ namespace boost explicit thread(BOOST_THREAD_RV_REF(F) f , typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0 ): - thread_info(make_thread_info(f)) +#ifdef BOOST_THREAD_USES_MOVE + thread_info(make_thread_info(boost::move<F>(f))) // todo : Add forward +#else + thread_info(make_thread_info(f)) // todo : Add forward +#endif { start_thread(); } template <class F> - thread(attributes& attrs, BOOST_THREAD_RV_REF(F) f): - thread_info(make_thread_info(f)) + thread(attributes const& attrs, BOOST_THREAD_RV_REF(F) f): +#ifdef BOOST_THREAD_USES_MOVE + thread_info(make_thread_info(boost::move<F>(f))) // todo : Add forward +#else + thread_info(make_thread_info(f)) // todo : Add forward +#endif { start_thread(attrs); } #endif - thread(BOOST_THREAD_RV_REF(thread) x) + thread(BOOST_THREAD_RV_REF(thread) x) BOOST_NOEXCEPT { thread_info=BOOST_THREAD_RV(x).thread_info; BOOST_THREAD_RV(x).thread_info.reset(); @@ -272,8 +358,32 @@ namespace boost return *this; } +#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) + template <class F, class Arg, class ...Args> + thread(F&& f, Arg&& arg, Args&&... args) : + thread_info(make_thread_info( + thread_detail::decay_copy(boost::forward<F>(f)), + thread_detail::decay_copy(boost::forward<Arg>(arg)), + thread_detail::decay_copy(boost::forward<Args>(args))...) + ) + + { + start_thread(); + } + template <class F, class Arg, class ...Args> + thread(attributes const& attrs, F&& f, Arg&& arg, Args&&... args) : + thread_info(make_thread_info( + thread_detail::decay_copy(boost::forward<F>(f)), + thread_detail::decay_copy(boost::forward<Arg>(arg)), + thread_detail::decay_copy(boost::forward<Args>(args))...) + ) + + { + start_thread(attrs); + } +#else template <class F,class A1> - thread(F f,A1 a1,typename disable_if<boost::is_convertible<F&,thread_attributes >, dummy* >::type=0): + thread(F f,A1 a1,typename disable_if<boost::thread_detail::is_convertible<F&,thread_attributes >, dummy* >::type=0): thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1))) { start_thread(); @@ -333,31 +443,53 @@ namespace boost { start_thread(); } - +#endif void swap(thread& x) BOOST_NOEXCEPT { thread_info.swap(x.thread_info); } - class BOOST_SYMBOL_VISIBLE id; + class id; +#ifdef BOOST_THREAD_PLATFORM_PTHREAD + inline id get_id() const BOOST_NOEXCEPT; +#else id get_id() const BOOST_NOEXCEPT; +#endif bool joinable() const BOOST_NOEXCEPT; - void join(); + private: + bool join_noexcept(); + public: + inline void join(); + #ifdef BOOST_THREAD_USES_CHRONO +#if defined(BOOST_THREAD_PLATFORM_WIN32) + template <class Rep, class Period> + bool try_join_for(const chrono::duration<Rep, Period>& rel_time) + { + chrono::milliseconds rel_time2= chrono::ceil<chrono::milliseconds>(rel_time); + return do_try_join_until(rel_time2.count()); + } +#else template <class Rep, class Period> bool try_join_for(const chrono::duration<Rep, Period>& rel_time) { return try_join_until(chrono::steady_clock::now() + rel_time); } +#endif template <class Clock, class Duration> bool try_join_until(const chrono::time_point<Clock, Duration>& t) { using namespace chrono; system_clock::time_point s_now = system_clock::now(); - typename Clock::time_point c_now = Clock::now(); - return try_join_until(s_now + ceil<nanoseconds>(t - c_now)); + bool joined= false; + do { + typename Clock::duration d = ceil<nanoseconds>(t-Clock::now()); + if (d <= Clock::duration::zero()) return false; // in case the Clock::time_point t is already reached + joined = try_join_until(s_now + d); + } while (! joined); + return true; } template <class Duration> bool try_join_until(const chrono::time_point<chrono::system_clock, Duration>& t) @@ -368,10 +500,15 @@ namespace boost } #endif #if defined(BOOST_THREAD_PLATFORM_WIN32) - bool timed_join(const system_time& abs_time); private: - bool do_try_join_until(uintmax_t milli); + bool do_try_join_until_noexcept(uintmax_t milli, bool& res); + inline bool do_try_join_until(uintmax_t milli); public: + bool timed_join(const system_time& abs_time); + //{ + // return do_try_join_until(get_milliseconds_until(wait_until)); + //} + #ifdef BOOST_THREAD_USES_CHRONO bool try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp) { @@ -382,49 +519,53 @@ namespace boost #else + private: + bool do_try_join_until_noexcept(struct timespec const &timeout, bool& res); + inline bool do_try_join_until(struct timespec const &timeout); + public: +#if defined BOOST_THREAD_USES_DATETIME bool timed_join(const system_time& abs_time) { - struct timespec const ts=detail::get_timespec(abs_time); + struct timespec const ts=detail::to_timespec(abs_time); return do_try_join_until(ts); } +#endif #ifdef BOOST_THREAD_USES_CHRONO bool try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp) { using namespace chrono; nanoseconds d = tp.time_since_epoch(); - timespec ts; - seconds s = duration_cast<seconds>(d); - ts.tv_sec = static_cast<long>(s.count()); - ts.tv_nsec = static_cast<long>((d - s).count()); + timespec ts = boost::detail::to_timespec(d); return do_try_join_until(ts); } #endif - private: - bool do_try_join_until(struct timespec const &timeout); - public: #endif + public: +#if defined BOOST_THREAD_USES_DATETIME template<typename TimeDuration> inline bool timed_join(TimeDuration const& rel_time) { return timed_join(get_system_time()+rel_time); } - +#endif void detach(); static unsigned hardware_concurrency() BOOST_NOEXCEPT; + static unsigned physical_concurrency() BOOST_NOEXCEPT; #define BOOST_THREAD_DEFINES_THREAD_NATIVE_HANDLE typedef detail::thread_data_base::native_handle_type native_handle_type; native_handle_type native_handle(); -#if defined BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 +#if defined BOOST_THREAD_PROVIDES_THREAD_EQ // Use thread::id when comparisions are needed // backwards compatibility bool operator==(const thread& other) const; bool operator!=(const thread& other) const; #endif +#if defined BOOST_THREAD_USES_DATETIME static inline void yield() BOOST_NOEXCEPT { this_thread::yield(); @@ -434,10 +575,13 @@ namespace boost { this_thread::sleep(xt); } +#endif +#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS // extensions void interrupt(); bool interruption_requested() const BOOST_NOEXCEPT; +#endif }; inline void swap(thread& lhs,thread& rhs) BOOST_NOEXCEPT @@ -456,16 +600,24 @@ namespace boost namespace this_thread { +#ifdef BOOST_THREAD_PLATFORM_PTHREAD + inline thread::id get_id() BOOST_NOEXCEPT; +#else thread::id BOOST_THREAD_DECL get_id() BOOST_NOEXCEPT; +#endif +#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS void BOOST_THREAD_DECL interruption_point(); bool BOOST_THREAD_DECL interruption_enabled() BOOST_NOEXCEPT; bool BOOST_THREAD_DECL interruption_requested() BOOST_NOEXCEPT; +#endif +#if defined BOOST_THREAD_USES_DATETIME inline BOOST_SYMBOL_VISIBLE void sleep(xtime const& abs_time) { sleep(system_time(abs_time)); } +#endif } class BOOST_SYMBOL_VISIBLE thread::id @@ -501,11 +653,7 @@ namespace boost public: id() BOOST_NOEXCEPT: #if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID -#if defined(BOOST_THREAD_PLATFORM_WIN32) - thread_data(0) -#else thread_data(0) -#endif #else thread_data() #endif @@ -583,6 +731,61 @@ namespace boost #endif }; +#ifdef BOOST_THREAD_PLATFORM_PTHREAD + thread::id thread::get_id() const BOOST_NOEXCEPT + { + #if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID + return const_cast<thread*>(this)->native_handle(); + #else + detail::thread_data_ptr const local_thread_info=(get_thread_info)(); + return (local_thread_info? id(local_thread_info) : id()); + #endif + } + + namespace this_thread + { + inline thread::id get_id() BOOST_NOEXCEPT + { + #if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID + return pthread_self(); + #else + boost::detail::thread_data_base* const thread_info=get_or_make_current_thread_data(); + return (thread_info?thread::id(thread_info->shared_from_this()):thread::id()); + #endif + } + } +#endif + void thread::join() { + if (this_thread::get_id() == get_id()) + boost::throw_exception(thread_resource_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost thread: trying joining itself")); + + BOOST_THREAD_VERIFY_PRECONDITION( join_noexcept(), + thread_resource_error(static_cast<int>(system::errc::invalid_argument), "boost thread: thread not joinable") + ); + } + +#ifdef BOOST_THREAD_PLATFORM_PTHREAD + bool thread::do_try_join_until(struct timespec const &timeout) +#else + bool thread::do_try_join_until(uintmax_t timeout) +#endif + { + if (this_thread::get_id() == get_id()) + boost::throw_exception(thread_resource_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost thread: trying joining itself")); + bool res; + if (do_try_join_until_noexcept(timeout, res)) + { + return res; + } + else + { + BOOST_THREAD_THROW_ELSE_RETURN( + (thread_resource_error(static_cast<int>(system::errc::invalid_argument), "boost thread: thread not joinable")), + false + ); + } + } + #if !defined(BOOST_NO_IOSTREAM) && defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) template<class charT, class traits> BOOST_SYMBOL_VISIBLE @@ -593,7 +796,7 @@ namespace boost } #endif -#if defined BOOST_THREAD_PROVIDES_DEPRECATED_FEATURES_SINCE_V3_0_0 +#if defined BOOST_THREAD_PROVIDES_THREAD_EQ inline bool thread::operator==(const thread& other) const { return get_id()==other.get_id(); @@ -631,6 +834,19 @@ namespace boost }; void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*); + struct shared_state_base; +#if defined(BOOST_THREAD_PLATFORM_WIN32) + inline void make_ready_at_thread_exit(shared_ptr<shared_state_base> as) + { + detail::thread_data_base* const current_thread_data(detail::get_current_thread_data()); + if(current_thread_data) + { + current_thread_data->make_ready_at_thread_exit(as); + } + } +#else + void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as); +#endif } namespace this_thread diff --git a/3rdParty/Boost/src/boost/thread/detail/thread_group.hpp b/3rdParty/Boost/src/boost/thread/detail/thread_group.hpp index f1ccdf8..69ce991 100644 --- a/3rdParty/Boost/src/boost/thread/detail/thread_group.hpp +++ b/3rdParty/Boost/src/boost/thread/detail/thread_group.hpp @@ -8,6 +8,7 @@ #include <list> #include <boost/thread/shared_mutex.hpp> #include <boost/thread/mutex.hpp> +#include <boost/thread/lock_guard.hpp> #include <boost/config/abi_prefix.hpp> @@ -22,7 +23,7 @@ namespace boost { private: thread_group(thread_group const&); - thread_group& operator=(thread_group const&); + thread_group& operator=(thread_group const&); public: thread_group() {} ~thread_group() @@ -35,6 +36,41 @@ namespace boost } } + bool is_this_thread_in() + { + thread::id id = this_thread::get_id(); + boost::shared_lock<shared_mutex> guard(m); + for(std::list<thread*>::iterator it=threads.begin(),end=threads.end(); + it!=end; + ++it) + { + if ((*it)->get_id() == id) + return true; + } + return false; + } + + bool is_thread_in(thread* thrd) + { + if(thrd) + { + thread::id id = thrd->get_id(); + boost::shared_lock<shared_mutex> guard(m); + for(std::list<thread*>::iterator it=threads.begin(),end=threads.end(); + it!=end; + ++it) + { + if ((*it)->get_id() == id) + return true; + } + return false; + } + else + { + return false; + } + } + template<typename F> thread* create_thread(F threadfunc) { @@ -43,16 +79,20 @@ namespace boost threads.push_back(new_thread.get()); return new_thread.release(); } - + void add_thread(thread* thrd) { if(thrd) { + BOOST_THREAD_ASSERT_PRECONDITION( ! is_thread_in(thrd) , + thread_resource_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost::thread_group: trying to add a duplicated thread") + ); + boost::lock_guard<shared_mutex> guard(m); threads.push_back(thrd); } } - + void remove_thread(thread* thrd) { boost::lock_guard<shared_mutex> guard(m); @@ -62,23 +102,28 @@ namespace boost threads.erase(it); } } - + void join_all() { + BOOST_THREAD_ASSERT_PRECONDITION( ! is_this_thread_in() , + thread_resource_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost::thread_group: trying joining itself") + ); boost::shared_lock<shared_mutex> guard(m); - + for(std::list<thread*>::iterator it=threads.begin(),end=threads.end(); it!=end; ++it) { + if ((*it)->joinable()) (*it)->join(); } } - + +#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS void interrupt_all() { boost::shared_lock<shared_mutex> guard(m); - + for(std::list<thread*>::iterator it=threads.begin(),end=threads.end(); it!=end; ++it) @@ -86,13 +131,14 @@ namespace boost (*it)->interrupt(); } } - +#endif + size_t size() const { boost::shared_lock<shared_mutex> guard(m); return threads.size(); } - + private: std::list<thread*> threads; mutable shared_mutex m; diff --git a/3rdParty/Boost/src/boost/thread/detail/thread_interruption.hpp b/3rdParty/Boost/src/boost/thread/detail/thread_interruption.hpp index f1a165c..5d7d10f 100644 --- a/3rdParty/Boost/src/boost/thread/detail/thread_interruption.hpp +++ b/3rdParty/Boost/src/boost/thread/detail/thread_interruption.hpp @@ -9,6 +9,8 @@ #include <boost/thread/detail/config.hpp> #include <boost/thread/detail/delete.hpp> +#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS + namespace boost { namespace this_thread @@ -33,4 +35,5 @@ namespace boost } } -#endif +#endif // BOOST_THREAD_PROVIDES_INTERRUPTIONS +#endif // header diff --git a/3rdParty/Boost/src/boost/thread/detail/variadic_footer.hpp b/3rdParty/Boost/src/boost/thread/detail/variadic_footer.hpp new file mode 100644 index 0000000..9ae25a8 --- /dev/null +++ b/3rdParty/Boost/src/boost/thread/detail/variadic_footer.hpp @@ -0,0 +1,10 @@ +// Copyright (C) 2013 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) + + +#if defined BOOST_NO_CXX11_VARIADIC_TEMPLATES + + +#endif diff --git a/3rdParty/Boost/src/boost/thread/detail/variadic_header.hpp b/3rdParty/Boost/src/boost/thread/detail/variadic_header.hpp new file mode 100644 index 0000000..8015ae3 --- /dev/null +++ b/3rdParty/Boost/src/boost/thread/detail/variadic_header.hpp @@ -0,0 +1,19 @@ +// Copyright (C) 2013 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) + +#include <boost/config.hpp> + +//#if defined BOOST_NO_CXX11_VARIADIC_TEMPLATES + +#include <boost/preprocessor/facilities/intercept.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> + +#ifndef BOOST_THREAD_MAX_ARGS +#define BOOST_THREAD_MAX_ARGS 9 +#endif + +//#endif + |