This is an unmodified subset of boost 1.58, created with boost/extract.sh.
--- /dev/null
+/*
+ (c) 2014 Glen Joseph Fernandes
+ glenjofe at gmail dot com
+
+ Distributed under the Boost Software
+ License, Version 1.0.
+ http://boost.org/LICENSE_1_0.txt
+*/
+#ifndef BOOST_ALIGN_ALIGN_HPP
+#define BOOST_ALIGN_ALIGN_HPP
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX11_STD_ALIGN)
+#include <boost/align/detail/align_cxx11.hpp>
+#else
+#include <boost/align/detail/align.hpp>
+#endif
+
+#endif
--- /dev/null
+/*
+ (c) 2014 Glen Joseph Fernandes
+ glenjofe at gmail dot com
+
+ Distributed under the Boost Software
+ License, Version 1.0.
+ http://boost.org/LICENSE_1_0.txt
+*/
+#ifndef BOOST_ALIGN_DETAIL_ADDRESS_HPP
+#define BOOST_ALIGN_DETAIL_ADDRESS_HPP
+
+#include <boost/cstdint.hpp>
+#include <cstddef>
+
+namespace boost {
+ namespace alignment {
+ namespace detail {
+#if defined(BOOST_HAS_INTPTR_T)
+ typedef boost::uintptr_t address_t;
+#else
+ typedef std::size_t address_t;
+#endif
+ }
+ }
+}
+
+#endif
--- /dev/null
+/*
+ (c) 2014 Glen Joseph Fernandes
+ glenjofe at gmail dot com
+
+ Distributed under the Boost Software
+ License, Version 1.0.
+ http://boost.org/LICENSE_1_0.txt
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGN_HPP
+#define BOOST_ALIGN_DETAIL_ALIGN_HPP
+
+#include <boost/assert.hpp>
+#include <boost/align/detail/address.hpp>
+#include <boost/align/detail/is_alignment.hpp>
+#include <cstddef>
+
+namespace boost {
+ namespace alignment {
+ inline void* align(std::size_t alignment, std::size_t size,
+ void*& ptr, std::size_t& space)
+ {
+ BOOST_ASSERT(detail::is_alignment(alignment));
+ std::size_t n = detail::address_t(ptr) & (alignment - 1);
+ if (n != 0) {
+ n = alignment - n;
+ }
+ void* p = 0;
+ if (n <= space && size <= space - n) {
+ p = static_cast<char*>(ptr) + n;
+ ptr = p;
+ space -= n;
+ }
+ return p;
+ }
+ }
+}
+
+#endif
--- /dev/null
+/*
+ (c) 2014 Glen Joseph Fernandes
+ glenjofe at gmail dot com
+
+ Distributed under the Boost Software
+ License, Version 1.0.
+ http://boost.org/LICENSE_1_0.txt
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP
+#define BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP
+
+#include <memory>
+
+namespace boost {
+ namespace alignment {
+ using std::align;
+ }
+}
+
+#endif
--- /dev/null
+/*
+ (c) 2014 Glen Joseph Fernandes
+ glenjofe at gmail dot com
+
+ Distributed under the Boost Software
+ License, Version 1.0.
+ http://boost.org/LICENSE_1_0.txt
+*/
+#ifndef BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP
+#define BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+namespace boost {
+ namespace alignment {
+ namespace detail {
+ BOOST_CONSTEXPR inline bool is_alignment(std::size_t
+ value) BOOST_NOEXCEPT
+ {
+ return (value > 0) && ((value & (value - 1)) == 0);
+ }
+ }
+ }
+}
+
+#endif
{
char buf[size_];
- typename mpl::eval_if_c<
+ typename ::boost::mpl::eval_if_c<
alignment_ == std::size_t(-1)
- , mpl::identity<detail::max_align>
- , type_with_alignment<alignment_>
+ , ::boost::mpl::identity< ::boost::detail::max_align >
+ , ::boost::type_with_alignment<alignment_>
>::type align_;
} data_;
void* address() const { return const_cast<aligned_storage_imp*>(this); }
#else
public
#endif
- detail::aligned_storage::aligned_storage_imp<size_, alignment_>
+ ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_>
{
public: // constants
- typedef detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
+ typedef ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
BOOST_STATIC_CONSTANT(
std::size_t
)
);
-#if defined(__GNUC__) &&\
- (__GNUC__ > 3) ||\
- (__GNUC__ == 3 && (__GNUC_MINOR__ > 2 ||\
- (__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >=3)))
-
private: // noncopyable
aligned_storage(const aligned_storage&);
aligned_storage& operator=(const aligned_storage&);
-#else // gcc less than 3.2.3
-
-public: // _should_ be noncopyable, but GCC compiler emits error
-
- aligned_storage(const aligned_storage&);
- aligned_storage& operator=(const aligned_storage&);
-
-#endif // gcc < 3.2.3 workaround
-
public: // structors
aligned_storage()
return static_cast<type*>(this)->address();
}
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-
const void* address() const
{
return static_cast<const type*>(this)->address();
}
-
-#else // MSVC6
-
- const void* address() const;
-
-#endif // MSVC6 workaround
-
};
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-
-// MSVC6 seems not to like inline functions with const void* returns, so we
-// declare the following here:
-
-template <std::size_t S, std::size_t A>
-const void* aligned_storage<S,A>::address() const
-{
- return const_cast< aligned_storage<S,A>* >(this)->address();
-}
-
-#endif // MSVC6 workaround
-
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
//
// Make sure that is_pod recognises aligned_storage<>::type
// as a POD (Note that aligned_storage<> itself is not a POD):
//
template <std::size_t size_, std::size_t alignment_>
-struct is_pod<boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
+struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
BOOST_TT_AUX_BOOL_C_BASE(true)
{
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(true)
};
-#endif
} // namespace boost
#ifndef BOOST_ANY_INCLUDED
#define BOOST_ANY_INCLUDED
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
# pragma once
#endif
// when: July 2001, April 2013 - May 2013
#include <algorithm>
-#include <typeinfo>
#include "boost/config.hpp"
+#include <boost/type_index.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/decay.hpp>
+#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_const.hpp>
-
-// See boost/python/type_id.hpp
-// TODO: add BOOST_TYPEID_COMPARE_BY_NAME to config.hpp
-# if (defined(__GNUC__) && __GNUC__ >= 3) \
- || defined(_AIX) \
- || ( defined(__sgi) && defined(__host_mips)) \
- || (defined(__hpux) && defined(__HP_aCC)) \
- || (defined(linux) && defined(__INTEL_COMPILER) && defined(__ICC))
-# define BOOST_AUX_ANY_TYPE_ID_NAME
-#include <cstring>
-# endif
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable: 4172) // Mistakenly warns: returning address of local variable or temporary
-#endif
+#include <boost/mpl/if.hpp>
namespace boost
{
template<typename ValueType>
any(const ValueType & value)
- : content(new holder<BOOST_DEDUCED_TYPENAME decay<const ValueType>::type>(value))
+ : content(new holder<
+ BOOST_DEDUCED_TYPENAME remove_cv<BOOST_DEDUCED_TYPENAME decay<const ValueType>::type>::type
+ >(value))
{
}
any().swap(*this);
}
- const std::type_info & type() const BOOST_NOEXCEPT
+ const boost::typeindex::type_info& type() const BOOST_NOEXCEPT
{
- return content ? content->type() : typeid(void);
+ return content ? content->type() : boost::typeindex::type_id<void>().type_info();
}
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
public: // queries
- virtual const std::type_info & type() const BOOST_NOEXCEPT = 0;
+ virtual const boost::typeindex::type_info& type() const BOOST_NOEXCEPT = 0;
virtual placeholder * clone() const = 0;
#endif
public: // queries
- virtual const std::type_info & type() const BOOST_NOEXCEPT
+ virtual const boost::typeindex::type_info& type() const BOOST_NOEXCEPT
{
- return typeid(ValueType);
+ return boost::typeindex::type_id<ValueType>().type_info();
}
virtual placeholder * clone() const
lhs.swap(rhs);
}
- class BOOST_SYMBOL_VISIBLE bad_any_cast : public std::bad_cast
+ class BOOST_SYMBOL_VISIBLE bad_any_cast :
+#ifndef BOOST_NO_RTTI
+ public std::bad_cast
+#else
+ public std::exception
+#endif
{
public:
virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
template<typename ValueType>
ValueType * any_cast(any * operand) BOOST_NOEXCEPT
{
- return operand &&
-#ifdef BOOST_AUX_ANY_TYPE_ID_NAME
- std::strcmp(operand->type().name(), typeid(ValueType).name()) == 0
-#else
- operand->type() == typeid(ValueType)
-#endif
- ? &static_cast<any::holder<ValueType> *>(operand->content)->held
+ return operand && operand->type() == boost::typeindex::type_id<ValueType>()
+ ? &static_cast<any::holder<BOOST_DEDUCED_TYPENAME remove_cv<ValueType>::type> *>(operand->content)->held
: 0;
}
{
typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
- // If 'nonref' is still reference type, it means the user has not
- // specialized 'remove_reference'.
-
- // Please use BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION macro
- // to generate specialization of remove_reference for your class
- // See type traits library documentation for details
- BOOST_STATIC_ASSERT(!is_reference<nonref>::value);
-#endif
nonref * result = any_cast<nonref>(&operand);
if(!result)
inline ValueType any_cast(const any & operand)
{
typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
- // The comment in the above version of 'any_cast' explains when this
- // assert is fired and what to do.
- BOOST_STATIC_ASSERT(!is_reference<nonref>::value);
-#endif
-
return any_cast<const nonref &>(const_cast<any &>(operand));
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template<typename ValueType>
- inline ValueType&& any_cast(any&& operand)
+ inline ValueType any_cast(any&& operand)
{
BOOST_STATIC_ASSERT_MSG(
- boost::is_rvalue_reference<ValueType&&>::value
+ boost::is_rvalue_reference<ValueType&&>::value /*true if ValueType is rvalue or just a value*/
|| boost::is_const< typename boost::remove_reference<ValueType>::type >::value,
"boost::any_cast shall not be used for getting nonconst references to temporary objects"
);
- return any_cast<ValueType&&>(operand);
+ return any_cast<ValueType>(operand);
}
#endif
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
#endif
// boost/assert.hpp - BOOST_ASSERT(expr)
// BOOST_ASSERT_MSG(expr, msg)
// BOOST_VERIFY(expr)
+// BOOST_VERIFY_MSG(expr, msg)
//
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-// Copyright (c) 2007 Peter Dimov
+// Copyright (c) 2007, 2014 Peter Dimov
// Copyright (c) Beman Dawes 2011
//
-// 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)
+// 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
//
// Note: There are no include guards. This is intentional.
//
-// See http://www.boost.org/libs/utility/assert.html for documentation.
+// See http://www.boost.org/libs/assert/assert.html for documentation.
//
//
// boostinspect:naassert_macro
//
-//--------------------------------------------------------------------------------------//
-// BOOST_ASSERT //
-//--------------------------------------------------------------------------------------//
+//
+// BOOST_ASSERT, BOOST_ASSERT_MSG
+//
#undef BOOST_ASSERT
+#undef BOOST_ASSERT_MSG
-#if defined(BOOST_DISABLE_ASSERTS)
+#if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) )
# define BOOST_ASSERT(expr) ((void)0)
+# define BOOST_ASSERT_MSG(expr, msg) ((void)0)
-#elif defined(BOOST_ENABLE_ASSERT_HANDLER)
+#elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) )
-#include <boost/config.hpp>
+#include <boost/config.hpp> // for BOOST_LIKELY
#include <boost/current_function.hpp>
namespace boost
{
- void assertion_failed(char const * expr,
- char const * function, char const * file, long line); // user defined
+ void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
+ void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line); // user defined
} // namespace boost
-#define BOOST_ASSERT(expr) (BOOST_LIKELY(!!(expr)) \
- ? ((void)0) \
- : ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#define BOOST_ASSERT(expr) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
#else
-# include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
-# define BOOST_ASSERT(expr) assert(expr)
-#endif
-
-//--------------------------------------------------------------------------------------//
-// BOOST_ASSERT_MSG //
-//--------------------------------------------------------------------------------------//
-
-# undef BOOST_ASSERT_MSG
-
-#if defined(BOOST_DISABLE_ASSERTS) || defined(NDEBUG)
-
- #define BOOST_ASSERT_MSG(expr, msg) ((void)0)
-#elif defined(BOOST_ENABLE_ASSERT_HANDLER)
-
- #include <boost/config.hpp>
- #include <boost/current_function.hpp>
-
- namespace boost
- {
- void assertion_failed_msg(char const * expr, char const * msg,
- char const * function, char const * file, long line); // user defined
- } // namespace boost
+# include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
- #define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr)) \
- ? ((void)0) \
- : ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+# define BOOST_ASSERT(expr) assert(expr)
+# define BOOST_ASSERT_MSG(expr, msg) assert((expr)&&(msg))
-#else
- #ifndef BOOST_ASSERT_HPP
- #define BOOST_ASSERT_HPP
- #include <cstdlib>
- #include <iostream>
- #include <boost/config.hpp>
- #include <boost/current_function.hpp>
-
- // IDE's like Visual Studio perform better if output goes to std::cout or
- // some other stream, so allow user to configure output stream:
- #ifndef BOOST_ASSERT_MSG_OSTREAM
- # define BOOST_ASSERT_MSG_OSTREAM std::cerr
- #endif
-
- namespace boost
- {
- namespace assertion
- {
- namespace detail
- {
- // Note: The template is needed to make the function non-inline and avoid linking errors
- template< typename CharT >
- BOOST_NOINLINE void assertion_failed_msg(CharT const * expr, char const * msg, char const * function,
- char const * file, long line)
- {
- BOOST_ASSERT_MSG_OSTREAM
- << "***** Internal Program Error - assertion (" << expr << ") failed in "
- << function << ":\n"
- << file << '(' << line << "): " << msg << std::endl;
-#ifdef UNDER_CE
- // The Windows CE CRT library does not have abort() so use exit(-1) instead.
- std::exit(-1);
-#else
- std::abort();
-#endif
- }
- } // detail
- } // assertion
- } // detail
- #endif
-
- #define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr)) \
- ? ((void)0) \
- : ::boost::assertion::detail::assertion_failed_msg(#expr, msg, \
- BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
#endif
-//--------------------------------------------------------------------------------------//
-// BOOST_VERIFY //
-//--------------------------------------------------------------------------------------//
+//
+// BOOST_VERIFY, BOOST_VERIFY_MSG
+//
#undef BOOST_VERIFY
+#undef BOOST_VERIFY_MSG
#if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )
# define BOOST_VERIFY(expr) ((void)(expr))
+# define BOOST_VERIFY_MSG(expr, msg) ((void)(expr))
#else
# define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+# define BOOST_VERIFY_MSG(expr, msg) BOOST_ASSERT_MSG(expr,msg)
#endif
#include <boost/config.hpp>
#include <boost/is_placeholder.hpp>
+#include <boost/static_assert.hpp>
namespace boost
{
template< class T > arg( T const & /* t */ )
{
- // static assert I == is_placeholder<T>::value
- typedef char T_must_be_placeholder[ I == is_placeholder<T>::value? 1: -1 ];
+ BOOST_STATIC_ASSERT( I == is_placeholder<T>::value );
}
};
// bind_t
-#ifndef BOOST_NO_VOID_RETURNS
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+template< class A > struct list_add_cref
+{
+ typedef A const & type;
+};
+
+template< class A > struct list_add_cref< A& >
+{
+ typedef A & type;
+};
+
+template<class R, class F, class L> class bind_t
+{
+private:
+
+ F f_;
+ L l_;
+
+public:
+
+ typedef typename result_traits<R, F>::type result_type;
+ typedef bind_t this_type;
+
+ bind_t( F f, L const & l ): f_( f ), l_( l ) {}
+
+ //
+
+ result_type operator()()
+ {
+ list0 a;
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ result_type operator()() const
+ {
+ list0 a;
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1> result_type operator()( A1 && a1 )
+ {
+ list1< typename list_add_cref<A1>::type > a( a1 );
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1> result_type operator()( A1 && a1 ) const
+ {
+ list1< typename list_add_cref<A1>::type > a( a1 );
+ return l_(type<result_type>(), f_, a, 0);
+ }
+
+ template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 )
+ {
+ list2< typename list_add_cref<A1>::type, typename list_add_cref<A2>::type > a( a1, a2 );
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 ) const
+ {
+ list2< typename list_add_cref<A1>::type, typename list_add_cref<A2>::type > a( a1, a2 );
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 )
+ {
+ list3<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type
+ > a( a1, a2, a3 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 ) const
+ {
+ list3<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type
+ > a( a1, a2, a3 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
+ {
+ list4<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type
+ > a( a1, a2, a3, a4 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 ) const
+ {
+ list4<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type
+ > a( a1, a2, a3, a4 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
+ {
+ list5<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type,
+ typename list_add_cref<A5>::type
+ > a( a1, a2, a3, a4, a5 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 ) const
+ {
+ list5<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type,
+ typename list_add_cref<A5>::type
+ > a( a1, a2, a3, a4, a5 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
+ {
+ list6<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type,
+ typename list_add_cref<A5>::type,
+ typename list_add_cref<A6>::type
+ > a( a1, a2, a3, a4, a5, a6 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 ) const
+ {
+ list6<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type,
+ typename list_add_cref<A5>::type,
+ typename list_add_cref<A6>::type
+ > a( a1, a2, a3, a4, a5, a6 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
+ {
+ list7<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type,
+ typename list_add_cref<A5>::type,
+ typename list_add_cref<A6>::type,
+ typename list_add_cref<A7>::type
+ > a( a1, a2, a3, a4, a5, a6, a7 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 ) const
+ {
+ list7<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type,
+ typename list_add_cref<A5>::type,
+ typename list_add_cref<A6>::type,
+ typename list_add_cref<A7>::type
+ > a( a1, a2, a3, a4, a5, a6, a7 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
+ {
+ list8<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type,
+ typename list_add_cref<A5>::type,
+ typename list_add_cref<A6>::type,
+ typename list_add_cref<A7>::type,
+ typename list_add_cref<A8>::type
+ > a( a1, a2, a3, a4, a5, a6, a7, a8 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 ) const
+ {
+ list8<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type,
+ typename list_add_cref<A5>::type,
+ typename list_add_cref<A6>::type,
+ typename list_add_cref<A7>::type,
+ typename list_add_cref<A8>::type
+ > a( a1, a2, a3, a4, a5, a6, a7, a8 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
+ {
+ list9<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type,
+ typename list_add_cref<A5>::type,
+ typename list_add_cref<A6>::type,
+ typename list_add_cref<A7>::type,
+ typename list_add_cref<A8>::type,
+ typename list_add_cref<A9>::type
+ > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 ) const
+ {
+ list9<
+ typename list_add_cref<A1>::type,
+ typename list_add_cref<A2>::type,
+ typename list_add_cref<A3>::type,
+ typename list_add_cref<A4>::type,
+ typename list_add_cref<A5>::type,
+ typename list_add_cref<A6>::type,
+ typename list_add_cref<A7>::type,
+ typename list_add_cref<A8>::type,
+ typename list_add_cref<A9>::type
+ > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
+
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ //
+
+ template<class A> result_type eval( A & a )
+ {
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class A> result_type eval( A & a ) const
+ {
+ return l_( type<result_type>(), f_, a, 0 );
+ }
+
+ template<class V> void accept( V & v ) const
+ {
+#if !defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP ) && !defined( __BORLANDC__ )
+ using boost::visit_each;
+#endif
+
+ BOOST_BIND_VISIT_EACH( v, f_, 0 );
+ l_.accept( v );
+ }
+
+ bool compare( this_type const & rhs ) const
+ {
+ return ref_compare( f_, rhs.f_, 0 ) && l_ == rhs.l_;
+ }
+};
+
+#elif !defined( BOOST_NO_VOID_RETURNS )
template<class R, class F, class L> class bind_t
{
};
-#else
+#else // no void returns
template<class R> struct bind_t_generator
{
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}
+template<class Rt2, class R, class T,
+ class A1>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(mf0)<R, T> F;
+ typedef typename _bi::list_av_1<A1>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+}
+
+template<class Rt2, class R, class T,
+ class A1>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T> F;
+ typedef typename _bi::list_av_1<A1>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+}
+
// 1
template<class R, class T,
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}
+template<class Rt2, class R, class T,
+ class B1,
+ class A1, class A2>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
+ typedef typename _bi::list_av_2<A1, A2>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+}
+
+template<class Rt2, class R, class T,
+ class B1,
+ class A1, class A2>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
+ typedef typename _bi::list_av_2<A1, A2>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+}
+
// 2
template<class R, class T,
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}
+template<class Rt2, class R, class T,
+ class B1, class B2,
+ class A1, class A2, class A3>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
+ typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+template<class Rt2, class R, class T,
+ class B1, class B2,
+ class A1, class A2, class A3>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
+ typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
// 3
template<class R, class T,
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3,
+ class A1, class A2, class A3, class A4>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
+ typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3,
+ class A1, class A2, class A3, class A4>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
+ typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
// 4
template<class R, class T,
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3, class B4,
+ class A1, class A2, class A3, class A4, class A5>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
+ typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3, class B4,
+ class A1, class A2, class A3, class A4, class A5>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
+ typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
// 5
template<class R, class T,
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3, class B4, class B5,
+ class A1, class A2, class A3, class A4, class A5, class A6>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
+ typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3, class B4, class B5,
+ class A1, class A2, class A3, class A4, class A5, class A6>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
+ typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
// 6
template<class R, class T,
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3, class B4, class B5, class B6,
+ class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
+ typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3, class B4, class B5, class B6,
+ class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
+ typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
// 7
template<class R, class T,
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+ class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+ typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+ class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+ typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
// 8
template<class R, class T,
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
+
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+ class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+ typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template<class Rt2, class R, class T,
+ class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+ class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+ _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+ BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+ typedef _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+ typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+ return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
//
// See http://www.boost.org/libs/utility for most recent version including documentation.
-// See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp
+// See boost/detail/call_traits.hpp
// for full copyright notices.
#ifndef BOOST_CALL_TRAITS_HPP
#include <boost/config.hpp>
#endif
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/detail/ob_call_traits.hpp>
-#else
#include <boost/detail/call_traits.hpp>
-#endif
#endif // BOOST_CALL_TRAITS_HPP
-#ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
-#define BOOST_CHECKED_DELETE_HPP_INCLUDED
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * 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)
+ */
-// MS compatible compilers support #pragma once
+#ifndef BOOST_CHECKED_DELETE_HPP
+#define BOOST_CHECKED_DELETE_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// boost/checked_delete.hpp
-//
-// Copyright (c) 2002, 2003 Peter Dimov
-// Copyright (c) 2003 Daniel Frey
-// Copyright (c) 2003 Howard Hinnant
-//
-// 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/utility/checked_delete.html for documentation.
-//
-
-namespace boost
-{
-
-// verify that types are complete for increased safety
-
-template<class T> inline void checked_delete(T * x)
-{
- // intentionally complex - simplification causes regressions
- typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
- (void) sizeof(type_must_be_complete);
- delete x;
-}
-
-template<class T> inline void checked_array_delete(T * x)
-{
- typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
- (void) sizeof(type_must_be_complete);
- delete [] x;
-}
+// The header file at this path is deprecated;
+// use boost/core/checked_delete.hpp instead.
-template<class T> struct checked_deleter
-{
- typedef void result_type;
- typedef T * argument_type;
+#include <boost/core/checked_delete.hpp>
- void operator()(T * x) const
- {
- // boost:: disables ADL
- boost::checked_delete(x);
- }
-};
-
-template<class T> struct checked_array_deleter
-{
- typedef void result_type;
- typedef T * argument_type;
-
- void operator()(T * x) const
- {
- boost::checked_array_delete(x);
- }
-};
-
-} // namespace boost
-
-#endif // #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
+#endif
# if !defined(BOOST_NO_OLD_CONCEPT_SUPPORT) \
&& !defined(BOOST_NO_SFINAE) \
\
- && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4)) \
- && !(BOOST_WORKAROUND(__GNUC__, == 2))
+ && !(BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4))
// Note: gcc-2.96 through 3.3.x have some SFINAE, but no ability to
// check for the presence of particularmember functions.
//
// Also defines an equivalent SomeNameConcept for backward compatibility.
// Maybe in the next release we can kill off the "Concept" suffix for good.
-#if BOOST_WORKAROUND(__GNUC__, <= 3)
# define BOOST_concept(name, params) \
template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) > \
struct name; /* forward declaration */ \
struct BOOST_PP_CAT(name,Concept) \
: name< BOOST_PP_SEQ_ENUM(params) > \
{ \
- /* at least 2.96 and 3.4.3 both need this */ \
- BOOST_PP_CAT(name,Concept)(); \
}; \
\
template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) > \
struct name
-#else
-# define BOOST_concept(name, params) \
- template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) > \
- struct name; /* forward declaration */ \
- \
- template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) > \
- struct BOOST_PP_CAT(name,Concept) \
- : name< BOOST_PP_SEQ_ENUM(params) > \
- { \
- }; \
- \
- template < BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONCEPT_typename,~,params) > \
- struct name
-#endif
// Helper for BOOST_concept, above.
# define BOOST_CONCEPT_typename(r, ignored, index, t) \
# endif
+// Version check from https://svn.boost.org/trac/boost/changeset/82886
+// (boost/static_assert.hpp)
+#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)))
+#define BOOST_CONCEPT_UNUSED_TYPEDEF __attribute__((unused))
+#else
+#define BOOST_CONCEPT_UNUSED_TYPEDEF /**/
+#endif
+
# define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr ) \
typedef ::boost::concepts::detail::instantiate< \
&::boost::concepts::requirement_<ModelFnPtr>::failed> \
- BOOST_PP_CAT(boost_concept_check,__LINE__)
+ BOOST_PP_CAT(boost_concept_check,__LINE__) \
+ BOOST_CONCEPT_UNUSED_TYPEDEF
}}
# include <boost/preprocessor/cat.hpp>
# include <boost/concept/detail/backward_compatibility.hpp>
+# include <boost/config.hpp>
# ifdef BOOST_OLD_CONCEPT_SUPPORT
# include <boost/concept/detail/has_constraints.hpp>
# include <boost/mpl/if.hpp>
# endif
+# ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable:4100)
+# endif
namespace boost { namespace concepts {
# endif
}}
+# ifdef BOOST_MSVC
+# pragma warning(pop)
+# endif
+
#endif // BOOST_CONCEPT_CHECK_MSVC_DWA2006429_HPP
namespace boost { namespace concepts {
-# if BOOST_WORKAROUND(__GNUC__, == 2)
-
-# define BOOST_CONCEPT_USAGE(model) ~model()
-
-# else
-
template <class Model>
struct usage_requirements
{
# endif
-# endif
-
}} // namespace boost::concepts
#endif // BOOST_CONCEPT_USAGE_DWA2006919_HPP
# include <boost/concept/usage.hpp>
# include <boost/concept/detail/concept_def.hpp>
+#if (defined _MSC_VER)
+# pragma warning( push )
+# pragma warning( disable : 4510 ) // default constructor could not be generated
+# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required
+#endif
+
namespace boost
{
TT b;
};
-#if (defined _MSC_VER)
-# pragma warning( push )
-# pragma warning( disable : 4510 ) // default constructor could not be generated
-# pragma warning( disable : 4610 ) // object 'class' can never be instantiated - user-defined constructor required
-#endif
// The SGI STL version of Assignable requires copy constructor and operator=
BOOST_concept(SGIAssignable,(TT))
{
TT a;
TT b;
};
-#if (defined _MSC_VER)
-# pragma warning( pop )
-#endif
BOOST_concept(Convertible,(X)(Y))
{
: ForwardIterator<TT>
{
BOOST_CONCEPT_USAGE(Mutable_ForwardIterator) {
- *i++ = *i; // require postincrement and assignment
+ *i++ = *j; // require postincrement and assignment
}
private:
- TT i;
+ TT i, j;
};
BOOST_concept(BidirectionalIterator,(TT))
{
BOOST_CONCEPT_USAGE(Mutable_BidirectionalIterator)
{
- *i-- = *i; // require postdecrement and assignment
+ *i-- = *j; // require postdecrement and assignment
}
private:
- TT i;
+ TT i, j;
};
BOOST_concept(RandomAccessIterator,(TT))
BOOST_CONCEPT_USAGE(Sequence)
{
S
- c(n),
- c2(n, t),
- c3(first, last);
+ c(n, t),
+ c2(first, last);
c.insert(p, t);
c.insert(p, n, t);
ignore_unused_variable_warning(c);
ignore_unused_variable_warning(c2);
- ignore_unused_variable_warning(c3);
ignore_unused_variable_warning(r);
const_constraints(c);
}
typename BackInsertionSequence::const_reference
r = cc.back();
ignore_unused_variable_warning(r);
- };
+ }
S c;
typename S::value_type t;
};
};
} // namespace boost
+#if (defined _MSC_VER)
+# pragma warning( pop )
+#endif
+
# include <boost/concept/detail/concept_undef.hpp>
#endif // BOOST_CONCEPT_CHECKS_HPP
// if we don't have a user config, then use the default location:
#if !defined(BOOST_USER_CONFIG) && !defined(BOOST_NO_USER_CONFIG)
# define BOOST_USER_CONFIG <boost/config/user.hpp>
+#if 0
+// For dependency trackers:
+# include <boost/config/user.hpp>
+#endif
#endif
// include it first:
#ifdef BOOST_USER_CONFIG
// vc11:
# define BOOST_LIB_TOOLSET "vc110"
-# elif defined(BOOST_MSVC)
+# elif defined(BOOST_MSVC) && (BOOST_MSVC < 1900)
// vc12:
# define BOOST_LIB_TOOLSET "vc120"
+# elif defined(BOOST_MSVC)
+
+ // vc14:
+# define BOOST_LIB_TOOLSET "vc140"
+
# elif defined(__BORLANDC__)
// CBuilder 6:
# ifdef BOOST_LIB_DIAGNOSTIC
# pragma message ("Linking to lib file: " BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
# endif
+#elif defined(BOOST_LIB_BUILDID)
+# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) ".lib")
+# ifdef BOOST_LIB_DIAGNOSTIC
+# pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) ".lib")
+# endif
#else
# pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
# ifdef BOOST_LIB_DIAGNOSTIC
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
#if __BORLANDC__ >= 0x590
# define BOOST_HAS_TR1_HASH
#define BOOST_HAS_PRAGMA_ONCE
+// Detecting `-fms-extension` compiler flag assuming that _MSC_VER defined when that flag is used.
+#if defined (_MSC_VER) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 4))
+# define BOOST_HAS_PRAGMA_DETECT_MISMATCH
+#endif
+
+// When compiling with clang before __has_extension was defined,
+// even if one writes 'defined(__has_extension) && __has_extension(xxx)',
+// clang reports a compiler error. So the only workaround found is:
+
+#ifndef __has_extension
+#define __has_extension __has_feature
+#endif
+
#if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
# define BOOST_NO_EXCEPTIONS
#endif
// Clang supports "long long" in all compilation modes.
#define BOOST_HAS_LONG_LONG
+//
+// We disable this if the compiler is really nvcc as it
+// doesn't actually support __int128 as of CUDA_VERSION=5000
+// even though it defines __SIZEOF_INT128__.
+// See https://svn.boost.org/trac/boost/ticket/10418
+// Only re-enable this for nvcc if you're absolutely sure
+// of the circumstances under which it's supported:
+//
+#if defined(__SIZEOF_INT128__) && !defined(__CUDACC__)
+# define BOOST_HAS_INT128
+#endif
+
+
//
// Dynamic shared object (DSO) and dynamic-link library (DLL) support
//
# define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#endif
-#if !(defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
+//
+// Currently clang on Windows using VC++ RTL does not support C++11's char16_t or char32_t
+//
+#if defined(_MSC_VER) || !(defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L)
# define BOOST_NO_CXX11_CHAR16_T
# define BOOST_NO_CXX11_CHAR32_T
#endif
# define BOOST_NO_CXX11_RAW_LITERALS
#endif
+#if !__has_feature(cxx_reference_qualified_functions)
+# define BOOST_NO_CXX11_REF_QUALIFIERS
+#endif
+
#if !__has_feature(cxx_generalized_initializers)
# define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#endif
# define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#endif
-#if !(__has_feature(cxx_alignas) || __has_extension(cxx_alignas))
+#if !__has_feature(cxx_alignas)
# define BOOST_NO_CXX11_ALIGNAS
#endif
# define BOOST_NO_CXX11_INLINE_NAMESPACES
#endif
-// Clang always supports variadic macros
-// Clang always supports extern templates
+#if !__has_feature(cxx_override_control)
+# define BOOST_NO_CXX11_FINAL
+#endif
+
+#if !(__has_feature(__cxx_binary_literals__) || __has_extension(__cxx_binary_literals__))
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+
+#if !__has_feature(__cxx_decltype_auto__)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+
+#if !__has_feature(__cxx_aggregate_nsdmi__)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+
+#if !__has_feature(__cxx_init_captures__)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+
+#if !__has_feature(__cxx_generic_lambdas__)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+
+// clang < 3.5 has a defect with dependent type, like following.
+//
+// template <class T>
+// constexpr typename enable_if<pred<T> >::type foo(T &)
+// { } // error: no return statement in constexpr function
+//
+// This issue also affects C++11 mode, but C++11 constexpr requires return stmt.
+// Therefore we don't care such case.
+//
+// Note that we can't check Clang version directly as the numbering system changes depending who's
+// creating the Clang release (see https://github.com/boostorg/config/pull/39#issuecomment-59927873)
+// so instead verify that we have a feature that was introduced at the same time as working C++14
+// constexpr (generic lambda's in this case):
+//
+#if !__has_feature(__cxx_generic_lambdas__) || !__has_feature(__cxx_relaxed_constexpr__)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+
+#if !__has_feature(__cxx_return_type_deduction__)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+
+#if !__has_feature(__cxx_variable_templates__)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
+
+#if __cplusplus < 201400
+// All versions with __cplusplus above this value seem to support this:
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+
+
+// Unused attribute:
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+# define BOOST_ATTRIBUTE_UNUSED __attribute__((unused))
+#endif
#ifndef BOOST_COMPILER
# define BOOST_COMPILER "Clang version " __clang_version__
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
//
// TR1 macros:
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
#ifdef c_plusplus
// EDG has "long long" in non-strict mode
// (C) Copyright John Maddock 2011.
+// (C) Copyright Cray, Inc. 2013
// Use, modification and distribution are subject to 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)
#define BOOST_COMPILER "Cray C version " BOOST_STRINGIZE(_RELEASE)
-#if _RELEASE < 7
-# error "Boost is not configured for Cray compilers prior to version 7, please try the configure script."
+#if _RELEASE < 8
+# error "Boost is not configured for Cray compilers prior to version 8, please try the configure script."
#endif
//
#include "boost/config/compiler/common_edg.hpp"
+
//
-// Cray peculiarities, probably version 7 specific:
//
-#undef BOOST_NO_CXX11_AUTO_DECLARATIONS
-#undef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#define BOOST_HAS_NRVO
+#define BOOST_NO_CXX11_VARIADIC_MACROS
#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#define BOOST_NO_CXX11_UNICODE_LITERALS
#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
#define BOOST_NO_CXX11_CHAR32_T
#define BOOST_NO_CXX11_CHAR16_T
-#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+
+
//#define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
#define BOOST_MATH_DISABLE_STD_FPCLASSIFY
//#define BOOST_HAS_FPCLASSIFY
-#define BOOST_SP_USE_PTHREADS
-#define BOOST_AC_USE_PTHREADS
+#define BOOST_SP_USE_PTHREADS
+#define BOOST_AC_USE_PTHREADS
+
+/* everything that follows is working around what are thought to be
+ * compiler shortcomings. Revist all of these regularly.
+ */
+
+//#define BOOST_USE_ENUM_STATIC_ASSERT
+//#define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS //(this may be implied by the previous #define
+
+// These constants should be provided by the
+// compiler, at least when -hgnu is asserted on the command line.
+
+#ifndef __ATOMIC_RELAXED
+#define __ATOMIC_RELAXED 0
+#define __ATOMIC_CONSUME 1
+#define __ATOMIC_ACQUIRE 2
+#define __ATOMIC_RELEASE 3
+#define __ATOMIC_ACQ_REL 4
+#define __ATOMIC_SEQ_CST 5
+#endif
+
+
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
#if (__DMC__ <= 0x840)
#error "Compiler not supported or configured - please reconfigure"
//
// Define BOOST_GCC so we know this is "real" GCC and not some pretender:
//
+#define BOOST_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
#if !defined(__CUDACC__)
-#define BOOST_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#define BOOST_GCC BOOST_GCC_VERSION
+#endif
+
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L)
+# define BOOST_GCC_CXX11
#endif
#if __GNUC__ == 3
#endif
// GCC prior to 3.4 had #pragma once too but it didn't work well with filesystem links
-#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#if BOOST_GCC_VERSION >= 30400
#define BOOST_HAS_PRAGMA_ONCE
#endif
-#if __GNUC__ < 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ < 4 )
+#if BOOST_GCC_VERSION < 40400
// Previous versions of GCC did not completely implement value-initialization:
// GCC Bug 30111, "Value-initialization of POD base class doesn't initialize
// members", reported by Jonathan Wakely in 2006,
//
// gcc has "long long"
+// Except on Darwin with standard compliance enabled (-pedantic)
+// Apple gcc helpfully defines this macro we can query
//
-#define BOOST_HAS_LONG_LONG
+#if !defined(__DARWIN_NO_LONG_LONG)
+# define BOOST_HAS_LONG_LONG
+#endif
//
// gcc implements the named return value optimization since version 3.1
//
// RTTI and typeinfo detection is possible post gcc-4.3:
//
-#if __GNUC__ * 100 + __GNUC_MINOR__ >= 403
+#if BOOST_GCC_VERSION > 40300
# ifndef __GXX_RTTI
# ifndef BOOST_NO_TYPEID
# define BOOST_NO_TYPEID
// C++0x features in 4.3.n and later
//
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) && defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_GCC_VERSION >= 40300) && defined(BOOST_GCC_CXX11)
// C++0x features are only enabled when -std=c++0x or -std=gnu++0x are
// passed on the command line, which in turn defines
// __GXX_EXPERIMENTAL_CXX0X__.
# define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
# define BOOST_NO_CXX11_RVALUE_REFERENCES
# define BOOST_NO_CXX11_STATIC_ASSERT
-
-// Variadic templates compiler:
-// http://www.generic-programming.org/~dgregor/cpp/variadic-templates.html
-# if defined(__VARIADIC_TEMPLATES) || (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4) && defined(__GXX_EXPERIMENTAL_CXX0X__))
-# define BOOST_HAS_VARIADIC_TMPL
-# else
-# define BOOST_NO_CXX11_VARIADIC_TEMPLATES
-# endif
#endif
// C++0x features in 4.4.n and later
//
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_GCC_VERSION < 40400) || !defined(BOOST_GCC_CXX11)
# define BOOST_NO_CXX11_AUTO_DECLARATIONS
# define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
# define BOOST_NO_CXX11_CHAR16_T
# define BOOST_NO_CXX11_DELETED_FUNCTIONS
# define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
# define BOOST_NO_CXX11_INLINE_NAMESPACES
+# define BOOST_NO_CXX11_VARIADIC_TEMPLATES
#endif
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
+#if BOOST_GCC_VERSION < 40500
# define BOOST_NO_SFINAE_EXPR
#endif
// GCC 4.5 forbids declaration of defaulted functions in private or protected sections
-#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && (__GNUC__ == 4 && __GNUC_MINOR__ <= 5)
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ == 5) || !defined(BOOST_GCC_CXX11)
# define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
#endif
// C++0x features in 4.5.0 and later
//
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_GCC_VERSION < 40500) || !defined(BOOST_GCC_CXX11)
# define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
# define BOOST_NO_CXX11_LAMBDAS
# define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
// C++0x features in 4.5.1 and later
//
-#if (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ < 40501) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_GCC_VERSION < 40501) || !defined(BOOST_GCC_CXX11)
// scoped enums have a serious bug in 4.4.0, so define BOOST_NO_CXX11_SCOPED_ENUMS before 4.5.1
// See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38064
# define BOOST_NO_CXX11_SCOPED_ENUMS
// C++0x features in 4.6.n and later
//
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_GCC_VERSION < 40600) || !defined(BOOST_GCC_CXX11)
#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_NOEXCEPT
#define BOOST_NO_CXX11_NULLPTR
// C++0x features in 4.7.n and later
//
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_GCC_VERSION < 40700) || !defined(BOOST_GCC_CXX11)
+# define BOOST_NO_CXX11_FINAL
# define BOOST_NO_CXX11_TEMPLATE_ALIASES
# define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+# define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
#endif
// C++0x features in 4.8.n and later
//
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_GCC_VERSION < 40800) || !defined(BOOST_GCC_CXX11)
# define BOOST_NO_CXX11_ALIGNAS
#endif
// C++0x features in 4.8.1 and later
//
-#if (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ < 40801) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_GCC_VERSION < 40801) || !defined(BOOST_GCC_CXX11)
# define BOOST_NO_CXX11_DECLTYPE_N3276
+# define BOOST_NO_CXX11_REF_QUALIFIERS
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+
+// C++14 features in 4.9.0 and later
+//
+#if (BOOST_GCC_VERSION < 40900) || (__cplusplus < 201300)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+# if !((BOOST_GCC_VERSION >= 40801) && (BOOST_GCC_VERSION < 40900) && defined(BOOST_GCC_CXX11))
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+# endif
+#endif
+
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
+
+//
+// Unused attribute:
+#if __GNUC__ >= 4
+# define BOOST_ATTRIBUTE_UNUSED __attribute__((unused))
#endif
#ifndef BOOST_COMPILER
// versions check:
// we don't know gcc prior to version 3.30:
-#if (__GNUC__ < 3) || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3))
+#if (BOOST_GCC_VERSION< 30300)
# error "Compiler not configured - please reconfigure"
#endif
//
-// last known and checked version is 4.6 (Pre-release):
-#if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6))
+// last known and checked version is 4.9:
+#if (BOOST_GCC_VERSION > 40900)
# if defined(BOOST_ASSERT_CONFIG)
# error "Unknown compiler version - please run the configure tests and report the results"
# else
# endif
#endif
-
# define BOOST_NO_CXX11_ALIGNAS
# define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
# define BOOST_NO_CXX11_INLINE_NAMESPACES
+# define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
#define BOOST_COMPILER "GCC-XML C++ version " __GCCXML__
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
/*
See https://forums13.itrc.hp.com/service/forums/questionanswer.do?threadId=1443331 and
#include "boost/config/compiler/common_edg.hpp"
#if defined(__INTEL_COMPILER)
+#if __INTEL_COMPILER == 9999
+# define BOOST_INTEL_CXX_VERSION 1200 // Intel bug in 12.1.
+#else
# define BOOST_INTEL_CXX_VERSION __INTEL_COMPILER
+#endif
#elif defined(__ICL)
# define BOOST_INTEL_CXX_VERSION __ICL
#elif defined(__ICC)
# define BOOST_INTEL_STDCXX0X
#endif
-#ifdef BOOST_INTEL_STDCXX0X
-#define BOOST_COMPILER "Intel C++ C++0x mode version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
-#else
-#define BOOST_COMPILER "Intel C++ version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
+#ifdef __GNUC__
+# define BOOST_INTEL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#endif
+
+#if !defined(BOOST_COMPILER)
+# if defined(BOOST_INTEL_STDCXX0X)
+# define BOOST_COMPILER "Intel C++ C++0x mode version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
+# else
+# define BOOST_COMPILER "Intel C++ version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION)
+# endif
#endif
+
#define BOOST_INTEL BOOST_INTEL_CXX_VERSION
#if defined(_WIN32) || defined(_WIN64)
#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
#endif
+// RTTI
+// __RTTI is the EDG macro
+// __INTEL_RTTI__ is the Intel macro
+// __GXX_RTTI is the g++ macro
+// _CPPRTTI is the MSVC++ macro
+#if !defined(__RTTI) && !defined(__INTEL_RTTI__) && !defined(__GXX_RTTI) && !defined(_CPPRTTI)
+
+#if !defined(BOOST_NO_RTTI)
+# define BOOST_NO_RTTI
+#endif
+
+// in MS mode, static typeid works even when RTTI is off
+#if !defined(_MSC_VER) && !defined(BOOST_NO_TYPEID)
+# define BOOST_NO_TYPEID
+#endif
+
+#endif
+
//
// versions check:
// we don't support Intel prior to version 6.0:
// (Niels Dekker, LKEB, May 2010)
// Apparently Intel 12.1 (compiler version number 9999 !!) has the same issue (compiler regression).
#if defined(__INTEL_COMPILER)
-# if (__INTEL_COMPILER <= 1110) || (__INTEL_COMPILER == 9999) || (defined(_WIN32) && (__INTEL_COMPILER < 1500))
+# if (__INTEL_COMPILER <= 1110) || (__INTEL_COMPILER == 9999) || (defined(_WIN32) && (__INTEL_COMPILER < 1600))
# define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
# endif
#endif
#endif
//
// C++0x features
-// - ICC added static_assert in 11.0 (first version with C++0x support)
+// For each feature we need to check both the Intel compiler version,
+// and the version of MSVC or GCC that we are emulating.
+// See http://software.intel.com/en-us/articles/c0x-features-supported-by-intel-c-compiler/
+// for a list of which features were implemented in which Intel releases.
//
#if defined(BOOST_INTEL_STDCXX0X)
-# undef BOOST_NO_CXX11_STATIC_ASSERT
-//
-// These pass our test cases, but aren't officially supported according to:
-// http://software.intel.com/en-us/articles/c0x-features-supported-by-intel-c-compiler/
-//
-//# undef BOOST_NO_CXX11_LAMBDAS
-//# undef BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
-//# undef BOOST_NO_CXX11_DECLTYPE
-//# undef BOOST_NO_CXX11_AUTO_DECLARATIONS
-//# undef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
-#endif
-
-#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION >= 1200)
-//# undef BOOST_NO_CXX11_RVALUE_REFERENCES // Enabling this breaks Filesystem and Exception libraries
-//# undef BOOST_NO_CXX11_SCOPED_ENUMS // doesn't really work!!
-# undef BOOST_NO_CXX11_DELETED_FUNCTIONS
-# undef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
-# undef BOOST_NO_CXX11_LAMBDAS
-# undef BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
-# undef BOOST_NO_CXX11_DECLTYPE
-# undef BOOST_NO_CXX11_AUTO_DECLARATIONS
-# undef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
-# undef BOOST_NO_CXX11_TRAILING_RESULT_TYPES
-#endif
-
-// icl Version 12.1.0.233 Build 20110811 and possibly some other builds
-// had an incorrect __INTEL_COMPILER value of 9999. Intel say this has been fixed.
-#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION > 1200)
-# undef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
-# undef BOOST_NO_CXX11_NULLPTR
-# undef BOOST_NO_CXX11_RVALUE_REFERENCES
-# undef BOOST_NO_SFINAE_EXPR
-# undef BOOST_NO_CXX11_TEMPLATE_ALIASES
-# undef BOOST_NO_CXX11_VARIADIC_TEMPLATES
-
-// http://software.intel.com/en-us/articles/c0x-features-supported-by-intel-c-compiler/
-// continues to list scoped enum support as "Partial"
-//# undef BOOST_NO_CXX11_SCOPED_ENUMS
-#endif
-#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION >= 1310) && !defined(_MSC_VER)
-# undef BOOST_NO_CXX11_INLINE_NAMESPACES
+// BOOST_NO_CXX11_CONSTEXPR:
+#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40600)) && !defined(_MSC_VER)
+// Available in earlier Intel versions, but fail our tests:
+# undef BOOST_NO_CXX11_CONSTEXPR
+#endif
+// BOOST_NO_CXX11_NULLPTR:
+#if (BOOST_INTEL_CXX_VERSION >= 1210) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40600)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
+# undef BOOST_NO_CXX11_NULLPTR
+#endif
+// BOOST_NO_CXX11_TEMPLATE_ALIASES
+#if (BOOST_INTEL_CXX_VERSION >= 1210) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40700)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
+# undef BOOST_NO_CXX11_TEMPLATE_ALIASES
+#endif
+
+// BOOST_NO_CXX11_DECLTYPE
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40300)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
+# undef BOOST_NO_CXX11_DECLTYPE
+#endif
+
+// BOOST_NO_CXX11_DECLTYPE_N3276
+#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40800)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
+# undef BOOST_NO_CXX11_DECLTYPE_N3276
+#endif
+
+// BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40300)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
# undef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
-// This one generates internal compiler errors in multiprecision, disabled for now:
-//# undef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-// This one generates errors when used with conditional exception specifications, for example in multiprecision:
-//# undef BOOST_NO_CXX11_NOEXCEPT
-# undef BOOST_NO_CXX11_RANGE_BASED_FOR
+#endif
+
+// BOOST_NO_CXX11_RVALUE_REFERENCES
+#if (BOOST_INTEL_CXX_VERSION >= 1300) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40300)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
+// This is available from earlier Intel versions, but breaks Filesystem and other libraries:
+# undef BOOST_NO_CXX11_RVALUE_REFERENCES
+#endif
+
+// BOOST_NO_CXX11_STATIC_ASSERT
+#if (BOOST_INTEL_CXX_VERSION >= 1110) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40300)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
+# undef BOOST_NO_CXX11_STATIC_ASSERT
+#endif
+
+// BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
+# undef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#endif
+
+// BOOST_NO_CXX11_VARIADIC_MACROS
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40200)) && (!defined(_MSC_VER) || (_MSC_VER >= 1400))
+# undef BOOST_NO_CXX11_VARIADIC_MACROS
+#endif
+
+// BOOST_NO_CXX11_AUTO_DECLARATIONS
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
+# undef BOOST_NO_CXX11_AUTO_DECLARATIONS
+#endif
+
+// BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
+# undef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#endif
+
+// BOOST_NO_CXX11_CHAR16_T
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
+# undef BOOST_NO_CXX11_CHAR16_T
+#endif
+
+// BOOST_NO_CXX11_CHAR32_T
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
+# undef BOOST_NO_CXX11_CHAR32_T
+#endif
+
+// BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
+# undef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#endif
+
+// BOOST_NO_CXX11_DELETED_FUNCTIONS
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
+# undef BOOST_NO_CXX11_DELETED_FUNCTIONS
+#endif
+
+// BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_VER >= 1700))
+# undef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#endif
+
+// BOOST_NO_CXX11_SCOPED_ENUMS
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40501)) && (!defined(_MSC_VER) || (_MSC_VER >= 1700))
+// This is available but broken in earlier Intel releases.
# undef BOOST_NO_CXX11_SCOPED_ENUMS
+#endif
+
+// BOOST_NO_SFINAE_EXPR
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
+# undef BOOST_NO_SFINAE_EXPR
+#endif
+
+// BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
+// This is available in earlier Intel releases, but breaks Multiprecision:
+# undef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#endif
+
+// BOOST_NO_CXX11_LAMBDAS
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500)) && (!defined(_MSC_VER) || (_MSC_VER >= 1600))
+# undef BOOST_NO_CXX11_LAMBDAS
+#endif
+
+// BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500))
+# undef BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#endif
+
+// BOOST_NO_CXX11_RANGE_BASED_FOR
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40600)) && (!defined(_MSC_VER) || (_MSC_VER >= 1700))
+# undef BOOST_NO_CXX11_RANGE_BASED_FOR
+#endif
+
+// BOOST_NO_CXX11_RAW_LITERALS
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
+# undef BOOST_NO_CXX11_RAW_LITERALS
+#endif
+
+// BOOST_NO_CXX11_UNICODE_LITERALS
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
+# undef BOOST_NO_CXX11_UNICODE_LITERALS
+#endif
+
+// BOOST_NO_CXX11_NOEXCEPT
+#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40600)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
+// Available in earlier Intel release, but generates errors when used with
+// conditional exception specifications, for example in multiprecision:
+# undef BOOST_NO_CXX11_NOEXCEPT
+#endif
+
+// BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40600)) && (!defined(_MSC_VER) || (_MSC_VER >= 9999))
# undef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#endif
-#if (BOOST_INTEL_CXX_VERSION >= 1310)
-# undef BOOST_NO_SFINAE_EXPR
-#endif
-#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION >= 1400) && !defined(_MSC_VER)
-# undef BOOST_NO_CXX11_UNICODE_LITERALS
-# undef BOOST_NO_CXX11_RAW_LITERALS
-// This one generates errors when used with conditional exception specifications, for example in multiprecision:
-//# undef BOOST_NO_CXX11_NOEXCEPT
-// This breaks multiprecision:
-//# undef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-# undef BOOST_NO_CXX11_HDR_THREAD
-# undef BOOST_NO_CXX11_CHAR32_T
-# undef BOOST_NO_CXX11_CHAR16_T
+
+// BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40700)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 190021730))
+# undef BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#endif
+
+// BOOST_NO_CXX11_ALIGNAS
+#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40800)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 190021730))
+# undef BOOST_NO_CXX11_ALIGNAS
+#endif
+
+// BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#if (BOOST_INTEL_CXX_VERSION >= 1200) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
+# undef BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#endif
+
+// BOOST_NO_CXX11_INLINE_NAMESPACES
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40400)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 190021730))
+# undef BOOST_NO_CXX11_INLINE_NAMESPACES
+#endif
+
+// BOOST_NO_CXX11_REF_QUALIFIERS
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40800)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 190021730))
+# undef BOOST_NO_CXX11_REF_QUALIFIERS
+#endif
+
+// BOOST_NO_CXX11_FINAL
+#if (BOOST_INTEL_CXX_VERSION >= 1400) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40700)) && (!defined(_MSC_VER) || (_MSC_VER >= 1700))
+# undef BOOST_NO_CXX11_FINAL
#endif
+#endif
+
+//
+// Broken in all versions up to 15:
+#define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
+
#if defined(BOOST_INTEL_STDCXX0X) && (BOOST_INTEL_CXX_VERSION <= 1310)
# define BOOST_NO_CXX11_HDR_FUTURE
# define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
# define BOOST_NO_CXX11_HDR_TUPLE
#endif
-#if defined(_MSC_VER) && (_MSC_VER <= 1700)
-//
-// Although the Intel compiler is capable of supporting these, it appears not to in MSVC compatibility mode:
-//
-# define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-# define BOOST_NO_CXX11_VARIADIC_TEMPLATES
-# define BOOST_NO_CXX11_DELETED_FUNCTIONS
-# define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
-# define BOOST_NO_CXX11_TEMPLATE_ALIASES
-# if(BOOST_INTEL_CXX_VERSION < 1310)
-# define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
-# endif
-#endif
-
#if (BOOST_INTEL_CXX_VERSION < 1200)
//
// fenv.h appears not to work with Intel prior to 12.0:
# define BOOST_NO_FENV_H
#endif
+// Intel 13.10 fails to access defaulted functions of a base class declared in private or protected sections,
+// producing the following errors:
+// error #453: protected function "..." (declared at ...") is not accessible through a "..." pointer or object
+#if (BOOST_INTEL_CXX_VERSION <= 1310)
+# define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
+#endif
+
#if defined(_MSC_VER) && (_MSC_VER >= 1600)
# define BOOST_HAS_STDINT_H
#endif
-#if defined(__LP64__) && defined(__GNUC__) && (BOOST_INTEL_CXX_VERSION >= 1310)
+#if defined(__LP64__) && defined(__GNUC__) && (BOOST_INTEL_CXX_VERSION >= 1310) && !defined(__CUDACC__)
# define BOOST_HAS_INT128
#endif
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
#define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
//
// versions check:
# define BOOST_NO_CXX11_ALIGNAS
# define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
# define BOOST_NO_CXX11_INLINE_NAMESPACES
+# define BOOST_NO_CXX11_REF_QUALIFIERS
+# define BOOST_NO_CXX11_FINAL
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
#endif
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
//
// version check:
// probably nothing to do here?
# define BOOST_SYMBOL_VISIBLE __global
#endif
-
-
-//
-// Issues that effect all known versions:
-//
+#if (__SUNPRO_CC < 0x5130)
+// C++03 features in 12.4:
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_ADL_BARRIER
+#define BOOST_NO_CXX11_VARIADIC_MACROS
+#endif
-//
-// C++0x features
-//
-# define BOOST_HAS_LONG_LONG
-
+#if (__SUNPRO_CC < 0x5130) || (__cplusplus < 201100)
+// C++11 only featuires in 12.4:
#define BOOST_NO_CXX11_AUTO_DECLARATIONS
#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#define BOOST_NO_CXX11_CHAR16_T
#define BOOST_NO_CXX11_CHAR32_T
#define BOOST_NO_CXX11_CONSTEXPR
#define BOOST_NO_CXX11_DECLTYPE
-#define BOOST_NO_CXX11_DECLTYPE_N3276
#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#define BOOST_NO_CXX11_DELETED_FUNCTIONS
#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#define BOOST_NO_CXX11_RAW_LITERALS
#define BOOST_NO_CXX11_RVALUE_REFERENCES
#define BOOST_NO_CXX11_SCOPED_ENUMS
-#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_NO_CXX11_TEMPLATE_ALIASES
#define BOOST_NO_CXX11_UNICODE_LITERALS
-#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
-#define BOOST_NO_CXX11_VARIADIC_MACROS
-#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_FINAL
+#endif
+//
+// Issues that effect all known versions:
+//
+// Variadic templates pass our test case, but enabling this
+// causes the compiler to issue a signal 11 and bail out
+// in various libraries. The others fail our test cases.
+//
+#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_COMPLETE_VALUE_INITIALIZATION
+//
+// C++0x features
+//
+# define BOOST_HAS_LONG_LONG
+
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
//
// Version
//
#define BOOST_NO_CXX11_ALIGNAS
#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#define BOOST_NO_CXX11_INLINE_NAMESPACES
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
+# define BOOST_NO_CXX14_BINARY_LITERALS
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#endif
+#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#endif
+#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
# define BOOST_NO_CXX11_VARIADIC_MACROS
#endif
-#if defined(UNDER_CE)
-// Windows CE does not have a conforming signature for swprintf
-# define BOOST_NO_SWPRINTF
-#endif
-
#if _MSC_VER < 1500 // 140X == VC++ 8.0
# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#endif
# define BOOST_NO_INTRINSIC_WCHAR_T
#endif
-#if defined(_WIN32_WCE) || defined(UNDER_CE)
-# define BOOST_NO_SWPRINTF
-#endif
-
-// we have ThreadEx or GetSystemTimeAsFileTime unless we're running WindowsCE
-#if !defined(_WIN32_WCE) && !defined(UNDER_CE)
-# define BOOST_HAS_THREADEX
-# define BOOST_HAS_GETSYSTEMTIMEASFILETIME
-#endif
-
//
// check for exception handling support:
#if !defined(_CPPUNWIND) && !defined(BOOST_NO_EXCEPTIONS)
#if (_MSC_VER >= 1400) && !defined(_DEBUG)
# define BOOST_HAS_NRVO
#endif
+#if _MSC_VER >= 1600 // 160X == VC++ 10.0
+# define BOOST_HAS_PRAGMA_DETECT_MISMATCH
+#endif
//
-// disable Win32 API's if compiler extentions are
+// disable Win32 API's if compiler extensions are
// turned off:
//
#if !defined(_MSC_EXTENSIONS) && !defined(BOOST_DISABLE_WIN32)
// C++11 features supported by VC++ 11 (aka 2012)
//
#if _MSC_VER < 1700
+# define BOOST_NO_CXX11_FINAL
# define BOOST_NO_CXX11_RANGE_BASED_FOR
# define BOOST_NO_CXX11_SCOPED_ENUMS
#endif // _MSC_VER < 1700
# define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
# define BOOST_NO_CXX11_VARIADIC_TEMPLATES
# define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+# define BOOST_NO_CXX11_DECLTYPE_N3276
+#endif
+
+// C++11 features supported by VC++ 14 (aka 2015) Preview
+//
+#if (_MSC_FULL_VER < 190022310)
+# define BOOST_NO_CXX11_NOEXCEPT
+# define BOOST_NO_CXX11_REF_QUALIFIERS
+# define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+# define BOOST_NO_CXX11_ALIGNAS
+# define BOOST_NO_CXX11_INLINE_NAMESPACES
+# define BOOST_NO_CXX11_CHAR16_T
+# define BOOST_NO_CXX11_CHAR32_T
+# define BOOST_NO_CXX11_UNICODE_LITERALS
+# define BOOST_NO_CXX14_DECLTYPE_AUTO
+# define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+# define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+# define BOOST_NO_CXX14_BINARY_LITERALS
+# define BOOST_NO_CXX14_GENERIC_LAMBDAS
#endif
// C++11 features not supported by any versions
-#define BOOST_NO_CXX11_CHAR16_T
-#define BOOST_NO_CXX11_CHAR32_T
#define BOOST_NO_CXX11_CONSTEXPR
-#define BOOST_NO_CXX11_DECLTYPE_N3276
-#define BOOST_NO_CXX11_NOEXCEPT
-#define BOOST_NO_CXX11_UNICODE_LITERALS
#define BOOST_NO_SFINAE_EXPR
#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
-#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
-#define BOOST_NO_CXX11_ALIGNAS
-#define BOOST_NO_CXX11_INLINE_NAMESPACES
+
+// C++ 14:
+#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
+# define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
+# define BOOST_NO_CXX14_CONSTEXPR
+#endif
+#if (__cplusplus < 201304) // There's no SD6 check for this....
+# define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#endif
+#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
+# define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
//
// prefix and suffix headers:
# define BOOST_COMPILER_VERSION evc11
# elif _MSC_VER < 1900
# define BOOST_COMPILER_VERSION evc12
+# elif _MSC_VER < 2000
+# define BOOST_COMPILER_VERSION evc14
# else
# if defined(BOOST_ASSERT_CONFIG)
# error "Unknown EVC++ compiler version - please run the configure tests and report the results"
# define BOOST_COMPILER_VERSION 11.0
# elif _MSC_VER < 1900
# define BOOST_COMPILER_VERSION 12.0
+# elif _MSC_VER < 2000
+# define BOOST_COMPILER_VERSION 14.0
# else
# define BOOST_COMPILER_VERSION _MSC_VER
# endif
#endif
//
-// last known and checked version is 18.00.20827.3 (VC12 RC, aka 2013 RC):
-#if (_MSC_VER > 1800 && _MSC_FULL_VER > 180020827)
+// last known and checked version is 19.00.22129 (VC14 Preview):
+#if (_MSC_VER > 1800 && _MSC_FULL_VER > 190022310)
# if defined(BOOST_ASSERT_CONFIG)
# error "Unknown compiler version - please run the configure tests and report the results"
# else
--- /dev/null
+// (C) Copyright Jessica Hamilton 2014.
+// Use, modification and distribution are subject to 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 for most recent version.
+
+// Haiku specific config options:
+
+#define BOOST_PLATFORM "Haiku"
+
+#define BOOST_HAS_UNISTD_H
+#define BOOST_HAS_STDINT_H
+#define BOOST_HASH_NO_EXTENSIONS
+
+#ifndef BOOST_DISABLE_THREADS
+# define BOOST_HAS_THREADS
+#endif
+
+#define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#define BOOST_NO_CXX11_STATIC_ASSERT
+#define BOOST_NO_CXX11_VARIADIC_MACROS
+
+//
+// thread API's not auto detected:
+//
+#define BOOST_HAS_SCHED_YIELD
+#define BOOST_HAS_PTHREAD_YIELD
+#define BOOST_HAS_GETTIMEOFDAY
+
+// boilerplate code:
+#include <boost/config/posix_features.hpp>
// boilerplate code:
#define BOOST_HAS_UNISTD_H
#include <boost/config/posix_features.hpp>
+#ifdef __USE_GNU
#define BOOST_HAS_PTHREAD_YIELD
+#endif
#ifndef __GNUC__
//
# undef BOOST_HAS_PTHREADS
#endif
-
+#define BOOST_HAS_STDINT_H
+#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#define BOOST_HAS_LOG1P
+#define BOOST_HAS_EXPM1
#endif
#if defined(__MINGW32__) && (__GNUC__ >= 4)
-# define BOOST_HAS_EXPM1
-# define BOOST_HAS_LOG1P
+// Mingw has these functions but there are persistent problems
+// with calls to these crashing, so disable for now:
+//# define BOOST_HAS_EXPM1
+//# define BOOST_HAS_LOG1P
# define BOOST_HAS_GETTIMEOFDAY
#endif
//
// all translation units (needed for shared_ptr etc).
//
-#ifdef _WIN32_WCE
+#ifndef BOOST_HAS_PTHREADS
+# define BOOST_HAS_WINTHREADS
+#endif
+
+//
+// WinCE configuration:
+//
+#if defined(_WIN32_WCE) || defined(UNDER_CE)
# define BOOST_NO_ANSI_APIS
+// Windows CE does not have a conforming signature for swprintf
+# define BOOST_NO_SWPRINTF
#else
# define BOOST_HAS_GETSYSTEMTIMEASFILETIME
-#endif
-
-#ifndef BOOST_HAS_PTHREADS
-# define BOOST_HAS_WINTHREADS
+# define BOOST_HAS_THREADEX
+# define BOOST_HAS_GETSYSTEMTIMEASFILETIME
#endif
#ifndef BOOST_DISABLE_WIN32
// Intel
# define BOOST_COMPILER_CONFIG "boost/config/compiler/intel.hpp"
-#elif defined __clang__
+#elif defined __clang__ && !defined(__CUDACC__)
+// when using clang and cuda at same time, you want to appear as gcc
// Clang C++ emulates GCC, so it has to appear early.
# define BOOST_COMPILER_CONFIG "boost/config/compiler/clang.hpp"
# error "Unknown compiler - please configure (http://www.boost.org/libs/config/config.htm#configuring) and report the results to the main boost mailing list (http://www.boost.org/more/mailing_lists.htm#main)"
#endif
+
+#if 0
+//
+// This section allows dependency scanners to find all the headers we *might* include:
+//
+#include "boost/config/compiler/gcc_xml.hpp"
+#include "boost/config/compiler/cray.hpp"
+#include "boost/config/compiler/comeau.hpp"
+#include "boost/config/compiler/pathscale.hpp"
+#include "boost/config/compiler/intel.hpp"
+#include "boost/config/compiler/clang.hpp"
+#include "boost/config/compiler/digitalmars.hpp"
+#include "boost/config/compiler/gcc.hpp"
+#include "boost/config/compiler/kai.hpp"
+#include "boost/config/compiler/sgi_mipspro.hpp"
+#include "boost/config/compiler/compaq_cxx.hpp"
+#include "boost/config/compiler/greenhills.hpp"
+#include "boost/config/compiler/codegear.hpp"
+#include "boost/config/compiler/borland.hpp"
+#include "boost/config/compiler/metrowerks.hpp"
+#include "boost/config/compiler/sunpro_cc.hpp"
+#include "boost/config/compiler/hp_acc.hpp"
+#include "boost/config/compiler/mpw.hpp"
+#include "boost/config/compiler/vacpp.hpp"
+#include "boost/config/compiler/pgi.hpp"
+#include "boost/config/compiler/visualc.hpp"
+
+#endif
+
// win32:
# define BOOST_PLATFORM_CONFIG "boost/config/platform/win32.hpp"
+#elif defined(__HAIKU__)
+// Haiku
+# define BOOST_PLATFORM_CONFIG "boost/config/platform/haiku.hpp"
+
#elif defined(__BEOS__)
// BeOS
# define BOOST_PLATFORM_CONFIG "boost/config/platform/beos.hpp"
#endif
+#if 0
+//
+// This section allows dependency scanners to find all the files we *might* include:
+//
+# include "boost/config/platform/linux.hpp"
+# include "boost/config/platform/bsd.hpp"
+# include "boost/config/platform/solaris.hpp"
+# include "boost/config/platform/irix.hpp"
+# include "boost/config/platform/hpux.hpp"
+# include "boost/config/platform/cygwin.hpp"
+# include "boost/config/platform/win32.hpp"
+# include "boost/config/platform/beos.hpp"
+# include "boost/config/platform/macos.hpp"
+# include "boost/config/platform/aix.hpp"
+# include "boost/config/platform/amigaos.hpp"
+# include "boost/config/platform/qnxnto.hpp"
+# include "boost/config/platform/vxworks.hpp"
+# include "boost/config/platform/symbian.hpp"
+# include "boost/config/platform/cray.hpp"
+# include "boost/config/platform/vms.hpp"
+# include <boost/config/posix_features.hpp>
+
+#endif
+
#else
-// If our std lib was not some version of STLport, then include <utility> as it is about
-// the smallest of the std lib headers that includes real C++ stuff. (Some std libs do not
-// include their C++-related macros in <cstddef> so this additional include makes sure
-// we get those definitions)
-// (again do not rely on this header being included since users can short-circuit this
-// header if they know whose std lib they are using.)
-#include <boost/config/no_tr1/utility.hpp>
+// If our std lib was not some version of STLport, and has not otherwise
+// been detected, then include <utility> as it is about
+// the smallest of the std lib headers that includes real C++ stuff.
+// Some std libs do not include their C++-related macros in <cstddef>
+// so this additional include makes sure we get those definitions.
+// Note: do not rely on this header being included since users can short-circuit this
+// #include if they know whose std lib they are using.
+#if !defined(__LIBCOMO__) && !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER)\
+ && !defined(_LIBCPP_VERSION) && !defined(__GLIBCPP__) && !defined(__GLIBCXX__)\
+ && !defined(__STL_CONFIG_H) && !defined(__MSL_CPP__) && !defined(__IBMCPP__)\
+ && !defined(MSIPL_COMPILE_H) && !defined(_YVALS) && !defined(_CPPLIB_VER)
+#include <utility>
+#endif
#if defined(__LIBCOMO__)
// Comeau STL:
#endif
-
+#if 0
+//
+// This section allows dependency scanners to find all the files we *might* include:
+//
+# include "boost/config/stdlib/stlport.hpp"
+# include "boost/config/stdlib/libcomo.hpp"
+# include "boost/config/stdlib/roguewave.hpp"
+# include "boost/config/stdlib/libcpp.hpp"
+# include "boost/config/stdlib/libstdcpp3.hpp"
+# include "boost/config/stdlib/sgi.hpp"
+# include "boost/config/stdlib/msl.hpp"
+# include "boost/config/stdlib/vacpp.hpp"
+# include "boost/config/stdlib/modena.hpp"
+# include "boost/config/stdlib/dinkumware.hpp"
+#endif
# define BOOST_NO_STD_LOCALE
#endif
+// Fix for VC++ 8.0 on up ( I do not have a previous version to test )
+// or clang-cl. If exceptions are off you must manually include the
+// <exception> header before including the <typeinfo> header. Admittedly
+// trying to use Boost libraries or the standard C++ libraries without
+// exception support is not suggested but currently clang-cl ( v 3.4 )
+// does not support exceptions and must be compiled with exceptions off.
+#if !_HAS_EXCEPTIONS && ((defined(BOOST_MSVC) && BOOST_MSVC >= 1400) || (defined(__clang__) && defined(_MSC_VER)))
+#include <exception>
+#endif
#include <typeinfo>
-#if ( (!_HAS_EXCEPTIONS && !defined(__ghs__)) || (!_HAS_NAMESPACE && defined(__ghs__)) ) && !defined(__TI_COMPILER_VERSION__)
-# define BOOST_NO_STD_TYPEINFO
+#if ( (!_HAS_EXCEPTIONS && !defined(__ghs__)) || (!_HAS_NAMESPACE && defined(__ghs__)) ) && !defined(__TI_COMPILER_VERSION__) && !defined(__VISUALDSPVERSION__)
+# define BOOST_NO_STD_TYPEINFO
#endif
// C++0x headers implemented in 520 (as shipped by Microsoft)
# define BOOST_NO_CXX11_HDR_MUTEX
# define BOOST_NO_CXX11_HDR_RATIO
# define BOOST_NO_CXX11_HDR_THREAD
-# define BOOST_NO_CXX11_ALLOCATOR
# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
#endif
//
#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 610
# define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+# define BOOST_NO_CXX11_HDR_ATOMIC
+# define BOOST_NO_CXX11_ALLOCATOR
+// 540 has std::align but it is not a conforming implementation
+# define BOOST_NO_CXX11_STD_ALIGN
+#endif
+
+#if defined(BOOST_INTEL) && (BOOST_INTEL <= 1400)
+// Intel's compiler can't handle this header yet:
+# define BOOST_NO_CXX11_HDR_ATOMIC
#endif
+
+// 520..610 have std::addressof, but it doesn't support functions
+//
+# define BOOST_NO_CXX11_ADDRESSOF
+
#ifdef _CPPLIB_VER
# define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER
#else
#else
# define BOOST_STDLIB "Dinkumware standard library version 1.x"
#endif
-
-
-
-
-
-
-
-
-
# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
# define BOOST_NO_CXX11_SMART_PTR
# define BOOST_NO_CXX11_HDR_FUNCTIONAL
+# define BOOST_NO_CXX11_HDR_ATOMIC
+# define BOOST_NO_CXX11_STD_ALIGN
+# define BOOST_NO_CXX11_ADDRESSOF
//
// Intrinsic type_traits support.
# define BOOST_NO_CXX11_HDR_TUPLE
#endif
+// BOOST_NO_CXX11_ALLOCATOR should imply no support for the C++11
+// allocator model. The C++11 allocator model requires a conforming
+// std::allocator_traits which is only possible with C++11 template
+// aliases since members rebind_alloc and rebind_traits require it.
+#if defined(_LIBCPP_HAS_NO_TEMPLATE_ALIASES)
+# define BOOST_NO_CXX11_ALLOCATOR
+#endif
+
+#if __cplusplus < 201103
+# define BOOST_NO_CXX11_HDR_ARRAY
+# define BOOST_NO_CXX11_HDR_CODECVT
+# define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+# define BOOST_NO_CXX11_HDR_FORWARD_LIST
+# define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+# define BOOST_NO_CXX11_HDR_MUTEX
+# define BOOST_NO_CXX11_HDR_RANDOM
+# define BOOST_NO_CXX11_HDR_RATIO
+# define BOOST_NO_CXX11_HDR_REGEX
+# define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+# define BOOST_NO_CXX11_HDR_THREAD
+# define BOOST_NO_CXX11_HDR_TUPLE
+# define BOOST_NO_CXX11_HDR_TYPEINDEX
+# define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+# define BOOST_NO_CXX11_HDR_UNORDERED_SET
+# define BOOST_NO_CXX11_NUMERIC_LIMITS
+# define BOOST_NO_CXX11_ALLOCATOR
+# define BOOST_NO_CXX11_SMART_PTR
+# define BOOST_NO_CXX11_HDR_FUNCTIONAL
+# define BOOST_NO_CXX11_STD_ALIGN
+# define BOOST_NO_CXX11_ADDRESSOF
+#endif
+
//
// These appear to be unusable/incomplete so far:
//
# define BOOST_NO_CXX11_HDR_FUTURE
# define BOOST_NO_CXX11_HDR_TYPE_TRAITS
# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+# define BOOST_NO_CXX11_HDR_ATOMIC
// libc++ uses a non-standard messages_base
#define BOOST_NO_STD_MESSAGES
|| defined(_GLIBCXX__PTHREADS) \
|| defined(_GLIBCXX_HAS_GTHREADS) \
|| defined(_WIN32) \
- || defined(_AIX)
+ || defined(_AIX) \
+ || defined(__HAIKU__)
//
// If the std lib has thread support turned on, then turn it on in Boost
// as well. We do this because some gcc-3.4 std lib headers define _REENTANT
# endif
#endif
+//
+// Decide whether we have C++11 support turned on:
+//
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103)
+# define BOOST_LIBSTDCXX11
+#endif
+//
+// Decide which version of libstdc++ we have, normally
// stdlibc++ C++0x support is detected via __GNUC__, __GNUC_MINOR__, and possibly
// __GNUC_PATCHLEVEL__ at the suggestion of Jonathan Wakely, one of the stdlibc++
// developers. He also commented:
//
// Another resource for understanding stdlibc++ features is:
// http://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#manual.intro.status.standard.200x
+//
+// However, using the GCC version number fails when the compiler is clang since this
+// only ever claims to emulate GCC-4.2, see https://svn.boost.org/trac/boost/ticket/7473
+// for a long discussion on this issue. What we can do though is use clang's __has_include
+// to detect the presence of a C++11 header that was introduced with a specific GCC release.
+// We still have to be careful though as many such headers were buggy and/or incomplete when
+// first introduced, so we only check for headers that were fully featured from day 1, and then
+// use that to infer the underlying GCC version:
+//
+#ifdef __clang__
+
+#if __has_include(<experimental/any>)
+# define BOOST_LIBSTDCXX_VERSION 50000
+#elif __has_include(<shared_mutex>)
+# define BOOST_LIBSTDCXX_VERSION 40900
+#elif __has_include(<ext/cmath>)
+# define BOOST_LIBSTDCXX_VERSION 40800
+#elif __has_include(<chrono>)
+# define BOOST_LIBSTDCXX_VERSION 40700
+#elif __has_include(<typeindex>)
+# define BOOST_LIBSTDCXX_VERSION 40600
+#elif __has_include(<future>)
+# define BOOST_LIBSTDCXX_VERSION 40500
+#elif __has_include(<ratio>)
+# define BOOST_LIBSTDCXX_VERSION 40400
+#elif __has_include(<array>)
+# define BOOST_LIBSTDCXX_VERSION 40300
+#endif
+//
+// GCC 4.8 and 9 add working versions of <atomic> and <regex> respectively.
+// However, we have no test for these as the headers were present but broken
+// in early GCC versions.
+//
+#endif
+
+#if defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130) && (__cplusplus >= 201103L)
+//
+// Oracle Solaris compiler uses it's own verison of libstdc++ but doesn't
+// set __GNUC__
+//
+#define BOOST_LIBSTDCXX_VERSION 40800
+#endif
+
+#if !defined(BOOST_LIBSTDCXX_VERSION)
+# define BOOST_LIBSTDCXX_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#endif
// C++0x headers in GCC 4.3.0 and later
//
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 3) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_LIBSTDCXX_VERSION < 40300) || !defined(BOOST_LIBSTDCXX11)
# define BOOST_NO_CXX11_HDR_ARRAY
-# define BOOST_NO_CXX11_HDR_REGEX
# define BOOST_NO_CXX11_HDR_TUPLE
# define BOOST_NO_CXX11_HDR_UNORDERED_MAP
# define BOOST_NO_CXX11_HDR_UNORDERED_SET
// C++0x headers in GCC 4.4.0 and later
//
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_LIBSTDCXX_VERSION < 40400) || !defined(BOOST_LIBSTDCXX11)
# define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
# define BOOST_NO_CXX11_HDR_FORWARD_LIST
# define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
# define BOOST_HAS_TR1_COMPLEX_OVERLOADS
#endif
-#if (!defined(_GLIBCXX_HAS_GTHREADS) || !defined(_GLIBCXX_USE_C99_STDINT_TR1)) && (!defined(BOOST_NO_CXX11_HDR_CONDITION_VARIABLE) || !defined(BOOST_NO_CXX11_HDR_MUTEX))
-# define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
-# define BOOST_NO_CXX11_HDR_MUTEX
-#endif
-
// C++0x features in GCC 4.5.0 and later
//
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_LIBSTDCXX_VERSION < 40500) || !defined(BOOST_LIBSTDCXX11)
# define BOOST_NO_CXX11_NUMERIC_LIMITS
# define BOOST_NO_CXX11_HDR_FUTURE
# define BOOST_NO_CXX11_HDR_RANDOM
// C++0x features in GCC 4.6.0 and later
//
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
+#if (BOOST_LIBSTDCXX_VERSION < 40600) || !defined(BOOST_LIBSTDCXX11)
# define BOOST_NO_CXX11_HDR_TYPEINDEX
+# define BOOST_NO_CXX11_ADDRESSOF
#endif
// C++0x features in GCC 4.7.0 and later
//
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
-// Note that although <chrono> existed prior to 4.7, "stead_clock" is spelled "monotonic_clock"
+#if (BOOST_LIBSTDCXX_VERSION < 40700) || !defined(BOOST_LIBSTDCXX11)
+// Note that although <chrono> existed prior to 4.7, "steady_clock" is spelled "monotonic_clock"
// so 4.7.0 is the first truely conforming one.
# define BOOST_NO_CXX11_HDR_CHRONO
# define BOOST_NO_CXX11_ALLOCATOR
#endif
-// C++0x headers not yet (fully!) implemented
+// C++0x features in GCC 4.8.0 and later
//
+#if (BOOST_LIBSTDCXX_VERSION < 40800) || !defined(BOOST_LIBSTDCXX11)
+// Note that although <atomic> existed prior to gcc 4.8 it was largely unimplemented for many types:
+# define BOOST_NO_CXX11_HDR_ATOMIC
# define BOOST_NO_CXX11_HDR_THREAD
+#endif
+#if (BOOST_LIBSTDCXX_VERSION < 40900) || !defined(BOOST_LIBSTDCXX11)
+// Although <regex> is present and compilable against, the actual implementation is not functional
+// even for the simplest patterns such as "\d" or "[0-9]". This is the case at least in gcc up to 4.8, inclusively.
+# define BOOST_NO_CXX11_HDR_REGEX
+#endif
+
+#if defined(__clang_major__) && ((__clang_major__ < 3) || ((__clang_major__ == 3) && (__clang_minor__ < 7)))
+// As of clang-3.6, libstdc++ header <atomic> throws up errors with clang:
+# define BOOST_NO_CXX11_HDR_ATOMIC
+#endif
+
+// C++0x headers not yet (fully!) implemented
+//
# define BOOST_NO_CXX11_HDR_TYPE_TRAITS
# define BOOST_NO_CXX11_HDR_CODECVT
# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+# define BOOST_NO_CXX11_STD_ALIGN
+
+//
+// Headers not present on Solaris with the Oracle compiler:
+#if defined(__SUNPRO_CC)
+#define BOOST_NO_CXX11_HDR_FUTURE
+#define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#define BOOST_NO_CXX11_HDR_ATOMIC
+#endif
+
+#if (!defined(_GLIBCXX_HAS_GTHREADS) || !defined(_GLIBCXX_USE_C99_STDINT_TR1))
+ // Headers not always available:
+# ifndef BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+# define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+# endif
+# ifndef BOOST_NO_CXX11_HDR_MUTEX
+# define BOOST_NO_CXX11_HDR_MUTEX
+# endif
+# ifndef BOOST_NO_CXX11_HDR_THREAD
+# define BOOST_NO_CXX11_HDR_THREAD
+# endif
+#endif
+
+#if (!defined(_GTHREAD_USE_MUTEX_TIMEDLOCK) || (_GTHREAD_USE_MUTEX_TIMEDLOCK == 0)) && !defined(BOOST_NO_CXX11_HDR_MUTEX)
+// Timed mutexes are not always available:
+# define BOOST_NO_CXX11_HDR_MUTEX
+#endif
// --- end ---
# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
# define BOOST_NO_CXX11_SMART_PTR
# define BOOST_NO_CXX11_HDR_FUNCTIONAL
+# define BOOST_NO_CXX11_HDR_ATOMIC
+# define BOOST_NO_CXX11_STD_ALIGN
+# define BOOST_NO_CXX11_ADDRESSOF
#define BOOST_STDLIB "Modena C++ standard library"
# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
# define BOOST_NO_CXX11_SMART_PTR
# define BOOST_NO_CXX11_HDR_FUNCTIONAL
+# define BOOST_NO_CXX11_HDR_ATOMIC
+# define BOOST_NO_CXX11_STD_ALIGN
+# define BOOST_NO_CXX11_ADDRESSOF
#define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__)
# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
# define BOOST_NO_CXX11_SMART_PTR
# define BOOST_NO_CXX11_HDR_FUNCTIONAL
+# define BOOST_NO_CXX11_HDR_ATOMIC
+# define BOOST_NO_CXX11_STD_ALIGN
+# define BOOST_NO_CXX11_ADDRESSOF
# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
# define BOOST_NO_CXX11_SMART_PTR
# define BOOST_NO_CXX11_HDR_FUNCTIONAL
+# define BOOST_NO_CXX11_HDR_ATOMIC
+# define BOOST_NO_CXX11_STD_ALIGN
+# define BOOST_NO_CXX11_ADDRESSOF
#define BOOST_STDLIB "SGI standard library"
# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
# define BOOST_NO_CXX11_SMART_PTR
# define BOOST_NO_CXX11_HDR_FUNCTIONAL
+# define BOOST_NO_CXX11_HDR_ATOMIC
+# define BOOST_NO_CXX11_STD_ALIGN
+# define BOOST_NO_CXX11_ADDRESSOF
#define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT)
# define BOOST_NO_CXX11_ATOMIC_SMART_PTR
# define BOOST_NO_CXX11_SMART_PTR
# define BOOST_NO_CXX11_HDR_FUNCTIONAL
+# define BOOST_NO_CXX11_HDR_ATOMIC
+# define BOOST_NO_CXX11_STD_ALIGN
+# define BOOST_NO_CXX11_ADDRESSOF
#define BOOST_STDLIB "Visual Age default standard library"
// Boost config.hpp configuration header file ------------------------------//
-// boostinspect:ndprecated_macros -- tell the inspect tool to ignore this file
+// boostinspect:ndprecated_macros -- tell the inspect tool to ignore this file
// Copyright (c) 2001-2003 John Maddock
// Copyright (c) 2001 Darin Adler
# define BOOST_NOINLINE __declspec(noinline)
# elif defined(__GNUC__) && __GNUC__ > 3
// Clang also defines __GNUC__ (as 4)
-# define BOOST_NOINLINE __attribute__ ((__noinline__))
+# if defined(__CUDACC__)
+ // nvcc doesn't always parse __noinline__,
+ // see: https://svn.boost.org/trac/boost/ticket/9392
+# define BOOST_NOINLINE __attribute__ ((noinline))
+# else
+# define BOOST_NOINLINE __attribute__ ((__noinline__))
+# endif
# else
# define BOOST_NOINLINE
# endif
#endif
+// BOOST_NORETURN ---------------------------------------------//
+// Macro to use before a function declaration/definition to designate
+// the function as not returning normally (i.e. with a return statement
+// or by leaving the function scope, if the function return type is void).
+#if !defined(BOOST_NORETURN)
+# if defined(_MSC_VER)
+# define BOOST_NORETURN __declspec(noreturn)
+# elif defined(__GNUC__)
+# define BOOST_NORETURN __attribute__ ((__noreturn__))
+# else
+# define BOOST_NO_NORETURN
+# define BOOST_NORETURN
+# endif
+#endif
+
// Branch prediction hints
// These macros are intended to wrap conditional expressions that yield true or false
//
# define BOOST_ALIGNMENT(x)
#endif
+// Lack of non-public defaulted functions is implied by the lack of any defaulted functions
+#if !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS) && defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+# define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
+#endif
+
// Defaulted and deleted function declaration helpers
// These macros are intended to be inside a class definition.
// BOOST_DEFAULTED_FUNCTION accepts the function declaration and its
// Set BOOST_NO_DECLTYPE_N3276 when BOOST_NO_DECLTYPE is defined
//
#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
-#define BOOST_NO_CXX11_DECLTYPE_N3276 BOOST_NO_CXX11_DECLTYPE
+#define BOOST_NO_CXX11_DECLTYPE_N3276 BOOST_NO_CXX11_DECLTYPE
#endif
// -------------------- Deprecated macros for 1.50 ---------------------------
#define BOOST_CONSTEXPR constexpr
#define BOOST_CONSTEXPR_OR_CONST constexpr
#endif
+#if defined(BOOST_NO_CXX14_CONSTEXPR)
+#define BOOST_CXX14_CONSTEXPR
+#else
+#define BOOST_CXX14_CONSTEXPR constexpr
+#endif
+
+//
+// Unused variable/typedef workarounds:
+//
+#ifndef BOOST_ATTRIBUTE_UNUSED
+# define BOOST_ATTRIBUTE_UNUSED
+#endif
#define BOOST_STATIC_CONSTEXPR static BOOST_CONSTEXPR_OR_CONST
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_HAS_VARIADIC_TMPL)
#define BOOST_HAS_VARIADIC_TMPL
#endif
+//
+// Set BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS when
+// BOOST_NO_CXX11_VARIADIC_TEMPLATES is set:
+//
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS)
+# define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
+#endif
+//
+// Finish off with checks for macros that are depricated / no longer supported,
+// if any of these are set then it's very likely that much of Boost will no
+// longer work. So stop with a #error for now, but give the user a chance
+// to continue at their own risk if they really want to:
+//
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_CONFIG_ALLOW_DEPRECATED)
+# error "You are using a compiler which lacks features which are now a minimum requirement in order to use Boost, define BOOST_CONFIG_ALLOW_DEPRECATED if you want to continue at your own risk!!!"
+#endif
#endif
// (this macro is used to turn on __declspec(dllimport) modifiers, so that
// the compiler knows which symbols to look for in a dll rather than in a
// static library). Note that there may be some libraries that can only
-// be statically linked (Boost.Test for example) and others which may only
-// be dynamically linked (Boost.Threads for example), in these cases this
+// be linked in one way (statically or dynamically), in these cases this
// macro has no effect.
// #define BOOST_ALL_DYN_LINK
// BOOST_REGEX_DYN_LINK etc (this macro is used to turn on __declspec(dllimport)
// modifiers, so that the compiler knows which symbols to look for in a dll
// rather than in a static library).
-// Note that there may be some libraries that can only be statically linked
-// (Boost.Test for example) and others which may only be dynamically linked
-// (Boost.Threads for example), in these cases this macro is unsupported.
+// Note that there may be some libraries that can only
+// be linked in one way (statically or dynamically),
+// in these cases this macro is unsupported.
// #define BOOST_WHATEVER_DYN_LINK
// BOOST_ALL_NO_LIB: Tells the config system not to automatically select
// that feature off.
// #define BOOST_WHATEVER_NO_LIB
-
+// BOOST_LIB_BUILDID: Set to the same value as the value passed to Boost.Build's
+// --buildid command line option. For example if you built using:
+//
+// bjam address-model=64 --buildid=amd64
+//
+// then compile your code with:
+//
+// -DBOOST_LIB_BUILDID = amd64
+//
+// to ensure the correct libraries are selected at link time.
+// #define BOOST_LIB_BUILDID amd64
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2005-2014. 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)
//
#ifndef BOOST_CONTAINER_CONTAINER_FWD_HPP
#define BOOST_CONTAINER_CONTAINER_FWD_HPP
-#if defined(_MSC_VER)
-# pragma once
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
#endif
-//////////////////////////////////////////////////////////////////////////////
-// Standard predeclarations
-//////////////////////////////////////////////////////////////////////////////
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
-/// @cond
+//! \file
+//! This header file forward declares the following containers:
+//! - boost::container::vector
+//! - boost::container::stable_vector
+//! - boost::container::static_vector
+//! - boost::container::slist
+//! - boost::container::list
+//! - boost::container::set
+//! - boost::container::multiset
+//! - boost::container::map
+//! - boost::container::multimap
+//! - boost::container::flat_set
+//! - boost::container::flat_multiset
+//! - boost::container::flat_map
+//! - boost::container::flat_multimap
+//! - boost::container::basic_string
+//! - boost::container::string
+//! - boost::container::wstring
+//!
+//! It forward declares the following allocators:
+//! - boost::container::allocator
+//! - boost::container::node_allocator
+//! - boost::container::adaptive_pool
+//!
+//! And finally it defines the following types
+
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+//Std forward declarations
+#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP
+ #include <boost/container/detail/std_fwd.hpp>
+#endif
namespace boost{
namespace intrusive{
}}
namespace boost{ namespace container{ namespace container_detail{
-
-namespace bi = boost::intrusive;
-
+ namespace bi = boost::intrusive;
}}}
-#include <utility>
-#include <memory>
-#include <functional>
-#include <iosfwd>
-#include <string>
+#include <cstddef>
-/// @endcond
+#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
//////////////////////////////////////////////////////////////////////////////
// Containers
namespace boost {
namespace container {
-//vector class
+//! Enumeration used to configure ordered associative containers
+//! with a concrete tree implementation.
+enum tree_type_enum
+{
+ red_black_tree,
+ avl_tree,
+ scapegoat_tree,
+ splay_tree
+};
+
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+template<class T>
+class new_allocator;
+
template <class T
- ,class Allocator = std::allocator<T> >
+ ,class Allocator = new_allocator<T> >
class vector;
-//vector class
template <class T
- ,class Allocator = std::allocator<T> >
+ ,class Allocator = new_allocator<T> >
class stable_vector;
-//vector class
+template <class T, std::size_t Capacity>
+class static_vector;
+
+template < class T, std::size_t N
+ , class Allocator= new_allocator<T> >
+class small_vector;
+
template <class T
- ,class Allocator = std::allocator<T> >
+ ,class Allocator = new_allocator<T> >
class deque;
-//list class
template <class T
- ,class Allocator = std::allocator<T> >
+ ,class Allocator = new_allocator<T> >
class list;
-//slist class
template <class T
- ,class Allocator = std::allocator<T> >
+ ,class Allocator = new_allocator<T> >
class slist;
-//set class
+template<tree_type_enum TreeType, bool OptimizeSize>
+struct tree_opt;
+
+typedef tree_opt<red_black_tree, true> tree_assoc_defaults;
+
template <class Key
,class Compare = std::less<Key>
- ,class Allocator = std::allocator<Key> >
+ ,class Allocator = new_allocator<Key>
+ ,class Options = tree_assoc_defaults >
class set;
-//multiset class
template <class Key
,class Compare = std::less<Key>
- ,class Allocator = std::allocator<Key> >
+ ,class Allocator = new_allocator<Key>
+ ,class Options = tree_assoc_defaults >
class multiset;
-//map class
template <class Key
,class T
,class Compare = std::less<Key>
- ,class Allocator = std::allocator<std::pair<const Key, T> > >
+ ,class Allocator = new_allocator<std::pair<const Key, T> >
+ ,class Options = tree_assoc_defaults >
class map;
-//multimap class
template <class Key
,class T
,class Compare = std::less<Key>
- ,class Allocator = std::allocator<std::pair<const Key, T> > >
+ ,class Allocator = new_allocator<std::pair<const Key, T> >
+ ,class Options = tree_assoc_defaults >
class multimap;
-//flat_set class
template <class Key
,class Compare = std::less<Key>
- ,class Allocator = std::allocator<Key> >
+ ,class Allocator = new_allocator<Key> >
class flat_set;
-//flat_multiset class
template <class Key
,class Compare = std::less<Key>
- ,class Allocator = std::allocator<Key> >
+ ,class Allocator = new_allocator<Key> >
class flat_multiset;
-//flat_map class
template <class Key
,class T
,class Compare = std::less<Key>
- ,class Allocator = std::allocator<std::pair<Key, T> > >
+ ,class Allocator = new_allocator<std::pair<Key, T> > >
class flat_map;
-//flat_multimap class
template <class Key
,class T
,class Compare = std::less<Key>
- ,class Allocator = std::allocator<std::pair<Key, T> > >
+ ,class Allocator = new_allocator<std::pair<Key, T> > >
class flat_multimap;
-//basic_string class
template <class CharT
,class Traits = std::char_traits<CharT>
- ,class Allocator = std::allocator<CharT> >
+ ,class Allocator = new_allocator<CharT> >
class basic_string;
+typedef basic_string
+ <char
+ ,std::char_traits<char>
+ ,new_allocator<char> >
+string;
+
+typedef basic_string
+ <wchar_t
+ ,std::char_traits<wchar_t>
+ ,new_allocator<wchar_t> >
+wstring;
+
+static const std::size_t ADP_nodes_per_block = 256u;
+static const std::size_t ADP_max_free_blocks = 2u;
+static const std::size_t ADP_overhead_percent = 1u;
+static const std::size_t ADP_only_alignment = 0u;
+
+template < class T
+ , std::size_t NodesPerBlock = ADP_nodes_per_block
+ , std::size_t MaxFreeBlocks = ADP_max_free_blocks
+ , std::size_t OverheadPercent = ADP_overhead_percent
+ , unsigned Version = 2
+ >
+class adaptive_pool;
+
+template < class T
+ , unsigned Version = 2
+ , unsigned int AllocationDisableMask = 0>
+class allocator;
+
+static const std::size_t NodeAlloc_nodes_per_block = 256u;
+
+template
+ < class T
+ , std::size_t NodesPerBlock = NodeAlloc_nodes_per_block
+ , std::size_t Version = 2>
+class node_allocator;
+
+#else
+
+//! Default options for tree-based associative containers
+//! - tree_type<red_black_tree>
+//! - optimize_size<true>
+typedef implementation_defined tree_assoc_defaults;
+
+#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
//! Type used to tag that the input range is
//! guaranteed to be ordered
struct ordered_range_t
//! guaranteed to be ordered and unique
static const ordered_unique_range_t ordered_unique_range = ordered_unique_range_t();
-//! Type used to tag that the input range is
-//! guaranteed to be ordered and unique
+//! Type used to tag that the inserted values
+//! should be default initialized
struct default_init_t
{};
-//! Value used to tag that the input range is
-//! guaranteed to be ordered and unique
+//! Value used to tag that the inserted values
+//! should be default initialized
static const default_init_t default_init = default_init_t();
-/// @cond
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+//! Type used to tag that the inserted values
+//! should be value initialized
+struct value_init_t
+{};
+
+//! Value used to tag that the inserted values
+//! should be value initialized
+static const value_init_t value_init = value_init_t();
-namespace detail_really_deep_namespace {
+namespace container_detail_really_deep_namespace {
//Otherwise, gcc issues a warning of previously defined
//anonymous_instance and unique_instance
} //detail_really_deep_namespace {
-/// @endcond
+
+#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
}} //namespace boost { namespace container {
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP
+#define BOOST_CONTAINER_DETAIL_STD_FWD_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+// Standard predeclarations
+//////////////////////////////////////////////////////////////////////////////
+
+#if defined(__clang__) && defined(_LIBCPP_VERSION)
+ #define BOOST_CONTAINER_CLANG_INLINE_STD_NS
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wc++11-extensions"
+ #define BOOST_CONTAINER_STD_NS_BEG _LIBCPP_BEGIN_NAMESPACE_STD
+ #define BOOST_CONTAINER_STD_NS_END _LIBCPP_END_NAMESPACE_STD
+#elif defined(BOOST_GNU_STDLIB) && defined(_GLIBCXX_BEGIN_NAMESPACE_VERSION) //GCC >= 4.6
+ #define BOOST_CONTAINER_STD_NS_BEG namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ #define BOOST_CONTAINER_STD_NS_END _GLIBCXX_END_NAMESPACE_VERSION } // namespace
+#elif defined(BOOST_GNU_STDLIB) && defined(_GLIBCXX_BEGIN_NAMESPACE) //GCC >= 4.2
+ #define BOOST_CONTAINER_STD_NS_BEG _GLIBCXX_BEGIN_NAMESPACE(std)
+ #define BOOST_CONTAINER_STD_NS_END _GLIBCXX_END_NAMESPACE
+#else
+ #define BOOST_CONTAINER_STD_NS_BEG namespace std{
+ #define BOOST_CONTAINER_STD_NS_END }
+#endif
+
+BOOST_CONTAINER_STD_NS_BEG
+
+template<class T>
+class allocator;
+
+template<class T>
+struct less;
+
+template<class T1, class T2>
+struct pair;
+
+template<class T>
+struct char_traits;
+
+struct input_iterator_tag;
+struct forward_iterator_tag;
+struct bidirectional_iterator_tag;
+struct random_access_iterator_tag;
+
+template<class Container>
+class insert_iterator;
+
+struct allocator_arg_t;
+
+BOOST_CONTAINER_STD_NS_END
+
+#ifdef BOOST_CONTAINER_CLANG_INLINE_STD_NS
+ #pragma GCC diagnostic pop
+ #undef BOOST_CONTAINER_CLANG_INLINE_STD_NS
+#endif //BOOST_CONTAINER_CLANG_INLINE_STD_NS
+
+#endif //#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP
--- /dev/null
+// Copyright (C) 2002 Brad King (brad.king@kitware.com)
+// Douglas Gregor (gregod@cs.rpi.edu)
+//
+// Copyright (C) 2002, 2008, 2013 Peter Dimov
+//
+// 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)
+
+// For more information, see http://www.boost.org
+
+#ifndef BOOST_CORE_ADDRESSOF_HPP
+#define BOOST_CORE_ADDRESSOF_HPP
+
+# include <boost/config.hpp>
+# include <boost/detail/workaround.hpp>
+# include <cstddef>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template<class T> struct addr_impl_ref
+{
+ T & v_;
+
+ BOOST_FORCEINLINE addr_impl_ref( T & v ): v_( v ) {}
+ BOOST_FORCEINLINE operator T& () const { return v_; }
+
+private:
+ addr_impl_ref & operator=(const addr_impl_ref &);
+};
+
+template<class T> struct addressof_impl
+{
+ static BOOST_FORCEINLINE T * f( T & v, long )
+ {
+ return reinterpret_cast<T*>(
+ &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+ }
+
+ static BOOST_FORCEINLINE T * f( T * v, int )
+ {
+ return v;
+ }
+};
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+#if !defined( BOOST_NO_CXX11_DECLTYPE ) && ( ( defined( __clang__ ) && !defined( _LIBCPP_VERSION ) ) || defined( __INTEL_COMPILER ) )
+
+ typedef decltype(nullptr) addr_nullptr_t;
+
+#else
+
+ typedef std::nullptr_t addr_nullptr_t;
+
+#endif
+
+template<> struct addressof_impl< addr_nullptr_t >
+{
+ typedef addr_nullptr_t T;
+
+ static BOOST_FORCEINLINE T * f( T & v, int )
+ {
+ return &v;
+ }
+};
+
+template<> struct addressof_impl< addr_nullptr_t const >
+{
+ typedef addr_nullptr_t const T;
+
+ static BOOST_FORCEINLINE T * f( T & v, int )
+ {
+ return &v;
+ }
+};
+
+template<> struct addressof_impl< addr_nullptr_t volatile >
+{
+ typedef addr_nullptr_t volatile T;
+
+ static BOOST_FORCEINLINE T * f( T & v, int )
+ {
+ return &v;
+ }
+};
+
+template<> struct addressof_impl< addr_nullptr_t const volatile >
+{
+ typedef addr_nullptr_t const volatile T;
+
+ static BOOST_FORCEINLINE T * f( T & v, int )
+ {
+ return &v;
+ }
+};
+
+#endif
+
+} // namespace detail
+
+template<class T>
+BOOST_FORCEINLINE
+T * addressof( T & v )
+{
+#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || (defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120))
+
+ return boost::detail::addressof_impl<T>::f( v, 0 );
+
+#else
+
+ return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
+
+#endif
+}
+
+#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
+
+namespace detail
+{
+
+template<class T> struct addressof_addp
+{
+ typedef T * type;
+};
+
+} // namespace detail
+
+template< class T, std::size_t N >
+BOOST_FORCEINLINE
+typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
+{
+ return &t;
+}
+
+#endif
+
+// Borland doesn't like casting an array reference to a char reference
+// but these overloads work around the problem.
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template<typename T,std::size_t N>
+BOOST_FORCEINLINE
+T (*addressof(T (&t)[N]))[N]
+{
+ return reinterpret_cast<T(*)[N]>(&t);
+}
+
+template<typename T,std::size_t N>
+BOOST_FORCEINLINE
+const T (*addressof(const T (&t)[N]))[N]
+{
+ return reinterpret_cast<const T(*)[N]>(&t);
+}
+#endif
+
+} // namespace boost
+
+#endif // BOOST_CORE_ADDRESSOF_HPP
--- /dev/null
+#ifndef BOOST_CORE_CHECKED_DELETE_HPP
+#define BOOST_CORE_CHECKED_DELETE_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// boost/checked_delete.hpp
+//
+// Copyright (c) 2002, 2003 Peter Dimov
+// Copyright (c) 2003 Daniel Frey
+// Copyright (c) 2003 Howard Hinnant
+//
+// 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/core/doc/html/core/checked_delete.html for documentation.
+//
+
+namespace boost
+{
+
+// verify that types are complete for increased safety
+
+template<class T> inline void checked_delete(T * x)
+{
+ // intentionally complex - simplification causes regressions
+ typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+ (void) sizeof(type_must_be_complete);
+ delete x;
+}
+
+template<class T> inline void checked_array_delete(T * x)
+{
+ typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+ (void) sizeof(type_must_be_complete);
+ delete [] x;
+}
+
+template<class T> struct checked_deleter
+{
+ typedef void result_type;
+ typedef T * argument_type;
+
+ void operator()(T * x) const
+ {
+ // boost:: disables ADL
+ boost::checked_delete(x);
+ }
+};
+
+template<class T> struct checked_array_deleter
+{
+ typedef void result_type;
+ typedef T * argument_type;
+
+ void operator()(T * x) const
+ {
+ boost::checked_array_delete(x);
+ }
+};
+
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_CHECKED_DELETE_HPP
--- /dev/null
+#ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED
+#define BOOST_CORE_DEMANGLE_HPP_INCLUDED
+
+// core::demangle
+//
+// Copyright 2014 Peter Dimov
+// Copyright 2014 Andrey Semashev
+//
+// 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>
+#include <string>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#if defined( __clang__ ) && defined( __has_include )
+# if __has_include(<cxxabi.h>)
+# define BOOST_CORE_HAS_CXXABI_H
+# endif
+#elif defined( __GLIBCXX__ ) || defined( __GLIBCPP__ )
+# define BOOST_CORE_HAS_CXXABI_H
+#endif
+
+#if defined( BOOST_CORE_HAS_CXXABI_H )
+# include <cxxabi.h>
+# include <cstdlib>
+# include <cstddef>
+#endif
+
+namespace boost
+{
+
+namespace core
+{
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT;
+inline void demangle_free( char const * name ) BOOST_NOEXCEPT;
+
+class scoped_demangled_name
+{
+private:
+ char const * m_p;
+
+public:
+ explicit scoped_demangled_name( char const * name ) BOOST_NOEXCEPT :
+ m_p( demangle_alloc( name ) )
+ {
+ }
+
+ ~scoped_demangled_name() BOOST_NOEXCEPT
+ {
+ demangle_free( m_p );
+ }
+
+ char const * get() const BOOST_NOEXCEPT
+ {
+ return m_p;
+ }
+
+ BOOST_DELETED_FUNCTION(scoped_demangled_name( scoped_demangled_name const& ))
+ BOOST_DELETED_FUNCTION(scoped_demangled_name& operator= ( scoped_demangled_name const& ))
+};
+
+
+#if defined( BOOST_CORE_HAS_CXXABI_H )
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT
+{
+ int status = 0;
+ std::size_t size = 0;
+ return abi::__cxa_demangle( name, NULL, &size, &status );
+}
+
+inline void demangle_free( char const * name ) BOOST_NOEXCEPT
+{
+ std::free( const_cast< char* >( name ) );
+}
+
+inline std::string demangle( char const * name )
+{
+ scoped_demangled_name demangled_name( name );
+ char const * const p = demangled_name.get();
+ if( p )
+ {
+ return p;
+ }
+ else
+ {
+ return name;
+ }
+}
+
+#else
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT
+{
+ return name;
+}
+
+inline void demangle_free( char const * ) BOOST_NOEXCEPT
+{
+}
+
+inline std::string demangle( char const * name )
+{
+ return name;
+}
+
+#endif
+
+} // namespace core
+
+} // namespace boost
+
+#undef BOOST_CORE_HAS_CXXABI_H
+
+#endif // #ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED
--- /dev/null
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// Use, modification, and distribution is subject to 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)
+
+// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
+// Jeremiah Willcock (jewillco at osl.iu.edu)
+// Andrew Lumsdaine (lums at osl.iu.edu)
+
+
+#ifndef BOOST_CORE_ENABLE_IF_HPP
+#define BOOST_CORE_ENABLE_IF_HPP
+
+#include "boost/config.hpp"
+
+// Even the definition of enable_if causes problems on some compilers,
+// so it's macroed out for all compilers that do not support SFINAE
+
+#ifndef BOOST_NO_SFINAE
+
+namespace boost
+{
+
+ template <bool B, class T = void>
+ struct enable_if_c {
+ typedef T type;
+ };
+
+ template <class T>
+ struct enable_if_c<false, T> {};
+
+ template <class Cond, class T = void>
+ struct enable_if : public enable_if_c<Cond::value, T> {};
+
+ template <bool B, class T>
+ struct lazy_enable_if_c {
+ typedef typename T::type type;
+ };
+
+ template <class T>
+ struct lazy_enable_if_c<false, T> {};
+
+ template <class Cond, class T>
+ struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
+
+
+ template <bool B, class T = void>
+ struct disable_if_c {
+ typedef T type;
+ };
+
+ template <class T>
+ struct disable_if_c<true, T> {};
+
+ template <class Cond, class T = void>
+ struct disable_if : public disable_if_c<Cond::value, T> {};
+
+ template <bool B, class T>
+ struct lazy_disable_if_c {
+ typedef typename T::type type;
+ };
+
+ template <class T>
+ struct lazy_disable_if_c<true, T> {};
+
+ template <class Cond, class T>
+ struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
+
+} // namespace boost
+
+#else
+
+namespace boost {
+
+ namespace detail { typedef void enable_if_default_T; }
+
+ template <typename T>
+ struct enable_if_does_not_work_on_this_compiler;
+
+ template <bool B, class T = detail::enable_if_default_T>
+ struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
+ { };
+
+ template <bool B, class T = detail::enable_if_default_T>
+ struct disable_if_c : enable_if_does_not_work_on_this_compiler<T>
+ { };
+
+ template <bool B, class T = detail::enable_if_default_T>
+ struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler<T>
+ { };
+
+ template <bool B, class T = detail::enable_if_default_T>
+ struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler<T>
+ { };
+
+ template <class Cond, class T = detail::enable_if_default_T>
+ struct enable_if : enable_if_does_not_work_on_this_compiler<T>
+ { };
+
+ template <class Cond, class T = detail::enable_if_default_T>
+ struct disable_if : enable_if_does_not_work_on_this_compiler<T>
+ { };
+
+ template <class Cond, class T = detail::enable_if_default_T>
+ struct lazy_enable_if : enable_if_does_not_work_on_this_compiler<T>
+ { };
+
+ template <class Cond, class T = detail::enable_if_default_T>
+ struct lazy_disable_if : enable_if_does_not_work_on_this_compiler<T>
+ { };
+
+} // namespace boost
+
+#endif // BOOST_NO_SFINAE
+
+#endif
--- /dev/null
+/*
+ * Copyright Andrey Semashev 2007 - 2013.
+ * 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)
+ */
+
+/*!
+ * \file explicit_operator_bool.hpp
+ * \author Andrey Semashev
+ * \date 08.03.2009
+ *
+ * This header defines a compatibility macro that implements an unspecified
+ * \c bool operator idiom, which is superseded with explicit conversion operators in
+ * C++11.
+ */
+
+#ifndef BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
+#define BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+/*!
+ * \brief The macro defines an explicit operator of conversion to \c bool
+ *
+ * The macro should be used inside the definition of a class that has to
+ * support the conversion. The class should also implement <tt>operator!</tt>,
+ * in terms of which the conversion operator will be implemented.
+ */
+#define BOOST_EXPLICIT_OPERATOR_BOOL()\
+ BOOST_FORCEINLINE explicit operator bool () const\
+ {\
+ return !this->operator! ();\
+ }
+
+/*!
+ * \brief The macro defines a noexcept explicit operator of conversion to \c bool
+ *
+ * The macro should be used inside the definition of a class that has to
+ * support the conversion. The class should also implement <tt>operator!</tt>,
+ * in terms of which the conversion operator will be implemented.
+ */
+#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\
+ BOOST_FORCEINLINE explicit operator bool () const BOOST_NOEXCEPT\
+ {\
+ return !this->operator! ();\
+ }
+
+/*!
+ * \brief The macro defines a constexpr explicit operator of conversion to \c bool
+ *
+ * The macro should be used inside the definition of a class that has to
+ * support the conversion. The class should also implement <tt>operator!</tt>,
+ * in terms of which the conversion operator will be implemented.
+ */
+#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
+ BOOST_FORCEINLINE BOOST_CONSTEXPR explicit operator bool () const BOOST_NOEXCEPT\
+ {\
+ return !this->operator! ();\
+ }
+
+#else // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+#if (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG)
+// Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
+#define BOOST_NO_UNSPECIFIED_BOOL
+#endif // (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG)
+
+#if !defined(BOOST_NO_UNSPECIFIED_BOOL)
+
+namespace boost {
+
+namespace detail {
+
+#if !defined(_MSC_VER) && !defined(__IBMCPP__)
+
+ struct unspecified_bool
+ {
+ // NOTE TO THE USER: If you see this in error messages then you tried
+ // to apply an unsupported operator on the object that supports
+ // explicit conversion to bool.
+ struct OPERATORS_NOT_ALLOWED;
+ static void true_value(OPERATORS_NOT_ALLOWED*) {}
+ };
+ typedef void (*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*);
+
+#else
+
+ // MSVC and VACPP are too eager to convert pointer to function to void* even though they shouldn't
+ struct unspecified_bool
+ {
+ // NOTE TO THE USER: If you see this in error messages then you tried
+ // to apply an unsupported operator on the object that supports
+ // explicit conversion to bool.
+ struct OPERATORS_NOT_ALLOWED;
+ void true_value(OPERATORS_NOT_ALLOWED*) {}
+ };
+ typedef void (unspecified_bool::*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*);
+
+#endif
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_EXPLICIT_OPERATOR_BOOL()\
+ BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const\
+ {\
+ return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
+ }
+
+#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\
+ BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\
+ {\
+ return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
+ }
+
+#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
+ BOOST_FORCEINLINE BOOST_CONSTEXPR operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\
+ {\
+ return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
+ }
+
+#else // !defined(BOOST_NO_UNSPECIFIED_BOOL)
+
+#define BOOST_EXPLICIT_OPERATOR_BOOL()\
+ BOOST_FORCEINLINE operator bool () const\
+ {\
+ return !this->operator! ();\
+ }
+
+#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\
+ BOOST_FORCEINLINE operator bool () const BOOST_NOEXCEPT\
+ {\
+ return !this->operator! ();\
+ }
+
+#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
+ BOOST_FORCEINLINE BOOST_CONSTEXPR operator bool () const BOOST_NOEXCEPT\
+ {\
+ return !this->operator! ();\
+ }
+
+#endif // !defined(BOOST_NO_UNSPECIFIED_BOOL)
+
+#endif // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+#endif // BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
--- /dev/null
+#ifndef BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP
+#define BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+//----------------------------------------------------------------------
+// (C) Copyright 2004 Pavel Vozenilek.
+// Use, modification and distribution is subject to 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)
+//
+//
+// This file contains helper macros used when exception support may be
+// disabled (as indicated by macro BOOST_NO_EXCEPTIONS).
+//
+// Before picking up these macros you may consider using RAII techniques
+// to deal with exceptions - their syntax can be always the same with
+// or without exception support enabled.
+//----------------------------------------------------------------------
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if !(defined BOOST_NO_EXCEPTIONS)
+# define BOOST_TRY { try
+# define BOOST_CATCH(x) catch(x)
+# define BOOST_RETHROW throw;
+# define BOOST_CATCH_END }
+#else
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# define BOOST_TRY { if ("")
+# define BOOST_CATCH(x) else if (!"")
+# else
+# define BOOST_TRY { if (true)
+# define BOOST_CATCH(x) else if (false)
+# endif
+# define BOOST_RETHROW
+# define BOOST_CATCH_END }
+#endif
+
+
+#endif
--- /dev/null
+// Boost noncopyable.hpp header file --------------------------------------//
+
+// (C) Copyright Beman Dawes 1999-2003. 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/utility for documentation.
+
+#ifndef BOOST_CORE_NONCOPYABLE_HPP
+#define BOOST_CORE_NONCOPYABLE_HPP
+
+#include <boost/config.hpp>
+
+namespace boost {
+
+// Private copy constructor and copy assignment ensure classes derived from
+// class noncopyable cannot be copied.
+
+// Contributed by Dave Abrahams
+
+namespace noncopyable_ // protection from unintended ADL
+{
+ class noncopyable
+ {
+ protected:
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
+ BOOST_CONSTEXPR noncopyable() = default;
+ ~noncopyable() = default;
+#else
+ noncopyable() {}
+ ~noncopyable() {}
+#endif
+#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+ noncopyable( const noncopyable& ) = delete;
+ noncopyable& operator=( const noncopyable& ) = delete;
+#else
+ private: // emphasize the following members are private
+ noncopyable( const noncopyable& );
+ noncopyable& operator=( const noncopyable& );
+#endif
+ };
+}
+
+typedef noncopyable_::noncopyable noncopyable;
+
+} // namespace boost
+
+#endif // BOOST_CORE_NONCOPYABLE_HPP
--- /dev/null
+#ifndef BOOST_CORE_REF_HPP
+#define BOOST_CORE_REF_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/detail/workaround.hpp>
+
+//
+// ref.hpp - ref/cref, useful helper functions
+//
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001, 2002 Peter Dimov
+// Copyright (C) 2002 David Abrahams
+//
+// Copyright (C) 2014 Glen Joseph Fernandes
+// glenfe at live dot com
+// Copyright (C) 2014 Agustin Berge
+//
+// 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/core/doc/html/core/ref.html for documentation.
+//
+
+/**
+ @file
+*/
+
+/**
+ Boost namespace.
+*/
+namespace boost
+{
+
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
+
+ struct ref_workaround_tag {};
+
+#endif
+
+// reference_wrapper
+
+/**
+ @brief Contains a reference to an object of type `T`.
+
+ `reference_wrapper` is primarily used to "feed" references to
+ function templates (algorithms) that take their parameter by
+ value. It provides an implicit conversion to `T&`, which
+ usually allows the function templates to work on references
+ unmodified.
+*/
+template<class T> class reference_wrapper
+{
+public:
+ /**
+ Type `T`.
+ */
+ typedef T type;
+
+ /**
+ Constructs a `reference_wrapper` object that stores a
+ reference to `t`.
+
+ @remark Does not throw.
+ */
+ BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
+
+ BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( boost::addressof( t ) ) {}
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ /**
+ @remark Construction from a temporary object is disabled.
+ */
+ BOOST_DELETED_FUNCTION(reference_wrapper(T&& t))
+public:
+#endif
+
+ /**
+ @return The stored reference.
+ @remark Does not throw.
+ */
+ BOOST_FORCEINLINE operator T& () const { return *t_; }
+
+ /**
+ @return The stored reference.
+ @remark Does not throw.
+ */
+ BOOST_FORCEINLINE T& get() const { return *t_; }
+
+ /**
+ @return A pointer to the object referenced by the stored
+ reference.
+ @remark Does not throw.
+ */
+ BOOST_FORCEINLINE T* get_pointer() const { return t_; }
+
+private:
+
+ T* t_;
+};
+
+// ref
+
+/**
+ @cond
+*/
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
+# define BOOST_REF_CONST
+#else
+# define BOOST_REF_CONST const
+#endif
+/**
+ @endcond
+*/
+
+/**
+ @return `reference_wrapper<T>(t)`
+ @remark Does not throw.
+*/
+template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t )
+{
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
+
+ return reference_wrapper<T>( t, ref_workaround_tag() );
+
+#else
+
+ return reference_wrapper<T>( t );
+
+#endif
+}
+
+// cref
+
+/**
+ @return `reference_wrapper<T const>(t)`
+ @remark Does not throw.
+*/
+template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t )
+{
+ return reference_wrapper<T const>(t);
+}
+
+#undef BOOST_REF_CONST
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+/**
+ @cond
+*/
+#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+# define BOOST_REF_DELETE
+#else
+# define BOOST_REF_DELETE = delete
+#endif
+/**
+ @endcond
+*/
+
+/**
+ @remark Construction from a temporary object is disabled.
+*/
+template<class T> void ref(T const&&) BOOST_REF_DELETE;
+
+/**
+ @remark Construction from a temporary object is disabled.
+*/
+template<class T> void cref(T const&&) BOOST_REF_DELETE;
+
+#undef BOOST_REF_DELETE
+
+#endif
+
+// is_reference_wrapper
+
+/**
+ @brief Determine if a type `T` is an instantiation of
+ `reference_wrapper`.
+
+ The value static constant will be true if the type `T` is a
+ specialization of `reference_wrapper`.
+*/
+template<typename T> struct is_reference_wrapper
+{
+ BOOST_STATIC_CONSTANT( bool, value = false );
+};
+
+/**
+ @cond
+*/
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> >
+{
+ BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> const >
+{
+ BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> volatile >
+{
+ BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> const volatile >
+{
+ BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+/**
+ @endcond
+*/
+
+
+// unwrap_reference
+
+/**
+ @brief Find the type in a `reference_wrapper`.
+
+ The `typedef` type is `T::type` if `T` is a
+ `reference_wrapper`, `T` otherwise.
+*/
+template<typename T> struct unwrap_reference
+{
+ typedef T type;
+};
+
+/**
+ @cond
+*/
+template<typename T> struct unwrap_reference< reference_wrapper<T> >
+{
+ typedef T type;
+};
+
+#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> const >
+{
+ typedef T type;
+};
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> volatile >
+{
+ typedef T type;
+};
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> const volatile >
+{
+ typedef T type;
+};
+
+#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+/**
+ @endcond
+*/
+
+// unwrap_ref
+
+/**
+ @return `unwrap_reference<T>::type&(t)`
+ @remark Does not throw.
+*/
+template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t )
+{
+ return t;
+}
+
+// get_pointer
+
+/**
+ @cond
+*/
+template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r )
+{
+ return r.get_pointer();
+}
+/**
+ @endcond
+*/
+
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_REF_HPP
--- /dev/null
+// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
+//
+// 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)
+// For more information, see http://www.boost.org
+
+
+#ifndef BOOST_CORE_SWAP_HPP
+#define BOOST_CORE_SWAP_HPP
+
+// Note: the implementation of this utility contains various workarounds:
+// - swap_impl is put outside the boost namespace, to avoid infinite
+// recursion (causing stack overflow) when swapping objects of a primitive
+// type.
+// - swap_impl has a using-directive, rather than a using-declaration,
+// because some compilers (including MSVC 7.1, Borland 5.9.3, and
+// Intel 8.1) don't do argument-dependent lookup when it has a
+// using-declaration instead.
+// - boost::swap has two template arguments, instead of one, to
+// avoid ambiguity when swapping objects of a Boost type that does
+// not have its own boost::swap overload.
+
+#include <utility> //for std::swap (C++11)
+#include <algorithm> //for std::swap (C++98)
+#include <cstddef> //for std::size_t
+#include <boost/config.hpp>
+
+namespace boost_swap_impl
+{
+ template<class T>
+ BOOST_GPU_ENABLED
+ void swap_impl(T& left, T& right)
+ {
+ using namespace std;//use std::swap if argument dependent lookup fails
+ swap(left,right);
+ }
+
+ template<class T, std::size_t N>
+ BOOST_GPU_ENABLED
+ void swap_impl(T (& left)[N], T (& right)[N])
+ {
+ for (std::size_t i = 0; i < N; ++i)
+ {
+ ::boost_swap_impl::swap_impl(left[i], right[i]);
+ }
+ }
+}
+
+namespace boost
+{
+ template<class T1, class T2>
+ BOOST_GPU_ENABLED
+ void swap(T1& left, T2& right)
+ {
+ ::boost_swap_impl::swap_impl(left, right);
+ }
+}
+
+#endif
--- /dev/null
+#ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED
+#define BOOST_CORE_TYPEINFO_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// core::typeinfo, BOOST_CORE_TYPEID
+//
+// Copyright 2007, 2014 Peter Dimov
+//
+// 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_TYPEID )
+
+#include <boost/current_function.hpp>
+#include <functional>
+
+namespace boost
+{
+
+namespace core
+{
+
+class typeinfo
+{
+private:
+
+ typeinfo( typeinfo const& );
+ typeinfo& operator=( typeinfo const& );
+
+ char const * name_;
+
+public:
+
+ explicit typeinfo( char const * name ): name_( name )
+ {
+ }
+
+ bool operator==( typeinfo const& rhs ) const
+ {
+ return this == &rhs;
+ }
+
+ bool operator!=( typeinfo const& rhs ) const
+ {
+ return this != &rhs;
+ }
+
+ bool before( typeinfo const& rhs ) const
+ {
+ return std::less< typeinfo const* >()( this, &rhs );
+ }
+
+ char const* name() const
+ {
+ return name_;
+ }
+};
+
+inline char const * demangled_name( core::typeinfo const & ti )
+{
+ return ti.name();
+}
+
+} // namespace core
+
+namespace detail
+{
+
+template<class T> struct core_typeid_
+{
+ static boost::core::typeinfo ti_;
+
+ static char const * name()
+ {
+ return BOOST_CURRENT_FUNCTION;
+ }
+};
+
+#if defined(__SUNPRO_CC)
+// see #4199, the Sun Studio compiler gets confused about static initialization
+// constructor arguments. But an assignment works just fine.
+template<class T> boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name();
+#else
+template<class T> boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name());
+#endif
+
+template<class T> struct core_typeid_< T & >: core_typeid_< T >
+{
+};
+
+template<class T> struct core_typeid_< T const >: core_typeid_< T >
+{
+};
+
+template<class T> struct core_typeid_< T volatile >: core_typeid_< T >
+{
+};
+
+template<class T> struct core_typeid_< T const volatile >: core_typeid_< T >
+{
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_CORE_TYPEID(T) (boost::detail::core_typeid_<T>::ti_)
+
+#else
+
+#include <boost/core/demangle.hpp>
+#include <typeinfo>
+
+namespace boost
+{
+
+namespace core
+{
+
+#if defined( BOOST_NO_STD_TYPEINFO )
+
+typedef ::type_info typeinfo;
+
+#else
+
+typedef std::type_info typeinfo;
+
+#endif
+
+inline std::string demangled_name( core::typeinfo const & ti )
+{
+ return core::demangle( ti.name() );
+}
+
+} // namespace core
+
+} // namespace boost
+
+#define BOOST_CORE_TYPEID(T) typeid(T)
+
+#endif
+
+#endif // #ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED
} // namespace boost
-#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || defined(__VMS)
+#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || defined(__VMS) || defined(__SOLARIS9__) || defined(__NetBSD__)
// FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
# include <inttypes.h>
|| (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0) && !defined(__UCLIBC__)) \
|| defined(__CYGWIN__) \
|| defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) \
- || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+ || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(sun)
namespace boost {
using ::intptr_t;
// 64-bit types + intmax_t and uintmax_t ----------------------------------//
#ifndef INT64_C
# if defined(BOOST_HAS_LONG_LONG) && \
- (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX) || defined(_LLONG_MAX))
+ (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX) || defined(_ULLONG_MAX) || defined(_LLONG_MAX))
# if defined(__hpux)
// HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
# elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || \
(defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || \
(defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) || \
- (defined(_LLONG_MAX) && _LLONG_MAX == 18446744073709551615ULL)
+ (defined(_ULLONG_MAX) && _ULLONG_MAX == 18446744073709551615ULL) || \
+ (defined(_LLONG_MAX) && _LLONG_MAX == 9223372036854775807LL)
# define INT64_C(value) value##LL
# define UINT64_C(value) value##uLL
//
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
//
-// 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)
+// 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
//
-// http://www.boost.org/libs/utility/current_function.html
+// http://www.boost.org/libs/assert/current_function.html
//
namespace boost
# define BOOST_CURRENT_FUNCTION __func__
+#elif defined(__cplusplus) && (__cplusplus >= 201103)
+
+# define BOOST_CURRENT_FUNCTION __func__
+
#else
# define BOOST_CURRENT_FUNCTION "(unknown)"
} // namespace boost
#endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
-
--- /dev/null
+//-----------------------------------------------------------------------------
+// boost detail/templated_streams.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2013 John Maddock, Antony Polukhin
+//
+//
+// 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)
+
+#ifndef BOOST_DETAIL_BASIC_POINTERBUF_HPP
+#define BOOST_DETAIL_BASIC_POINTERBUF_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include "boost/config.hpp"
+#include <streambuf>
+
+namespace boost { namespace detail {
+
+//
+// class basic_pointerbuf:
+// acts as a stream buffer which wraps around a pair of pointers:
+//
+template <class charT, class BufferT >
+class basic_pointerbuf : public BufferT {
+protected:
+ typedef BufferT base_type;
+ typedef basic_pointerbuf<charT, BufferT> this_type;
+ typedef typename base_type::int_type int_type;
+ typedef typename base_type::char_type char_type;
+ typedef typename base_type::pos_type pos_type;
+ typedef ::std::streamsize streamsize;
+ typedef typename base_type::off_type off_type;
+
+public:
+ basic_pointerbuf() : base_type() { setbuf(0, 0); }
+ const charT* getnext() { return this->gptr(); }
+
+#ifndef BOOST_NO_USING_TEMPLATE
+ using base_type::pptr;
+ using base_type::pbase;
+#else
+ charT* pptr() const { return base_type::pptr(); }
+ charT* pbase() const { return base_type::pbase(); }
+#endif
+
+protected:
+ // VC mistakenly assumes that `setbuf` and other functions are not referenced.
+ // Marking those functions with `inline` suppresses the warnings.
+ // There must be no harm from marking virtual functions as inline: inline virtual
+ // call can be inlined ONLY when the compiler knows the "exact class".
+ inline base_type* setbuf(char_type* s, streamsize n);
+ inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which);
+ inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which);
+
+private:
+ basic_pointerbuf& operator=(const basic_pointerbuf&);
+ basic_pointerbuf(const basic_pointerbuf&);
+};
+
+template<class charT, class BufferT>
+BufferT*
+basic_pointerbuf<charT, BufferT>::setbuf(char_type* s, streamsize n)
+{
+ this->setg(s, s, s + n);
+ return this;
+}
+
+template<class charT, class BufferT>
+typename basic_pointerbuf<charT, BufferT>::pos_type
+basic_pointerbuf<charT, BufferT>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)
+{
+ typedef typename boost::int_t<sizeof(way) * CHAR_BIT>::least cast_type;
+
+ if(which & ::std::ios_base::out)
+ return pos_type(off_type(-1));
+ std::ptrdiff_t size = this->egptr() - this->eback();
+ std::ptrdiff_t pos = this->gptr() - this->eback();
+ charT* g = this->eback();
+ switch(static_cast<cast_type>(way))
+ {
+ case ::std::ios_base::beg:
+ if((off < 0) || (off > size))
+ return pos_type(off_type(-1));
+ else
+ this->setg(g, g + off, g + size);
+ break;
+ case ::std::ios_base::end:
+ if((off < 0) || (off > size))
+ return pos_type(off_type(-1));
+ else
+ this->setg(g, g + size - off, g + size);
+ break;
+ case ::std::ios_base::cur:
+ {
+ std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off);
+ if((newpos < 0) || (newpos > size))
+ return pos_type(off_type(-1));
+ else
+ this->setg(g, g + newpos, g + size);
+ break;
+ }
+ default: ;
+ }
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4244)
+#endif
+ return static_cast<pos_type>(this->gptr() - this->eback());
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+}
+
+template<class charT, class BufferT>
+typename basic_pointerbuf<charT, BufferT>::pos_type
+basic_pointerbuf<charT, BufferT>::seekpos(pos_type sp, ::std::ios_base::openmode which)
+{
+ if(which & ::std::ios_base::out)
+ return pos_type(off_type(-1));
+ off_type size = static_cast<off_type>(this->egptr() - this->eback());
+ charT* g = this->eback();
+ if(off_type(sp) <= size)
+ {
+ this->setg(g, g + off_type(sp), g + size);
+ }
+ return pos_type(off_type(-1));
+}
+
+}} // namespace boost::detail
+
+#endif // BOOST_DETAIL_BASIC_POINTERBUF_HPP
+
#if !defined(BOOST_DETAIL_CONTAINER_FWD_HPP)
#define BOOST_DETAIL_CONTAINER_FWD_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1020) && \
+#if defined(_MSC_VER) && \
!defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
# pragma once
#endif
template <class T> class allocator;
template <class charT, class traits, class Allocator> class basic_string;
-#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-
- template <class charT> struct string_char_traits;
-#else
template <class charT> struct char_traits;
-#endif
#if defined(BOOST_CONTAINER_FWD_COMPLEX_STRUCT)
template <class T> struct complex;
-// Copyright 2013 Redshift Software Inc
+// Copyright 2013 Rene Rivera
// Distributed under the Boost Software License, Version 1.0. (See accompany-
// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#if !defined(BOOST_DETAIL_FENV_HPP)
#define BOOST_DETAIL_FENV_HPP
-/* If we're using clang + glibc, we have to get hacky.
+/* If we're using clang + glibc, we have to get hacky.
* See http://llvm.org/bugs/show_bug.cgi?id=6907 */
#if defined(__clang__) && (__clang_major__ < 3) && \
defined(__GNU_LIBRARY__) && /* up to version 5 */ \
using ::feholdexcept;
} }
+#elif defined(__MINGW32__) && defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 408
+
+ // MinGW (32-bit) has a bug in mingw32/bits/c++config.h, it does not define _GLIBCXX_HAVE_FENV_H,
+ // which prevents the C fenv.h header contents to be included in the C++ wrapper header fenv.h. This is at least
+ // the case with gcc 4.8.1 packages tested so far, up to 4.8.1-4. Note that there is no issue with
+ // MinGW-w64.
+ // To work around the bug we avoid including the C++ wrapper header and include the C header directly
+ // and import all relevant symbols into std:: ourselves.
+
+ #include <../include/fenv.h>
+
+ namespace std {
+ using ::fenv_t;
+ using ::fexcept_t;
+ using ::fegetexceptflag;
+ using ::fesetexceptflag;
+ using ::feclearexcept;
+ using ::feraiseexcept;
+ using ::fetestexcept;
+ using ::fegetround;
+ using ::fesetround;
+ using ::fegetenv;
+ using ::fesetenv;
+ using ::feupdateenv;
+ using ::feholdexcept;
+ }
+
#else /* if we're not using GNU's C stdlib, fenv.h should work with clang */
+
#if defined(__SUNPRO_CC) /* lol suncc */
#include <stdio.h>
#endif
-
+
#include <fenv.h>
#endif
#endif /* BOOST_DETAIL_FENV_HPP */
-
# include <boost/type_traits/remove_reference.hpp>
# include <boost/type_traits/remove_pointer.hpp>
-# include <boost/type_traits/detail/ice_and.hpp>
# include <boost/detail/workaround.hpp>
# include <boost/mpl/eval_if.hpp>
# include <boost/mpl/not.hpp>
# include <boost/mpl/aux_/lambda_support.hpp>
-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-# include <boost/detail/is_function_ref_tester.hpp>
-# endif
namespace boost { namespace detail {
namespace indirect_traits {
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <class T>
struct is_reference_to_const : mpl::false_
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T))
};
-# else
-
-using namespace boost::detail::is_function_ref_tester_;
-
-typedef char (&inner_yes_type)[3];
-typedef char (&inner_no_type)[2];
-typedef char (&outer_no_type)[1];
-
-template <typename V>
-struct is_const_help
-{
- typedef typename mpl::if_<
- is_const<V>
- , inner_yes_type
- , inner_no_type
- >::type type;
-};
-
-template <typename V>
-struct is_volatile_help
-{
- typedef typename mpl::if_<
- is_volatile<V>
- , inner_yes_type
- , inner_no_type
- >::type type;
-};
-
-template <typename V>
-struct is_pointer_help
-{
- typedef typename mpl::if_<
- is_pointer<V>
- , inner_yes_type
- , inner_no_type
- >::type type;
-};
-
-template <typename V>
-struct is_class_help
-{
- typedef typename mpl::if_<
- is_class<V>
- , inner_yes_type
- , inner_no_type
- >::type type;
-};
-
-template <class T>
-struct is_reference_to_function_aux
-{
- static T t;
- BOOST_STATIC_CONSTANT(
- bool, value = sizeof(detail::is_function_ref_tester(t,0)) == sizeof(::boost::type_traits::yes_type));
- typedef mpl::bool_<value> type;
- };
-
-template <class T>
-struct is_reference_to_function
- : mpl::if_<is_reference<T>, is_reference_to_function_aux<T>, mpl::bool_<false> >::type
-{
-};
-
-template <class T>
-struct is_pointer_to_function_aux
-{
- static T t;
- BOOST_STATIC_CONSTANT(
- bool, value
- = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type));
- typedef mpl::bool_<value> type;
-};
-
-template <class T>
-struct is_pointer_to_function
- : mpl::if_<is_pointer<T>, is_pointer_to_function_aux<T>, mpl::bool_<false> >::type
-{
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T))
-};
-
-struct false_helper1
-{
- template <class T>
- struct apply : mpl::false_
- {
- };
-};
-
-template <typename V>
-typename is_const_help<V>::type reference_to_const_helper(V&);
-outer_no_type
-reference_to_const_helper(...);
-
-struct true_helper1
-{
- template <class T>
- struct apply
- {
- static T t;
- BOOST_STATIC_CONSTANT(
- bool, value
- = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type));
- typedef mpl::bool_<value> type;
- };
-};
-
-template <bool ref = true>
-struct is_reference_to_const_helper1 : true_helper1
-{
-};
-
-template <>
-struct is_reference_to_const_helper1<false> : false_helper1
-{
-};
-
-
-template <class T>
-struct is_reference_to_const
- : is_reference_to_const_helper1<is_reference<T>::value>::template apply<T>
-{
-};
-
-
-template <bool ref = true>
-struct is_reference_to_non_const_helper1
-{
- template <class T>
- struct apply
- {
- static T t;
- BOOST_STATIC_CONSTANT(
- bool, value
- = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type));
-
- typedef mpl::bool_<value> type;
- };
-};
-
-template <>
-struct is_reference_to_non_const_helper1<false> : false_helper1
-{
-};
-
-
-template <class T>
-struct is_reference_to_non_const
- : is_reference_to_non_const_helper1<is_reference<T>::value>::template apply<T>
-{
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_non_const,(T))
-};
-
-
-template <typename V>
-typename is_volatile_help<V>::type reference_to_volatile_helper(V&);
-outer_no_type
-reference_to_volatile_helper(...);
-
-template <bool ref = true>
-struct is_reference_to_volatile_helper1
-{
- template <class T>
- struct apply
- {
- static T t;
- BOOST_STATIC_CONSTANT(
- bool, value
- = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type));
- typedef mpl::bool_<value> type;
- };
-};
-
-template <>
-struct is_reference_to_volatile_helper1<false> : false_helper1
-{
-};
-
-
-template <class T>
-struct is_reference_to_volatile
- : is_reference_to_volatile_helper1<is_reference<T>::value>::template apply<T>
-{
-};
-
-template <typename V>
-typename is_pointer_help<V>::type reference_to_pointer_helper(V&);
-outer_no_type reference_to_pointer_helper(...);
-
-template <class T>
-struct reference_to_pointer_impl
-{
- static T t;
- BOOST_STATIC_CONSTANT(
- bool, value
- = (sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type))
- );
-
- typedef mpl::bool_<value> type;
-};
-
-template <class T>
-struct is_reference_to_pointer
- : mpl::eval_if<is_reference<T>, reference_to_pointer_impl<T>, mpl::false_>::type
-{
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_pointer,(T))
-};
-
-template <class T>
-struct is_reference_to_function_pointer
- : mpl::eval_if<is_reference<T>, is_pointer_to_function_aux<T>, mpl::false_>::type
-{
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T))
-};
-
-
-template <class T>
-struct is_member_function_pointer_help
- : mpl::if_<is_member_function_pointer<T>, inner_yes_type, inner_no_type>
-{};
-
-template <typename V>
-typename is_member_function_pointer_help<V>::type member_function_pointer_helper(V&);
-outer_no_type member_function_pointer_helper(...);
-
-template <class T>
-struct is_pointer_to_member_function_aux
-{
- static T t;
- BOOST_STATIC_CONSTANT(
- bool, value
- = sizeof((member_function_pointer_helper)(t)) == sizeof(inner_yes_type));
- typedef mpl::bool_<value> type;
-};
-
-template <class T>
-struct is_reference_to_member_function_pointer
- : mpl::if_<
- is_reference<T>
- , is_pointer_to_member_function_aux<T>
- , mpl::bool_<false>
- >::type
-{
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T))
-};
-
-template <typename V>
-typename is_class_help<V>::type reference_to_class_helper(V const volatile&);
-outer_no_type reference_to_class_helper(...);
-
-template <class T>
-struct is_reference_to_class
-{
- static T t;
- BOOST_STATIC_CONSTANT(
- bool, value
- = (is_reference<T>::value
- & (sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type)))
- );
- typedef mpl::bool_<value> type;
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T))
-};
-
-template <typename V>
-typename is_class_help<V>::type pointer_to_class_helper(V const volatile*);
-outer_no_type pointer_to_class_helper(...);
-
-template <class T>
-struct is_pointer_to_class
-{
- static T t;
- BOOST_STATIC_CONSTANT(
- bool, value
- = (is_pointer<T>::value
- && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type))
- );
- typedef mpl::bool_<value> type;
-};
-# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
}
+++ /dev/null
-#ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
-#define BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
-
-//
-// boost/detail/interlocked.hpp
-//
-// Copyright 2005 Peter Dimov
-//
-// 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>
-
-// MS compatible compilers support #pragma once
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-#if defined( BOOST_USE_WINDOWS_H )
-
-# include <windows.h>
-
-# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER InterlockedCompareExchangePointer
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER InterlockedExchangePointer
-
-#elif defined( BOOST_USE_INTRIN_H )
-
-#include <intrin.h>
-
-# define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT _InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
-
-# if defined(_M_IA64) || defined(_M_AMD64) || defined(__x86_64__) || defined(__x86_64)
-
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER _InterlockedCompareExchangePointer
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER _InterlockedExchangePointer
-
-# else
-
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
- ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
- ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
-
-# endif
-
-#elif defined(_WIN32_WCE)
-
-#if _WIN32_WCE >= 0x600
-
-extern "C" long __cdecl _InterlockedIncrement( long volatile * );
-extern "C" long __cdecl _InterlockedDecrement( long volatile * );
-extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long );
-extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
-extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );
-
-# define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT _InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
-
-#else
-// under Windows CE we still have old-style Interlocked* functions
-
-extern "C" long __cdecl InterlockedIncrement( long* );
-extern "C" long __cdecl InterlockedDecrement( long* );
-extern "C" long __cdecl InterlockedCompareExchange( long*, long, long );
-extern "C" long __cdecl InterlockedExchange( long*, long );
-extern "C" long __cdecl InterlockedExchangeAdd( long*, long );
-
-# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
-
-#endif
-
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
- ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest),(long)(exchange),(long)(compare)))
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
- ((void*)BOOST_INTERLOCKED_EXCHANGE((long*)(dest),(long)(exchange)))
-
-#elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN )
-
-#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1500
-
-#include <intrin.h>
-
-#elif defined( __CLRCALL_PURE_OR_CDECL )
-
-extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedIncrement( long volatile * );
-extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedDecrement( long volatile * );
-extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedCompareExchange( long volatile *, long, long );
-extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchange( long volatile *, long );
-extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchangeAdd( long volatile *, long );
-
-#else
-
-extern "C" long __cdecl _InterlockedIncrement( long volatile * );
-extern "C" long __cdecl _InterlockedDecrement( long volatile * );
-extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long );
-extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
-extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );
-
-#endif
-
-# if defined(_M_IA64) || defined(_M_AMD64)
-
-extern "C" void* __cdecl _InterlockedCompareExchangePointer( void* volatile *, void*, void* );
-extern "C" void* __cdecl _InterlockedExchangePointer( void* volatile *, void* );
-
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER _InterlockedCompareExchangePointer
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER _InterlockedExchangePointer
-
-# else
-
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
- ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
- ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
-
-# endif
-
-# define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT _InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
-
-// Unlike __MINGW64__, __MINGW64_VERSION_MAJOR is defined by MinGW-w64 for both 32 and 64-bit targets.
-#elif defined(__MINGW64_VERSION_MAJOR)
-
-// MinGW-w64 provides intrin.h for both 32 and 64-bit targets.
-#include <intrin.h>
-
-# define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT _InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
-# if defined(__x86_64__) || defined(__x86_64)
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER _InterlockedCompareExchangePointer
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER _InterlockedExchangePointer
-# else
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
- ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
- ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
-# endif
-
-#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
-
-#define BOOST_INTERLOCKED_IMPORT __declspec(dllimport)
-
-namespace boost
-{
-
-namespace detail
-{
-
-extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedIncrement( long volatile * );
-extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedDecrement( long volatile * );
-extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedCompareExchange( long volatile *, long, long );
-extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchange( long volatile *, long );
-extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchangeAdd( long volatile *, long );
-
-# if defined(_M_IA64) || defined(_M_AMD64)
-extern "C" BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedCompareExchangePointer( void* volatile *, void*, void* );
-extern "C" BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedExchangePointer( void* volatile *, void* );
-# endif
-
-} // namespace detail
-
-} // namespace boost
-
-# define BOOST_INTERLOCKED_INCREMENT ::boost::detail::InterlockedIncrement
-# define BOOST_INTERLOCKED_DECREMENT ::boost::detail::InterlockedDecrement
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE ::boost::detail::InterlockedCompareExchange
-# define BOOST_INTERLOCKED_EXCHANGE ::boost::detail::InterlockedExchange
-# define BOOST_INTERLOCKED_EXCHANGE_ADD ::boost::detail::InterlockedExchangeAdd
-
-# if defined(_M_IA64) || defined(_M_AMD64)
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER ::boost::detail::InterlockedCompareExchangePointer
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER ::boost::detail::InterlockedExchangePointer
-# else
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
- ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
- ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
-# endif
-
-#else
-
-# error "Interlocked intrinsics not available"
-
-#endif
-
-#endif // #ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED
+++ /dev/null
-
-// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes,
-// Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000.
-// 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_PP_IS_ITERATING)
-
-///// header body
-
-#ifndef BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
-#define BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
-
-#include "boost/type_traits/detail/yes_no_type.hpp"
-#include "boost/type_traits/config.hpp"
-
-#if defined(BOOST_TT_PREPROCESSING_MODE)
-# include "boost/preprocessor/iterate.hpp"
-# include "boost/preprocessor/enum_params.hpp"
-# include "boost/preprocessor/comma_if.hpp"
-#endif
-
-namespace boost {
-namespace detail {
-namespace is_function_ref_tester_ {
-
-template <class T>
-boost::type_traits::no_type BOOST_TT_DECL is_function_ref_tester(T& ...);
-
-#if !defined(BOOST_TT_PREPROCESSING_MODE)
-// preprocessor-generated part, don't edit by hand!
-
-template <class R>
-boost::type_traits::yes_type is_function_ref_tester(R (&)(), int);
-
-template <class R,class T0 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0), int);
-
-template <class R,class T0,class T1 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1), int);
-
-template <class R,class T0,class T1,class T2 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2), int);
-
-template <class R,class T0,class T1,class T2,class T3 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23), int);
-
-template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24 >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24), int);
-
-#else
-
-#define BOOST_PP_ITERATION_PARAMS_1 \
- (3, (0, 25, "boost/detail/is_function_ref_tester.hpp"))
-#include BOOST_PP_ITERATE()
-
-#endif // BOOST_TT_PREPROCESSING_MODE
-
-} // namespace detail
-} // namespace python
-} // namespace boost
-
-#endif // BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED
-
-///// iteration
-
-#else
-#define i BOOST_PP_FRAME_ITERATION(1)
-
-template <class R BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T) >
-boost::type_traits::yes_type is_function_ref_tester(R (&)(BOOST_PP_ENUM_PARAMS(i,T)), int);
-
-#undef i
-#endif // BOOST_PP_IS_ITERATING
-
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
-// Boost versions of
-//
-// std::iterator_traits<>::iterator_category
-// std::iterator_traits<>::difference_type
-// std::distance()
-//
-// ...for all compilers and iterators
-//
-// Additionally, if X is a pointer
-// std::iterator_traits<X>::pointer
-
-// Otherwise, if partial specialization is supported or X is not a pointer
-// std::iterator_traits<X>::value_type
-// std::iterator_traits<X>::pointer
-// std::iterator_traits<X>::reference
-//
-// See http://www.boost.org for most recent version including documentation.
-
-// Revision History
-// 04 Mar 2001 - More attempted fixes for Intel C++ (David Abrahams)
-// 03 Mar 2001 - Put all implementation into namespace
-// boost::detail::iterator_traits_. Some progress made on fixes
-// for Intel compiler. (David Abrahams)
-// 02 Mar 2001 - Changed BOOST_MSVC to BOOST_MSVC_STD_ITERATOR in a few
-// places. (Jeremy Siek)
-// 19 Feb 2001 - Improved workarounds for stock MSVC6; use yes_type and
-// no_type from type_traits.hpp; stopped trying to remove_cv
-// before detecting is_pointer, in honor of the new type_traits
-// semantics. (David Abrahams)
-// 13 Feb 2001 - Make it work with nearly all standard-conforming iterators
-// under raw VC6. The one category remaining which will fail is
-// that of iterators derived from std::iterator but not
-// boost::iterator and which redefine difference_type.
-// 11 Feb 2001 - Clean away code which can never be used (David Abrahams)
-// 09 Feb 2001 - Always have a definition for each traits member, even if it
-// can't be properly deduced. These will be incomplete types in
-// some cases (undefined<void>), but it helps suppress MSVC errors
-// elsewhere (David Abrahams)
-// 07 Feb 2001 - Support for more of the traits members where possible, making
-// this useful as a replacement for std::iterator_traits<T> when
-// used as a default template parameter.
-// 06 Feb 2001 - Removed useless #includes of standard library headers
-// (David Abrahams)
-
#ifndef ITERATOR_DWA122600_HPP_
-# define ITERATOR_DWA122600_HPP_
-
-# include <boost/config.hpp>
-# include <iterator>
-
-// STLPort 4.0 and betas have a bug when debugging is enabled and there is no
-// partial specialization: instead of an iterator_category typedef, the standard
-// container iterators have _Iterator_category.
-//
-// Also, whether debugging is enabled or not, there is a broken specialization
-// of std::iterator<output_iterator_tag,void,void,void,void> which has no
-// typedefs but iterator_category.
-# if defined(__SGI_STL_PORT)
-
-# if (__SGI_STL_PORT <= 0x410) && !defined(__STL_CLASS_PARTIAL_SPECIALIZATION) && defined(__STL_DEBUG)
-# define BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
-# endif
-
-# define BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
-
-# endif // STLPort <= 4.1b4 && no partial specialization
-
-# if !defined(BOOST_NO_STD_ITERATOR_TRAITS) \
- && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
- && !defined(BOOST_MSVC_STD_ITERATOR)
-
-namespace boost { namespace detail {
-
-// Define a new template so it can be specialized
-template <class Iterator>
-struct iterator_traits
- : std::iterator_traits<Iterator>
-{};
-using std::distance;
-
-}} // namespace boost::detail
-
-# else
-
-# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
- && !defined(BOOST_MSVC_STD_ITERATOR)
-
-// This is the case where everything conforms except BOOST_NO_STD_ITERATOR_TRAITS
-
-namespace boost { namespace detail {
-
-// Rogue Wave Standard Library fools itself into thinking partial
-// specialization is missing on some platforms (e.g. Sun), so fails to
-// supply iterator_traits!
-template <class Iterator>
-struct iterator_traits
-{
- typedef typename Iterator::value_type value_type;
- typedef typename Iterator::reference reference;
- typedef typename Iterator::pointer pointer;
- typedef typename Iterator::difference_type difference_type;
- typedef typename Iterator::iterator_category iterator_category;
-};
-
-template <class T>
-struct iterator_traits<T*>
-{
- typedef T value_type;
- typedef T& reference;
- typedef T* pointer;
- typedef std::ptrdiff_t difference_type;
- typedef std::random_access_iterator_tag iterator_category;
-};
-
-template <class T>
-struct iterator_traits<T const*>
-{
- typedef T value_type;
- typedef T const& reference;
- typedef T const* pointer;
- typedef std::ptrdiff_t difference_type;
- typedef std::random_access_iterator_tag iterator_category;
-};
-
-}} // namespace boost::detail
-
-# else
-
-# include <boost/type_traits/remove_const.hpp>
-# include <boost/type_traits/detail/yes_no_type.hpp>
-# include <boost/type_traits/is_pointer.hpp>
-
-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-# include <boost/type_traits/is_same.hpp>
-# include <boost/type_traits/remove_pointer.hpp>
-# endif
-# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
-# include <boost/type_traits/is_base_and_derived.hpp>
-# endif
-
-# include <boost/mpl/if.hpp>
-# include <boost/mpl/has_xxx.hpp>
-# include <cstddef>
-
-// should be the last #include
-# include "boost/type_traits/detail/bool_trait_def.hpp"
-
-namespace boost { namespace detail {
-
-BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(pointer)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(difference_type)
-BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category)
-
-// is_mutable_iterator --
-//
-// A metafunction returning true iff T is a mutable iterator type
-// with a nested value_type. Will only work portably with iterators
-// whose operator* returns a reference, but that seems to be OK for
-// the iterators supplied by Dinkumware. Some input iterators may
-// compile-time if they arrive here, and if the compiler is strict
-// about not taking the address of an rvalue.
-
-// This one detects ordinary mutable iterators - the result of
-// operator* is convertible to the value_type.
-template <class T>
-type_traits::yes_type is_mutable_iterator_helper(T const*, BOOST_DEDUCED_TYPENAME T::value_type*);
-
-// Since you can't take the address of an rvalue, the guts of
-// is_mutable_iterator_impl will fail if we use &*t directly. This
-// makes sure we can still work with non-lvalue iterators.
-template <class T> T* mutable_iterator_lvalue_helper(T& x);
-int mutable_iterator_lvalue_helper(...);
-
-
-// This one detects output iterators such as ostream_iterator which
-// return references to themselves.
-template <class T>
-type_traits::yes_type is_mutable_iterator_helper(T const*, T const*);
-
-type_traits::no_type is_mutable_iterator_helper(...);
-
-template <class T>
-struct is_mutable_iterator_impl
-{
- static T t;
-
- BOOST_STATIC_CONSTANT(
- bool, value = sizeof(
- detail::is_mutable_iterator_helper(
- (T*)0
- , mutable_iterator_lvalue_helper(*t) // like &*t
- ))
- == sizeof(type_traits::yes_type)
- );
-};
-
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
- is_mutable_iterator,T,::boost::detail::is_mutable_iterator_impl<T>::value)
-
-
-// is_full_iterator_traits --
-//
-// A metafunction returning true iff T has all the requisite nested
-// types to satisfy the requirements for a fully-conforming
-// iterator_traits implementation.
-template <class T>
-struct is_full_iterator_traits_impl
-{
- enum { value =
- has_value_type<T>::value
- & has_reference<T>::value
- & has_pointer<T>::value
- & has_difference_type<T>::value
- & has_iterator_category<T>::value
- };
-};
-
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
- is_full_iterator_traits,T,::boost::detail::is_full_iterator_traits_impl<T>::value)
+#define ITERATOR_DWA122600_HPP_
+// This header is obsolete and will be deprecated.
-# ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
-BOOST_MPL_HAS_XXX_TRAIT_DEF(_Iterator_category)
-
-// is_stlport_40_debug_iterator --
-//
-// A metafunction returning true iff T has all the requisite nested
-// types to satisfy the requirements of an STLPort 4.0 debug iterator
-// iterator_traits implementation.
-template <class T>
-struct is_stlport_40_debug_iterator_impl
-{
- enum { value =
- has_value_type<T>::value
- & has_reference<T>::value
- & has_pointer<T>::value
- & has_difference_type<T>::value
- & has__Iterator_category<T>::value
- };
-};
-
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(
- is_stlport_40_debug_iterator,T,::boost::detail::is_stlport_40_debug_iterator_impl<T>::value)
-
-template <class T>
-struct stlport_40_debug_iterator_traits
-{
- typedef typename T::value_type value_type;
- typedef typename T::reference reference;
- typedef typename T::pointer pointer;
- typedef typename T::difference_type difference_type;
- typedef typename T::_Iterator_category iterator_category;
-};
-# endif // BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
-
-template <class T> struct pointer_iterator_traits;
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct pointer_iterator_traits<T*>
-{
- typedef typename remove_const<T>::type value_type;
- typedef T* pointer;
- typedef T& reference;
- typedef std::random_access_iterator_tag iterator_category;
- typedef std::ptrdiff_t difference_type;
-};
-# else
-
-// In case of no template partial specialization, and if T is a
-// pointer, iterator_traits<T>::value_type can still be computed. For
-// some basic types, remove_pointer is manually defined in
-// type_traits/broken_compiler_spec.hpp. For others, do it yourself.
-
-template<class P> class please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee;
-
-template<class P>
-struct pointer_value_type
- : mpl::if_<
- is_same<P, typename remove_pointer<P>::type>
- , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P>
- , typename remove_const<
- typename remove_pointer<P>::type
- >::type
- >
-{
-};
-
-
-template<class P>
-struct pointer_reference
- : mpl::if_<
- is_same<P, typename remove_pointer<P>::type>
- , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<P>
- , typename remove_pointer<P>::type&
- >
-{
-};
-
-template <class T>
-struct pointer_iterator_traits
-{
- typedef T pointer;
- typedef std::random_access_iterator_tag iterator_category;
- typedef std::ptrdiff_t difference_type;
-
- typedef typename pointer_value_type<T>::type value_type;
- typedef typename pointer_reference<T>::type reference;
-};
-
-# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-// We'll sort iterator types into one of these classifications, from which we
-// can determine the difference_type, pointer, reference, and value_type
-template <class Iterator>
-struct standard_iterator_traits
-{
- typedef typename Iterator::difference_type difference_type;
- typedef typename Iterator::value_type value_type;
- typedef typename Iterator::pointer pointer;
- typedef typename Iterator::reference reference;
- typedef typename Iterator::iterator_category iterator_category;
-};
-
-template <class Iterator>
-struct msvc_stdlib_mutable_traits
- : std::iterator_traits<Iterator>
-{
- typedef typename std::iterator_traits<Iterator>::distance_type difference_type;
- typedef typename std::iterator_traits<Iterator>::value_type* pointer;
- typedef typename std::iterator_traits<Iterator>::value_type& reference;
-};
+#include <iterator>
-template <class Iterator>
-struct msvc_stdlib_const_traits
- : std::iterator_traits<Iterator>
+namespace boost
{
- typedef typename std::iterator_traits<Iterator>::distance_type difference_type;
- typedef const typename std::iterator_traits<Iterator>::value_type* pointer;
- typedef const typename std::iterator_traits<Iterator>::value_type& reference;
-};
-# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
-template <class Iterator>
-struct is_bad_output_iterator
- : is_base_and_derived<
- std::iterator<std::output_iterator_tag,void,void,void,void>
- , Iterator>
+namespace detail
{
-};
-struct bad_output_iterator_traits
-{
- typedef void value_type;
- typedef void difference_type;
- typedef std::output_iterator_tag iterator_category;
- typedef void pointer;
- typedef void reference;
-};
-# endif
-
-// If we're looking at an MSVC6 (old Dinkumware) ``standard''
-// iterator, this will generate an appropriate traits class.
-template <class Iterator>
-struct msvc_stdlib_iterator_traits
- : mpl::if_<
- is_mutable_iterator<Iterator>
- , msvc_stdlib_mutable_traits<Iterator>
- , msvc_stdlib_const_traits<Iterator>
- >::type
-{};
-
-template <class Iterator>
-struct non_pointer_iterator_traits
- : mpl::if_<
- // if the iterator contains all the right nested types...
- is_full_iterator_traits<Iterator>
- // Use a standard iterator_traits implementation
- , standard_iterator_traits<Iterator>
-# ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
- // Check for STLPort 4.0 broken _Iterator_category type
- , mpl::if_<
- is_stlport_40_debug_iterator<Iterator>
- , stlport_40_debug_iterator_traits<Iterator>
-# endif
- // Otherwise, assume it's a Dinkum iterator
- , msvc_stdlib_iterator_traits<Iterator>
-# ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
- >::type
-# endif
- >::type
-{
-};
-
-template <class Iterator>
-struct iterator_traits_aux
- : mpl::if_<
- is_pointer<Iterator>
- , pointer_iterator_traits<Iterator>
- , non_pointer_iterator_traits<Iterator>
- >::type
-{
-};
-
-template <class Iterator>
-struct iterator_traits
-{
- // Explicit forwarding from base class needed to keep MSVC6 happy
- // under some circumstances.
- private:
-# ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
- typedef
- typename mpl::if_<
- is_bad_output_iterator<Iterator>
- , bad_output_iterator_traits
- , iterator_traits_aux<Iterator>
- >::type base;
-# else
- typedef iterator_traits_aux<Iterator> base;
-# endif
- public:
- typedef typename base::value_type value_type;
- typedef typename base::pointer pointer;
- typedef typename base::reference reference;
- typedef typename base::difference_type difference_type;
- typedef typename base::iterator_category iterator_category;
-};
-
-// This specialization cuts off ETI (Early Template Instantiation) for MSVC.
-template <> struct iterator_traits<int>
-{
- typedef int value_type;
- typedef int pointer;
- typedef int reference;
- typedef int difference_type;
- typedef int iterator_category;
-};
-
-}} // namespace boost::detail
-
-# endif // workarounds
-
-namespace boost { namespace detail {
-
-namespace iterator_traits_
-{
- template <class Iterator, class Difference>
- struct distance_select
- {
- static Difference execute(Iterator i1, const Iterator i2, ...)
- {
- Difference result = 0;
- while (i1 != i2)
- {
- ++i1;
- ++result;
- }
- return result;
- }
-
- static Difference execute(Iterator i1, const Iterator i2, std::random_access_iterator_tag*)
- {
- return i2 - i1;
- }
- };
-} // namespace boost::detail::iterator_traits_
-
-template <class Iterator>
-inline typename iterator_traits<Iterator>::difference_type
-distance(Iterator first, Iterator last)
-{
- typedef typename iterator_traits<Iterator>::difference_type diff_t;
- typedef typename ::boost::detail::iterator_traits<Iterator>::iterator_category iterator_category;
-
- return iterator_traits_::distance_select<Iterator,diff_t>::execute(
- first, last, (iterator_category*)0);
-}
-
-}}
-
-# endif
+using std::iterator_traits;
+using std::distance;
+} // namespace detail
-# undef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
-# undef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION
+} // namespace boost
#endif // ITERATOR_DWA122600_HPP_
-#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
-#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * 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 _MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-//----------------------------------------------------------------------
-// (C) Copyright 2004 Pavel Vozenilek.
-// Use, modification and distribution is subject to 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)
-//
-//
-// This file contains helper macros used when exception support may be
-// disabled (as indicated by macro BOOST_NO_EXCEPTIONS).
-//
-// Before picking up these macros you may consider using RAII techniques
-// to deal with exceptions - their syntax can be always the same with
-// or without exception support enabled.
-//
-
-/* Example of use:
-
-void foo() {
- BOOST_TRY {
- ...
- } BOOST_CATCH(const std::bad_alloc&) {
- ...
- BOOST_RETHROW
- } BOOST_CATCH(const std::exception& e) {
- ...
- }
- BOOST_CATCH_END
-}
-
-With exception support enabled it will expand into:
+#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP
+#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP
-void foo() {
- { try {
- ...
- } catch (const std::bad_alloc&) {
- ...
- throw;
- } catch (const std::exception& e) {
- ...
- }
- }
-}
+// The header file at this path is deprecated;
+// use boost/core/no_exceptions_support.hpp instead.
-With exception support disabled it will expand into:
+#include <boost/core/no_exceptions_support.hpp>
-void foo() {
- { if(true) {
- ...
- } else if (false) {
- ...
- } else if (false) {
- ...
- }
- }
-}
-*/
-//----------------------------------------------------------------------
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#if !(defined BOOST_NO_EXCEPTIONS)
-# define BOOST_TRY { try
-# define BOOST_CATCH(x) catch(x)
-# define BOOST_RETHROW throw;
-# define BOOST_CATCH_END }
-#else
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-# define BOOST_TRY { if ("")
-# define BOOST_CATCH(x) else if (!"")
-# else
-# define BOOST_TRY { if (true)
-# define BOOST_CATCH(x) else if (false)
-# endif
-# define BOOST_RETHROW
-# define BOOST_CATCH_END }
#endif
-
-
-#endif
+++ /dev/null
-// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-// Use, modification and distribution are subject to 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/utility for most recent version including documentation.
-//
-// Crippled version for crippled compilers:
-// see libs/utility/call_traits.htm
-//
-
-/* Release notes:
- 01st October 2000:
- Fixed call_traits on VC6, using "poor man's partial specialisation",
- using ideas taken from "Generative programming" by Krzysztof Czarnecki
- & Ulrich Eisenecker.
-*/
-
-#ifndef BOOST_OB_CALL_TRAITS_HPP
-#define BOOST_OB_CALL_TRAITS_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#include <boost/config.hpp>
-#endif
-
-#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
-#include <boost/type_traits/arithmetic_traits.hpp>
-#endif
-#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
-#include <boost/type_traits/composite_traits.hpp>
-#endif
-
-namespace boost{
-
-#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
-//
-// use member templates to emulate
-// partial specialisation:
-//
-namespace detail{
-
-template <class T>
-struct standard_call_traits
-{
- typedef T value_type;
- typedef T& reference;
- typedef const T& const_reference;
- typedef const T& param_type;
-};
-template <class T>
-struct simple_call_traits
-{
- typedef T value_type;
- typedef T& reference;
- typedef const T& const_reference;
- typedef const T param_type;
-};
-template <class T>
-struct reference_call_traits
-{
- typedef T value_type;
- typedef T reference;
- typedef T const_reference;
- typedef T param_type;
-};
-
-template <bool pointer, bool arithmetic, bool reference>
-struct call_traits_chooser
-{
- template <class T>
- struct rebind
- {
- typedef standard_call_traits<T> type;
- };
-};
-
-template <>
-struct call_traits_chooser<true, false, false>
-{
- template <class T>
- struct rebind
- {
- typedef simple_call_traits<T> type;
- };
-};
-
-template <>
-struct call_traits_chooser<false, false, true>
-{
- template <class T>
- struct rebind
- {
- typedef reference_call_traits<T> type;
- };
-};
-
-template <bool size_is_small>
-struct call_traits_sizeof_chooser2
-{
- template <class T>
- struct small_rebind
- {
- typedef simple_call_traits<T> small_type;
- };
-};
-
-template<>
-struct call_traits_sizeof_chooser2<false>
-{
- template <class T>
- struct small_rebind
- {
- typedef standard_call_traits<T> small_type;
- };
-};
-
-template <>
-struct call_traits_chooser<false, true, false>
-{
- template <class T>
- struct rebind
- {
- enum { sizeof_choice = (sizeof(T) <= sizeof(void*)) };
- typedef call_traits_sizeof_chooser2<(sizeof(T) <= sizeof(void*))> chooser;
- typedef typename chooser::template small_rebind<T> bound_type;
- typedef typename bound_type::small_type type;
- };
-};
-
-} // namespace detail
-template <typename T>
-struct call_traits
-{
-private:
- typedef detail::call_traits_chooser<
- ::boost::is_pointer<T>::value,
- ::boost::is_arithmetic<T>::value,
- ::boost::is_reference<T>::value
- > chooser;
- typedef typename chooser::template rebind<T> bound_type;
- typedef typename bound_type::type call_traits_type;
-public:
- typedef typename call_traits_type::value_type value_type;
- typedef typename call_traits_type::reference reference;
- typedef typename call_traits_type::const_reference const_reference;
- typedef typename call_traits_type::param_type param_type;
-};
-
-#else
-//
-// sorry call_traits is completely non-functional
-// blame your broken compiler:
-//
-
-template <typename T>
-struct call_traits
-{
- typedef T value_type;
- typedef T& reference;
- typedef const T& const_reference;
- typedef const T& param_type;
-};
-
-#endif // member templates
-
-}
-
-#endif // BOOST_OB_CALL_TRAITS_HPP
#include "boost/config.hpp"
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
# include "boost/mpl/bool.hpp"
# include "boost/type_traits/has_nothrow_copy.hpp"
-#else
-# include "boost/mpl/if.hpp"
-# include "boost/type_traits/is_reference.hpp"
-#endif
#include "boost/mpl/void.hpp"
template <typename T = mpl::void_> struct make_reference_content;
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template <typename T>
struct make_reference_content
typedef reference_content<T&> type;
};
-#else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-
-template <typename T>
-struct make_reference_content
- : mpl::if_<
- is_reference<T>
- , reference_content<T>
- , T
- >
-{
-};
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround
template <>
struct make_reference_content< mpl::void_ >
// reference_content<T&> type traits specializations
//
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template <typename T>
struct has_nothrow_copy<
{
};
-#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
} // namespace boost
// detail/sp_typeinfo.hpp
//
+// Deprecated, please use boost/core/typeinfo.hpp
+//
// Copyright 2007 Peter Dimov
//
-// 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_TYPEID )
-
-#include <boost/current_function.hpp>
-#include <functional>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class sp_typeinfo
-{
-private:
-
- sp_typeinfo( sp_typeinfo const& );
- sp_typeinfo& operator=( sp_typeinfo const& );
-
- char const * name_;
-
-public:
-
- explicit sp_typeinfo( char const * name ): name_( name )
- {
- }
-
- bool operator==( sp_typeinfo const& rhs ) const
- {
- return this == &rhs;
- }
-
- bool operator!=( sp_typeinfo const& rhs ) const
- {
- return this != &rhs;
- }
-
- bool before( sp_typeinfo const& rhs ) const
- {
- return std::less< sp_typeinfo const* >()( this, &rhs );
- }
-
- char const* name() const
- {
- return name_;
- }
-};
-
-template<class T> struct sp_typeid_
-{
- static sp_typeinfo ti_;
-
- static char const * name()
- {
- return BOOST_CURRENT_FUNCTION;
- }
-};
+// 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(__SUNPRO_CC)
-// see #4199, the Sun Studio compiler gets confused about static initialization
-// constructor arguments. But an assignment works just fine.
-template<class T> sp_typeinfo sp_typeid_< T >::ti_ = sp_typeid_< T >::name();
-#else
-template<class T> sp_typeinfo sp_typeid_< T >::ti_(sp_typeid_< T >::name());
-#endif
-
-template<class T> struct sp_typeid_< T & >: sp_typeid_< T >
-{
-};
-
-template<class T> struct sp_typeid_< T const >: sp_typeid_< T >
-{
-};
-
-template<class T> struct sp_typeid_< T volatile >: sp_typeid_< T >
-{
-};
-
-template<class T> struct sp_typeid_< T const volatile >: sp_typeid_< T >
-{
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#define BOOST_SP_TYPEID(T) (boost::detail::sp_typeid_<T>::ti_)
-
-#else
-
-#include <typeinfo>
+#include <boost/core/typeinfo.hpp>
namespace boost
{
namespace detail
{
-#if defined( BOOST_NO_STD_TYPEINFO )
-
-typedef ::type_info sp_typeinfo;
-
-#else
-
-typedef std::type_info sp_typeinfo;
-
-#endif
+typedef boost::core::typeinfo sp_typeinfo;
} // namespace detail
} // namespace boost
-#define BOOST_SP_TYPEID(T) typeid(T)
-
-#endif
+#define BOOST_SP_TYPEID(T) BOOST_CORE_TYPEID(T)
#endif // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED
+++ /dev/null
-//Copyright (c) 2009 Emil Dotchevski and Reverge Studios, Inc.
-
-//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)
-
-#ifndef UUID_61531AB0680611DEADD5846855D89593
-#define UUID_61531AB0680611DEADD5846855D89593
-
-#if defined(_MSC_VER)
-#define BOOST_ATTRIBUTE_NORETURN __declspec(noreturn)
-#elif defined(__GNUC__)
-#define BOOST_ATTRIBUTE_NORETURN __attribute__((__noreturn__))
-#else
-#define BOOST_ATTRIBUTE_NORETURN
-#endif
-
-#endif
class
exception
{
+ //<N3757>
+ public:
+ template <class Tag> void set( typename Tag::type const & );
+ template <class Tag> typename Tag::type const * get() const;
+ //</N3757>
+
protected:
exception():
#define BOOST_NO_OVERLOAD_FOR_NON_CONST
#endif
-// gcc-2.95's native stringstream is not usable
-#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
-#define BOOST_FORMAT_IGNORE_STRINGSTREAM
-#endif
-
-
// **** Workaround for io streams, stlport and msvc.
#ifdef BOOST_IO_NEEDS_USING_DECLARATION
namespace boost {
// -end N.S. boost
#endif // needs_using_declaration
+#if ! defined(BOOST_NO_STD_LOCALE)
+#include <locale>
+#endif
+
// *** hide std::locale if it doesnt exist.
// this typedef is either std::locale or int, avoids placing ifdefs everywhere
#ifndef BOOST_MSVC_DISAMBIGUATER_HPP
#define BOOST_MSVC_DISAMBIGUATER_HPP
-#if BOOST_WORKAROUND( BOOST_MSVC, <= 1300) || \
- BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
- // this whole header is specifically for msvc up to 7.0
+#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
#include <boost/format/group.hpp>
#include <ostream>
} // namespace io
} // namespace boost
-#endif // -BOOST_MSVC
+#endif // -__DECCXX_VER
#endif // -BOOST_MSVC_DISAMBIGUATER_HPP
#ifndef BOOST_MACROS_STLPORT_HPP
#define BOOST_MACROS_STLPORT_HPP
-#if defined(_STLPORT_VERSION) && BOOST_WORKAROUND( BOOST_MSVC, <= 1300)
-// msvc-6-stlport fails to find basic_string::append( iterator, iterator) when linking
-// might affect other MSwindows compilers
-#define BOOST_NO_STRING_APPEND
-#endif
-
// *** This should go to "boost/config/stdlib/stlport.hpp".
// If the streams are not native and there are problems with using templates
} // -mk_str(..)
-#if BOOST_WORKAROUND( BOOST_MSVC, <= 1300) || \
- BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
-// MSVC needs to be tricked to disambiguate this simple overload..
+#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
+// __DECCXX needs to be tricked to disambiguate this simple overload..
// the trick is in "boost/format/msvc_disambiguater.hpp"
template< class Ch, class Tr, class T> inline
os << x ;
}
#endif
-#endif // -msvc workaround
+#endif // -__DECCXX workaround
+
+ template< class Ch, class Tr, class T>
+ void call_put_head(BOOST_IO_STD basic_ostream<Ch, Tr> & os, const void* x) {
+ put_head(os, *(typename ::boost::remove_reference<T>::type*)x);
+ }
+
+ template< class Ch, class Tr, class T>
+ void call_put_last(BOOST_IO_STD basic_ostream<Ch, Tr> & os, const void* x) {
+ put_last(os, *(T*)x);
+ }
+
+ template< class Ch, class Tr>
+ struct put_holder {
+ template<class T>
+ put_holder(T& t)
+ : arg(&t),
+ put_head(&call_put_head<Ch, Tr, T>),
+ put_last(&call_put_last<Ch, Tr, T>)
+ {}
+ const void* arg;
+ void (*put_head)(BOOST_IO_STD basic_ostream<Ch, Tr> & os, const void* x);
+ void (*put_last)(BOOST_IO_STD basic_ostream<Ch, Tr> & os, const void* x);
+ };
+
+ template< class Ch, class Tr> inline
+ void put_head( BOOST_IO_STD basic_ostream<Ch, Tr> & os, const put_holder<Ch, Tr>& t) {
+ t.put_head(os, t.arg);
+ }
+
+ template< class Ch, class Tr> inline
+ void put_last( BOOST_IO_STD basic_ostream<Ch, Tr> & os, const put_holder<Ch, Tr>& t) {
+ t.put_last(os, t.arg);
+ }
template< class Ch, class Tr, class Alloc, class T>
template<class Ch, class Tr, class Alloc, class T>
basic_format<Ch, Tr, Alloc>&
- feed (basic_format<Ch,Tr, Alloc>& self, T x) {
+ feed_impl (basic_format<Ch,Tr, Alloc>& self, T x) {
if(self.dumped_) self.clear();
distribute<Ch, Tr, Alloc, T> (self, x);
++self.cur_arg_;
}
return self;
}
+
+ template<class Ch, class Tr, class Alloc, class T> inline
+ basic_format<Ch, Tr, Alloc>&
+ feed (basic_format<Ch,Tr, Alloc>& self, T x) {
+ return feed_impl<Ch, Tr, Alloc, const put_holder<Ch, Tr>&>(self, put_holder<Ch, Tr>(x));
+ }
} // namespace detail
} // namespace io
template<class Ch2, class Tr2, class Alloc2, class T>
friend basic_format<Ch2, Tr2, Alloc2>&
- io::detail::feed (basic_format<Ch2, Tr2, Alloc2>&, T);
+ io::detail::feed_impl (basic_format<Ch2, Tr2, Alloc2>&, T);
template<class Ch2, class Tr2, class Alloc2, class T> friend
void io::detail::distribute (basic_format<Ch2, Tr2, Alloc2>&, T);
namespace boost {
template <class Ch,
-#if !( BOOST_WORKAROUND(__GNUC__, <3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) )
- // gcc-2.95's native stdlid needs special treatment
- class Tr = BOOST_IO_STD char_traits<Ch>, class Alloc = std::allocator<Ch> >
-#else
- class Tr = std::string_char_traits<Ch>, class Alloc = std::alloc >
-#endif
+ class Tr = BOOST_IO_STD char_traits<Ch>, class Alloc = std::allocator<Ch> >
class basic_format;
typedef basic_format<char > format;
-#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_STD_WSTREAMBUF) \
- && !defined(BOOST_FORMAT_IGNORE_STRINGSTREAM)
+#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_STD_WSTREAMBUF)
typedef basic_format<wchar_t > wformat;
#endif
template<class Ch, class Tr>
void stream_format_state<Ch,Tr>:: apply_on (basic_ios & os,
boost::io::detail::locale_t * loc_default) const {
+ // If a locale is available, set it first. "os.fill(fill_);" may chrash otherwise.
+#if !defined(BOOST_NO_STD_LOCALE)
+ if(loc_)
+ os.imbue(loc_.get());
+ else if(loc_default)
+ os.imbue(*loc_default);
+#else
+ (void) loc_default; // keep compiler quiet if we don't support locales
+#endif
// set the state of this stream according to our params
if(width_ != -1)
os.width(width_);
os.flags(flags_);
os.clear(rdstate_);
os.exceptions(exceptions_);
-#if !defined(BOOST_NO_STD_LOCALE)
- if(loc_)
- os.imbue(loc_.get());
- else if(loc_default)
- os.imbue(*loc_default);
-#else
- (void) loc_default; // keep compiler quiet if we don't support locales
-#endif
}
template<class Ch, class Tr>
template<class Ch, class Tr, class Alloc, class T>
basic_format<Ch, Tr, Alloc>&
feed (basic_format<Ch,Tr, Alloc>& self, T x);
+
+ template<class Ch, class Tr, class Alloc, class T>
+ basic_format<Ch, Tr, Alloc>&
+ feed_impl (basic_format<Ch,Tr, Alloc>& self, T x);
} // namespace detail
void append_string(String& dst, const String& src,
const typename String::size_type beg,
const typename String::size_type end) {
-#if !defined(BOOST_NO_STRING_APPEND)
dst.append(src.begin()+beg, src.begin()+end);
-#else
- dst += src.substr(beg, end-beg);
-#endif
}
} // detail namespace
if( !ordered_args) {
if(max_argN >= 0 ) { // dont mix positional with non-positionnal directives
if(exceptions() & io::bad_format_string_bit)
- boost::throw_exception(io::bad_format_string(max_argN, 0));
+ boost::throw_exception(
+ io::bad_format_string(static_cast<std::size_t>(max_argN), 0));
// else do nothing. => positionnal arguments are processed as non-positionnal
}
// set things like it would have been with positional directives :
// need to use std::type_info::name to compare instead of operator==.
#if defined( BOOST_NO_TYPEID )
# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
-#elif (defined(__GNUC__) && __GNUC__ >= 3) \
+#elif defined(__GNUC__) \
|| defined(_AIX) \
|| ( defined(__sgi) && defined(__host_mips))
# include <cstring>
# define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
#endif
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
+#if defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
# define BOOST_FUNCTION_TARGET_FIX(x) x
#else
# define BOOST_FUNCTION_TARGET_FIX(x)
-#endif // not MSVC
+#endif // __ICL etc
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
# define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) \
} else if (op == destroy_functor_tag)
out_buffer.func_ptr = 0;
else if (op == check_functor_type_tag) {
- const detail::sp_typeinfo& check_type
+ const boost::detail::sp_typeinfo& check_type
= *out_buffer.type.type;
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
out_buffer.obj_ptr = &in_buffer.func_ptr;
}
template<typename Functor>
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- const Functor* target( Functor * = 0 ) const
-#else
const Functor* target() const
-#endif
{
if (!vtable) return 0;
template<typename F>
bool contains(const F& f) const
{
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- if (const F* fp = this->target( (F*)0 ))
-#else
if (const F* fp = this->template target<F>())
-#endif
{
return function_equal(*fp, f);
} else {
}}}
#endif
-#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
- || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
+#if defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
|| !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
# define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
#endif
#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
-#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+# define BOOST_FUNCTION_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, a)
+#else
+# include <boost/move/utility_core.hpp>
+# define BOOST_FUNCTION_ARG(J,I,D) ::boost::forward< BOOST_PP_CAT(T,I) >(BOOST_PP_CAT(a,I))
+# define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+#endif
#define BOOST_FUNCTION_ARG_TYPE(J,I,D) \
typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
template<typename Functor>
void assign_to(Functor f)
{
- using detail::function::vtable_base;
+ using boost::detail::function::vtable_base;
- typedef typename detail::function::get_function_tag<Functor>::type tag;
- typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+ typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+ typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
typedef typename get_invoker::
template apply<Functor, R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS>
if (stored_vtable.assign_to(f, functor)) {
std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+ // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
if (boost::has_trivial_copy_constructor<Functor>::value &&
boost::has_trivial_destructor<Functor>::value &&
- detail::function::function_allows_small_object_optimization<Functor>::value)
- value |= static_cast<size_t>(0x01);
- vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+ boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+ value |= static_cast<std::size_t>(0x01);
+ vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
} else
vtable = 0;
}
template<typename Functor,typename Allocator>
void assign_to_a(Functor f,Allocator a)
{
- using detail::function::vtable_base;
+ using boost::detail::function::vtable_base;
- typedef typename detail::function::get_function_tag<Functor>::type tag;
- typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+ typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+ typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
typedef typename get_invoker::
template apply_a<Functor, R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_ARGS,
if (stored_vtable.assign_to_a(f, functor, a)) {
std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+ // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
if (boost::has_trivial_copy_constructor<Functor>::value &&
boost::has_trivial_destructor<Functor>::value &&
- detail::function::function_allows_small_object_optimization<Functor>::value)
+ boost::detail::function::function_allows_small_object_optimization<Functor>::value)
value |= static_cast<std::size_t>(0x01);
- vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+ vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
} else
vtable = 0;
}
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
#undef BOOST_FUNCTION_PARM
+#ifdef BOOST_FUNCTION_ARG
+# undef BOOST_FUNCTION_ARG
+#endif
#undef BOOST_FUNCTION_ARGS
#undef BOOST_FUNCTION_ARG_TYPE
#undef BOOST_FUNCTION_ARG_TYPES
// Boost functional.hpp header file
// See http://www.boost.org/libs/functional for documentation.
// ------------------------------------------------------------------------------
-// $Id: functional.hpp 36246 2006-12-02 14:17:26Z andreas_huber69 $
+// $Id$
// ------------------------------------------------------------------------------
#ifndef BOOST_FUNCTIONAL_HPP
#define BOOST_FUNCTIONAL_HASH_DETAIL_FLOAT_FUNCTIONS_HPP
#include <boost/config.hpp>
-#include <boost/config/no_tr1/cmath.hpp>
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
#endif
+#include <boost/config/no_tr1/cmath.hpp>
+
// Set BOOST_HASH_CONFORMANT_FLOATS to 1 for libraries known to have
// sufficiently good floating point support to not require any
// workarounds.
#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER)
#define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
#endif
-#include <boost/config.hpp>
#include <boost/functional/hash/detail/float_functions.hpp>
#include <boost/functional/hash/detail/limits.hpp>
#include <boost/utility/enable_if.hpp>
std::size_t seed = 0;
if (length >= sizeof(std::size_t)) {
- seed = *(std::size_t*) ptr;
+ std::memcpy(&seed, ptr, sizeof(std::size_t));
length -= sizeof(std::size_t);
ptr += sizeof(std::size_t);
#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER)
#define BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
#endif
#include <boost/limits.hpp>
#if !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
#define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
#include <boost/functional/hash/hash.hpp>
#include <boost/detail/container_fwd.hpp>
#include <boost/utility/enable_if.hpp>
# include <memory>
#endif
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
#include <boost/type_traits/is_array.hpp>
#endif
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-#include <boost/type_traits/is_const.hpp>
-#endif
-
namespace boost
{
template <class A, class B>
template <class Array>
struct inner
{
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
static std::size_t call(Array const& v)
-#else
- static std::size_t call(Array& v)
-#endif
{
const int size = sizeof(v) / sizeof(*v);
return boost::hash_range(v, v + size);
template <bool IsPointer>
struct hash_impl;
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-
template <>
struct hash_impl<false>
{
#endif
};
};
-
-#else // Visual C++ 6.5
-
- // Visual C++ 6.5 has problems with nested member functions and
- // applying const to const types in templates. So we get this:
-
- template <bool IsConst>
- struct hash_impl_msvc
- {
- template <class T>
- struct inner
- : public std::unary_function<T, std::size_t>
- {
- std::size_t operator()(T const& val) const
- {
- return hash_detail::call_hash<T const>::call(val);
- }
-
- std::size_t operator()(T& val) const
- {
- return hash_detail::call_hash<T>::call(val);
- }
- };
- };
-
- template <>
- struct hash_impl_msvc<true>
- {
- template <class T>
- struct inner
- : public std::unary_function<T, std::size_t>
- {
- std::size_t operator()(T& val) const
- {
- return hash_detail::call_hash<T>::call(val);
- }
- };
- };
-
- template <class T>
- struct hash_impl_msvc2
- : public hash_impl_msvc<boost::is_const<T>::value>
- ::BOOST_NESTED_TEMPLATE inner<T> {};
-
- template <>
- struct hash_impl<false>
- {
- template <class T>
- struct inner : public hash_impl_msvc2<T> {};
- };
-
-#endif // Visual C++ 6.5
}
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
}
-// Copyright 2005-2009 Daniel James.
+// Copyright 2005-2014 Daniel James.
// 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)
// Based on Peter Dimov's proposal
// http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
// issue 6.18.
+//
+// This also contains public domain code from MurmurHash. From the
+// MurmurHash header:
+
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
#if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP)
#define BOOST_FUNCTIONAL_HASH_HASH_HPP
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/utility/enable_if.hpp>
+#include <boost/cstdint.hpp>
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
#include <boost/type_traits/is_pointer.hpp>
#if defined(BOOST_MSVC)
#pragma warning(push)
+
+#if BOOST_MSVC >= 1400
#pragma warning(disable:6295) // Ill-defined for-loop : 'unsigned int' values
// are always of range '0' to '4294967295'.
// Loop executes infinitely.
#endif
+#endif
+
#if BOOST_WORKAROUND(__GNUC__, < 3) \
&& !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
#define BOOST_HASH_CHAR_TRAITS string_char_traits
#define BOOST_HASH_CHAR_TRAITS char_traits
#endif
+#if defined(_MSC_VER)
+# define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) _rotl(x,r)
+#else
+# define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r))
+#endif
+
namespace boost
{
namespace hash_detail
return seed;
}
+
+ template <typename SizeT>
+ inline void hash_combine_impl(SizeT& seed, SizeT value)
+ {
+ seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
+ }
+
+ template <typename SizeT>
+ inline void hash_combine_impl(boost::uint32_t& h1,
+ boost::uint32_t k1)
+ {
+ const uint32_t c1 = 0xcc9e2d51;
+ const uint32_t c2 = 0x1b873593;
+
+ k1 *= c1;
+ k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15);
+ k1 *= c2;
+
+ h1 ^= k1;
+ h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13);
+ h1 = h1*5+0xe6546b64;
+ }
+
+
+// Don't define 64-bit hash combine on platforms with 64 bit integers,
+// and also not for 32-bit gcc as it warns about the 64-bit constant.
+#if !defined(BOOST_NO_INT64_T) && \
+ !(defined(__GNUC__) && ULONG_MAX == 0xffffffff)
+
+ template <typename SizeT>
+ inline void hash_combine_impl(boost::uint64_t& h,
+ boost::uint64_t k)
+ {
+ const uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
+ const int r = 47;
+
+ k *= m;
+ k ^= k >> r;
+ k *= m;
+
+ h ^= k;
+ h *= m;
+ }
+
+#endif // BOOST_NO_INT64_T
}
template <typename T>
#endif
#endif
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- template <class T>
- inline void hash_combine(std::size_t& seed, T& v)
-#else
template <class T>
inline void hash_combine(std::size_t& seed, T const& v)
-#endif
{
boost::hash<T> hasher;
- seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+ return boost::hash_detail::hash_combine_impl(seed, hasher(v));
}
#if defined(BOOST_MSVC)
//
// These are undefined later.
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-#define BOOST_HASH_SPECIALIZE(type) \
- template <> struct hash<type> \
- : public std::unary_function<type, std::size_t> \
- { \
- std::size_t operator()(type v) const \
- { \
- return boost::hash_value(v); \
- } \
- };
-
-#define BOOST_HASH_SPECIALIZE_REF(type) \
- template <> struct hash<type> \
- : public std::unary_function<type, std::size_t> \
- { \
- std::size_t operator()(type const& v) const \
- { \
- return boost::hash_value(v); \
- } \
- };
-#else
#define BOOST_HASH_SPECIALIZE(type) \
template <> struct hash<type> \
: public std::unary_function<type, std::size_t> \
{ \
return boost::hash_value(v); \
} \
- }; \
- \
- template <> struct hash<const type> \
- : public std::unary_function<const type, std::size_t> \
- { \
- std::size_t operator()(const type v) const \
- { \
- return boost::hash_value(v); \
- } \
};
#define BOOST_HASH_SPECIALIZE_REF(type) \
{ \
return boost::hash_value(v); \
} \
- }; \
- \
- template <> struct hash<const type> \
- : public std::unary_function<const type, std::size_t> \
- { \
- std::size_t operator()(type const& v) const \
- { \
- return boost::hash_value(v); \
- } \
};
-#endif
BOOST_HASH_SPECIALIZE(bool)
BOOST_HASH_SPECIALIZE(char)
}
#undef BOOST_HASH_CHAR_TRAITS
+#undef BOOST_FUNCTIONAL_HASH_ROTL32
#if defined(BOOST_MSVC)
#pragma warning(pop)
#if !defined(BOOST_FUNCTIONAL_HASH_FWD_HPP)
#define BOOST_FUNCTIONAL_HASH_FWD_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
#endif
-#include <boost/config.hpp>
#include <cstddef>
#include <boost/detail/workaround.hpp>
{
template <class T> struct hash;
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- template <class T> void hash_combine(std::size_t& seed, T& v);
-#else
template <class T> void hash_combine(std::size_t& seed, T const& v);
-#endif
template <class It> std::size_t hash_range(It, It);
template <class It> void hash_range(std::size_t&, It, It);
// 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/functional/hash/hash_fwd.hpp>
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+#include <boost/functional/hash/hash_fwd.hpp>
// fast integers from least integers
// int_fast_t<> works correctly for unsigned too, in spite of the name.
template< typename LeastInt >
- struct int_fast_t
- {
- typedef LeastInt fast;
+ struct int_fast_t
+ {
+ typedef LeastInt fast;
typedef fast type;
}; // imps may specialize
namespace detail{
- // convert category to type
+ // convert category to type
template< int Category > struct int_least_helper {}; // default is empty
template< int Category > struct uint_least_helper {}; // default is empty
template <> struct exact_signed_base_helper<sizeof(int)* CHAR_BIT> { typedef int exact; };
template <> struct exact_unsigned_base_helper<sizeof(unsigned int)* CHAR_BIT> { typedef unsigned int exact; };
#endif
-#if ULONG_MAX != UINT_MAX
+#if ULONG_MAX != UINT_MAX && ( !defined __TI_COMPILER_VERSION__ || \
+ ( __TI_COMPILER_VERSION__ >= 7000000 && !defined __TI_40BIT_LONG__ ) )
template <> struct exact_signed_base_helper<sizeof(long)* CHAR_BIT> { typedef long exact; };
template <> struct exact_unsigned_base_helper<sizeof(unsigned long)* CHAR_BIT> { typedef unsigned long exact; };
#endif
// signed
template< int Bits > // bits (including sign) required
- struct int_t : public detail::exact_signed_base_helper<Bits>
+ struct int_t : public boost::detail::exact_signed_base_helper<Bits>
{
BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::intmax_t) * CHAR_BIT),
"No suitable signed integer type with the requested number of bits is available.");
- typedef typename detail::int_least_helper
+ typedef typename boost::detail::int_least_helper
<
#ifdef BOOST_HAS_LONG_LONG
(Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
// unsigned
template< int Bits > // bits required
- struct uint_t : public detail::exact_unsigned_base_helper<Bits>
+ struct uint_t : public boost::detail::exact_unsigned_base_helper<Bits>
{
BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::uintmax_t) * CHAR_BIT),
"No suitable unsigned integer type with the requested number of bits is available.");
#if (defined(__BORLANDC__) || defined(__CODEGEAR__)) && defined(BOOST_NO_INTEGRAL_INT64_T)
// It's really not clear why this workaround should be needed... shrug I guess! JM
- BOOST_STATIC_CONSTANT(int, s =
+ BOOST_STATIC_CONSTANT(int, s =
6 +
(Bits <= ::std::numeric_limits<unsigned long>::digits) +
(Bits <= ::std::numeric_limits<unsigned int>::digits) +
(Bits <= ::std::numeric_limits<unsigned char>::digits));
typedef typename detail::int_least_helper< ::boost::uint_t<Bits>::s>::least least;
#else
- typedef typename detail::uint_least_helper
- <
+ typedef typename boost::detail::uint_least_helper
+ <
#ifdef BOOST_HAS_LONG_LONG
(Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
#else
// integer templates specifying extreme value ----------------------------//
// signed
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
template< boost::long_long_type MaxValue > // maximum value to require support
#else
template< long MaxValue > // maximum value to require support
#endif
- struct int_max_value_t
+ struct int_max_value_t
{
- typedef typename detail::int_least_helper
+ typedef typename boost::detail::int_least_helper
<
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
(MaxValue <= ::boost::integer_traits<boost::long_long_type>::const_max) +
#else
1 +
typedef typename int_fast_t<least>::type fast;
};
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
template< boost::long_long_type MinValue > // minimum value to require support
#else
template< long MinValue > // minimum value to require support
#endif
- struct int_min_value_t
+ struct int_min_value_t
{
- typedef typename detail::int_least_helper
+ typedef typename boost::detail::int_least_helper
<
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
(MinValue >= ::boost::integer_traits<boost::long_long_type>::const_min) +
#else
1 +
#else
template< unsigned long MaxValue > // minimum value to require support
#endif
- struct uint_value_t
+ struct uint_value_t
{
#if (defined(__BORLANDC__) || defined(__CODEGEAR__))
// It's really not clear why this workaround should be needed... shrug I guess! JM
#if defined(BOOST_NO_INTEGRAL_INT64_T)
- BOOST_STATIC_CONSTANT(unsigned, which =
+ BOOST_STATIC_CONSTANT(unsigned, which =
1 +
(MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
(MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
(MaxValue <= ::boost::integer_traits<unsigned char>::const_max));
typedef typename detail::int_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
#else // BOOST_NO_INTEGRAL_INT64_T
- BOOST_STATIC_CONSTANT(unsigned, which =
+ BOOST_STATIC_CONSTANT(unsigned, which =
1 +
(MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
(MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
typedef typename detail::uint_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
#endif // BOOST_NO_INTEGRAL_INT64_T
#else
- typedef typename detail::uint_least_helper
- <
+ typedef typename boost::detail::uint_least_helper
+ <
#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
(MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
#else
template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
struct static_unsigned_max;
+
+// From <boost/integer/common_factor_ct.hpp>
+
+#ifdef BOOST_NO_INTEGRAL_INT64_T
+ typedef unsigned long static_gcd_type;
+#else
+ typedef boost::uintmax_t static_gcd_type;
+#endif
+
+template < static_gcd_type Value1, static_gcd_type Value2 >
+ struct static_gcd;
+template < static_gcd_type Value1, static_gcd_type Value2 >
+ struct static_lcm;
+
+
+// From <boost/integer/common_factor_rt.hpp>
+
+template < typename IntegerType >
+ class gcd_evaluator;
+template < typename IntegerType >
+ class lcm_evaluator;
+
+
} // namespace boost
* accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
- * $Id: integer_traits.hpp 85813 2013-09-21 20:17:00Z jewillco $
+ * $Id$
*
* Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers
*/
// - Mac OS X with native library
// - gcc on FreeBSD, OpenBSD and NetBSD
public detail::integer_traits_base<wchar_t, INT_MIN, INT_MAX>
-#elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !defined(__SGI_STL_PORT)
- // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigned int.
- // - gcc 2.95.x on HP-UX
- // (also, std::numeric_limits<wchar_t> appears to return the wrong values).
- public detail::integer_traits_base<wchar_t, 0, UINT_MAX>
#else
#error No WCHAR_MIN and WCHAR_MAX present, please adjust integer_traits<> for your compiler.
#endif
-// iterator.hpp workarounds for non-conforming standard libraries ---------//
-
// (C) Copyright Beman Dawes 2000. 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/utility for documentation.
-
-// Revision History
-// 12 Jan 01 added <cstddef> for std::ptrdiff_t (Jens Maurer)
-// 28 Jun 00 Workarounds to deal with known MSVC bugs (David Abrahams)
-// 26 Jun 00 Initial version (Jeremy Siek)
-
#ifndef BOOST_ITERATOR_HPP
#define BOOST_ITERATOR_HPP
+// This header is obsolete and will be deprecated.
+
#include <iterator>
#include <cstddef> // std::ptrdiff_t
-#include <boost/config.hpp>
namespace boost
{
-# if defined(BOOST_NO_STD_ITERATOR) && !defined(BOOST_MSVC_STD_ITERATOR)
- template <class Category, class T,
- class Distance = std::ptrdiff_t,
- class Pointer = T*, class Reference = T&>
- struct iterator
- {
- typedef T value_type;
- typedef Distance difference_type;
- typedef Pointer pointer;
- typedef Reference reference;
- typedef Category iterator_category;
- };
-# else
- // declare iterator_base in namespace detail to work around MSVC bugs which
- // prevent derivation from an identically-named class in a different namespace.
- namespace detail {
- template <class Category, class T, class Distance, class Pointer, class Reference>
-# if !defined(BOOST_MSVC_STD_ITERATOR)
- struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
-# else
- struct iterator_base : std::iterator<Category, T, Distance>
- {
- typedef Reference reference;
- typedef Pointer pointer;
- typedef Distance difference_type;
- };
-# endif
- }
+using std::iterator;
- template <class Category, class T, class Distance = std::ptrdiff_t,
- class Pointer = T*, class Reference = T&>
- struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
-# endif
} // namespace boost
#endif // BOOST_ITERATOR_HPP
#endif
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0)) \
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x5A0)) \
|| (BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700) && defined(_MSC_VER)) \
|| BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042)) \
|| BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
# define BOOST_NO_IS_CONVERTIBLE // "is_convertible doesn't work for simple types"
#endif
-#if BOOST_WORKAROUND(__GNUC__, == 2) \
- || BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__) \
+#if BOOST_WORKAROUND(__GNUC__, == 3) && BOOST_WORKAROUND(__GNUC_MINOR__, < 4) && !defined(__EDG_VERSION__) \
|| BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
# define BOOST_NO_IS_CONVERTIBLE_TEMPLATE // The following program fails to compile:
# define BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
#endif
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-# define BOOST_ARG_DEPENDENT_TYPENAME typename
-# else
-# define BOOST_ARG_DEPENDENT_TYPENAME
-# endif
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-# if BOOST_WORKAROUND(__GNUC__, == 2) && BOOST_WORKAROUND(__GNUC_MINOR__, BOOST_TESTED_AT(95)) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-
-// GCC-2.95 eagerly instantiates templated constructors and conversion
+// GCC-2.95 (obsolete) eagerly instantiates templated constructors and conversion
// operators in convertibility checks, causing premature errors.
//
// Borland's problems are harder to diagnose due to lack of an
#undef BOOST_NO_IS_CONVERTIBLE
#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-#undef BOOST_ARG_DEPENDENT_TYPENAME
#undef BOOST_NO_LVALUE_RETURN_DETECTION
#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
typedef T type;
};
};
-
+
//
// For compilers that don't support "Substitution Failure Is Not An Error"
// enable_if falls back to always enabled. See comments
: enabled<(Cond::value)>::template base<Return>
# else
: mpl::identity<Return>
-# endif
+# endif
{
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- typedef Return type;
-# endif
};
} // namespace iterators
// iterator_category deduction for iterator_facade
//
+namespace boost {
+namespace iterators {
+
// forward declaration
-namespace boost { struct use_default; }
+struct use_default;
-namespace boost { namespace detail {
+namespace detail {
struct input_output_iterator_tag
: std::input_iterator_tag
, boost::detail::indirect_traits::is_reference_to_const<Reference>
, is_const<ValueParam>
>
-# else
+# else
: is_const<ValueParam>
-# endif
+# endif
{};
// Convert an iterator_facade's traversal category, Value parameter,
// and ::reference type to an appropriate old-style category.
//
-// If writability has been disabled per the above metafunction, the
-// result will not be convertible to output_iterator_tag.
-//
-// Otherwise, if Traversal == single_pass_traversal_tag, the following
-// conditions will result in a tag that is convertible both to
-// input_iterator_tag and output_iterator_tag:
-//
-// 1. Reference is a reference to non-const
-// 2. Reference is not a reference and is convertible to Value
+// Due to changeset 21683, this now never results in a category convertible
+// to output_iterator_tag.
//
+// Change at: https://svn.boost.org/trac/boost/changeset/21683
template <class Traversal, class ValueParam, class Reference>
struct iterator_facade_default_category
: mpl::eval_if<
, typename mpl::eval_if<
mpl::and_<
is_convertible<Traversal, single_pass_traversal_tag>
-
+
// check for readability
, is_convertible<Reference, ValueParam>
>
struct iterator_category_with_traversal
: Category, Traversal
{
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
// Make sure this isn't used to build any categories where
// convertibility to Traversal is redundant. Should just use the
// Category element in that case.
BOOST_MPL_ASSERT_NOT((is_iterator_traversal<Category>));
# if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
BOOST_MPL_ASSERT((is_iterator_traversal<Traversal>));
-# endif
-# endif
+# endif
};
// Computes an iterator_category tag whose traversal is Traversal and
template <class Traversal, class ValueParam, class Reference>
struct facade_iterator_category_impl
{
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
BOOST_MPL_ASSERT_NOT((is_iterator_category<Traversal>));
-# endif
-
+
typedef typename iterator_facade_default_category<
Traversal,ValueParam,Reference
>::type category;
-
+
typedef typename mpl::if_<
is_same<
Traversal
{
};
-}} // namespace boost::detail
+}}} // namespace boost::iterators::detail
# include <boost/iterator/detail/config_undef.hpp>
+++ /dev/null
-// Copyright David Abrahams 2003. Use, modification and distribution is
-// subject to 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)
-#ifndef MINIMUM_CATEGORY_DWA20031119_HPP
-# define MINIMUM_CATEGORY_DWA20031119_HPP
-
-# include <boost/type_traits/is_convertible.hpp>
-# include <boost/type_traits/is_same.hpp>
-
-# include <boost/mpl/aux_/lambda_support.hpp>
-
-namespace boost { namespace detail {
-//
-// Returns the minimum category type or error_type
-// if T1 and T2 are unrelated.
-//
-// For compilers not supporting is_convertible this only
-// works with the new boost return and traversal category
-// types. The exact boost _types_ are required. No derived types
-// will work.
-//
-//
-template <bool GreaterEqual, bool LessEqual>
-struct minimum_category_impl
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-{
- template <class T1, class T2> struct apply
- {
- typedef T2 type;
- };
- typedef void type;
-}
-# endif
-;
-
-template <class T1, class T2>
-struct error_not_related_by_convertibility;
-
-template <>
-struct minimum_category_impl<true,false>
-{
- template <class T1, class T2> struct apply
- {
- typedef T2 type;
- };
-};
-
-template <>
-struct minimum_category_impl<false,true>
-{
- template <class T1, class T2> struct apply
- {
- typedef T1 type;
- };
-};
-
-template <>
-struct minimum_category_impl<true,true>
-{
- template <class T1, class T2> struct apply
- {
- BOOST_STATIC_ASSERT((is_same<T1,T2>::value));
- typedef T1 type;
- };
-};
-
-template <>
-struct minimum_category_impl<false,false>
-{
- template <class T1, class T2> struct apply
- : error_not_related_by_convertibility<T1,T2>
- {
- };
-};
-
-template <class T1 = mpl::_1, class T2 = mpl::_2>
-struct minimum_category
-{
- typedef minimum_category_impl<
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
- is_same<T2,int>::value ||
-# endif
- ::boost::is_convertible<T1,T2>::value
- , ::boost::is_convertible<T2,T1>::value
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
- || is_same<T1,int>::value
-# endif
- > outer;
-
- typedef typename outer::template apply<T1,T2> inner;
- typedef typename inner::type type;
-
- BOOST_MPL_AUX_LAMBDA_SUPPORT(2,minimum_category,(T1,T2))
-};
-
-template <>
-struct minimum_category<mpl::_1,mpl::_2>
-{
- template <class T1, class T2>
- struct apply : minimum_category<T1,T2>
- {};
-
- BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,minimum_category,(mpl::_1,mpl::_2))
-};
-
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // ETI workaround
-template <>
-struct minimum_category<int,int>
-{
- typedef int type;
-};
-# endif
-
-}} // namespace boost::detail
-
-#endif // MINIMUM_CATEGORY_DWA20031119_HPP
# include <boost/iterator/detail/config_def.hpp> // must appear last
-namespace boost
-{
+namespace boost {
+namespace iterators {
//
// Meta function that determines whether two
// standards requirements on constant/mutable container
// iterators (23.1 [lib.container.requirements]).
//
- // For compilers that don't support is_convertible
+ // For compilers that don't support is_convertible
// is_interoperable gives false positives. See comments
// on operator implementation for consequences.
//
is_convertible< A, B >
, is_convertible< B, A > >
# endif
- {
+ {
};
+} // namespace iterators
+
+using iterators::is_interoperable;
+
} // namespace boost
# include <boost/iterator/detail/config_undef.hpp>
#include <boost/iterator/iterator_traits.hpp>
-namespace boost
-{
+namespace boost {
+namespace iterators {
+
// Used as a default template argument internally, merely to
// indicate "use the default", this can also be passed by users
// explicitly in order to specify that the default should be used.
struct use_default;
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
- // the incompleteness of use_default causes massive problems for
- // is_convertible (naturally). This workaround is fortunately not
- // needed for vc6/vc7.
- template<class To>
- struct is_convertible<use_default,To>
- : mpl::false_ {};
-# endif
-
+
+} // namespace iterators
+
+using iterators::use_default;
+
+// the incompleteness of use_default causes massive problems for
+// is_convertible (naturally). This workaround is fortunately not
+// needed for vc6/vc7.
+template<class To>
+struct is_convertible<use_default,To>
+ : mpl::false_ {};
+
+namespace iterators {
+
namespace detail
{
- //
+ //
// Result type used in enable_if_convertible meta function.
- // This can be an incomplete type, as only pointers to
+ // This can be an incomplete type, as only pointers to
// enable_if_convertible< ... >::type are used.
// We could have used void for this, but conversion to
// void* is just to easy.
// public iterator_adaptor< adapted_iterator<Iterator>, Iterator >
// {
// public:
- //
+ //
// ...
//
// template <class OtherIterator>
// and not at the actual instantiation.
//
// enable_if_interoperable can be safely used in user code. It falls back to
- // always enabled for compilers that don't support enable_if or is_convertible.
- // There is no need for compiler specific workarounds in user code.
+ // always enabled for compilers that don't support enable_if or is_convertible.
+ // There is no need for compiler specific workarounds in user code.
//
// The operators implementation relies on boost::is_convertible not returning
// false positives for user/library defined iterator types. See comments
// on operator implementation for consequences.
//
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-
- template<typename From, typename To>
- struct enable_if_convertible
- {
- typedef typename mpl::if_<
- mpl::or_<
- is_same<From,To>
- , is_convertible<From, To>
- >
- , boost::detail::enable_type
- , int&
- >::type type;
- };
-
-# elif defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
-
+# if defined(BOOST_NO_IS_CONVERTIBLE) || defined(BOOST_NO_SFINAE)
+
template <class From, class To>
struct enable_if_convertible
{
- typedef boost::detail::enable_type type;
+ typedef boost::iterators::detail::enable_type type;
};
-
-# elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292)) && BOOST_MSVC > 1300
-
+
+# elif BOOST_WORKAROUND(_MSC_FULL_VER, BOOST_TESTED_AT(13102292))
+
// For some reason vc7.1 needs us to "cut off" instantiation
// of is_convertible in a few cases.
template<typename From, typename To>
is_same<From,To>
, is_convertible<From, To>
>
- , boost::detail::enable_type
+ , boost::iterators::detail::enable_type
>
{};
-
-# else
-
+
+# else
+
template<typename From, typename To>
struct enable_if_convertible
: iterators::enable_if<
is_convertible<From, To>
- , boost::detail::enable_type
+ , boost::iterators::detail::enable_type
>
{};
-
+
# endif
-
+
//
// Default template argument handling for iterator_adaptor
//
{
typedef iterator_facade<
Derived
-
+
# ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
- , typename boost::detail::ia_dflt_help<
+ , typename boost::iterators::detail::ia_dflt_help<
Value
, mpl::eval_if<
is_same<Reference,use_default>
>
>::type
# else
- , typename boost::detail::ia_dflt_help<
+ , typename boost::iterators::detail::ia_dflt_help<
Value, iterator_value<Base>
>::type
# endif
-
- , typename boost::detail::ia_dflt_help<
+
+ , typename boost::iterators::detail::ia_dflt_help<
Traversal
, iterator_traversal<Base>
>::type
- , typename boost::detail::ia_dflt_help<
+ , typename boost::iterators::detail::ia_dflt_help<
Reference
, mpl::eval_if<
is_same<Value,use_default>
>
>::type
- , typename boost::detail::ia_dflt_help<
+ , typename boost::iterators::detail::ia_dflt_help<
Difference, iterator_difference<Base>
>::type
>
type;
};
-
+
// workaround for aC++ CR JAGaf33512
template <class Tr1, class Tr2>
inline void iterator_adaptor_assert_traversal ()
BOOST_STATIC_ASSERT((is_convertible<Tr1, Tr2>::value));
}
}
-
+
//
// Iterator Adaptor
//
, class Difference = use_default
>
class iterator_adaptor
- : public boost::detail::iterator_adaptor_base<
+ : public boost::iterators::detail::iterator_adaptor_base<
Derived, Base, Value, Traversal, Reference, Difference
>::type
{
friend class iterator_core_access;
protected:
- typedef typename boost::detail::iterator_adaptor_base<
+ typedef typename boost::iterators::detail::iterator_adaptor_base<
Derived, Base, Value, Traversal, Reference, Difference
>::type super_t;
public:
protected:
// for convenience in derived classes
typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;
-
+
//
// lvalue access to the Base object for Derived
//
// to prevent temptation for Derived classes to use it, which
// will often result in an error. Derived classes should use
// base_reference(), above, to get direct access to m_iterator.
- //
+ //
typename super_t::reference dereference() const
{ return *m_iterator; }
template <
class OtherDerived, class OtherIterator, class V, class C, class R, class D
- >
+ >
bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
{
// Maybe readd with same_distance
>::type my_traversal;
# define BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(cat) \
- boost::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
+ boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, cat>();
void advance(typename super_t::difference_type n)
{
BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(random_access_traversal_tag)
m_iterator += n;
}
-
+
void increment() { ++m_iterator; }
- void decrement()
+ void decrement()
{
BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL(bidirectional_traversal_tag)
--m_iterator;
template <
class OtherDerived, class OtherIterator, class V, class C, class R, class D
- >
+ >
typename super_t::difference_type distance_to(
iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
{
}
# undef BOOST_ITERATOR_ADAPTOR_ASSERT_TRAVERSAL
-
+
private: // data members
Base m_iterator;
};
+} // namespace iterators
+
+using iterators::iterator_adaptor;
+using iterators::enable_if_convertible;
+
} // namespace boost
#include <boost/iterator/detail/config_undef.hpp>
# include <boost/static_assert.hpp>
namespace boost {
+namespace iterators {
//
// Traversal Categories
struct no_traversal_tag {};
-struct incrementable_traversal_tag
+struct incrementable_traversal_tag
: no_traversal_tag
{
// incrementable_traversal_tag() {}
// incrementable_traversal_tag(std::output_iterator_tag const&) {};
};
-
+
struct single_pass_traversal_tag
: incrementable_traversal_tag
{
// single_pass_traversal_tag() {}
// single_pass_traversal_tag(std::input_iterator_tag const&) {};
};
-
+
struct forward_traversal_tag
: single_pass_traversal_tag
{
// forward_traversal_tag() {}
// forward_traversal_tag(std::forward_iterator_tag const&) {};
};
-
+
struct bidirectional_traversal_tag
: forward_traversal_tag
{
// bidirectional_traversal_tag() {};
// bidirectional_traversal_tag(std::bidirectional_iterator_tag const&) {};
};
-
+
struct random_access_traversal_tag
: bidirectional_traversal_tag
{
};
namespace detail
-{
+{
//
// Convert a "strictly old-style" iterator category to a traversal
// tag. This is broken out into a separate metafunction to reduce
>
{};
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- template <>
- struct old_category_to_traversal<int>
- {
- typedef int type;
- };
-# endif
-
- template <class Traversal>
- struct pure_traversal_tag
- : mpl::eval_if<
- is_convertible<Traversal,random_access_traversal_tag>
- , mpl::identity<random_access_traversal_tag>
- , mpl::eval_if<
- is_convertible<Traversal,bidirectional_traversal_tag>
- , mpl::identity<bidirectional_traversal_tag>
- , mpl::eval_if<
- is_convertible<Traversal,forward_traversal_tag>
- , mpl::identity<forward_traversal_tag>
- , mpl::eval_if<
- is_convertible<Traversal,single_pass_traversal_tag>
- , mpl::identity<single_pass_traversal_tag>
- , mpl::eval_if<
- is_convertible<Traversal,incrementable_traversal_tag>
- , mpl::identity<incrementable_traversal_tag>
- , void
- >
- >
- >
- >
- >
- {
- };
-
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- template <>
- struct pure_traversal_tag<int>
- {
- typedef int type;
- };
-# endif
-
} // namespace detail
-
//
// Convert an iterator category into a traversal tag
//
: mpl::eval_if< // if already convertible to a traversal tag, we're done.
is_convertible<Cat,incrementable_traversal_tag>
, mpl::identity<Cat>
- , boost::detail::old_category_to_traversal<Cat>
+ , boost::iterators::detail::old_category_to_traversal<Cat>
>
{};
{};
# endif
+//
+// Convert an iterator traversal to one of the traversal tags.
+//
+template <class Traversal>
+struct pure_traversal_tag
+ : mpl::eval_if<
+ is_convertible<Traversal,random_access_traversal_tag>
+ , mpl::identity<random_access_traversal_tag>
+ , mpl::eval_if<
+ is_convertible<Traversal,bidirectional_traversal_tag>
+ , mpl::identity<bidirectional_traversal_tag>
+ , mpl::eval_if<
+ is_convertible<Traversal,forward_traversal_tag>
+ , mpl::identity<forward_traversal_tag>
+ , mpl::eval_if<
+ is_convertible<Traversal,single_pass_traversal_tag>
+ , mpl::identity<single_pass_traversal_tag>
+ , mpl::eval_if<
+ is_convertible<Traversal,incrementable_traversal_tag>
+ , mpl::identity<incrementable_traversal_tag>
+ , void
+ >
+ >
+ >
+ >
+ >
+{
+};
+
+// This import is needed for backward compatibility with Boost.Range:
+// boost/range/detail/demote_iterator_traversal_tag.hpp
+// It should be removed when that header is fixed.
+namespace detail {
+using iterators::pure_traversal_tag;
+} // namespace detail
+
+//
+// Trait to retrieve one of the iterator traversal tags from the iterator category or traversal.
+//
+template <class Iterator = mpl::_1>
+struct pure_iterator_traversal
+ : pure_traversal_tag<typename iterator_traversal<Iterator>::type>
+{};
+
+# ifdef BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT
+template <>
+struct pure_iterator_traversal<mpl::_1>
+{
+ template <class T>
+ struct apply : pure_iterator_traversal<T>
+ {};
+};
+template <>
+struct pure_iterator_traversal<mpl::_>
+ : pure_iterator_traversal<mpl::_1>
+{};
+# endif
+
+} // namespace iterators
+
+using iterators::no_traversal_tag;
+using iterators::incrementable_traversal_tag;
+using iterators::single_pass_traversal_tag;
+using iterators::forward_traversal_tag;
+using iterators::bidirectional_traversal_tag;
+using iterators::random_access_traversal_tag;
+using iterators::iterator_category_to_traversal;
+using iterators::iterator_traversal;
+
+// This import is needed for backward compatibility with Boost.Range:
+// boost/range/detail/demote_iterator_traversal_tag.hpp
+// It should be removed when that header is fixed.
+namespace detail {
+using iterators::pure_traversal_tag;
+} // namespace detail
+
} // namespace boost
#include <boost/iterator/detail/config_undef.hpp>
private:
Iterator i;
};
-
+
template <
typename Iterator
, typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
, typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
>
struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
-
+
BOOST_concept(SwappableIterator,(Iterator))
{
BOOST_CONCEPT_USAGE(SwappableIterator)
BOOST_concept(LvalueIterator,(Iterator))
{
typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
-
+
BOOST_CONCEPT_USAGE(LvalueIterator)
{
value_type& r = const_cast<value_type&>(*i);
Iterator i;
};
-
+
//===========================================================================
// Iterator Traversal Concepts
, boost::DefaultConstructible<Iterator>
{
typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
-
+
BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
, boost::forward_traversal_tag
> ));
};
-
+
BOOST_concept(BidirectionalTraversal,(Iterator))
: ForwardTraversal<Iterator>
{
i = i - n;
n = i - j;
}
-
+
private:
typename BidirectionalTraversal<Iterator>::difference_type n;
Iterator i, j;
};
//===========================================================================
- // Iterator Interoperability
+ // Iterator Interoperability
namespace detail
{
BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator))
{
private:
- typedef typename boost::detail::pure_traversal_tag<
- typename boost::iterator_traversal<
- Iterator
- >::type
- >::type traversal_category;
-
- typedef typename boost::detail::pure_traversal_tag<
- typename boost::iterator_traversal<
- ConstIterator
- >::type
- >::type const_traversal_category;
-
- public:
+ typedef typename boost::iterators::pure_iterator_traversal<Iterator>::type traversal_category;
+ typedef typename boost::iterators::pure_iterator_traversal<ConstIterator>::type const_traversal_category;
+
+ public:
BOOST_CONCEPT_ASSERT((SinglePassIterator<Iterator>));
BOOST_CONCEPT_ASSERT((SinglePassIterator<ConstIterator>));
ci = i;
}
-
+
private:
Iterator i;
ConstIterator ci;
#ifndef BOOST_ITERATOR_FACADE_23022003THW_HPP
#define BOOST_ITERATOR_FACADE_23022003THW_HPP
+#include <boost/config.hpp>
#include <boost/iterator.hpp>
#include <boost/iterator/interoperable.hpp>
#include <boost/iterator/iterator_traits.hpp>
+#include <boost/iterator/iterator_categories.hpp>
#include <boost/iterator/detail/facade_iterator_category.hpp>
#include <boost/iterator/detail/enable_if.hpp>
#include <boost/iterator/detail/config_def.hpp> // this goes last
-namespace boost
-{
+namespace boost {
+namespace iterators {
+
// This forward declaration is required for the friend declaration
// in iterator_core_access
template <class I, class V, class TC, class R, class D> class iterator_facade;
};
};
+ // The type trait checks if the category or traversal is at least as advanced as the specified required traversal
+ template< typename CategoryOrTraversal, typename Required >
+ struct is_traversal_at_least :
+ public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >
+ {};
+
//
// enable if for use in operator implementation.
//
, class Facade2
, class Return
>
- struct enable_if_interoperable
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
- {
- typedef typename mpl::if_<
- mpl::or_<
- is_convertible<Facade1, Facade2>
- , is_convertible<Facade2, Facade1>
+ struct enable_if_interoperable :
+ public boost::iterators::enable_if<
+ is_interoperable< Facade1, Facade2 >
+ , Return
+ >
+ {};
+
+ //
+ // enable if for use in implementation of operators specific for random access traversal.
+ //
+ template <
+ class Facade1
+ , class Facade2
+ , class Return
+ >
+ struct enable_if_interoperable_and_random_access_traversal :
+ public boost::iterators::enable_if<
+ mpl::and_<
+ is_interoperable< Facade1, Facade2 >
+ , is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag >
+ , is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag >
>
, Return
- , int[3]
- >::type type;
- };
-#else
- : ::boost::iterators::enable_if<
- mpl::or_<
- is_convertible<Facade1, Facade2>
- , is_convertible<Facade2, Facade1>
- >
- , Return
>
{};
-#endif
//
// Generates associated types for an iterator_facade with the
template <
class ValueParam
, class CategoryOrTraversal
- , class Reference
+ , class Reference
, class Difference
>
struct iterator_facade_types
typedef typename facade_iterator_category<
CategoryOrTraversal, ValueParam, Reference
>::type iterator_category;
-
+
typedef typename remove_const<ValueParam>::type value_type;
-
+
// Not the real associated pointer type
typedef typename mpl::eval_if<
- boost::detail::iterator_writability_disabled<ValueParam,Reference>
+ boost::iterators::detail::iterator_writability_disabled<ValueParam,Reference>
, add_pointer<const value_type>
, add_pointer<value_type>
>::type pointer;
-
+
# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
&& (BOOST_WORKAROUND(_STLPORT_VERSION, BOOST_TESTED_AT(0x452)) \
|| BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(310))) \
private:
mutable value_type stored_value;
};
-
+
//
// In general, we can't determine that such an iterator isn't
// writable -- we also need to store a copy of the old iterator so
{
return stored_iterator;
}
-
+
private:
mutable value_type stored_value;
Iterator stored_iterator;
struct is_non_proxy_reference_impl
{
static Reference r;
-
+
template <class R>
static typename mpl::if_<
is_convertible<
, char[1]
, char[2]
>::type& helper(R const&);
-
+
BOOST_STATIC_CONSTANT(bool, value = sizeof(helper(r)) == 1);
};
-
+
template <class Reference, class Value>
struct is_non_proxy_reference
: mpl::bool_<
is_non_proxy_reference_impl<Reference, Value>::value
>
{};
-# else
+# else
template <class Reference, class Value>
struct is_non_proxy_reference
: is_convertible<
, Value const volatile*
>
{};
-# endif
-
+# endif
+
// A metafunction to choose the result type of postfix ++
//
// Because the C++98 input iterator requirements say that *r++ has
mpl::and_<
// A proxy is only needed for readable iterators
is_convertible<Reference,Value const&>
-
+
// No multipass iterator can have values that disappear
// before positions can be re-visited
, mpl::not_<
}
};
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- // Deal with ETI
- template<>
- struct operator_arrow_dispatch<int, int>
- {
- typedef int result_type;
- };
-# endif
-
// A proxy return type for operator[], needed to deal with
// iterators that may invalidate referents upon destruction.
// Consider the temporary iterator in *(a + n)
>
>
{};
-
+
template <class Iterator, class Value, class Reference>
struct operator_brackets_result
{
:
# ifdef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
iterator_difference<I1>
-# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- mpl::if_<
- is_convertible<I2,I1>
- , typename I1::difference_type
- , typename I2::difference_type
- >
-# else
+# else
mpl::eval_if<
is_convertible<I2,I1>
, iterator_difference<I1>
, iterator_difference<I2>
>
-# endif
+# endif
{};
};
+
+ template <
+ class Derived
+ , class Value
+ , class CategoryOrTraversal
+ , class Reference
+ , class Difference
+ , bool IsBidirectionalTraversal
+ , bool IsRandomAccessTraversal
+ >
+ class iterator_facade_base;
+
} // namespace detail
// Macros which describe the declarations of binary operators
# ifdef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
-# define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \
+# define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler) \
template < \
class Derived1, class V1, class TC1, class Reference1, class Difference1 \
, class Derived2, class V2, class TC2, class Reference2, class Difference2 \
operator op( \
iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs \
, iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
-# else
-# define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \
+# else
+# define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, enabler) \
template < \
class Derived1, class V1, class TC1, class Reference1, class Difference1 \
, class Derived2, class V2, class TC2, class Reference2, class Difference2 \
> \
- prefix typename boost::detail::enable_if_interoperable< \
+ prefix typename enabler< \
Derived1, Derived2 \
, typename mpl::apply2<result_type,Derived1,Derived2>::type \
>::type \
operator op( \
iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs \
, iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
-# endif
+# endif
+
+# define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix, op, result_type) \
+ BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable)
+
+# define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(prefix, op, result_type) \
+ BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable_and_random_access_traversal)
# define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args) \
template <class Derived, class V, class TC, class R, class D> \
- prefix Derived operator+ args
+ prefix typename boost::iterators::enable_if< \
+ boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, \
+ Derived \
+ >::type operator+ args
//
// Helper class for granting access to the iterator core interface.
//
class iterator_core_access
{
-# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+# if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
// Tasteless as this may seem, making all members public allows member templates
// to work in the absence of member template friends.
public:
# else
-
+
template <class I, class V, class TC, class R, class D> friend class iterator_facade;
+ template <class I, class V, class TC, class R, class D, bool IsBidirectionalTraversal, bool IsRandomAccessTraversal>
+ friend class detail::iterator_facade_base;
# define BOOST_ITERATOR_FACADE_RELATION(op) \
- BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::detail::always_bool2);
+ BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::iterators::detail::always_bool2);
BOOST_ITERATOR_FACADE_RELATION(==)
BOOST_ITERATOR_FACADE_RELATION(!=)
- BOOST_ITERATOR_FACADE_RELATION(<)
- BOOST_ITERATOR_FACADE_RELATION(>)
- BOOST_ITERATOR_FACADE_RELATION(<=)
- BOOST_ITERATOR_FACADE_RELATION(>=)
# undef BOOST_ITERATOR_FACADE_RELATION
- BOOST_ITERATOR_FACADE_INTEROP_HEAD(
- friend, -, boost::detail::choose_difference_type)
+# define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op) \
+ BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend,op, boost::iterators::detail::always_bool2);
+
+ BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<)
+ BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>)
+ BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=)
+ BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=)
+
+# undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
+
+ BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(
+ friend, -, boost::iterators::detail::choose_difference_type)
;
BOOST_ITERATOR_FACADE_PLUS_HEAD(
friend inline
- , (iterator_facade<Derived, V, TC, R, D> const&
- , typename Derived::difference_type)
+ , (iterator_facade<Derived, V, TC, R, D> const&
+ , typename Derived::difference_type)
)
;
BOOST_ITERATOR_FACADE_PLUS_HEAD(
friend inline
, (typename Derived::difference_type
- , iterator_facade<Derived, V, TC, R, D> const&)
+ , iterator_facade<Derived, V, TC, R, D> const&)
)
;
return *static_cast<I const*>(&facade);
}
- private:
// objects of this class are useless
- iterator_core_access(); //undefined
+ BOOST_DELETED_FUNCTION(iterator_core_access())
};
- //
- // iterator_facade - use as a public base class for defining new
- // standard-conforming iterators.
- //
- template <
- class Derived // The derived iterator type being constructed
- , class Value
- , class CategoryOrTraversal
- , class Reference = Value&
- , class Difference = std::ptrdiff_t
- >
- class iterator_facade
+ namespace detail {
+
+ // Implementation for forward traversal iterators
+ template <
+ class Derived
+ , class Value
+ , class CategoryOrTraversal
+ , class Reference
+ , class Difference
+ >
+ class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
# ifdef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
- : public boost::detail::iterator_facade_types<
- Value, CategoryOrTraversal, Reference, Difference
- >::base
+ : public boost::iterators::detail::iterator_facade_types<
+ Value, CategoryOrTraversal, Reference, Difference
+ >::base
# undef BOOST_ITERATOR_FACADE_NEEDS_ITERATOR_BASE
# endif
- {
- private:
- //
- // Curiously Recurring Template interface.
- //
- Derived& derived()
- {
- return *static_cast<Derived*>(this);
- }
+ {
+ private:
+ typedef boost::iterators::detail::iterator_facade_types<
+ Value, CategoryOrTraversal, Reference, Difference
+ > associated_types;
- Derived const& derived() const
- {
- return *static_cast<Derived const*>(this);
- }
+ typedef boost::iterators::detail::operator_arrow_dispatch<
+ Reference
+ , typename associated_types::pointer
+ > operator_arrow_dispatch_;
- typedef boost::detail::iterator_facade_types<
- Value, CategoryOrTraversal, Reference, Difference
- > associated_types;
+ public:
+ typedef typename associated_types::value_type value_type;
+ typedef Reference reference;
+ typedef Difference difference_type;
- typedef boost::detail::operator_arrow_dispatch<
- Reference
- , typename associated_types::pointer
- > operator_arrow_dispatch_;
+ typedef typename operator_arrow_dispatch_::result_type pointer;
- protected:
- // For use by derived classes
- typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;
-
- public:
+ typedef typename associated_types::iterator_category iterator_category;
- typedef typename associated_types::value_type value_type;
- typedef Reference reference;
- typedef Difference difference_type;
+ public:
+ reference operator*() const
+ {
+ return iterator_core_access::dereference(this->derived());
+ }
- typedef typename operator_arrow_dispatch_::result_type pointer;
+ pointer operator->() const
+ {
+ return operator_arrow_dispatch_::apply(*this->derived());
+ }
- typedef typename associated_types::iterator_category iterator_category;
+ Derived& operator++()
+ {
+ iterator_core_access::increment(this->derived());
+ return this->derived();
+ }
- reference operator*() const
- {
- return iterator_core_access::dereference(this->derived());
- }
+ protected:
+ //
+ // Curiously Recurring Template interface.
+ //
+ Derived& derived()
+ {
+ return *static_cast<Derived*>(this);
+ }
- pointer operator->() const
- {
- return operator_arrow_dispatch_::apply(*this->derived());
- }
-
- typename boost::detail::operator_brackets_result<Derived,Value,reference>::type
- operator[](difference_type n) const
- {
- typedef boost::detail::use_operator_brackets_proxy<Value,Reference> use_proxy;
-
- return boost::detail::make_operator_brackets_result<Derived>(
- this->derived() + n
- , use_proxy()
- );
- }
+ Derived const& derived() const
+ {
+ return *static_cast<Derived const*>(this);
+ }
+ };
- Derived& operator++()
- {
- iterator_core_access::increment(this->derived());
- return this->derived();
- }
+ // Implementation for bidirectional traversal iterators
+ template <
+ class Derived
+ , class Value
+ , class CategoryOrTraversal
+ , class Reference
+ , class Difference
+ >
+ class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > :
+ public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
+ {
+ public:
+ Derived& operator--()
+ {
+ iterator_core_access::decrement(this->derived());
+ return this->derived();
+ }
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- typename boost::detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type
- operator++(int)
- {
- typename boost::detail::postfix_increment_result<Derived,Value,Reference,CategoryOrTraversal>::type
- tmp(this->derived());
- ++*this;
- return tmp;
- }
-# endif
-
- Derived& operator--()
- {
- iterator_core_access::decrement(this->derived());
- return this->derived();
- }
+ Derived operator--(int)
+ {
+ Derived tmp(this->derived());
+ --*this;
+ return tmp;
+ }
+ };
- Derived operator--(int)
- {
- Derived tmp(this->derived());
- --*this;
- return tmp;
- }
+ // Implementation for random access traversal iterators
+ template <
+ class Derived
+ , class Value
+ , class CategoryOrTraversal
+ , class Reference
+ , class Difference
+ >
+ class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > :
+ public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false >
+ {
+ private:
+ typedef iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > base_type;
- Derived& operator+=(difference_type n)
- {
- iterator_core_access::advance(this->derived(), n);
- return this->derived();
- }
+ public:
+ typedef typename base_type::reference reference;
+ typedef typename base_type::difference_type difference_type;
- Derived& operator-=(difference_type n)
- {
- iterator_core_access::advance(this->derived(), -n);
- return this->derived();
- }
+ public:
+ typename boost::iterators::detail::operator_brackets_result<Derived, Value, reference>::type
+ operator[](difference_type n) const
+ {
+ typedef boost::iterators::detail::use_operator_brackets_proxy<Value, Reference> use_proxy;
- Derived operator-(difference_type x) const
- {
- Derived result(this->derived());
- return result -= x;
- }
+ return boost::iterators::detail::make_operator_brackets_result<Derived>(
+ this->derived() + n
+ , use_proxy()
+ );
+ }
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- // There appears to be a bug which trashes the data of classes
- // derived from iterator_facade when they are assigned unless we
- // define this assignment operator. This bug is only revealed
- // (so far) in STLPort debug mode, but it's clearly a codegen
- // problem so we apply the workaround for all MSVC6.
- iterator_facade& operator=(iterator_facade const&)
- {
- return *this;
- }
-# endif
+ Derived& operator+=(difference_type n)
+ {
+ iterator_core_access::advance(this->derived(), n);
+ return this->derived();
+ }
+
+ Derived& operator-=(difference_type n)
+ {
+ iterator_core_access::advance(this->derived(), -n);
+ return this->derived();
+ }
+
+ Derived operator-(difference_type x) const
+ {
+ Derived result(this->derived());
+ return result -= x;
+ }
+ };
+
+ } // namespace detail
+
+ //
+ // iterator_facade - use as a public base class for defining new
+ // standard-conforming iterators.
+ //
+ template <
+ class Derived // The derived iterator type being constructed
+ , class Value
+ , class CategoryOrTraversal
+ , class Reference = Value&
+ , class Difference = std::ptrdiff_t
+ >
+ class iterator_facade :
+ public detail::iterator_facade_base<
+ Derived,
+ Value,
+ CategoryOrTraversal,
+ Reference,
+ Difference,
+ detail::is_traversal_at_least< CategoryOrTraversal, bidirectional_traversal_tag >::value,
+ detail::is_traversal_at_least< CategoryOrTraversal, random_access_traversal_tag >::value
+ >
+ {
+ protected:
+ // For use by derived classes
+ typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;
};
-# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
template <class I, class V, class TC, class R, class D>
- inline typename boost::detail::postfix_increment_result<I,V,R,TC>::type
+ inline typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
operator++(
iterator_facade<I,V,TC,R,D>& i
, int
)
{
- typename boost::detail::postfix_increment_result<I,V,R,TC>::type
+ typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
tmp(*static_cast<I*>(&i));
-
+
++i;
-
+
return tmp;
}
-# endif
-
+
//
// Comparison operator implementation. The library supplied operators
// enables the user to provide fully interoperable constant/mutable
# define BOOST_ITERATOR_FACADE_RELATION(op, return_prefix, base_op) \
BOOST_ITERATOR_FACADE_INTEROP( \
op \
- , boost::detail::always_bool2 \
+ , boost::iterators::detail::always_bool2 \
, return_prefix \
, base_op \
)
BOOST_ITERATOR_FACADE_RELATION(==, return, equal)
BOOST_ITERATOR_FACADE_RELATION(!=, return !, equal)
- BOOST_ITERATOR_FACADE_RELATION(<, return 0 >, distance_from)
- BOOST_ITERATOR_FACADE_RELATION(>, return 0 <, distance_from)
- BOOST_ITERATOR_FACADE_RELATION(<=, return 0 >=, distance_from)
- BOOST_ITERATOR_FACADE_RELATION(>=, return 0 <=, distance_from)
# undef BOOST_ITERATOR_FACADE_RELATION
+
+# define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(op, result_type, return_prefix, base_op) \
+ BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type) \
+ { \
+ /* For those compilers that do not support enable_if */ \
+ BOOST_STATIC_ASSERT(( \
+ is_interoperable< Derived1, Derived2 >::value && \
+ boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && \
+ boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value \
+ )); \
+ return_prefix iterator_core_access::base_op( \
+ *static_cast<Derived1 const*>(&lhs) \
+ , *static_cast<Derived2 const*>(&rhs) \
+ , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) \
+ ); \
+ }
+
+# define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op, return_prefix, base_op) \
+ BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS( \
+ op \
+ , boost::iterators::detail::always_bool2 \
+ , return_prefix \
+ , base_op \
+ )
+
+ BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<, return 0 >, distance_from)
+ BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>, return 0 <, distance_from)
+ BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(<=, return 0 >=, distance_from)
+ BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(>=, return 0 <=, distance_from)
+
+# undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
+
// operator- requires an additional part in the static assertion
- BOOST_ITERATOR_FACADE_INTEROP(
+ BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(
-
- , boost::detail::choose_difference_type
+ , boost::iterators::detail::choose_difference_type
, return
, distance_from
)
+
# undef BOOST_ITERATOR_FACADE_INTEROP
-# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD
+# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS
# define BOOST_ITERATOR_FACADE_PLUS(args) \
BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args) \
return tmp += n; \
}
-BOOST_ITERATOR_FACADE_PLUS((
- iterator_facade<Derived, V, TC, R, D> const& i
- , typename Derived::difference_type n
-))
+ BOOST_ITERATOR_FACADE_PLUS((
+ iterator_facade<Derived, V, TC, R, D> const& i
+ , typename Derived::difference_type n
+ ))
-BOOST_ITERATOR_FACADE_PLUS((
- typename Derived::difference_type n
+ BOOST_ITERATOR_FACADE_PLUS((
+ typename Derived::difference_type n
, iterator_facade<Derived, V, TC, R, D> const& i
-))
+ ))
+
# undef BOOST_ITERATOR_FACADE_PLUS
# undef BOOST_ITERATOR_FACADE_PLUS_HEAD
+# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD
+# undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD
+# undef BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL
+
+} // namespace iterators
+
+using iterators::iterator_core_access;
+using iterators::iterator_facade;
+
} // namespace boost
#include <boost/iterator/detail/config_undef.hpp>
# include <boost/detail/iterator.hpp>
# include <boost/detail/workaround.hpp>
-namespace boost {
+namespace boost {
+namespace iterators {
-// Unfortunately, g++ 2.95.x chokes when we define a class template
-// iterator_category which has the same name as its
-// std::iterator_category() function, probably due in part to the
-// "std:: is visible globally" hack it uses. Use
-// BOOST_ITERATOR_CATEGORY to write code that's portable to older
-// GCCs.
-
-# if BOOST_WORKAROUND(__GNUC__, <= 2)
-# define BOOST_ITERATOR_CATEGORY iterator_category_
-# else
-# define BOOST_ITERATOR_CATEGORY iterator_category
-# endif
+// Macro for supporting old compilers, no longer needed but kept
+// for backwards compatibility (it was documented).
+#define BOOST_ITERATOR_CATEGORY iterator_category
template <class Iterator>
{
typedef typename boost::detail::iterator_traits<Iterator>::value_type type;
};
-
+
template <class Iterator>
struct iterator_reference
{
typedef typename boost::detail::iterator_traits<Iterator>::reference type;
};
-
-
+
+
template <class Iterator>
struct iterator_pointer
{
typedef typename boost::detail::iterator_traits<Iterator>::pointer type;
};
-
+
template <class Iterator>
struct iterator_difference
{
};
template <class Iterator>
-struct BOOST_ITERATOR_CATEGORY
+struct iterator_category
{
typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;
};
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-template <>
-struct iterator_value<int>
-{
- typedef void type;
-};
-
-template <>
-struct iterator_reference<int>
-{
- typedef void type;
-};
+} // namespace iterators
-template <>
-struct iterator_pointer<int>
-{
- typedef void type;
-};
-
-template <>
-struct iterator_difference<int>
-{
- typedef void type;
-};
-
-template <>
-struct BOOST_ITERATOR_CATEGORY<int>
-{
- typedef void type;
-};
-# endif
+using iterators::iterator_value;
+using iterators::iterator_reference;
+using iterators::iterator_pointer;
+using iterators::iterator_difference;
+using iterators::iterator_category;
-} // namespace boost::iterator
+} // namespace boost
#endif // ITERATOR_TRAITS_DWA200347_HPP
--- /dev/null
+// Copyright David Abrahams 2003. Use, modification and distribution is
+// subject to 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)
+#ifndef BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
+# define BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
+
+# include <boost/static_assert.hpp>
+# include <boost/type_traits/is_convertible.hpp>
+# include <boost/type_traits/is_same.hpp>
+
+# include <boost/mpl/placeholders.hpp>
+# include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost {
+namespace iterators {
+namespace detail {
+
+template <bool GreaterEqual, bool LessEqual>
+struct minimum_category_impl;
+
+template <class T1, class T2>
+struct error_not_related_by_convertibility;
+
+template <>
+struct minimum_category_impl<true,false>
+{
+ template <class T1, class T2> struct apply
+ {
+ typedef T2 type;
+ };
+};
+
+template <>
+struct minimum_category_impl<false,true>
+{
+ template <class T1, class T2> struct apply
+ {
+ typedef T1 type;
+ };
+};
+
+template <>
+struct minimum_category_impl<true,true>
+{
+ template <class T1, class T2> struct apply
+ {
+ BOOST_STATIC_ASSERT((is_same<T1,T2>::value));
+ typedef T1 type;
+ };
+};
+
+template <>
+struct minimum_category_impl<false,false>
+{
+ template <class T1, class T2> struct apply
+ : error_not_related_by_convertibility<T1,T2>
+ {
+ };
+};
+
+} // namespace detail
+
+//
+// Returns the minimum category type or fails to compile
+// if T1 and T2 are unrelated.
+//
+template <class T1 = mpl::_1, class T2 = mpl::_2>
+struct minimum_category
+{
+ typedef boost::iterators::detail::minimum_category_impl<
+ ::boost::is_convertible<T1,T2>::value
+ , ::boost::is_convertible<T2,T1>::value
+ > outer;
+
+ typedef typename outer::template apply<T1,T2> inner;
+ typedef typename inner::type type;
+
+ BOOST_MPL_AUX_LAMBDA_SUPPORT(2,minimum_category,(T1,T2))
+};
+
+template <>
+struct minimum_category<mpl::_1,mpl::_2>
+{
+ template <class T1, class T2>
+ struct apply : minimum_category<T1,T2>
+ {};
+
+ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,minimum_category,(mpl::_1,mpl::_2))
+};
+
+} // namespace iterators
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_MINIMUM_CATEGORY_HPP_INCLUDED_
#include <boost/iterator.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
-namespace boost
-{
+namespace boost {
+namespace iterators {
//
//
public:
reverse_iterator() {}
- explicit reverse_iterator(Iterator x)
+ explicit reverse_iterator(Iterator x)
: super_t(x) {}
template<class OtherIterator>
private:
typename super_t::reference dereference() const { return *boost::prior(this->base()); }
-
+
void increment() { --this->base_reference(); }
void decrement() { ++this->base_reference(); }
};
template <class BidirectionalIterator>
- reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
+ inline reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
{
return reverse_iterator<BidirectionalIterator>(x);
}
+} // namespace iterators
+
+using iterators::reverse_iterator;
+using iterators::make_reverse_iterator;
+
} // namespace boost
#endif // BOOST_REVERSE_ITERATOR_23022003THW_HPP
-#ifndef BOOST_LEXICAL_CAST_INCLUDED
-#define BOOST_LEXICAL_CAST_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-// Boost lexical_cast.hpp header -------------------------------------------//
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2014.
//
-// See http://www.boost.org/libs/conversion for documentation.
-// See end of this header for rights and permissions.
+// 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)
//
// what: lexical_cast custom keyword cast
// who: contributed by Kevlin Henney,
// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
-// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2013
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
-#define BOOST_LCAST_NO_WCHAR_T
-#endif
+// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
-#include <climits>
-#include <cstddef>
-#include <string>
-#include <cstring>
-#include <cstdio>
-#include <typeinfo>
-#include <exception>
-#include <boost/limits.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/type_traits/ice.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/detail/lcast_precision.hpp>
-#include <boost/detail/workaround.hpp>
-
-
-#ifndef BOOST_NO_STD_LOCALE
-# include <locale>
-#else
-# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
- // Getting error at this point means, that your STL library is old/lame/misconfigured.
- // If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
- // but beware: lexical_cast will understand only 'C' locale delimeters and thousands
- // separators.
-# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
-# error "boost::lexical_cast to use only 'C' locale during conversions."
-# endif
-#endif
-
-#ifdef BOOST_NO_STRINGSTREAM
-#include <strstream>
-#else
-#include <sstream>
-#endif
-
-#ifdef BOOST_NO_TYPEID
-#define BOOST_LCAST_THROW_BAD_CAST(S, T) throw_exception(bad_lexical_cast())
-#else
-#define BOOST_LCAST_THROW_BAD_CAST(Source, Target) \
- throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)))
-#endif
-
-namespace boost
-{
- // exception used to indicate runtime lexical_cast failure
- class BOOST_SYMBOL_VISIBLE bad_lexical_cast :
- // workaround MSVC bug with std::bad_cast when _HAS_EXCEPTIONS == 0
-#if defined(BOOST_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
- public std::exception
-#else
- public std::bad_cast
-#endif
-
-#if defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x560 )
- // under bcc32 5.5.1 bad_cast doesn't derive from exception
- , public std::exception
-#endif
-
- {
- public:
- bad_lexical_cast() BOOST_NOEXCEPT :
-#ifndef BOOST_NO_TYPEID
- source(&typeid(void)), target(&typeid(void))
-#else
- source(0), target(0) // this breaks getters
-#endif
- {
- }
-
- bad_lexical_cast(
- const std::type_info &source_type_arg,
- const std::type_info &target_type_arg) BOOST_NOEXCEPT :
- source(&source_type_arg), target(&target_type_arg)
- {
- }
-
- const std::type_info &source_type() const
- {
- return *source;
- }
- const std::type_info &target_type() const
- {
- return *target;
- }
-
-#ifndef BOOST_NO_CXX11_NOEXCEPT
- virtual const char *what() const noexcept
-#else
- virtual const char *what() const throw()
-#endif
- {
- return "bad lexical cast: "
- "source type value could not be interpreted as target";
- }
+#ifndef BOOST_LEXICAL_CAST_INCLUDED
+#define BOOST_LEXICAL_CAST_INCLUDED
-#ifndef BOOST_NO_CXX11_NOEXCEPT
- virtual ~bad_lexical_cast() BOOST_NOEXCEPT
-#else
- virtual ~bad_lexical_cast() throw()
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
#endif
- {}
- private:
- const std::type_info *source;
- const std::type_info *target;
- };
-
- namespace detail // widest_char
- {
- template <typename TargetChar, typename SourceChar>
- struct widest_char
- {
- typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
- (sizeof(TargetChar) > sizeof(SourceChar))
- , TargetChar
- , SourceChar >::type type;
- };
- }
-} // namespace boost
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC) && !defined(__PGIC__)
-
-#include <cmath>
-#include <istream>
-
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
-#include <array>
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
#endif
-#include <boost/array.hpp>
-#include <boost/numeric/conversion/cast.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/type_traits/is_signed.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/has_left_shift.hpp>
-#include <boost/type_traits/has_right_shift.hpp>
-#include <boost/math/special_functions/sign.hpp>
-#include <boost/math/special_functions/fpclassify.hpp>
#include <boost/range/iterator_range_core.hpp>
-#include <boost/container/container_fwd.hpp>
-#include <boost/integer.hpp>
-#ifndef BOOST_NO_CWCHAR
-# include <cwchar>
-#endif
-
-namespace boost {
-
- namespace detail // is_char_or_wchar<...>
- {
- // returns true, if T is one of the character types
- template < typename T >
- struct is_char_or_wchar
- {
- typedef boost::type_traits::ice_or<
- boost::is_same< T, char >::value,
- #ifndef BOOST_LCAST_NO_WCHAR_T
- boost::is_same< T, wchar_t >::value,
- #endif
- #ifndef BOOST_NO_CXX11_CHAR16_T
- boost::is_same< T, char16_t >::value,
- #endif
- #ifndef BOOST_NO_CXX11_CHAR32_T
- boost::is_same< T, char32_t >::value,
- #endif
- boost::is_same< T, unsigned char >::value,
- boost::is_same< T, signed char >::value
- > result_type;
-
- BOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
- };
- }
-
- namespace detail // normalize_single_byte_char<Char>
- {
- // Converts signed/unsigned char to char
- template < class Char >
- struct normalize_single_byte_char
- {
- typedef Char type;
- };
-
- template <>
- struct normalize_single_byte_char< signed char >
- {
- typedef char type;
- };
-
- template <>
- struct normalize_single_byte_char< unsigned char >
- {
- typedef char type;
- };
- }
-
- namespace detail // deduce_character_type_later<T>
- {
- // Helper type, meaning that stram character for T must be deduced
- // at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
- template < class T > struct deduce_character_type_later {};
- }
-
- namespace detail // stream_char_common<T>
- {
- // Selectors to choose stream character type (common for Source and Target)
- // Returns one of char, wchar_t, char16_t, char32_t or deduce_character_type_later<T> types
- // Executed on Stage 1 (See deduce_source_char<T> and deduce_target_char<T>)
- template < typename Type >
- struct stream_char_common: public boost::mpl::if_c<
- boost::detail::is_char_or_wchar< Type >::value,
- Type,
- boost::detail::deduce_character_type_later< Type >
- > {};
-
- template < typename Char >
- struct stream_char_common< Char* >: public boost::mpl::if_c<
- boost::detail::is_char_or_wchar< Char >::value,
- Char,
- boost::detail::deduce_character_type_later< Char* >
- > {};
-
- template < typename Char >
- struct stream_char_common< const Char* >: public boost::mpl::if_c<
- boost::detail::is_char_or_wchar< Char >::value,
- Char,
- boost::detail::deduce_character_type_later< const Char* >
- > {};
-
- template < typename Char >
- struct stream_char_common< boost::iterator_range< Char* > >: public boost::mpl::if_c<
- boost::detail::is_char_or_wchar< Char >::value,
- Char,
- boost::detail::deduce_character_type_later< boost::iterator_range< Char* > >
- > {};
-
- template < typename Char >
- struct stream_char_common< boost::iterator_range< const Char* > >: public boost::mpl::if_c<
- boost::detail::is_char_or_wchar< Char >::value,
- Char,
- boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > >
- > {};
-
- template < class Char, class Traits, class Alloc >
- struct stream_char_common< std::basic_string< Char, Traits, Alloc > >
- {
- typedef Char type;
- };
-
- template < class Char, class Traits, class Alloc >
- struct stream_char_common< boost::container::basic_string< Char, Traits, Alloc > >
- {
- typedef Char type;
- };
-
- template < typename Char, std::size_t N >
- struct stream_char_common< boost::array< Char, N > >: public boost::mpl::if_c<
- boost::detail::is_char_or_wchar< Char >::value,
- Char,
- boost::detail::deduce_character_type_later< boost::array< Char, N > >
- > {};
-
- template < typename Char, std::size_t N >
- struct stream_char_common< boost::array< const Char, N > >: public boost::mpl::if_c<
- boost::detail::is_char_or_wchar< Char >::value,
- Char,
- boost::detail::deduce_character_type_later< boost::array< const Char, N > >
- > {};
-
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
- template < typename Char, std::size_t N >
- struct stream_char_common< std::array<Char, N > >: public boost::mpl::if_c<
- boost::detail::is_char_or_wchar< Char >::value,
- Char,
- boost::detail::deduce_character_type_later< std::array< Char, N > >
- > {};
-
- template < typename Char, std::size_t N >
- struct stream_char_common< std::array< const Char, N > >: public boost::mpl::if_c<
- boost::detail::is_char_or_wchar< Char >::value,
- Char,
- boost::detail::deduce_character_type_later< std::array< const Char, N > >
- > {};
-#endif
-
-#ifdef BOOST_HAS_INT128
- template <> struct stream_char_common< boost::int128_type >: public boost::mpl::identity< char > {};
- template <> struct stream_char_common< boost::uint128_type >: public boost::mpl::identity< char > {};
-#endif
-
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T)
- template <>
- struct stream_char_common< wchar_t >
- {
- typedef char type;
- };
-#endif
- }
-
- namespace detail // deduce_source_char_impl<T>
- {
- // If type T is `deduce_character_type_later` type, then tries to deduce
- // character type using boost::has_left_shift<T> metafunction.
- // Otherwise supplied type T is a character type, that must be normalized
- // using normalize_single_byte_char<Char>.
- // Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
- template < class Char >
- struct deduce_source_char_impl
- {
- typedef BOOST_DEDUCED_TYPENAME boost::detail::normalize_single_byte_char< Char >::type type;
- };
-
- template < class T >
- struct deduce_source_char_impl< deduce_character_type_later< T > >
- {
- typedef boost::has_left_shift< std::basic_ostream< char >, T > result_t;
-
-#if defined(BOOST_LCAST_NO_WCHAR_T)
- BOOST_STATIC_ASSERT_MSG((result_t::value),
- "Source type is not std::ostream`able and std::wostream`s are not supported by your STL implementation");
- typedef char type;
-#else
- typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
- result_t::value, char, wchar_t
- >::type type;
-
- BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_left_shift< std::basic_ostream< type >, T >::value),
- "Source type is neither std::ostream`able nor std::wostream`able");
-#endif
- };
- }
-
- namespace detail // deduce_target_char_impl<T>
- {
- // If type T is `deduce_character_type_later` type, then tries to deduce
- // character type using boost::has_right_shift<T> metafunction.
- // Otherwise supplied type T is a character type, that must be normalized
- // using normalize_single_byte_char<Char>.
- // Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
- template < class Char >
- struct deduce_target_char_impl
- {
- typedef BOOST_DEDUCED_TYPENAME normalize_single_byte_char< Char >::type type;
- };
-
- template < class T >
- struct deduce_target_char_impl< deduce_character_type_later<T> >
- {
- typedef boost::has_right_shift<std::basic_istream<char>, T > result_t;
-
-#if defined(BOOST_LCAST_NO_WCHAR_T)
- BOOST_STATIC_ASSERT_MSG((result_t::value),
- "Target type is not std::istream`able and std::wistream`s are not supported by your STL implementation");
- typedef char type;
-#else
- typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
- result_t::value, char, wchar_t
- >::type type;
-
- BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_right_shift<std::basic_istream<wchar_t>, T >::value),
- "Target type is neither std::istream`able nor std::wistream`able");
-#endif
- };
- }
-
- namespace detail // deduce_target_char<T> and deduce_source_char<T>
- {
- // We deduce stream character types in two stages.
- //
- // Stage 1 is common for Target and Source. At Stage 1 we get
- // non normalized character type (may contain unsigned/signed char)
- // or deduce_character_type_later<T> where T is the original type.
- // Stage 1 is executed by stream_char_common<T>
- //
- // At Stage 2 we normalize character types or try to deduce character
- // type using metafunctions.
- // Stage 2 is executed by deduce_target_char_impl<T> and
- // deduce_source_char_impl<T>
- //
- // deduce_target_char<T> and deduce_source_char<T> functions combine
- // both stages
-
- template < class T >
- struct deduce_target_char
- {
- typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
- typedef BOOST_DEDUCED_TYPENAME deduce_target_char_impl< stage1_type >::type stage2_type;
-
- typedef stage2_type type;
- };
-
- template < class T >
- struct deduce_source_char
- {
- typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
- typedef BOOST_DEDUCED_TYPENAME deduce_source_char_impl< stage1_type >::type stage2_type;
-
- typedef stage2_type type;
- };
- }
-
- namespace detail // deduce_char_traits template
- {
- // We are attempting to get char_traits<> from Source or Tagret
- // template parameter. Otherwise we'll be using std::char_traits<Char>
- template < class Char, class Target, class Source >
- struct deduce_char_traits
- {
- typedef std::char_traits< Char > type;
- };
-
- template < class Char, class Traits, class Alloc, class Source >
- struct deduce_char_traits< Char
- , std::basic_string< Char, Traits, Alloc >
- , Source
- >
- {
- typedef Traits type;
- };
-
- template < class Char, class Target, class Traits, class Alloc >
- struct deduce_char_traits< Char
- , Target
- , std::basic_string< Char, Traits, Alloc >
- >
- {
- typedef Traits type;
- };
-
- template < class Char, class Traits, class Alloc, class Source >
- struct deduce_char_traits< Char
- , boost::container::basic_string< Char, Traits, Alloc >
- , Source
- >
- {
- typedef Traits type;
- };
-
- template < class Char, class Target, class Traits, class Alloc >
- struct deduce_char_traits< Char
- , Target
- , boost::container::basic_string< Char, Traits, Alloc >
- >
- {
- typedef Traits type;
- };
-
- template < class Char, class Traits, class Alloc1, class Alloc2 >
- struct deduce_char_traits< Char
- , std::basic_string< Char, Traits, Alloc1 >
- , std::basic_string< Char, Traits, Alloc2 >
- >
- {
- typedef Traits type;
- };
-
- template<class Char, class Traits, class Alloc1, class Alloc2>
- struct deduce_char_traits< Char
- , boost::container::basic_string< Char, Traits, Alloc1 >
- , boost::container::basic_string< Char, Traits, Alloc2 >
- >
- {
- typedef Traits type;
- };
-
- template < class Char, class Traits, class Alloc1, class Alloc2 >
- struct deduce_char_traits< Char
- , boost::container::basic_string< Char, Traits, Alloc1 >
- , std::basic_string< Char, Traits, Alloc2 >
- >
- {
- typedef Traits type;
- };
-
- template < class Char, class Traits, class Alloc1, class Alloc2 >
- struct deduce_char_traits< Char
- , std::basic_string< Char, Traits, Alloc1 >
- , boost::container::basic_string< Char, Traits, Alloc2 >
- >
- {
- typedef Traits type;
- };
- }
-
- namespace detail // array_to_pointer_decay<T>
- {
- template<class T>
- struct array_to_pointer_decay
- {
- typedef T type;
- };
-
- template<class T, std::size_t N>
- struct array_to_pointer_decay<T[N]>
- {
- typedef const T * type;
- };
- }
-
- namespace detail // is_this_float_conversion_optimized<Float, Char>
- {
- // this metafunction evaluates to true, if we have optimized comnversion
- // from Float type to Char array.
- // Must be in sync with lexical_stream_limited_src<Char, ...>::shl_real_type(...)
- template <typename Float, typename Char>
- struct is_this_float_conversion_optimized
- {
- typedef boost::type_traits::ice_and<
- boost::is_float<Float>::value,
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
- boost::type_traits::ice_or<
- boost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value,
- boost::is_same<Char, wchar_t>::value
- >::value
-#else
- boost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value
-#endif
- > result_type;
-
- BOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
- };
- }
-
- namespace detail // lcast_src_length
- {
- // Return max. length of string representation of Source;
- template< class Source // Source type of lexical_cast.
- >
- struct lcast_src_length
- {
- BOOST_STATIC_CONSTANT(std::size_t, value = 1);
- // To check coverage, build the test with
- // bjam --v2 profile optimization=off
- static void check_coverage() {}
- };
-
- // Helper for integral types.
- // Notes on length calculation:
- // Max length for 32bit int with grouping "\1" and thousands_sep ',':
- // "-2,1,4,7,4,8,3,6,4,7"
- // ^ - is_signed
- // ^ - 1 digit not counted by digits10
- // ^^^^^^^^^^^^^^^^^^ - digits10 * 2
- //
- // Constant is_specialized is used instead of constant 1
- // to prevent buffer overflow in a rare case when
- // <boost/limits.hpp> doesn't add missing specialization for
- // numeric_limits<T> for some integral type T.
- // When is_specialized is false, the whole expression is 0.
- template<class Source>
- struct lcast_src_length_integral
- {
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
- BOOST_STATIC_CONSTANT(std::size_t, value =
- std::numeric_limits<Source>::is_signed +
- std::numeric_limits<Source>::is_specialized + /* == 1 */
- std::numeric_limits<Source>::digits10 * 2
- );
-#else
- BOOST_STATIC_CONSTANT(std::size_t, value = 156);
- BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256);
-#endif
- };
-
-#define BOOST_LCAST_DEF(T) \
- template<> struct lcast_src_length<T> \
- : lcast_src_length_integral<T> \
- { static void check_coverage() {} };
-
- BOOST_LCAST_DEF(short)
- BOOST_LCAST_DEF(unsigned short)
- BOOST_LCAST_DEF(int)
- BOOST_LCAST_DEF(unsigned int)
- BOOST_LCAST_DEF(long)
- BOOST_LCAST_DEF(unsigned long)
-#if defined(BOOST_HAS_LONG_LONG)
- BOOST_LCAST_DEF(boost::ulong_long_type)
- BOOST_LCAST_DEF(boost::long_long_type )
-#elif defined(BOOST_HAS_MS_INT64)
- BOOST_LCAST_DEF(unsigned __int64)
- BOOST_LCAST_DEF( __int64)
-#endif
-#ifdef BOOST_HAS_INT128
- BOOST_LCAST_DEF(boost::int128_type)
- BOOST_LCAST_DEF(boost::uint128_type)
-#endif
-
-#undef BOOST_LCAST_DEF
-
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
- // Helper for floating point types.
- // -1.23456789e-123456
- // ^ sign
- // ^ leading digit
- // ^ decimal point
- // ^^^^^^^^ lcast_precision<Source>::value
- // ^ "e"
- // ^ exponent sign
- // ^^^^^^ exponent (assumed 6 or less digits)
- // sign + leading digit + decimal point + "e" + exponent sign == 5
- template<class Source>
- struct lcast_src_length_floating
- {
- BOOST_STATIC_ASSERT(
- std::numeric_limits<Source>::max_exponent10 <= 999999L &&
- std::numeric_limits<Source>::min_exponent10 >= -999999L
- );
- BOOST_STATIC_CONSTANT(std::size_t, value =
- 5 + lcast_precision<Source>::value + 6
- );
- };
-
- template<>
- struct lcast_src_length<float>
- : lcast_src_length_floating<float>
- {
- static void check_coverage() {}
- };
-
- template<>
- struct lcast_src_length<double>
- : lcast_src_length_floating<double>
- {
- static void check_coverage() {}
- };
-
- template<>
- struct lcast_src_length<long double>
- : lcast_src_length_floating<long double>
- {
- static void check_coverage() {}
- };
-
-#endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
- }
-
- namespace detail // lexical_cast_stream_traits<Source, Target>
- {
- template <class Source, class Target>
- struct lexical_cast_stream_traits {
- typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src;
- typedef BOOST_DEDUCED_TYPENAME boost::remove_cv<src>::type no_cv_src;
-
- typedef boost::detail::deduce_source_char<no_cv_src> deduce_src_char_metafunc;
- typedef BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::type src_char_t;
- typedef BOOST_DEDUCED_TYPENAME boost::detail::deduce_target_char<Target>::type target_char_t;
-
- typedef BOOST_DEDUCED_TYPENAME boost::detail::widest_char<
- target_char_t, src_char_t
- >::type char_type;
-
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char16_t, src_char_t>::value
- && !boost::is_same<char16_t, target_char_t>::value),
- "Your compiler does not have full support for char16_t" );
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char32_t, src_char_t>::value
- && !boost::is_same<char32_t, target_char_t>::value),
- "Your compiler does not have full support for char32_t" );
-#endif
-
- typedef BOOST_DEDUCED_TYPENAME boost::detail::deduce_char_traits<
- char_type, Target, no_cv_src
- >::type traits;
-
- typedef boost::type_traits::ice_and<
- boost::is_same<char, src_char_t>::value, // source is not a wide character based type
- boost::type_traits::ice_ne<sizeof(char), sizeof(target_char_t) >::value, // target type is based on wide character
- boost::type_traits::ice_not<
- boost::detail::is_char_or_wchar<no_cv_src>::value // single character widening is optimized
- >::value // and does not requires stringbuffer
- > is_string_widening_required_t;
-
- typedef boost::type_traits::ice_not< boost::type_traits::ice_or<
- boost::is_integral<no_cv_src>::value,
- boost::detail::is_this_float_conversion_optimized<no_cv_src, char_type >::value,
- boost::detail::is_char_or_wchar<
- BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type // if we did not get character type at stage1
- >::value // then we have no optimization for that type
- >::value > is_source_input_not_optimized_t;
-
- // If we have an optimized conversion for
- // Source, we do not need to construct stringbuf.
- BOOST_STATIC_CONSTANT(bool, requires_stringbuf =
- (boost::type_traits::ice_or<
- is_string_widening_required_t::value, is_source_input_not_optimized_t::value
- >::value)
- );
-
- typedef boost::detail::lcast_src_length<no_cv_src> len_t;
- };
- }
-
- namespace detail // '0', '+' and '-' constants
- {
- template < typename Char > struct lcast_char_constants;
-
- template<>
- struct lcast_char_constants<char>
- {
- BOOST_STATIC_CONSTANT(char, zero = '0');
- BOOST_STATIC_CONSTANT(char, minus = '-');
- BOOST_STATIC_CONSTANT(char, plus = '+');
- BOOST_STATIC_CONSTANT(char, lowercase_e = 'e');
- BOOST_STATIC_CONSTANT(char, capital_e = 'E');
- BOOST_STATIC_CONSTANT(char, c_decimal_separator = '.');
- };
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
- template<>
- struct lcast_char_constants<wchar_t>
- {
- BOOST_STATIC_CONSTANT(wchar_t, zero = L'0');
- BOOST_STATIC_CONSTANT(wchar_t, minus = L'-');
- BOOST_STATIC_CONSTANT(wchar_t, plus = L'+');
- BOOST_STATIC_CONSTANT(wchar_t, lowercase_e = L'e');
- BOOST_STATIC_CONSTANT(wchar_t, capital_e = L'E');
- BOOST_STATIC_CONSTANT(wchar_t, c_decimal_separator = L'.');
- };
-#endif
-
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- template<>
- struct lcast_char_constants<char16_t>
- {
- BOOST_STATIC_CONSTANT(char16_t, zero = u'0');
- BOOST_STATIC_CONSTANT(char16_t, minus = u'-');
- BOOST_STATIC_CONSTANT(char16_t, plus = u'+');
- BOOST_STATIC_CONSTANT(char16_t, lowercase_e = u'e');
- BOOST_STATIC_CONSTANT(char16_t, capital_e = u'E');
- BOOST_STATIC_CONSTANT(char16_t, c_decimal_separator = u'.');
- };
-#endif
-
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- template<>
- struct lcast_char_constants<char32_t>
- {
- BOOST_STATIC_CONSTANT(char32_t, zero = U'0');
- BOOST_STATIC_CONSTANT(char32_t, minus = U'-');
- BOOST_STATIC_CONSTANT(char32_t, plus = U'+');
- BOOST_STATIC_CONSTANT(char32_t, lowercase_e = U'e');
- BOOST_STATIC_CONSTANT(char32_t, capital_e = U'E');
- BOOST_STATIC_CONSTANT(char32_t, c_decimal_separator = U'.');
- };
-#endif
- }
-
- namespace detail // lcast_to_unsigned
- {
- template<class T>
- inline
- BOOST_DEDUCED_TYPENAME make_unsigned<T>::type lcast_to_unsigned(T value) BOOST_NOEXCEPT
- {
- typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type result_type;
- return static_cast<result_type>(
- value < 0 ? 0u - static_cast<result_type>(value) : value
- );
- }
- }
-
- namespace detail // lcast_put_unsigned
- {
- template<class Traits, class T, class CharT>
- CharT* lcast_put_unsigned(const T n_param, CharT* finish)
- {
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
- BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
-#endif
-
- typedef typename Traits::int_type int_type;
- CharT const czero = lcast_char_constants<CharT>::zero;
- int_type const zero = Traits::to_int_type(czero);
- BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
- (sizeof(int_type) > sizeof(T))
- , int_type
- , T
- >::type n = n_param;
-
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
- std::locale loc;
- if (loc != std::locale::classic()) {
- typedef std::numpunct<CharT> numpunct;
- numpunct const& np = BOOST_USE_FACET(numpunct, loc);
- std::string const grouping = np.grouping();
- std::string::size_type const grouping_size = grouping.size();
-
- if ( grouping_size && grouping[0] > 0 )
- {
-
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
- // Check that ulimited group is unreachable:
- BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX);
-#endif
- CharT thousands_sep = np.thousands_sep();
- std::string::size_type group = 0; // current group number
- char last_grp_size = grouping[0];
- char left = last_grp_size;
-
- do
- {
- if(left == 0)
- {
- ++group;
- if(group < grouping_size)
- {
- char const grp_size = grouping[group];
- last_grp_size = grp_size <= 0 ? static_cast<char>(CHAR_MAX) : grp_size;
- }
-
- left = last_grp_size;
- --finish;
- Traits::assign(*finish, thousands_sep);
- }
-
- --left;
-
- --finish;
- int_type const digit = static_cast<int_type>(n % 10U);
- Traits::assign(*finish, Traits::to_char_type(zero + digit));
- n /= 10;
- } while(n);
- return finish;
- }
- }
-#endif
- {
- do
- {
- --finish;
- int_type const digit = static_cast<int_type>(n % 10U);
- Traits::assign(*finish, Traits::to_char_type(zero + digit));
- n /= 10;
- } while(n);
- }
-
- return finish;
- }
- }
-
- namespace detail // lcast_ret_unsigned
- {
- template<class Traits, class T, class CharT>
- inline bool lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end)
- {
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
- BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
-
- // GCC when used with flag -std=c++0x may not have std::numeric_limits
- // specializations for __int128 and unsigned __int128 types.
- // Try compilation with -std=gnu++0x or -std=gnu++11.
- //
- // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856
- BOOST_STATIC_ASSERT_MSG(std::numeric_limits<T>::is_specialized,
- "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast"
- );
-#endif
- CharT const czero = lcast_char_constants<CharT>::zero;
- --end;
- value = 0;
-
- if (begin > end || *end < czero || *end >= czero + 10)
- return false;
- value = static_cast<T>(*end - czero);
- --end;
- T multiplier = 1;
- bool multiplier_overflowed = false;
-
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
- std::locale loc;
- if (loc != std::locale::classic()) {
- typedef std::numpunct<CharT> numpunct;
- numpunct const& np = BOOST_USE_FACET(numpunct, loc);
- std::string const& grouping = np.grouping();
- std::string::size_type const grouping_size = grouping.size();
-
- /* According to Programming languages - C++
- * we MUST check for correct grouping
- */
- if (grouping_size && grouping[0] > 0)
- {
- unsigned char current_grouping = 0;
- CharT const thousands_sep = np.thousands_sep();
- char remained = static_cast<char>(grouping[current_grouping] - 1);
- bool shall_we_return = true;
-
- for(;end>=begin; --end)
- {
- if (remained) {
- T const multiplier_10 = static_cast<T>(multiplier * 10);
- if (multiplier_10 / 10 != multiplier) multiplier_overflowed = true;
-
- T const dig_value = static_cast<T>(*end - czero);
- T const new_sub_value = static_cast<T>(multiplier_10 * dig_value);
-
- if (*end < czero || *end >= czero + 10
- /* detecting overflow */
- || (dig_value && new_sub_value / dig_value != multiplier_10)
- || static_cast<T>((std::numeric_limits<T>::max)()-new_sub_value) < value
- || (multiplier_overflowed && dig_value)
- )
- return false;
-
- value = static_cast<T>(value + new_sub_value);
- multiplier = static_cast<T>(multiplier * 10);
- --remained;
- } else {
- if ( !Traits::eq(*end, thousands_sep) ) //|| begin == end ) return false;
- {
- /*
- * According to Programming languages - C++
- * Digit grouping is checked. That is, the positions of discarded
- * separators is examined for consistency with
- * use_facet<numpunct<charT> >(loc ).grouping()
- *
- * BUT what if there is no separators at all and grouping()
- * is not empty? Well, we have no extraced separators, so we
- * won`t check them for consistency. This will allow us to
- * work with "C" locale from other locales
- */
- shall_we_return = false;
- break;
- } else {
- if ( begin == end ) return false;
- if (current_grouping < grouping_size-1 ) ++current_grouping;
- remained = grouping[current_grouping];
- }
- }
- }
-
- if (shall_we_return) return true;
- }
- }
-#endif
- {
- while ( begin <= end )
- {
- T const multiplier_10 = static_cast<T>(multiplier * 10);
- if (multiplier_10 / 10 != multiplier) multiplier_overflowed = true;
-
- T const dig_value = static_cast<T>(*end - czero);
- T const new_sub_value = static_cast<T>(multiplier_10 * dig_value);
-
- if (*end < czero || *end >= czero + 10
- /* detecting overflow */
- || (dig_value && new_sub_value / dig_value != multiplier_10)
- || static_cast<T>((std::numeric_limits<T>::max)()-new_sub_value) < value
- || (multiplier_overflowed && dig_value)
- )
- return false;
-
- value = static_cast<T>(value + new_sub_value);
- multiplier = static_cast<T>(multiplier * 10);
- --end;
- }
- }
- return true;
- }
- }
-
- namespace detail
- {
- template <class CharT>
- bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) BOOST_NOEXCEPT {
- for( unsigned int i=0; i < len; ++i ) {
- if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
- }
-
- return true;
- }
-
- /* Returns true and sets the correct value if found NaN or Inf. */
- template <class CharT, class T>
- inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
- , const CharT* lc_NAN, const CharT* lc_nan
- , const CharT* lc_INFINITY, const CharT* lc_infinity
- , const CharT opening_brace, const CharT closing_brace) BOOST_NOEXCEPT
- {
- using namespace std;
- if (begin == end) return false;
- const CharT minus = lcast_char_constants<CharT>::minus;
- const CharT plus = lcast_char_constants<CharT>::plus;
- const int inifinity_size = 8;
-
- bool has_minus = false;
- /* Parsing +/- */
- if( *begin == minus)
- {
- ++ begin;
- has_minus = true;
- }
- else if( *begin == plus ) ++begin;
-
- if( end-begin < 3 ) return false;
- if( lc_iequal(begin, lc_nan, lc_NAN, 3) )
- {
- begin += 3;
- if (end != begin) /* It is 'nan(...)' or some bad input*/
- {
- if(end-begin<2) return false; // bad input
- -- end;
- if( *begin != opening_brace || *end != closing_brace) return false; // bad input
- }
-
- if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
- else value = (boost::math::changesign) (std::numeric_limits<T>::quiet_NaN());
- return true;
- } else
- if (( /* 'INF' or 'inf' */
- end-begin==3
- &&
- lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
- )
- ||
- ( /* 'INFINITY' or 'infinity' */
- end-begin==inifinity_size
- &&
- lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
- )
- )
- {
- if( !has_minus ) value = std::numeric_limits<T>::infinity();
- else value = (boost::math::changesign) (std::numeric_limits<T>::infinity());
- return true;
- }
-
- return false;
- }
-
- template <class CharT, class T>
- bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
- , const CharT* lc_nan
- , const CharT* lc_infinity) BOOST_NOEXCEPT
- {
- using namespace std;
- const CharT minus = lcast_char_constants<CharT>::minus;
- if ( (boost::math::isnan)(value) )
- {
- if ( (boost::math::signbit)(value) )
- {
- *begin = minus;
- ++ begin;
- }
-
- memcpy(begin, lc_nan, 3 * sizeof(CharT));
- end = begin + 3;
- return true;
- } else if ( (boost::math::isinf)(value) )
- {
- if ( (boost::math::signbit)(value) )
- {
- *begin = minus;
- ++ begin;
- }
-
- memcpy(begin, lc_infinity, 3 * sizeof(CharT));
- end = begin + 3;
- return true;
- }
-
- return false;
- }
-
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
- template <class T>
- bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT
- {
- return parse_inf_nan_impl(begin, end, value
- , L"NAN", L"nan"
- , L"INFINITY", L"infinity"
- , L'(', L')');
- }
-
- template <class T>
- bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT
- {
- return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
- }
-
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- template <class T>
- bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT
- {
- return parse_inf_nan_impl(begin, end, value
- , u"NAN", u"nan"
- , u"INFINITY", u"infinity"
- , u'(', u')');
- }
-
- template <class T>
- bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT
- {
- return put_inf_nan_impl(begin, end, value, u"nan", u"infinity");
- }
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- template <class T>
- bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT
- {
- return parse_inf_nan_impl(begin, end, value
- , U"NAN", U"nan"
- , U"INFINITY", U"infinity"
- , U'(', U')');
- }
-
- template <class T>
- bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT
- {
- return put_inf_nan_impl(begin, end, value, U"nan", U"infinity");
- }
-#endif
-
- template <class CharT, class T>
- bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT
- {
- return parse_inf_nan_impl(begin, end, value
- , "NAN", "nan"
- , "INFINITY", "infinity"
- , '(', ')');
- }
-
- template <class CharT, class T>
- bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT
- {
- return put_inf_nan_impl(begin, end, value, "nan", "infinity");
- }
- }
-
-
- namespace detail // lcast_ret_float
- {
-
-// Silence buggy MS warnings like C4244: '+=' : conversion from 'int' to 'unsigned short', possible loss of data
-#if defined(_MSC_VER) && (_MSC_VER == 1400)
-# pragma warning(push)
-# pragma warning(disable:4244)
-#endif
- template <class T>
- struct mantissa_holder_type
- {
- /* Can not be used with this type */
- };
-
- template <>
- struct mantissa_holder_type<float>
- {
- typedef unsigned int type;
- typedef double wide_result_t;
- };
-
- template <>
- struct mantissa_holder_type<double>
- {
-#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
- typedef long double wide_result_t;
-#if defined(BOOST_HAS_LONG_LONG)
- typedef boost::ulong_long_type type;
-#elif defined(BOOST_HAS_MS_INT64)
- typedef unsigned __int64 type;
-#endif
-#endif
- };
-
- template<class Traits, class T, class CharT>
- inline bool lcast_ret_float(T& value, const CharT* begin, const CharT* end)
- {
-
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
- std::locale loc;
- typedef std::numpunct<CharT> numpunct;
- numpunct const& np = BOOST_USE_FACET(numpunct, loc);
- std::string const grouping(
- (loc == std::locale::classic())
- ? std::string()
- : np.grouping()
- );
- std::string::size_type const grouping_size = grouping.size();
- CharT const thousands_sep = static_cast<CharT>(grouping_size ? np.thousands_sep() : 0);
- CharT const decimal_point = np.decimal_point();
- bool found_grouping = false;
- std::string::size_type last_grouping_pos = grouping_size - 1;
-#else
- CharT const decimal_point = lcast_char_constants<CharT>::c_decimal_separator;
-#endif
-
- CharT const czero = lcast_char_constants<CharT>::zero;
- CharT const minus = lcast_char_constants<CharT>::minus;
- CharT const plus = lcast_char_constants<CharT>::plus;
- CharT const capital_e = lcast_char_constants<CharT>::capital_e;
- CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
-
- value = static_cast<T>(0);
-
- if (parse_inf_nan(begin, end, value)) return true;
-
- typedef typename Traits::int_type int_type;
- typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::type mantissa_type;
- typedef BOOST_DEDUCED_TYPENAME mantissa_holder_type<T>::wide_result_t wide_result_t;
- int_type const zero = Traits::to_int_type(czero);
- if (begin == end) return false;
-
- /* Getting the plus/minus sign */
- bool has_minus = false;
- if (Traits::eq(*begin, minus) ) {
- ++ begin;
- has_minus = true;
- if (begin == end) return false;
- } else if (Traits::eq(*begin, plus) ) {
- ++begin;
- if (begin == end) return false;
- }
-
- bool found_decimal = false;
- bool found_number_before_exp = false;
- int pow_of_10 = 0;
- mantissa_type mantissa=0;
- bool is_mantissa_full = false;
-
- char length_since_last_delim = 0;
-
- while ( begin != end )
- {
- if (found_decimal) {
- /* We allow no thousand_separators after decimal point */
-
- mantissa_type tmp_mantissa = mantissa * 10u;
- if (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) break;
- if ( *begin < czero || *begin >= czero + 10 ) return false;
- if ( is_mantissa_full
- || tmp_mantissa / 10u != mantissa
- || (std::numeric_limits<mantissa_type>::max)()-(*begin - zero) < tmp_mantissa
- ) {
- is_mantissa_full = true;
- ++ begin;
- continue;
- }
-
- -- pow_of_10;
- mantissa = tmp_mantissa;
- mantissa += *begin - zero;
-
- found_number_before_exp = true;
- } else {
-
- if (*begin >= czero && *begin < czero + 10) {
-
- /* Checking for mantissa overflow. If overflow will
- * occur, them we only increase multiplyer
- */
- mantissa_type tmp_mantissa = mantissa * 10u;
- if( !is_mantissa_full
- && tmp_mantissa / 10u == mantissa
- && (std::numeric_limits<mantissa_type>::max)()-(*begin - zero) >= tmp_mantissa
- )
- {
- mantissa = tmp_mantissa;
- mantissa += *begin - zero;
- } else
- {
- is_mantissa_full = true;
- ++ pow_of_10;
- }
-
- found_number_before_exp = true;
- ++ length_since_last_delim;
- } else if (Traits::eq(*begin, decimal_point) || Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) {
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
- /* If ( we need to check grouping
- * and ( grouping missmatches
- * or grouping position is incorrect
- * or we are using the grouping position 0 twice
- * )
- * ) then return error
- */
- if( grouping_size && found_grouping
- && (
- length_since_last_delim != grouping[0]
- || last_grouping_pos>1
- || (last_grouping_pos==0 && grouping_size>1)
- )
- ) return false;
-#endif
-
- if(Traits::eq(*begin, decimal_point)) {
- ++ begin;
- found_decimal = true;
- if (!found_number_before_exp && begin==end) return false;
- continue;
- }else {
- if (!found_number_before_exp) return false;
- break;
- }
- }
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
- else if (grouping_size && Traits::eq(*begin, thousands_sep)){
- if(found_grouping)
- {
- /* It is not he first time, when we find thousands separator,
- * so we need to chek, is the distance between two groupings
- * equal to grouping[last_grouping_pos] */
-
- if (length_since_last_delim != grouping[last_grouping_pos] )
- {
- if (!last_grouping_pos) return false;
- else
- {
- -- last_grouping_pos;
- if (length_since_last_delim != grouping[last_grouping_pos]) return false;
- }
- } else
- /* We are calling the grouping[0] twice, when grouping size is more than 1 */
- if (grouping_size>1u && last_grouping_pos+1<grouping_size) return false;
-
- } else {
- /* Delimiter at the begining ',000' */
- if (!length_since_last_delim) return false;
-
- found_grouping = true;
- if (length_since_last_delim > grouping[last_grouping_pos] ) return false;
- }
-
- length_since_last_delim = 0;
- ++ begin;
-
- /* Delimiter at the end '100,' */
- if (begin == end) return false;
- continue;
- }
-#endif
- else return false;
- }
-
- ++begin;
- }
-
- // Exponent found
- if ( begin != end && (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) ) {
- ++ begin;
- if ( begin == end ) return false;
-
- bool exp_has_minus = false;
- if(Traits::eq(*begin, minus)) {
- exp_has_minus = true;
- ++ begin;
- if ( begin == end ) return false;
- } else if (Traits::eq(*begin, plus)) {
- ++ begin;
- if ( begin == end ) return false;
- }
-
- int exp_pow_of_10 = 0;
- while ( begin != end )
- {
- if ( *begin < czero
- || *begin >= czero + 10
- || exp_pow_of_10 * 10 < exp_pow_of_10) /* Overflows are checked lower more precisely*/
- return false;
-
- exp_pow_of_10 *= 10;
- exp_pow_of_10 += *begin - zero;
- ++ begin;
- };
-
- if ( exp_pow_of_10 ) {
- /* Overflows are checked lower */
- if ( exp_has_minus ) {
- pow_of_10 -= exp_pow_of_10;
- } else {
- pow_of_10 += exp_pow_of_10;
- }
- }
- }
-
- /* We need a more accurate algorithm... We can not use current algorithm
- * with long doubles (and with doubles if sizeof(double)==sizeof(long double)).
- */
- const wide_result_t result = std::pow(static_cast<wide_result_t>(10.0), pow_of_10) * mantissa;
- value = static_cast<T>( has_minus ? (boost::math::changesign)(result) : result);
-
- if ( (boost::math::isinf)(value) || (boost::math::isnan)(value) ) return false;
-
- return true;
- }
-// Unsilence buggy MS warnings like C4244: '+=' : conversion from 'int' to 'unsigned short', possible loss of data
-#if defined(_MSC_VER) && (_MSC_VER == 1400)
-# pragma warning(pop)
-#endif
- }
-
- namespace detail // parser_buf
- {
- //
- // class parser_buf:
- // acts as a stream buffer which wraps around a pair of pointers
- //
- // This class is copied (and slightly changed) from
- // boost/regex/v4/cpp_regex_traits.hpp
- // Thanks John Maddock for it! (previous version had some
- // problems with libc++ and some other STL implementations)
- template <class BufferType, class charT>
- class parser_buf : public BufferType {
- typedef BufferType base_type;
- typedef typename base_type::int_type int_type;
- typedef typename base_type::char_type char_type;
- typedef typename base_type::pos_type pos_type;
- typedef ::std::streamsize streamsize;
- typedef typename base_type::off_type off_type;
-
- public:
- parser_buf() : base_type() { setbuf(0, 0); }
- const charT* getnext() { return this->gptr(); }
-#ifndef BOOST_NO_USING_TEMPLATE
- using base_type::pptr;
- using base_type::pbase;
-#else
- charT* pptr() const { return base_type::pptr(); }
- charT* pbase() const { return base_type::pbase(); }
-#endif
- base_type* setbuf(char_type* s, streamsize n) {
- this->setg(s, s, s + n);
- return this;
- }
-
- pos_type seekpos(pos_type sp, ::std::ios_base::openmode which) {
- if(which & ::std::ios_base::out)
- return pos_type(off_type(-1));
- off_type size = static_cast<off_type>(this->egptr() - this->eback());
- charT* g = this->eback();
- if(off_type(sp) <= size)
- {
- this->setg(g, g + off_type(sp), g + size);
- }
- return pos_type(off_type(-1));
- }
-
- pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) {
- typedef typename boost::int_t<sizeof(way) * CHAR_BIT>::least cast_type;
-
- if(which & ::std::ios_base::out)
- return pos_type(off_type(-1));
- std::ptrdiff_t size = this->egptr() - this->eback();
- std::ptrdiff_t pos = this->gptr() - this->eback();
- charT* g = this->eback();
- switch(static_cast<cast_type>(way))
- {
- case ::std::ios_base::beg:
- if((off < 0) || (off > size))
- return pos_type(off_type(-1));
- else
- this->setg(g, g + off, g + size);
- break;
- case ::std::ios_base::end:
- if((off < 0) || (off > size))
- return pos_type(off_type(-1));
- else
- this->setg(g, g + size - off, g + size);
- break;
- case ::std::ios_base::cur:
- {
- std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off);
- if((newpos < 0) || (newpos > size))
- return pos_type(off_type(-1));
- else
- this->setg(g, g + newpos, g + size);
- break;
- }
- default: ;
- }
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4244)
-#endif
- return static_cast<pos_type>(this->gptr() - this->eback());
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
- }
- private:
- parser_buf& operator=(const parser_buf&);
- parser_buf(const parser_buf&);
- };
- }
-
- namespace detail
- {
- struct do_not_construct_out_stream_t{};
- }
-
- namespace detail // optimized stream wrapper
- {
- // String representation of Source has an upper limit.
- template< class CharT // a result of widest_char transformation
- , class Traits // usually char_traits<CharT>
- , bool RequiresStringbuffer
- >
- class lexical_stream_limited_src
- {
-
-#if defined(BOOST_NO_STRINGSTREAM)
- typedef std::ostrstream out_stream_t;
-#elif defined(BOOST_NO_STD_LOCALE)
- typedef std::ostringstream out_stream_t;
- typedef parser_buf<std::streambuf, char> buffer_t;
-#else
- typedef std::basic_ostringstream<CharT, Traits> out_stream_t;
- typedef parser_buf<std::basic_streambuf<CharT, Traits>, CharT> buffer_t;
-#endif
- typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
- RequiresStringbuffer,
- out_stream_t,
- do_not_construct_out_stream_t
- >::type deduced_out_stream_t;
-
- // A string representation of Source is written to [start, finish).
- CharT* start;
- CharT* finish;
- deduced_out_stream_t out_stream;
-
- public:
- lexical_stream_limited_src(CharT* sta, CharT* fin) BOOST_NOEXCEPT
- : start(sta)
- , finish(fin)
- {}
-
- private:
- // Undefined:
- lexical_stream_limited_src(lexical_stream_limited_src const&);
- void operator=(lexical_stream_limited_src const&);
-
-/************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/
- bool shl_char(CharT ch) BOOST_NOEXCEPT
- {
- Traits::assign(*start, ch);
- finish = start + 1;
- return true;
- }
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
- template <class T>
- bool shl_char(T ch)
- {
- BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) ,
- "boost::lexical_cast does not support narrowing of char types."
- "Use boost::locale instead" );
-#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
- std::locale loc;
- CharT const w = BOOST_USE_FACET(std::ctype<CharT>, loc).widen(ch);
-#else
- CharT const w = static_cast<CharT>(ch);
-#endif
- Traits::assign(*start, w);
- finish = start + 1;
- return true;
- }
-#endif
-
- bool shl_char_array(CharT const* str) BOOST_NOEXCEPT
- {
- start = const_cast<CharT*>(str);
- finish = start + Traits::length(str);
- return true;
- }
-
- template <class T>
- bool shl_char_array(T const* str)
- {
- BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)),
- "boost::lexical_cast does not support narrowing of char types."
- "Use boost::locale instead" );
- return shl_input_streamable(str);
- }
-
- bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT
- {
- start = const_cast<CharT*>(str);
- finish = std::find(start, start + max_size, Traits::to_char_type(0));
- return true;
- }
-
- template<typename InputStreamable>
- bool shl_input_streamable(InputStreamable& input)
- {
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
- // If you have compilation error at this point, than your STL library
- // does not support such conversions. Try updating it.
- BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));
-#endif
-
-#ifndef BOOST_NO_EXCEPTIONS
- out_stream.exceptions(std::ios::badbit);
- try {
-#endif
- bool const result = !(out_stream << input).fail();
- const buffer_t* const p = static_cast<buffer_t*>(
- static_cast<std::basic_streambuf<CharT, Traits>*>(out_stream.rdbuf())
- );
- start = p->pbase();
- finish = p->pptr();
- return result;
-#ifndef BOOST_NO_EXCEPTIONS
- } catch (const ::std::ios_base::failure& /*f*/) {
- return false;
- }
-#endif
- }
-
- template <class T>
- inline bool shl_signed(T n)
- {
- start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
- if(n < 0)
- {
- --start;
- CharT const minus = lcast_char_constants<CharT>::minus;
- Traits::assign(*start, minus);
- }
- return true;
- }
-
- template <class T, class SomeCharT>
- bool shl_real_type(const T& val, SomeCharT* begin, SomeCharT*& end)
- {
- if (put_inf_nan(begin, end, val)) return true;
- lcast_set_precision(out_stream, &val);
- return shl_input_streamable(val);
- }
-
- static bool shl_real_type(float val, char* begin, char*& end)
- { using namespace std;
- if (put_inf_nan(begin, end, val)) return true;
- const double val_as_double = val;
- end = begin +
-#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
- sprintf_s(begin, end-begin,
-#else
- sprintf(begin,
-#endif
- "%.*g", static_cast<int>(boost::detail::lcast_get_precision<float>()), val_as_double);
- return end > begin;
- }
-
- static bool shl_real_type(double val, char* begin, char*& end)
- { using namespace std;
- if (put_inf_nan(begin, end, val)) return true;
- end = begin +
-#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
- sprintf_s(begin, end-begin,
-#else
- sprintf(begin,
-#endif
- "%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val);
- return end > begin;
- }
-
-#ifndef __MINGW32__
- static bool shl_real_type(long double val, char* begin, char*& end)
- { using namespace std;
- if (put_inf_nan(begin, end, val)) return true;
- end = begin +
-#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
- sprintf_s(begin, end-begin,
-#else
- sprintf(begin,
-#endif
- "%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double>()), val );
- return end > begin;
- }
-#endif
-
-
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
- static bool shl_real_type(float val, wchar_t* begin, wchar_t*& end)
- { using namespace std;
- if (put_inf_nan(begin, end, val)) return true;
- const double val_as_double = val;
- end = begin + swprintf(begin, end-begin,
- L"%.*g",
- static_cast<int>(boost::detail::lcast_get_precision<float >()),
- val_as_double );
- return end > begin;
- }
-
- static bool shl_real_type(double val, wchar_t* begin, wchar_t*& end)
- { using namespace std;
- if (put_inf_nan(begin, end, val)) return true;
- end = begin + swprintf(begin, end-begin,
- L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
- return end > begin;
- }
-
- static bool shl_real_type(long double val, wchar_t* begin, wchar_t*& end)
- { using namespace std;
- if (put_inf_nan(begin, end, val)) return true;
- end = begin + swprintf(begin, end-begin,
- L"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val );
- return end > begin;
- }
-#endif
-
-/************************************ OPERATORS << ( ... ) ********************************/
- public:
- template<class Alloc>
- bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT
- {
- start = const_cast<CharT*>(str.data());
- finish = start + str.length();
- return true;
- }
-
- template<class Alloc>
- bool operator<<(boost::container::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT
- {
- start = const_cast<CharT*>(str.data());
- finish = start + str.length();
- return true;
- }
-
- bool operator<<(bool value) BOOST_NOEXCEPT
- {
- CharT const czero = lcast_char_constants<CharT>::zero;
- Traits::assign(*start, Traits::to_char_type(czero + value));
- finish = start + 1;
- return true;
- }
-
- bool operator<<(const iterator_range<CharT*>& rng) BOOST_NOEXCEPT
- {
- start = rng.begin();
- finish = rng.end();
- return true;
- }
-
- bool operator<<(const iterator_range<const CharT*>& rng) BOOST_NOEXCEPT
- {
- start = const_cast<CharT*>(rng.begin());
- finish = const_cast<CharT*>(rng.end());
- return true;
- }
-
- bool operator<<(const iterator_range<const signed char*>& rng) BOOST_NOEXCEPT
- {
- return (*this) << iterator_range<char*>(
- const_cast<char*>(reinterpret_cast<const char*>(rng.begin())),
- const_cast<char*>(reinterpret_cast<const char*>(rng.end()))
- );
- }
-
- bool operator<<(const iterator_range<const unsigned char*>& rng) BOOST_NOEXCEPT
- {
- return (*this) << iterator_range<char*>(
- const_cast<char*>(reinterpret_cast<const char*>(rng.begin())),
- const_cast<char*>(reinterpret_cast<const char*>(rng.end()))
- );
- }
-
- bool operator<<(const iterator_range<signed char*>& rng) BOOST_NOEXCEPT
- {
- return (*this) << iterator_range<char*>(
- reinterpret_cast<char*>(rng.begin()),
- reinterpret_cast<char*>(rng.end())
- );
- }
-
- bool operator<<(const iterator_range<unsigned char*>& rng) BOOST_NOEXCEPT
- {
- return (*this) << iterator_range<char*>(
- reinterpret_cast<char*>(rng.begin()),
- reinterpret_cast<char*>(rng.end())
- );
- }
-
- bool operator<<(char ch) { return shl_char(ch); }
- bool operator<<(unsigned char ch) { return ((*this) << static_cast<char>(ch)); }
- bool operator<<(signed char ch) { return ((*this) << static_cast<char>(ch)); }
-#if !defined(BOOST_LCAST_NO_WCHAR_T)
- bool operator<<(wchar_t const* str) { return shl_char_array(str); }
- bool operator<<(wchar_t * str) { return shl_char_array(str); }
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
- bool operator<<(wchar_t ch) { return shl_char(ch); }
-#endif
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- bool operator<<(char16_t ch) { return shl_char(ch); }
- bool operator<<(char16_t * str) { return shl_char_array(str); }
- bool operator<<(char16_t const * str) { return shl_char_array(str); }
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- bool operator<<(char32_t ch) { return shl_char(ch); }
- bool operator<<(char32_t * str) { return shl_char_array(str); }
- bool operator<<(char32_t const * str) { return shl_char_array(str); }
-#endif
- bool operator<<(unsigned char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
- bool operator<<(unsigned char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
- bool operator<<(signed char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
- bool operator<<(signed char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
- bool operator<<(char const* str) { return shl_char_array(str); }
- bool operator<<(char* str) { return shl_char_array(str); }
- bool operator<<(short n) { return shl_signed(n); }
- bool operator<<(int n) { return shl_signed(n); }
- bool operator<<(long n) { return shl_signed(n); }
- bool operator<<(unsigned short n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
- bool operator<<(unsigned int n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
- bool operator<<(unsigned long n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
-
-#if defined(BOOST_HAS_LONG_LONG)
- bool operator<<(boost::ulong_long_type n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
- bool operator<<(boost::long_long_type n) { return shl_signed(n); }
-#elif defined(BOOST_HAS_MS_INT64)
- bool operator<<(unsigned __int64 n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
- bool operator<<( __int64 n) { return shl_signed(n); }
-#endif
-
-#ifdef BOOST_HAS_INT128
- bool operator<<(const boost::uint128_type& n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
- bool operator<<(const boost::int128_type& n) { return shl_signed(n); }
-#endif
-
- bool operator<<(float val) { return shl_real_type(val, start, finish); }
- bool operator<<(double val) { return shl_real_type(val, start, finish); }
- bool operator<<(long double val) {
-#ifndef __MINGW32__
- return shl_real_type(val, start, finish);
-#else
- return shl_real_type(static_cast<double>(val), start, finish);
-#endif
- }
-
- template <std::size_t N>
- bool operator<<(boost::array<CharT, N> const& input) BOOST_NOEXCEPT
- { return shl_char_array_limited(input.begin(), N); }
-
- template <std::size_t N>
- bool operator<<(boost::array<unsigned char, N> const& input) BOOST_NOEXCEPT
- { return ((*this) << reinterpret_cast<boost::array<char, N> const& >(input)); }
-
- template <std::size_t N>
- bool operator<<(boost::array<signed char, N> const& input) BOOST_NOEXCEPT
- { return ((*this) << reinterpret_cast<boost::array<char, N> const& >(input)); }
-
- template <std::size_t N>
- bool operator<<(boost::array<const CharT, N> const& input) BOOST_NOEXCEPT
- { return shl_char_array_limited(input.begin(), N); }
-
- template <std::size_t N>
- bool operator<<(boost::array<const unsigned char, N> const& input) BOOST_NOEXCEPT
- { return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); }
-
- template <std::size_t N>
- bool operator<<(boost::array<const signed char, N> const& input) BOOST_NOEXCEPT
- { return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); }
-
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
- template <std::size_t N>
- bool operator<<(std::array<CharT, N> const& input) BOOST_NOEXCEPT
- {
- if (input.size()) return shl_char_array_limited(&input[0], N);
- else return true;
- }
-
- template <std::size_t N>
- bool operator<<(std::array<unsigned char, N> const& input) BOOST_NOEXCEPT
- { return ((*this) << reinterpret_cast<boost::array<char, N> const& >(input)); }
-
- template <std::size_t N>
- bool operator<<(std::array<signed char, N> const& input) BOOST_NOEXCEPT
- { return ((*this) << reinterpret_cast<boost::array<char, N> const& >(input)); }
-
- template <std::size_t N>
- bool operator<<(std::array<const CharT, N> const& input) BOOST_NOEXCEPT
- {
- if (input.size()) return shl_char_array_limited(&input[0], N);
- else return true;
- }
-
- template <std::size_t N>
- bool operator<<(std::array<const unsigned char, N> const& input) BOOST_NOEXCEPT
- { return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); }
-
- template <std::size_t N>
- bool operator<<(std::array<const signed char, N> const& input) BOOST_NOEXCEPT
- { return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); }
-#endif
-
- template <class InStreamable>
- bool operator<<(const InStreamable& input) { return shl_input_streamable(input); }
-
-/************************************ HELPER FUNCTIONS FOR OPERATORS >> ( ... ) ********************************/
- private:
-
- template <typename Type>
- bool shr_unsigned(Type& output)
- {
- if (start == finish) return false;
- CharT const minus = lcast_char_constants<CharT>::minus;
- CharT const plus = lcast_char_constants<CharT>::plus;
- bool has_minus = false;
-
- /* We won`t use `start' any more, so no need in decrementing it after */
- if ( Traits::eq(minus,*start) )
- {
- ++start;
- has_minus = true;
- } else if ( Traits::eq( plus, *start ) )
- {
- ++start;
- }
-
- bool const succeed = lcast_ret_unsigned<Traits>(output, start, finish);
-
- if (has_minus) {
- output = static_cast<Type>(0u - output);
- }
-
- return succeed;
- }
-
- template <typename Type>
- bool shr_signed(Type& output)
- {
- if (start == finish) return false;
- CharT const minus = lcast_char_constants<CharT>::minus;
- CharT const plus = lcast_char_constants<CharT>::plus;
- typedef BOOST_DEDUCED_TYPENAME make_unsigned<Type>::type utype;
- utype out_tmp =0;
- bool has_minus = false;
-
- /* We won`t use `start' any more, so no need in decrementing it after */
- if ( Traits::eq(minus,*start) )
- {
- ++start;
- has_minus = true;
- } else if ( Traits::eq(plus, *start) )
- {
- ++start;
- }
-
- bool succeed = lcast_ret_unsigned<Traits>(out_tmp, start, finish);
- if (has_minus) {
- utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits);
- succeed = succeed && out_tmp<=comp_val;
- output = static_cast<Type>(0u - out_tmp);
- } else {
- utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)());
- succeed = succeed && out_tmp<=comp_val;
- output = out_tmp;
- }
- return succeed;
- }
-
- template<typename InputStreamable>
- bool shr_using_base_class(InputStreamable& output)
- {
- BOOST_STATIC_ASSERT_MSG(
- (!boost::is_pointer<InputStreamable>::value),
- "boost::lexical_cast can not convert to pointers"
- );
-
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
- BOOST_STATIC_ASSERT_MSG((boost::is_same<char, CharT>::value),
- "boost::lexical_cast can not convert, because your STL library does not "
- "support such conversions. Try updating it."
- );
-#endif
-
-#if defined(BOOST_NO_STRINGSTREAM)
- std::istrstream stream(start, finish - start);
-#else
-
- buffer_t buf;
- buf.setbuf(start, finish - start);
-#if defined(BOOST_NO_STD_LOCALE)
- std::istream stream(&buf);
-#else
- std::basic_istream<CharT, Traits> stream(&buf);
-#endif // BOOST_NO_STD_LOCALE
-#endif // BOOST_NO_STRINGSTREAM
-
-#ifndef BOOST_NO_EXCEPTIONS
- stream.exceptions(std::ios::badbit);
- try {
-#endif
- stream.unsetf(std::ios::skipws);
- lcast_set_precision(stream, static_cast<InputStreamable*>(0));
-
- return stream >> output &&
- stream.get() ==
-#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING)
- // GCC 2.9x lacks std::char_traits<>::eof().
- // We use BOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3
- // configurations, which do provide std::char_traits<>::eof().
-
- EOF;
-#else
- Traits::eof();
-#endif
-
-#ifndef BOOST_NO_EXCEPTIONS
- } catch (const ::std::ios_base::failure& /*f*/) {
- return false;
- }
-#endif
- }
-
- template<class T>
- inline bool shr_xchar(T& output)
- {
- BOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ),
- "boost::lexical_cast does not support narrowing of character types."
- "Use boost::locale instead" );
- bool const ok = (finish - start == 1);
- if (ok) {
- CharT out;
- Traits::assign(out, *start);
- output = static_cast<T>(out);
- }
- return ok;
- }
-
-/************************************ OPERATORS >> ( ... ) ********************************/
- public:
- bool operator>>(unsigned short& output) { return shr_unsigned(output); }
- bool operator>>(unsigned int& output) { return shr_unsigned(output); }
- bool operator>>(unsigned long int& output) { return shr_unsigned(output); }
- bool operator>>(short& output) { return shr_signed(output); }
- bool operator>>(int& output) { return shr_signed(output); }
- bool operator>>(long int& output) { return shr_signed(output); }
-#if defined(BOOST_HAS_LONG_LONG)
- bool operator>>(boost::ulong_long_type& output) { return shr_unsigned(output); }
- bool operator>>(boost::long_long_type& output) { return shr_signed(output); }
-#elif defined(BOOST_HAS_MS_INT64)
- bool operator>>(unsigned __int64& output) { return shr_unsigned(output); }
- bool operator>>(__int64& output) { return shr_signed(output); }
-#endif
-
-#ifdef BOOST_HAS_INT128
- bool operator>>(boost::uint128_type& output) { return shr_unsigned(output); }
- bool operator>>(boost::int128_type& output) { return shr_signed(output); }
-#endif
-
- bool operator>>(char& output) { return shr_xchar(output); }
- bool operator>>(unsigned char& output) { return shr_xchar(output); }
- bool operator>>(signed char& output) { return shr_xchar(output); }
-#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- bool operator>>(wchar_t& output) { return shr_xchar(output); }
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- bool operator>>(char16_t& output) { return shr_xchar(output); }
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- bool operator>>(char32_t& output) { return shr_xchar(output); }
-#endif
- template<class Alloc>
- bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
-
- template<class Alloc>
- bool operator>>(boost::container::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
-
-
- private:
- template <std::size_t N, class ArrayT>
- bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT
- {
- using namespace std;
- const std::size_t size = finish - start;
- if (size > N - 1) { // `-1` because we need to store \0 at the end
- return false;
- }
-
- memcpy(&output[0], start, size * sizeof(CharT));
- output[size] = Traits::to_char_type(0);
- return true;
- }
-
- public:
-
- template <std::size_t N>
- bool operator>>(boost::array<CharT, N>& output) BOOST_NOEXCEPT
- {
- return shr_std_array<N>(output);
- }
-
- template <std::size_t N>
- bool operator>>(boost::array<unsigned char, N>& output)
- {
- return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
- }
-
- template <std::size_t N>
- bool operator>>(boost::array<signed char, N>& output)
- {
- return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
- }
-
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
- template <std::size_t N>
- bool operator>>(std::array<CharT, N>& output) BOOST_NOEXCEPT
- {
- return shr_std_array<N>(output);
- }
-
- template <std::size_t N>
- bool operator>>(std::array<unsigned char, N>& output)
- {
- return ((*this) >> reinterpret_cast<std::array<char, N>& >(output));
- }
-
- template <std::size_t N>
- bool operator>>(std::array<signed char, N>& output)
- {
- return ((*this) >> reinterpret_cast<std::array<char, N>& >(output));
- }
-#endif
-
-
- /*
- * case "-0" || "0" || "+0" : output = false; return true;
- * case "1" || "+1": output = true; return true;
- * default: return false;
- */
- bool operator>>(bool& output) BOOST_NOEXCEPT
- {
- CharT const zero = lcast_char_constants<CharT>::zero;
- CharT const plus = lcast_char_constants<CharT>::plus;
- CharT const minus = lcast_char_constants<CharT>::minus;
-
- switch(finish-start)
- {
- case 1:
- output = Traits::eq(start[0], zero+1);
- return output || Traits::eq(start[0], zero );
- case 2:
- if ( Traits::eq( plus, *start) )
- {
- ++start;
- output = Traits::eq(start[0], zero +1);
- return output || Traits::eq(start[0], zero );
- } else
- {
- output = false;
- return Traits::eq( minus, *start)
- && Traits::eq( zero, start[1]);
- }
- default:
- output = false; // Suppress warning about uninitalized variable
- return false;
- }
- }
-
- bool operator>>(float& output) { return lcast_ret_float<Traits>(output,start,finish); }
-
- private:
- // Not optimised converter
- template <class T>
- bool float_types_converter_internal(T& output, int /*tag*/) {
- if (parse_inf_nan(start, finish, output)) return true;
- bool return_value = shr_using_base_class(output);
-
- /* Some compilers and libraries successfully
- * parse 'inf', 'INFINITY', '1.0E', '1.0E-'...
- * We are trying to provide a unified behaviour,
- * so we just forbid such conversions (as some
- * of the most popular compilers/libraries do)
- * */
- CharT const minus = lcast_char_constants<CharT>::minus;
- CharT const plus = lcast_char_constants<CharT>::plus;
- CharT const capital_e = lcast_char_constants<CharT>::capital_e;
- CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
- if ( return_value &&
- (
- Traits::eq(*(finish-1), lowercase_e) // 1.0e
- || Traits::eq(*(finish-1), capital_e) // 1.0E
- || Traits::eq(*(finish-1), minus) // 1.0e- or 1.0E-
- || Traits::eq(*(finish-1), plus) // 1.0e+ or 1.0E+
- )
- ) return false;
-
- return return_value;
- }
-
- // Optimised converter
- bool float_types_converter_internal(double& output,char /*tag*/) {
- return lcast_ret_float<Traits>(output,start,finish);
- }
- public:
-
- bool operator>>(double& output)
- {
- /*
- * Some compilers implement long double as double. In that case these types have
- * same size, same precision, same max and min values... And it means,
- * that current implementation of lcast_ret_float cannot be used for type
- * double, because it will give a big precision loss.
- * */
- boost::mpl::if_c<
-#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
- boost::type_traits::ice_eq< sizeof(double), sizeof(long double) >::value,
-#else
- 1,
-#endif
- int,
- char
- >::type tag = 0;
-
- return float_types_converter_internal(output, tag);
- }
-
- bool operator>>(long double& output)
- {
- int tag = 0;
- return float_types_converter_internal(output, tag);
- }
-
- // Generic istream-based algorithm.
- // lcast_streambuf_for_target<InputStreamable>::value is true.
- template<typename InputStreamable>
- bool operator>>(InputStreamable& output) { return shr_using_base_class(output); }
- };
- }
-
- namespace detail
- {
- template<typename T>
- struct is_stdstring
- {
- BOOST_STATIC_CONSTANT(bool, value = false );
- };
-
- template<typename CharT, typename Traits, typename Alloc>
- struct is_stdstring< std::basic_string<CharT, Traits, Alloc> >
- {
- BOOST_STATIC_CONSTANT(bool, value = true );
- };
-
- template<typename CharT, typename Traits, typename Alloc>
- struct is_stdstring< boost::container::basic_string<CharT, Traits, Alloc> >
- {
- BOOST_STATIC_CONSTANT(bool, value = true );
- };
-
- template<typename Target, typename Source>
- struct is_arithmetic_and_not_xchars
- {
- BOOST_STATIC_CONSTANT(bool, value =
- (
- boost::type_traits::ice_and<
- boost::is_arithmetic<Source>::value,
- boost::is_arithmetic<Target>::value,
- boost::type_traits::ice_not<
- detail::is_char_or_wchar<Target>::value
- >::value,
- boost::type_traits::ice_not<
- detail::is_char_or_wchar<Source>::value
- >::value
- >::value
- )
- );
- };
-
- /*
- * is_xchar_to_xchar<Target, Source>::value is true, when
- * Target and Souce are the same char types, or when
- * Target and Souce are char types of the same size.
- */
- template<typename Target, typename Source>
- struct is_xchar_to_xchar
- {
- BOOST_STATIC_CONSTANT(bool, value =
- (
- boost::type_traits::ice_or<
- boost::type_traits::ice_and<
- is_same<Source,Target>::value,
- is_char_or_wchar<Target>::value
- >::value,
- boost::type_traits::ice_and<
- boost::type_traits::ice_eq< sizeof(char),sizeof(Target)>::value,
- boost::type_traits::ice_eq< sizeof(char),sizeof(Source)>::value,
- is_char_or_wchar<Target>::value,
- is_char_or_wchar<Source>::value
- >::value
- >::value
- )
- );
- };
-
- template<typename Target, typename Source>
- struct is_char_array_to_stdstring
- {
- BOOST_STATIC_CONSTANT(bool, value = false );
- };
-
- template<typename CharT, typename Traits, typename Alloc>
- struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, CharT* >
- {
- BOOST_STATIC_CONSTANT(bool, value = true );
- };
-
- template<typename CharT, typename Traits, typename Alloc>
- struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, const CharT* >
- {
- BOOST_STATIC_CONSTANT(bool, value = true );
- };
-
- template<typename CharT, typename Traits, typename Alloc>
- struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
- {
- BOOST_STATIC_CONSTANT(bool, value = true );
- };
-
- template<typename CharT, typename Traits, typename Alloc>
- struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
- {
- BOOST_STATIC_CONSTANT(bool, value = true );
- };
-
-#if (defined _MSC_VER)
-# pragma warning( push )
-# pragma warning( disable : 4701 ) // possible use of ... before initialization
-# pragma warning( disable : 4702 ) // unreachable code
-# pragma warning( disable : 4267 ) // conversion from 'size_t' to 'unsigned int'
-#endif
- template<typename Target, typename Source>
- struct lexical_cast_do_cast
- {
- static inline Target lexical_cast_impl(const Source& arg)
- {
- typedef lexical_cast_stream_traits<Source, Target> stream_trait;
-
- typedef detail::lexical_stream_limited_src<
- BOOST_DEDUCED_TYPENAME stream_trait::char_type,
- BOOST_DEDUCED_TYPENAME stream_trait::traits,
- stream_trait::requires_stringbuf
- > interpreter_type;
-
- // Target type must be default constructible
- Target result;
-
- BOOST_DEDUCED_TYPENAME stream_trait::char_type buf[stream_trait::len_t::value + 1];
- stream_trait::len_t::check_coverage();
-
- interpreter_type interpreter(buf, buf + stream_trait::len_t::value + 1);
-
- // Disabling ADL, by directly specifying operators.
- if(!(interpreter.operator <<(arg) && interpreter.operator >>(result)))
- BOOST_LCAST_THROW_BAD_CAST(Source, Target);
-
- return result;
- }
- };
-#if (defined _MSC_VER)
-# pragma warning( pop )
-#endif
-
- template <typename Source>
- struct lexical_cast_copy
- {
- static inline const Source& lexical_cast_impl(const Source &arg) BOOST_NOEXCEPT
- {
- return arg;
- }
- };
-
- template <class Source, class Target >
- struct detect_precision_loss
- {
- typedef boost::numeric::Trunc<Source> Rounder;
- typedef Source source_type ;
-
- typedef BOOST_DEDUCED_TYPENAME mpl::if_<
- boost::is_arithmetic<Source>, Source, Source const&
- >::type argument_type ;
-
- static source_type nearbyint ( argument_type s )
- {
- const source_type near_int = Rounder::nearbyint(s);
- if (near_int) {
- const source_type orig_div_round = s / near_int;
- const source_type eps = std::numeric_limits<source_type>::epsilon();
-
- if ((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps)
- BOOST_LCAST_THROW_BAD_CAST(Source, Target);
- }
-
- return s ;
- }
-
- typedef typename Rounder::round_style round_style;
- } ;
-
- template <class Source, class Target >
- struct nothrow_overflow_handler
- {
- void operator() ( boost::numeric::range_check_result r )
- {
- if (r != boost::numeric::cInRange)
- BOOST_LCAST_THROW_BAD_CAST(Source, Target);
- }
- } ;
-
- template <typename Target, typename Source>
- struct lexical_cast_dynamic_num_not_ignoring_minus
- {
- static inline Target lexical_cast_impl(const Source &arg)
- {
- return boost::numeric::converter<
- Target,
- Source,
- boost::numeric::conversion_traits<Target,Source>,
- nothrow_overflow_handler<Source, Target>,
- detect_precision_loss<Source, Target>
- >::convert(arg);
- }
- };
-
- template <typename Target, typename Source>
- struct lexical_cast_dynamic_num_ignoring_minus
- {
- static inline Target lexical_cast_impl(const Source &arg)
- {
- typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if_c<
- boost::is_float<Source>::value,
- boost::mpl::identity<Source>,
- boost::make_unsigned<Source>
- >::type usource_t;
-
- typedef boost::numeric::converter<
- Target,
- usource_t,
- boost::numeric::conversion_traits<Target,usource_t>,
- nothrow_overflow_handler<usource_t, Target>,
- detect_precision_loss<usource_t, Target>
- > converter_t;
-
- return (
- arg < 0 ? static_cast<Target>(0u - converter_t::convert(0u - arg)) : converter_t::convert(arg)
- );
- }
- };
-
- /*
- * lexical_cast_dynamic_num follows the rules:
- * 1) If Source can be converted to Target without precision loss and
- * without overflows, then assign Source to Target and return
- *
- * 2) If Source is less than 0 and Target is an unsigned integer,
- * then negate Source, check the requirements of rule 1) and if
- * successful, assign static_casted Source to Target and return
- *
- * 3) Otherwise throw a bad_lexical_cast exception
- *
- *
- * Rule 2) required because boost::lexical_cast has the behavior of
- * stringstream, which uses the rules of scanf for conversions. And
- * in the C99 standard for unsigned input value minus sign is
- * optional, so if a negative number is read, no errors will arise
- * and the result will be the two's complement.
- */
- template <typename Target, typename Source>
- struct lexical_cast_dynamic_num
- {
- static inline Target lexical_cast_impl(const Source &arg)
- {
- typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
- boost::type_traits::ice_and<
- boost::type_traits::ice_or<
- boost::is_signed<Source>::value,
- boost::is_float<Source>::value
- >::value,
- boost::type_traits::ice_not<
- boost::is_same<Source, bool>::value
- >::value,
- boost::type_traits::ice_not<
- boost::is_same<Target, bool>::value
- >::value,
- boost::is_unsigned<Target>::value
- >::value,
- lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
- lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
- >::type caster_type;
-
- return caster_type::lexical_cast_impl(arg);
- }
- };
- }
+#include <boost/lexical_cast/bad_lexical_cast.hpp>
+#include <boost/lexical_cast/try_lexical_convert.hpp>
+namespace boost
+{
template <typename Target, typename Source>
inline Target lexical_cast(const Source &arg)
{
- typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src;
-
- typedef BOOST_DEDUCED_TYPENAME boost::type_traits::ice_or<
- boost::detail::is_xchar_to_xchar<Target, src >::value,
- boost::detail::is_char_array_to_stdstring<Target, src >::value,
- boost::type_traits::ice_and<
- boost::is_same<Target, src >::value,
- boost::detail::is_stdstring<Target >::value
- >::value
- > shall_we_copy_t;
-
- typedef BOOST_DEDUCED_TYPENAME
- boost::detail::is_arithmetic_and_not_xchars<Target, src > shall_we_copy_with_dynamic_check_t;
+ Target result;
- typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
- shall_we_copy_t::value,
- boost::detail::lexical_cast_copy<src >,
- BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
- shall_we_copy_with_dynamic_check_t::value,
- boost::detail::lexical_cast_dynamic_num<Target, src >,
- boost::detail::lexical_cast_do_cast<Target, src >
- >::type
- >::type caster_type;
+ if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
+ boost::conversion::detail::throw_bad_cast<Source, Target>();
+ }
- return caster_type::lexical_cast_impl(arg);
+ return result;
}
template <typename Target>
inline Target lexical_cast(const char* chars, std::size_t count)
- {
+ {
return ::boost::lexical_cast<Target>(
::boost::iterator_range<const char*>(chars, chars + count)
);
}
-
template <typename Target>
inline Target lexical_cast(const unsigned char* chars, std::size_t count)
{
- return ::boost::lexical_cast<Target>(
+ return ::boost::lexical_cast<Target>(
::boost::iterator_range<const unsigned char*>(chars, chars + count)
- );
- }
+ );
+ }
template <typename Target>
inline Target lexical_cast(const signed char* chars, std::size_t count)
} // namespace boost
-#else // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-namespace boost {
- namespace detail
- {
-
- // selectors for choosing stream character type
- template<typename Type>
- struct stream_char
- {
- typedef char type;
- };
-
-#ifndef BOOST_LCAST_NO_WCHAR_T
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
- template<>
- struct stream_char<wchar_t>
- {
- typedef wchar_t type;
- };
-#endif
-
- template<>
- struct stream_char<wchar_t *>
- {
- typedef wchar_t type;
- };
-
- template<>
- struct stream_char<const wchar_t *>
- {
- typedef wchar_t type;
- };
-
- template<>
- struct stream_char<std::wstring>
- {
- typedef wchar_t type;
- };
-#endif
-
- // stream wrapper for handling lexical conversions
- template<typename Target, typename Source, typename Traits>
- class lexical_stream
- {
- private:
- typedef typename widest_char<
- typename stream_char<Target>::type,
- typename stream_char<Source>::type>::type char_type;
-
- typedef Traits traits_type;
-
- public:
- lexical_stream(char_type* = 0, char_type* = 0)
- {
- stream.unsetf(std::ios::skipws);
- lcast_set_precision(stream, static_cast<Source*>(0), static_cast<Target*>(0) );
- }
- ~lexical_stream()
- {
- #if defined(BOOST_NO_STRINGSTREAM)
- stream.freeze(false);
- #endif
- }
- bool operator<<(const Source &input)
- {
- return !(stream << input).fail();
- }
- template<typename InputStreamable>
- bool operator>>(InputStreamable &output)
- {
- return !is_pointer<InputStreamable>::value &&
- stream >> output &&
- stream.get() ==
-#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING)
-// GCC 2.9x lacks std::char_traits<>::eof().
-// We use BOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3
-// configurations, which do provide std::char_traits<>::eof().
-
- EOF;
-#else
- traits_type::eof();
-#endif
- }
-
- bool operator>>(std::string &output)
- {
- #if defined(BOOST_NO_STRINGSTREAM)
- stream << '\0';
- #endif
- stream.str().swap(output);
- return true;
- }
- #ifndef BOOST_LCAST_NO_WCHAR_T
- bool operator>>(std::wstring &output)
- {
- stream.str().swap(output);
- return true;
- }
- #endif
-
- private:
- #if defined(BOOST_NO_STRINGSTREAM)
- std::strstream stream;
- #elif defined(BOOST_NO_STD_LOCALE)
- std::stringstream stream;
- #else
- std::basic_stringstream<char_type,traits_type> stream;
- #endif
- };
- }
-
- // call-by-value fallback version (deprecated)
-
- template<typename Target, typename Source>
- Target lexical_cast(Source arg)
- {
- typedef typename detail::widest_char<
- BOOST_DEDUCED_TYPENAME detail::stream_char<Target>::type
- , BOOST_DEDUCED_TYPENAME detail::stream_char<Source>::type
- >::type char_type;
-
- typedef std::char_traits<char_type> traits;
- detail::lexical_stream<Target, Source, traits> interpreter;
- Target result;
-
- if(!(interpreter << arg && interpreter >> result))
- BOOST_LCAST_THROW_BAD_CAST(Source, Target);
- return result;
- }
-
-} // namespace boost
-
-#endif
-
-// Copyright Kevlin Henney, 2000-2005.
-// Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2013.
-//
-// 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)
-
-#undef BOOST_LCAST_THROW_BAD_CAST
#undef BOOST_LCAST_NO_WCHAR_T
#endif // BOOST_LEXICAL_CAST_INCLUDED
--- /dev/null
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2014.
+//
+// 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)
+//
+// what: lexical_cast custom keyword cast
+// who: contributed by Kevlin Henney,
+// enhanced with contributions from Terje Slettebo,
+// with additional fixes and suggestions from Gennaro Prota,
+// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
+// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
+// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+
+#ifndef BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP
+#define BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <typeinfo>
+#include <exception>
+#include <boost/throw_exception.hpp>
+
+namespace boost
+{
+ // exception used to indicate runtime lexical_cast failure
+ class BOOST_SYMBOL_VISIBLE bad_lexical_cast :
+ // workaround MSVC bug with std::bad_cast when _HAS_EXCEPTIONS == 0
+#if defined(BOOST_MSVC) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS
+ public std::exception
+#else
+ public std::bad_cast
+#endif
+
+#if defined(__BORLANDC__) && BOOST_WORKAROUND( __BORLANDC__, < 0x560 )
+ // under bcc32 5.5.1 bad_cast doesn't derive from exception
+ , public std::exception
+#endif
+
+ {
+ public:
+ bad_lexical_cast() BOOST_NOEXCEPT
+#ifndef BOOST_NO_TYPEID
+ : source(&typeid(void)), target(&typeid(void))
+#endif
+ {}
+
+ virtual const char *what() const BOOST_NOEXCEPT_OR_NOTHROW {
+ return "bad lexical cast: "
+ "source type value could not be interpreted as target";
+ }
+
+ virtual ~bad_lexical_cast() BOOST_NOEXCEPT_OR_NOTHROW
+ {}
+
+#ifndef BOOST_NO_TYPEID
+ bad_lexical_cast(
+ const std::type_info &source_type_arg,
+ const std::type_info &target_type_arg) BOOST_NOEXCEPT
+ : source(&source_type_arg), target(&target_type_arg)
+ {}
+
+ const std::type_info &source_type() const BOOST_NOEXCEPT {
+ return *source;
+ }
+
+ const std::type_info &target_type() const BOOST_NOEXCEPT {
+ return *target;
+ }
+
+ private:
+ const std::type_info *source;
+ const std::type_info *target;
+#endif
+ };
+
+ namespace conversion { namespace detail {
+#ifdef BOOST_NO_TYPEID
+ template <class S, class T>
+ inline void throw_bad_cast() {
+ boost::throw_exception(bad_lexical_cast());
+ }
+#else
+ template <class S, class T>
+ inline void throw_bad_cast() {
+ boost::throw_exception(bad_lexical_cast(typeid(S), typeid(T)));
+ }
+#endif
+ }} // namespace conversion::detail
+
+
+} // namespace boost
+
+#endif // BOOST_LEXICAL_CAST_BAD_LEXICAL_CAST_HPP
+
--- /dev/null
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2014.
+//
+// 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)
+//
+// what: lexical_cast custom keyword cast
+// who: contributed by Kevlin Henney,
+// enhanced with contributions from Terje Slettebo,
+// with additional fixes and suggestions from Gennaro Prota,
+// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
+// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
+// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+
+#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
+#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
+
+#include <cstddef>
+#include <string>
+#include <boost/limits.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_float.hpp>
+#include <boost/type_traits/has_left_shift.hpp>
+#include <boost/type_traits/has_right_shift.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/detail/lcast_precision.hpp>
+
+#include <boost/lexical_cast/detail/widest_char.hpp>
+#include <boost/lexical_cast/detail/is_character.hpp>
+
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
+#include <array>
+#endif
+
+#include <boost/array.hpp>
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/container/container_fwd.hpp>
+
+#include <boost/lexical_cast/detail/converter_lexical_streams.hpp>
+
+namespace boost {
+
+ namespace detail // normalize_single_byte_char<Char>
+ {
+ // Converts signed/unsigned char to char
+ template < class Char >
+ struct normalize_single_byte_char
+ {
+ typedef Char type;
+ };
+
+ template <>
+ struct normalize_single_byte_char< signed char >
+ {
+ typedef char type;
+ };
+
+ template <>
+ struct normalize_single_byte_char< unsigned char >
+ {
+ typedef char type;
+ };
+ }
+
+ namespace detail // deduce_character_type_later<T>
+ {
+ // Helper type, meaning that stram character for T must be deduced
+ // at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
+ template < class T > struct deduce_character_type_later {};
+ }
+
+ namespace detail // stream_char_common<T>
+ {
+ // Selectors to choose stream character type (common for Source and Target)
+ // Returns one of char, wchar_t, char16_t, char32_t or deduce_character_type_later<T> types
+ // Executed on Stage 1 (See deduce_source_char<T> and deduce_target_char<T>)
+ template < typename Type >
+ struct stream_char_common: public boost::mpl::if_c<
+ boost::detail::is_character< Type >::value,
+ Type,
+ boost::detail::deduce_character_type_later< Type >
+ > {};
+
+ template < typename Char >
+ struct stream_char_common< Char* >: public boost::mpl::if_c<
+ boost::detail::is_character< Char >::value,
+ Char,
+ boost::detail::deduce_character_type_later< Char* >
+ > {};
+
+ template < typename Char >
+ struct stream_char_common< const Char* >: public boost::mpl::if_c<
+ boost::detail::is_character< Char >::value,
+ Char,
+ boost::detail::deduce_character_type_later< const Char* >
+ > {};
+
+ template < typename Char >
+ struct stream_char_common< boost::iterator_range< Char* > >: public boost::mpl::if_c<
+ boost::detail::is_character< Char >::value,
+ Char,
+ boost::detail::deduce_character_type_later< boost::iterator_range< Char* > >
+ > {};
+
+ template < typename Char >
+ struct stream_char_common< boost::iterator_range< const Char* > >: public boost::mpl::if_c<
+ boost::detail::is_character< Char >::value,
+ Char,
+ boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > >
+ > {};
+
+ template < class Char, class Traits, class Alloc >
+ struct stream_char_common< std::basic_string< Char, Traits, Alloc > >
+ {
+ typedef Char type;
+ };
+
+ template < class Char, class Traits, class Alloc >
+ struct stream_char_common< boost::container::basic_string< Char, Traits, Alloc > >
+ {
+ typedef Char type;
+ };
+
+ template < typename Char, std::size_t N >
+ struct stream_char_common< boost::array< Char, N > >: public boost::mpl::if_c<
+ boost::detail::is_character< Char >::value,
+ Char,
+ boost::detail::deduce_character_type_later< boost::array< Char, N > >
+ > {};
+
+ template < typename Char, std::size_t N >
+ struct stream_char_common< boost::array< const Char, N > >: public boost::mpl::if_c<
+ boost::detail::is_character< Char >::value,
+ Char,
+ boost::detail::deduce_character_type_later< boost::array< const Char, N > >
+ > {};
+
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
+ template < typename Char, std::size_t N >
+ struct stream_char_common< std::array<Char, N > >: public boost::mpl::if_c<
+ boost::detail::is_character< Char >::value,
+ Char,
+ boost::detail::deduce_character_type_later< std::array< Char, N > >
+ > {};
+
+ template < typename Char, std::size_t N >
+ struct stream_char_common< std::array< const Char, N > >: public boost::mpl::if_c<
+ boost::detail::is_character< Char >::value,
+ Char,
+ boost::detail::deduce_character_type_later< std::array< const Char, N > >
+ > {};
+#endif
+
+#ifdef BOOST_HAS_INT128
+ template <> struct stream_char_common< boost::int128_type >: public boost::mpl::identity< char > {};
+ template <> struct stream_char_common< boost::uint128_type >: public boost::mpl::identity< char > {};
+#endif
+
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && defined(BOOST_NO_INTRINSIC_WCHAR_T)
+ template <>
+ struct stream_char_common< wchar_t >
+ {
+ typedef char type;
+ };
+#endif
+ }
+
+ namespace detail // deduce_source_char_impl<T>
+ {
+ // If type T is `deduce_character_type_later` type, then tries to deduce
+ // character type using boost::has_left_shift<T> metafunction.
+ // Otherwise supplied type T is a character type, that must be normalized
+ // using normalize_single_byte_char<Char>.
+ // Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
+ template < class Char >
+ struct deduce_source_char_impl
+ {
+ typedef BOOST_DEDUCED_TYPENAME boost::detail::normalize_single_byte_char< Char >::type type;
+ };
+
+ template < class T >
+ struct deduce_source_char_impl< deduce_character_type_later< T > >
+ {
+ typedef boost::has_left_shift< std::basic_ostream< char >, T > result_t;
+
+#if defined(BOOST_LCAST_NO_WCHAR_T)
+ BOOST_STATIC_ASSERT_MSG((result_t::value),
+ "Source type is not std::ostream`able and std::wostream`s are not supported by your STL implementation");
+ typedef char type;
+#else
+ typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+ result_t::value, char, wchar_t
+ >::type type;
+
+ BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_left_shift< std::basic_ostream< type >, T >::value),
+ "Source type is neither std::ostream`able nor std::wostream`able");
+#endif
+ };
+ }
+
+ namespace detail // deduce_target_char_impl<T>
+ {
+ // If type T is `deduce_character_type_later` type, then tries to deduce
+ // character type using boost::has_right_shift<T> metafunction.
+ // Otherwise supplied type T is a character type, that must be normalized
+ // using normalize_single_byte_char<Char>.
+ // Executed at Stage 2 (See deduce_source_char<T> and deduce_target_char<T>)
+ template < class Char >
+ struct deduce_target_char_impl
+ {
+ typedef BOOST_DEDUCED_TYPENAME normalize_single_byte_char< Char >::type type;
+ };
+
+ template < class T >
+ struct deduce_target_char_impl< deduce_character_type_later<T> >
+ {
+ typedef boost::has_right_shift<std::basic_istream<char>, T > result_t;
+
+#if defined(BOOST_LCAST_NO_WCHAR_T)
+ BOOST_STATIC_ASSERT_MSG((result_t::value),
+ "Target type is not std::istream`able and std::wistream`s are not supported by your STL implementation");
+ typedef char type;
+#else
+ typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+ result_t::value, char, wchar_t
+ >::type type;
+
+ BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_right_shift<std::basic_istream<wchar_t>, T >::value),
+ "Target type is neither std::istream`able nor std::wistream`able");
+#endif
+ };
+ }
+
+ namespace detail // deduce_target_char<T> and deduce_source_char<T>
+ {
+ // We deduce stream character types in two stages.
+ //
+ // Stage 1 is common for Target and Source. At Stage 1 we get
+ // non normalized character type (may contain unsigned/signed char)
+ // or deduce_character_type_later<T> where T is the original type.
+ // Stage 1 is executed by stream_char_common<T>
+ //
+ // At Stage 2 we normalize character types or try to deduce character
+ // type using metafunctions.
+ // Stage 2 is executed by deduce_target_char_impl<T> and
+ // deduce_source_char_impl<T>
+ //
+ // deduce_target_char<T> and deduce_source_char<T> functions combine
+ // both stages
+
+ template < class T >
+ struct deduce_target_char
+ {
+ typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
+ typedef BOOST_DEDUCED_TYPENAME deduce_target_char_impl< stage1_type >::type stage2_type;
+
+ typedef stage2_type type;
+ };
+
+ template < class T >
+ struct deduce_source_char
+ {
+ typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
+ typedef BOOST_DEDUCED_TYPENAME deduce_source_char_impl< stage1_type >::type stage2_type;
+
+ typedef stage2_type type;
+ };
+ }
+
+ namespace detail // extract_char_traits template
+ {
+ // We are attempting to get char_traits<> from T
+ // template parameter. Otherwise we'll be using std::char_traits<Char>
+ template < class Char, class T >
+ struct extract_char_traits
+ : boost::false_type
+ {
+ typedef std::char_traits< Char > trait_t;
+ };
+
+ template < class Char, class Traits, class Alloc >
+ struct extract_char_traits< Char, std::basic_string< Char, Traits, Alloc > >
+ : boost::true_type
+ {
+ typedef Traits trait_t;
+ };
+
+ template < class Char, class Traits, class Alloc>
+ struct extract_char_traits< Char, boost::container::basic_string< Char, Traits, Alloc > >
+ : boost::true_type
+ {
+ typedef Traits trait_t;
+ };
+ }
+
+ namespace detail // array_to_pointer_decay<T>
+ {
+ template<class T>
+ struct array_to_pointer_decay
+ {
+ typedef T type;
+ };
+
+ template<class T, std::size_t N>
+ struct array_to_pointer_decay<T[N]>
+ {
+ typedef const T * type;
+ };
+ }
+
+ namespace detail // lcast_src_length
+ {
+ // Return max. length of string representation of Source;
+ template< class Source, // Source type of lexical_cast.
+ class Enable = void // helper type
+ >
+ struct lcast_src_length
+ {
+ BOOST_STATIC_CONSTANT(std::size_t, value = 1);
+ };
+
+ // Helper for integral types.
+ // Notes on length calculation:
+ // Max length for 32bit int with grouping "\1" and thousands_sep ',':
+ // "-2,1,4,7,4,8,3,6,4,7"
+ // ^ - is_signed
+ // ^ - 1 digit not counted by digits10
+ // ^^^^^^^^^^^^^^^^^^ - digits10 * 2
+ //
+ // Constant is_specialized is used instead of constant 1
+ // to prevent buffer overflow in a rare case when
+ // <boost/limits.hpp> doesn't add missing specialization for
+ // numeric_limits<T> for some integral type T.
+ // When is_specialized is false, the whole expression is 0.
+ template <class Source>
+ struct lcast_src_length<
+ Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_integral<Source> >::type
+ >
+ {
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+ BOOST_STATIC_CONSTANT(std::size_t, value =
+ std::numeric_limits<Source>::is_signed +
+ std::numeric_limits<Source>::is_specialized + /* == 1 */
+ std::numeric_limits<Source>::digits10 * 2
+ );
+#else
+ BOOST_STATIC_CONSTANT(std::size_t, value = 156);
+ BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256);
+#endif
+ };
+
+#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+ // Helper for floating point types.
+ // -1.23456789e-123456
+ // ^ sign
+ // ^ leading digit
+ // ^ decimal point
+ // ^^^^^^^^ lcast_precision<Source>::value
+ // ^ "e"
+ // ^ exponent sign
+ // ^^^^^^ exponent (assumed 6 or less digits)
+ // sign + leading digit + decimal point + "e" + exponent sign == 5
+ template<class Source>
+ struct lcast_src_length<
+ Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_float<Source> >::type
+ >
+ {
+ BOOST_STATIC_ASSERT(
+ std::numeric_limits<Source>::max_exponent10 <= 999999L &&
+ std::numeric_limits<Source>::min_exponent10 >= -999999L
+ );
+
+ BOOST_STATIC_CONSTANT(std::size_t, value =
+ 5 + lcast_precision<Source>::value + 6
+ );
+ };
+#endif // #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
+ }
+
+ namespace detail // lexical_cast_stream_traits<Source, Target>
+ {
+ template <class Source, class Target>
+ struct lexical_cast_stream_traits {
+ typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src;
+ typedef BOOST_DEDUCED_TYPENAME boost::remove_cv<src>::type no_cv_src;
+
+ typedef boost::detail::deduce_source_char<no_cv_src> deduce_src_char_metafunc;
+ typedef BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::type src_char_t;
+ typedef BOOST_DEDUCED_TYPENAME boost::detail::deduce_target_char<Target>::type target_char_t;
+
+ typedef BOOST_DEDUCED_TYPENAME boost::detail::widest_char<
+ target_char_t, src_char_t
+ >::type char_type;
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+ BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char16_t, src_char_t>::value
+ && !boost::is_same<char16_t, target_char_t>::value),
+ "Your compiler does not have full support for char16_t" );
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+ BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char32_t, src_char_t>::value
+ && !boost::is_same<char32_t, target_char_t>::value),
+ "Your compiler does not have full support for char32_t" );
+#endif
+
+ typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+ boost::detail::extract_char_traits<char_type, Target>::value,
+ BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, Target>,
+ BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, no_cv_src>
+ >::type::trait_t traits;
+
+ typedef boost::type_traits::ice_and<
+ boost::is_same<char, src_char_t>::value, // source is not a wide character based type
+ boost::type_traits::ice_ne<sizeof(char), sizeof(target_char_t) >::value, // target type is based on wide character
+ boost::type_traits::ice_not<
+ boost::detail::is_character<no_cv_src>::value // single character widening is optimized
+ >::value // and does not requires stringbuffer
+ > is_string_widening_required_t;
+
+ typedef boost::type_traits::ice_not< boost::type_traits::ice_or<
+ boost::is_integral<no_cv_src>::value,
+ boost::detail::is_character<
+ BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type // if we did not get character type at stage1
+ >::value // then we have no optimization for that type
+ >::value > is_source_input_not_optimized_t;
+
+ // If we have an optimized conversion for
+ // Source, we do not need to construct stringbuf.
+ BOOST_STATIC_CONSTANT(bool, requires_stringbuf =
+ (boost::type_traits::ice_or<
+ is_string_widening_required_t::value, is_source_input_not_optimized_t::value
+ >::value)
+ );
+
+ typedef boost::detail::lcast_src_length<no_cv_src> len_t;
+ };
+ }
+
+ namespace detail
+ {
+ template<typename Target, typename Source>
+ struct lexical_converter_impl
+ {
+ typedef lexical_cast_stream_traits<Source, Target> stream_trait;
+
+ typedef detail::lexical_istream_limited_src<
+ BOOST_DEDUCED_TYPENAME stream_trait::char_type,
+ BOOST_DEDUCED_TYPENAME stream_trait::traits,
+ stream_trait::requires_stringbuf,
+ stream_trait::len_t::value + 1
+ > i_interpreter_type;
+
+ typedef detail::lexical_ostream_limited_src<
+ BOOST_DEDUCED_TYPENAME stream_trait::char_type,
+ BOOST_DEDUCED_TYPENAME stream_trait::traits
+ > o_interpreter_type;
+
+ static inline bool try_convert(const Source& arg, Target& result) {
+ i_interpreter_type i_interpreter;
+
+ // Disabling ADL, by directly specifying operators.
+ if (!(i_interpreter.operator <<(arg)))
+ return false;
+
+ o_interpreter_type out(i_interpreter.cbegin(), i_interpreter.cend());
+
+ // Disabling ADL, by directly specifying operators.
+ if(!(out.operator >>(result)))
+ return false;
+
+ return true;
+ }
+ };
+ }
+
+} // namespace boost
+
+#undef BOOST_LCAST_NO_WCHAR_T
+
+#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
+
--- /dev/null
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2014.
+//
+// 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)
+//
+// what: lexical_cast custom keyword cast
+// who: contributed by Kevlin Henney,
+// enhanced with contributions from Terje Slettebo,
+// with additional fixes and suggestions from Gennaro Prota,
+// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
+// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
+// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+
+#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
+#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
+
+#include <cstddef>
+#include <string>
+#include <cstring>
+#include <cstdio>
+#include <boost/limits.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/detail/workaround.hpp>
+
+
+#ifndef BOOST_NO_STD_LOCALE
+# include <locale>
+#else
+# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+ // Getting error at this point means, that your STL library is old/lame/misconfigured.
+ // If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
+ // but beware: lexical_cast will understand only 'C' locale delimeters and thousands
+ // separators.
+# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
+# error "boost::lexical_cast to use only 'C' locale during conversions."
+# endif
+#endif
+
+#ifdef BOOST_NO_STRINGSTREAM
+#include <strstream>
+#else
+#include <sstream>
+#endif
+
+#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
+#include <boost/lexical_cast/detail/lcast_unsigned_converters.hpp>
+#include <boost/lexical_cast/detail/inf_nan.hpp>
+
+#include <istream>
+
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
+#include <array>
+#endif
+
+#include <boost/array.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_float.hpp>
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/container/container_fwd.hpp>
+#include <boost/integer.hpp>
+#include <boost/detail/basic_pointerbuf.hpp>
+#include <boost/noncopyable.hpp>
+#ifndef BOOST_NO_CWCHAR
+# include <cwchar>
+#endif
+
+namespace boost {
+
+ namespace detail // basic_unlockedbuf
+ {
+ // acts as a stream buffer which wraps around a pair of pointers
+ // and gives acces to internals
+ template <class BufferType, class CharT>
+ class basic_unlockedbuf : public basic_pointerbuf<CharT, BufferType> {
+ public:
+ typedef basic_pointerbuf<CharT, BufferType> base_type;
+ typedef BOOST_DEDUCED_TYPENAME base_type::streamsize streamsize;
+
+#ifndef BOOST_NO_USING_TEMPLATE
+ using base_type::pptr;
+ using base_type::pbase;
+ using base_type::setbuf;
+#else
+ charT* pptr() const { return base_type::pptr(); }
+ charT* pbase() const { return base_type::pbase(); }
+ BufferType* setbuf(char_type* s, streamsize n) { return base_type::setbuf(s, n); }
+#endif
+ };
+ }
+
+ namespace detail
+ {
+ struct do_not_construct_out_stream_t{};
+
+ template <class CharT, class Traits>
+ struct out_stream_helper_trait {
+#if defined(BOOST_NO_STRINGSTREAM)
+ typedef std::ostrstream out_stream_t;
+ typedef void buffer_t;
+#elif defined(BOOST_NO_STD_LOCALE)
+ typedef std::ostringstream out_stream_t;
+ typedef basic_unlockedbuf<std::streambuf, char> buffer_t;
+#else
+ typedef std::basic_ostringstream<CharT, Traits>
+ out_stream_t;
+ typedef basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT>
+ buffer_t;
+#endif
+ };
+ }
+
+ namespace detail // optimized stream wrappers
+ {
+ template< class CharT // a result of widest_char transformation
+ , class Traits
+ , bool RequiresStringbuffer
+ , std::size_t CharacterBufferSize
+ >
+ class lexical_istream_limited_src: boost::noncopyable {
+ typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t
+ buffer_t;
+
+ typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::out_stream_t
+ out_stream_t;
+
+ typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+ RequiresStringbuffer,
+ out_stream_t,
+ do_not_construct_out_stream_t
+ >::type deduced_out_stream_t;
+
+ // A string representation of Source is written to `buffer`.
+ deduced_out_stream_t out_stream;
+ CharT buffer[CharacterBufferSize];
+
+ // After the `operator <<` finishes, `[start, finish)` is
+ // the range to output by `operator >>`
+ const CharT* start;
+ const CharT* finish;
+
+ public:
+ lexical_istream_limited_src() BOOST_NOEXCEPT
+ : start(buffer)
+ , finish(buffer + CharacterBufferSize)
+ {}
+
+ const CharT* cbegin() const BOOST_NOEXCEPT {
+ return start;
+ }
+
+ const CharT* cend() const BOOST_NOEXCEPT {
+ return finish;
+ }
+
+ private:
+ // Undefined:
+ lexical_istream_limited_src(lexical_istream_limited_src const&);
+ void operator=(lexical_istream_limited_src const&);
+
+/************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/
+ bool shl_char(CharT ch) BOOST_NOEXCEPT {
+ Traits::assign(buffer[0], ch);
+ finish = start + 1;
+ return true;
+ }
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+ template <class T>
+ bool shl_char(T ch) {
+ BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) ,
+ "boost::lexical_cast does not support narrowing of char types."
+ "Use boost::locale instead" );
+#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+ std::locale loc;
+ CharT const w = BOOST_USE_FACET(std::ctype<CharT>, loc).widen(ch);
+#else
+ CharT const w = static_cast<CharT>(ch);
+#endif
+ Traits::assign(buffer[0], w);
+ finish = start + 1;
+ return true;
+ }
+#endif
+
+ bool shl_char_array(CharT const* str) BOOST_NOEXCEPT {
+ start = str;
+ finish = start + Traits::length(str);
+ return true;
+ }
+
+ template <class T>
+ bool shl_char_array(T const* str) {
+ BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)),
+ "boost::lexical_cast does not support narrowing of char types."
+ "Use boost::locale instead" );
+ return shl_input_streamable(str);
+ }
+
+ bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT {
+ start = str;
+ finish = std::find(start, start + max_size, Traits::to_char_type(0));
+ return true;
+ }
+
+ template<typename InputStreamable>
+ bool shl_input_streamable(InputStreamable& input) {
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
+ // If you have compilation error at this point, than your STL library
+ // does not support such conversions. Try updating it.
+ BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));
+#endif
+
+#ifndef BOOST_NO_EXCEPTIONS
+ out_stream.exceptions(std::ios::badbit);
+ try {
+#endif
+ bool const result = !(out_stream << input).fail();
+ const buffer_t* const p = static_cast<buffer_t*>(
+ static_cast<std::basic_streambuf<CharT, Traits>*>(out_stream.rdbuf())
+ );
+ start = p->pbase();
+ finish = p->pptr();
+ return result;
+#ifndef BOOST_NO_EXCEPTIONS
+ } catch (const ::std::ios_base::failure& /*f*/) {
+ return false;
+ }
+#endif
+ }
+
+ template <class T>
+ inline bool shl_unsigned(const T n) {
+ CharT* tmp_finish = buffer + CharacterBufferSize;
+ start = lcast_put_unsigned<Traits, T, CharT>(n, tmp_finish).convert();
+ finish = tmp_finish;
+ return true;
+ }
+
+ template <class T>
+ inline bool shl_signed(const T n) {
+ CharT* tmp_finish = buffer + CharacterBufferSize;
+ typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type utype;
+ CharT* tmp_start = lcast_put_unsigned<Traits, utype, CharT>(lcast_to_unsigned(n), tmp_finish).convert();
+ if (n < 0) {
+ --tmp_start;
+ CharT const minus = lcast_char_constants<CharT>::minus;
+ Traits::assign(*tmp_start, minus);
+ }
+ start = tmp_start;
+ finish = tmp_finish;
+ return true;
+ }
+
+ template <class T, class SomeCharT>
+ bool shl_real_type(const T& val, SomeCharT* /*begin*/) {
+ lcast_set_precision(out_stream, &val);
+ return shl_input_streamable(val);
+ }
+
+ bool shl_real_type(float val, char* begin) {
+ using namespace std;
+ const double val_as_double = val;
+ finish = start +
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+ sprintf_s(begin, CharacterBufferSize,
+#else
+ sprintf(begin,
+#endif
+ "%.*g", static_cast<int>(boost::detail::lcast_get_precision<float>()), val_as_double);
+ return finish > start;
+ }
+
+ bool shl_real_type(double val, char* begin) {
+ using namespace std;
+ finish = start +
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+ sprintf_s(begin, CharacterBufferSize,
+#else
+ sprintf(begin,
+#endif
+ "%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val);
+ return finish > start;
+ }
+
+#ifndef __MINGW32__
+ bool shl_real_type(long double val, char* begin) {
+ using namespace std;
+ finish = start +
+#if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+ sprintf_s(begin, CharacterBufferSize,
+#else
+ sprintf(begin,
+#endif
+ "%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double>()), val );
+ return finish > start;
+ }
+#endif
+
+
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
+ bool shl_real_type(float val, wchar_t* begin) {
+ using namespace std;
+ const double val_as_double = val;
+ finish = start + swprintf(begin, CharacterBufferSize,
+ L"%.*g",
+ static_cast<int>(boost::detail::lcast_get_precision<float >()),
+ val_as_double );
+ return finish > start;
+ }
+
+ bool shl_real_type(double val, wchar_t* begin) {
+ using namespace std;
+ finish = start + swprintf(begin, CharacterBufferSize,
+ L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
+ return finish > start;
+ }
+
+ bool shl_real_type(long double val, wchar_t* begin) {
+ using namespace std;
+ finish = start + swprintf(begin, CharacterBufferSize,
+ L"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val );
+ return finish > start;
+ }
+#endif
+ template <class T>
+ bool shl_real(T val) {
+ CharT* tmp_finish = buffer + CharacterBufferSize;
+ if (put_inf_nan(buffer, tmp_finish, val)) {
+ finish = tmp_finish;
+ return true;
+ }
+
+ return shl_real_type(val, static_cast<CharT*>(buffer));
+ }
+
+/************************************ OPERATORS << ( ... ) ********************************/
+ public:
+ template<class Alloc>
+ bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT {
+ start = str.data();
+ finish = start + str.length();
+ return true;
+ }
+
+ template<class Alloc>
+ bool operator<<(boost::container::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT {
+ start = str.data();
+ finish = start + str.length();
+ return true;
+ }
+
+ bool operator<<(bool value) BOOST_NOEXCEPT {
+ CharT const czero = lcast_char_constants<CharT>::zero;
+ Traits::assign(buffer[0], Traits::to_char_type(czero + value));
+ finish = start + 1;
+ return true;
+ }
+
+ template <class C>
+ BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type
+ operator<<(const iterator_range<C*>& rng) BOOST_NOEXCEPT {
+ return (*this) << iterator_range<const C*>(rng.begin(), rng.end());
+ }
+
+ bool operator<<(const iterator_range<const CharT*>& rng) BOOST_NOEXCEPT {
+ start = rng.begin();
+ finish = rng.end();
+ return true;
+ }
+
+ bool operator<<(const iterator_range<const signed char*>& rng) BOOST_NOEXCEPT {
+ return (*this) << iterator_range<const char*>(
+ reinterpret_cast<const char*>(rng.begin()),
+ reinterpret_cast<const char*>(rng.end())
+ );
+ }
+
+ bool operator<<(const iterator_range<const unsigned char*>& rng) BOOST_NOEXCEPT {
+ return (*this) << iterator_range<const char*>(
+ reinterpret_cast<const char*>(rng.begin()),
+ reinterpret_cast<const char*>(rng.end())
+ );
+ }
+
+ bool operator<<(char ch) { return shl_char(ch); }
+ bool operator<<(unsigned char ch) { return ((*this) << static_cast<char>(ch)); }
+ bool operator<<(signed char ch) { return ((*this) << static_cast<char>(ch)); }
+#if !defined(BOOST_LCAST_NO_WCHAR_T)
+ bool operator<<(wchar_t const* str) { return shl_char_array(str); }
+ bool operator<<(wchar_t * str) { return shl_char_array(str); }
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ bool operator<<(wchar_t ch) { return shl_char(ch); }
+#endif
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+ bool operator<<(char16_t ch) { return shl_char(ch); }
+ bool operator<<(char16_t * str) { return shl_char_array(str); }
+ bool operator<<(char16_t const * str) { return shl_char_array(str); }
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+ bool operator<<(char32_t ch) { return shl_char(ch); }
+ bool operator<<(char32_t * str) { return shl_char_array(str); }
+ bool operator<<(char32_t const * str) { return shl_char_array(str); }
+#endif
+ bool operator<<(unsigned char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
+ bool operator<<(unsigned char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
+ bool operator<<(signed char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
+ bool operator<<(signed char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
+ bool operator<<(char const* str) { return shl_char_array(str); }
+ bool operator<<(char* str) { return shl_char_array(str); }
+ bool operator<<(short n) { return shl_signed(n); }
+ bool operator<<(int n) { return shl_signed(n); }
+ bool operator<<(long n) { return shl_signed(n); }
+ bool operator<<(unsigned short n) { return shl_unsigned(n); }
+ bool operator<<(unsigned int n) { return shl_unsigned(n); }
+ bool operator<<(unsigned long n) { return shl_unsigned(n); }
+
+#if defined(BOOST_HAS_LONG_LONG)
+ bool operator<<(boost::ulong_long_type n) { return shl_unsigned(n); }
+ bool operator<<(boost::long_long_type n) { return shl_signed(n); }
+#elif defined(BOOST_HAS_MS_INT64)
+ bool operator<<(unsigned __int64 n) { return shl_unsigned(n); }
+ bool operator<<( __int64 n) { return shl_signed(n); }
+#endif
+
+#ifdef BOOST_HAS_INT128
+ bool operator<<(const boost::uint128_type& n) { return shl_unsigned(n); }
+ bool operator<<(const boost::int128_type& n) { return shl_signed(n); }
+#endif
+ bool operator<<(float val) { return shl_real(val); }
+ bool operator<<(double val) { return shl_real(val); }
+ bool operator<<(long double val) {
+#ifndef __MINGW32__
+ return shl_real(val);
+#else
+ return shl_real(static_cast<double>(val));
+#endif
+ }
+
+ // Adding constness to characters. Constness does not change layout
+ template <class C, std::size_t N>
+ BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type
+ operator<<(boost::array<C, N> const& input) BOOST_NOEXCEPT {
+ BOOST_STATIC_ASSERT_MSG(
+ (sizeof(boost::array<const C, N>) == sizeof(boost::array<C, N>)),
+ "boost::array<C, N> and boost::array<const C, N> must have exactly the same layout."
+ );
+ return ((*this) << reinterpret_cast<boost::array<const C, N> const& >(input));
+ }
+
+ template <std::size_t N>
+ bool operator<<(boost::array<const CharT, N> const& input) BOOST_NOEXCEPT {
+ return shl_char_array_limited(input.begin(), N);
+ }
+
+ template <std::size_t N>
+ bool operator<<(boost::array<const unsigned char, N> const& input) BOOST_NOEXCEPT {
+ return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input));
+ }
+
+ template <std::size_t N>
+ bool operator<<(boost::array<const signed char, N> const& input) BOOST_NOEXCEPT {
+ return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input));
+ }
+
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
+ // Making a Boost.Array from std::array
+ template <class C, std::size_t N>
+ bool operator<<(std::array<C, N> const& input) BOOST_NOEXCEPT {
+ BOOST_STATIC_ASSERT_MSG(
+ (sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)),
+ "std::array and boost::array must have exactly the same layout. "
+ "Bug in implementation of std::array or boost::array."
+ );
+ return ((*this) << reinterpret_cast<boost::array<C, N> const& >(input));
+ }
+#endif
+ template <class InStreamable>
+ bool operator<<(const InStreamable& input) { return shl_input_streamable(input); }
+ };
+
+
+ template <class CharT, class Traits>
+ class lexical_ostream_limited_src: boost::noncopyable {
+ //`[start, finish)` is the range to output by `operator >>`
+ const CharT* start;
+ const CharT* const finish;
+
+ public:
+ lexical_ostream_limited_src(const CharT* begin, const CharT* end) BOOST_NOEXCEPT
+ : start(begin)
+ , finish(end)
+ {}
+
+/************************************ HELPER FUNCTIONS FOR OPERATORS >> ( ... ) ********************************/
+ private:
+ template <typename Type>
+ bool shr_unsigned(Type& output) {
+ if (start == finish) return false;
+ CharT const minus = lcast_char_constants<CharT>::minus;
+ CharT const plus = lcast_char_constants<CharT>::plus;
+ bool const has_minus = Traits::eq(minus, *start);
+
+ /* We won`t use `start' any more, so no need in decrementing it after */
+ if (has_minus || Traits::eq(plus, *start)) {
+ ++start;
+ }
+
+ bool const succeed = lcast_ret_unsigned<Traits, Type, CharT>(output, start, finish).convert();
+
+ if (has_minus) {
+ output = static_cast<Type>(0u - output);
+ }
+
+ return succeed;
+ }
+
+ template <typename Type>
+ bool shr_signed(Type& output) {
+ if (start == finish) return false;
+ CharT const minus = lcast_char_constants<CharT>::minus;
+ CharT const plus = lcast_char_constants<CharT>::plus;
+ typedef BOOST_DEDUCED_TYPENAME make_unsigned<Type>::type utype;
+ utype out_tmp = 0;
+ bool const has_minus = Traits::eq(minus, *start);
+
+ /* We won`t use `start' any more, so no need in decrementing it after */
+ if (has_minus || Traits::eq(plus, *start)) {
+ ++start;
+ }
+
+ bool succeed = lcast_ret_unsigned<Traits, utype, CharT>(out_tmp, start, finish).convert();
+ if (has_minus) {
+ utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits);
+ succeed = succeed && out_tmp<=comp_val;
+ output = static_cast<Type>(0u - out_tmp);
+ } else {
+ utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)());
+ succeed = succeed && out_tmp<=comp_val;
+ output = static_cast<Type>(out_tmp);
+ }
+ return succeed;
+ }
+
+ template<typename InputStreamable>
+ bool shr_using_base_class(InputStreamable& output)
+ {
+ BOOST_STATIC_ASSERT_MSG(
+ (!boost::is_pointer<InputStreamable>::value),
+ "boost::lexical_cast can not convert to pointers"
+ );
+
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
+ BOOST_STATIC_ASSERT_MSG((boost::is_same<char, CharT>::value),
+ "boost::lexical_cast can not convert, because your STL library does not "
+ "support such conversions. Try updating it."
+ );
+#endif
+ typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t
+ buffer_t;
+
+#if defined(BOOST_NO_STRINGSTREAM)
+ std::istrstream stream(start, finish - start);
+#else
+
+ buffer_t buf;
+ // Usually `istream` and `basic_istream` do not modify
+ // content of buffer; `buffer_t` assures that this is true
+ buf.setbuf(const_cast<CharT*>(start), finish - start);
+#if defined(BOOST_NO_STD_LOCALE)
+ std::istream stream(&buf);
+#else
+ std::basic_istream<CharT, Traits> stream(&buf);
+#endif // BOOST_NO_STD_LOCALE
+#endif // BOOST_NO_STRINGSTREAM
+
+#ifndef BOOST_NO_EXCEPTIONS
+ stream.exceptions(std::ios::badbit);
+ try {
+#endif
+ stream.unsetf(std::ios::skipws);
+ lcast_set_precision(stream, static_cast<InputStreamable*>(0));
+
+ return (stream >> output)
+ && (stream.get() == Traits::eof());
+
+#ifndef BOOST_NO_EXCEPTIONS
+ } catch (const ::std::ios_base::failure& /*f*/) {
+ return false;
+ }
+#endif
+ }
+
+ template<class T>
+ inline bool shr_xchar(T& output) BOOST_NOEXCEPT {
+ BOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ),
+ "boost::lexical_cast does not support narrowing of character types."
+ "Use boost::locale instead" );
+ bool const ok = (finish - start == 1);
+ if (ok) {
+ CharT out;
+ Traits::assign(out, *start);
+ output = static_cast<T>(out);
+ }
+ return ok;
+ }
+
+ template <std::size_t N, class ArrayT>
+ bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT {
+ using namespace std;
+ const std::size_t size = static_cast<std::size_t>(finish - start);
+ if (size > N - 1) { // `-1` because we need to store \0 at the end
+ return false;
+ }
+
+ memcpy(&output[0], start, size * sizeof(CharT));
+ output[size] = Traits::to_char_type(0);
+ return true;
+ }
+
+/************************************ OPERATORS >> ( ... ) ********************************/
+ public:
+ bool operator>>(unsigned short& output) { return shr_unsigned(output); }
+ bool operator>>(unsigned int& output) { return shr_unsigned(output); }
+ bool operator>>(unsigned long int& output) { return shr_unsigned(output); }
+ bool operator>>(short& output) { return shr_signed(output); }
+ bool operator>>(int& output) { return shr_signed(output); }
+ bool operator>>(long int& output) { return shr_signed(output); }
+#if defined(BOOST_HAS_LONG_LONG)
+ bool operator>>(boost::ulong_long_type& output) { return shr_unsigned(output); }
+ bool operator>>(boost::long_long_type& output) { return shr_signed(output); }
+#elif defined(BOOST_HAS_MS_INT64)
+ bool operator>>(unsigned __int64& output) { return shr_unsigned(output); }
+ bool operator>>(__int64& output) { return shr_signed(output); }
+#endif
+
+#ifdef BOOST_HAS_INT128
+ bool operator>>(boost::uint128_type& output) { return shr_unsigned(output); }
+ bool operator>>(boost::int128_type& output) { return shr_signed(output); }
+#endif
+
+ bool operator>>(char& output) { return shr_xchar(output); }
+ bool operator>>(unsigned char& output) { return shr_xchar(output); }
+ bool operator>>(signed char& output) { return shr_xchar(output); }
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+ bool operator>>(wchar_t& output) { return shr_xchar(output); }
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+ bool operator>>(char16_t& output) { return shr_xchar(output); }
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+ bool operator>>(char32_t& output) { return shr_xchar(output); }
+#endif
+ template<class Alloc>
+ bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) {
+ str.assign(start, finish); return true;
+ }
+
+ template<class Alloc>
+ bool operator>>(boost::container::basic_string<CharT,Traits,Alloc>& str) {
+ str.assign(start, finish); return true;
+ }
+
+ template <std::size_t N>
+ bool operator>>(boost::array<CharT, N>& output) BOOST_NOEXCEPT {
+ return shr_std_array<N>(output);
+ }
+
+ template <std::size_t N>
+ bool operator>>(boost::array<unsigned char, N>& output) BOOST_NOEXCEPT {
+ return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
+ }
+
+ template <std::size_t N>
+ bool operator>>(boost::array<signed char, N>& output) BOOST_NOEXCEPT {
+ return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
+ }
+
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
+ template <class C, std::size_t N>
+ bool operator>>(std::array<C, N>& output) BOOST_NOEXCEPT {
+ BOOST_STATIC_ASSERT_MSG(
+ (sizeof(boost::array<C, N>) == sizeof(boost::array<C, N>)),
+ "std::array<C, N> and boost::array<C, N> must have exactly the same layout."
+ );
+ return ((*this) >> reinterpret_cast<boost::array<C, N>& >(output));
+ }
+#endif
+
+ bool operator>>(bool& output) BOOST_NOEXCEPT {
+ output = false; // Suppress warning about uninitalized variable
+
+ if (start == finish) return false;
+ CharT const zero = lcast_char_constants<CharT>::zero;
+ CharT const plus = lcast_char_constants<CharT>::plus;
+ CharT const minus = lcast_char_constants<CharT>::minus;
+
+ const CharT* const dec_finish = finish - 1;
+ output = Traits::eq(*dec_finish, zero + 1);
+ if (!output && !Traits::eq(*dec_finish, zero)) {
+ return false; // Does not ends on '0' or '1'
+ }
+
+ if (start == dec_finish) return true;
+
+ // We may have sign at the beginning
+ if (Traits::eq(plus, *start) || (Traits::eq(minus, *start) && !output)) {
+ ++ start;
+ }
+
+ // Skipping zeros
+ while (start != dec_finish) {
+ if (!Traits::eq(zero, *start)) {
+ return false; // Not a zero => error
+ }
+
+ ++ start;
+ }
+
+ return true;
+ }
+
+ private:
+ // Not optimised converter
+ template <class T>
+ bool float_types_converter_internal(T& output) {
+ if (parse_inf_nan(start, finish, output)) return true;
+ bool const return_value = shr_using_base_class(output);
+
+ /* Some compilers and libraries successfully
+ * parse 'inf', 'INFINITY', '1.0E', '1.0E-'...
+ * We are trying to provide a unified behaviour,
+ * so we just forbid such conversions (as some
+ * of the most popular compilers/libraries do)
+ * */
+ CharT const minus = lcast_char_constants<CharT>::minus;
+ CharT const plus = lcast_char_constants<CharT>::plus;
+ CharT const capital_e = lcast_char_constants<CharT>::capital_e;
+ CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
+ if ( return_value &&
+ (
+ Traits::eq(*(finish-1), lowercase_e) // 1.0e
+ || Traits::eq(*(finish-1), capital_e) // 1.0E
+ || Traits::eq(*(finish-1), minus) // 1.0e- or 1.0E-
+ || Traits::eq(*(finish-1), plus) // 1.0e+ or 1.0E+
+ )
+ ) return false;
+
+ return return_value;
+ }
+
+ public:
+ bool operator>>(float& output) { return float_types_converter_internal(output); }
+ bool operator>>(double& output) { return float_types_converter_internal(output); }
+ bool operator>>(long double& output) { return float_types_converter_internal(output); }
+
+ // Generic istream-based algorithm.
+ // lcast_streambuf_for_target<InputStreamable>::value is true.
+ template <typename InputStreamable>
+ bool operator>>(InputStreamable& output) {
+ return shr_using_base_class(output);
+ }
+ };
+ }
+} // namespace boost
+
+#undef BOOST_LCAST_NO_WCHAR_T
+
+#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_HPP
+
--- /dev/null
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2014.
+//
+// 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)
+//
+// what: lexical_cast custom keyword cast
+// who: contributed by Kevlin Henney,
+// enhanced with contributions from Terje Slettebo,
+// with additional fixes and suggestions from Gennaro Prota,
+// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
+// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
+// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+
+#ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
+#define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <boost/limits.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_float.hpp>
+
+#include <boost/numeric/conversion/cast.hpp>
+
+namespace boost { namespace detail {
+
+template <class Source >
+struct detect_precision_loss
+{
+ typedef Source source_type;
+ typedef boost::numeric::Trunc<Source> Rounder;
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ boost::is_arithmetic<Source>, Source, Source const&
+ >::type argument_type ;
+
+ static inline source_type nearbyint(argument_type s, bool& is_ok) BOOST_NOEXCEPT {
+ const source_type near_int = Rounder::nearbyint(s);
+ if (near_int && is_ok) {
+ const source_type orig_div_round = s / near_int;
+ const source_type eps = std::numeric_limits<source_type>::epsilon();
+
+ is_ok = !((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps);
+ }
+
+ return s;
+ }
+
+ typedef typename Rounder::round_style round_style;
+};
+
+template <typename Base, class Source>
+struct fake_precision_loss: public Base
+{
+ typedef Source source_type ;
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ boost::is_arithmetic<Source>, Source, Source const&
+ >::type argument_type ;
+
+ static inline source_type nearbyint(argument_type s, bool& /*is_ok*/) BOOST_NOEXCEPT {
+ return s;
+ }
+};
+
+struct nothrow_overflow_handler
+{
+ inline bool operator() ( boost::numeric::range_check_result r ) const BOOST_NOEXCEPT {
+ return (r == boost::numeric::cInRange);
+ }
+};
+
+template <typename Target, typename Source>
+inline bool noexcept_numeric_convert(const Source& arg, Target& result) BOOST_NOEXCEPT {
+ typedef boost::numeric::converter<
+ Target,
+ Source,
+ boost::numeric::conversion_traits<Target, Source >,
+ nothrow_overflow_handler,
+ detect_precision_loss<Source >
+ > converter_orig_t;
+
+ typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+ boost::is_base_of< detect_precision_loss<Source >, converter_orig_t >::value,
+ converter_orig_t,
+ fake_precision_loss<converter_orig_t, Source>
+ >::type converter_t;
+
+ bool res = nothrow_overflow_handler()(converter_t::out_of_range(arg));
+ result = converter_t::low_level_convert(converter_t::nearbyint(arg, res));
+ return res;
+}
+
+template <typename Target, typename Source>
+struct lexical_cast_dynamic_num_not_ignoring_minus
+{
+ static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
+ return noexcept_numeric_convert<Target, Source >(arg, result);
+ }
+};
+
+template <typename Target, typename Source>
+struct lexical_cast_dynamic_num_ignoring_minus
+{
+ static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
+ typedef BOOST_DEDUCED_TYPENAME boost::mpl::eval_if_c<
+ boost::is_float<Source>::value,
+ boost::mpl::identity<Source>,
+ boost::make_unsigned<Source>
+ >::type usource_t;
+
+ if (arg < 0) {
+ const bool res = noexcept_numeric_convert<Target, usource_t>(0u - arg, result);
+ result = static_cast<Target>(0u - result);
+ return res;
+ } else {
+ return noexcept_numeric_convert<Target, usource_t>(arg, result);
+ }
+ }
+};
+
+/*
+ * lexical_cast_dynamic_num follows the rules:
+ * 1) If Source can be converted to Target without precision loss and
+ * without overflows, then assign Source to Target and return
+ *
+ * 2) If Source is less than 0 and Target is an unsigned integer,
+ * then negate Source, check the requirements of rule 1) and if
+ * successful, assign static_casted Source to Target and return
+ *
+ * 3) Otherwise throw a bad_lexical_cast exception
+ *
+ *
+ * Rule 2) required because boost::lexical_cast has the behavior of
+ * stringstream, which uses the rules of scanf for conversions. And
+ * in the C99 standard for unsigned input value minus sign is
+ * optional, so if a negative number is read, no errors will arise
+ * and the result will be the two's complement.
+ */
+template <typename Target, typename Source>
+struct dynamic_num_converter_impl
+{
+ static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
+ typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+ boost::type_traits::ice_and<
+ boost::is_unsigned<Target>::value,
+ boost::type_traits::ice_or<
+ boost::is_signed<Source>::value,
+ boost::is_float<Source>::value
+ >::value,
+ boost::type_traits::ice_not<
+ boost::is_same<Source, bool>::value
+ >::value,
+ boost::type_traits::ice_not<
+ boost::is_same<Target, bool>::value
+ >::value
+ >::value,
+ lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
+ lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
+ >::type caster_type;
+
+ return caster_type::try_convert(arg, result);
+ }
+};
+
+}} // namespace boost::detail
+
+#endif // BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
+
--- /dev/null
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2014.
+//
+// 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)
+//
+// what: lexical_cast custom keyword cast
+// who: contributed by Kevlin Henney,
+// enhanced with contributions from Terje Slettebo,
+// with additional fixes and suggestions from Gennaro Prota,
+// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
+// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
+// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+
+#ifndef BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP
+#define BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
+
+#include <cstddef>
+#include <cstring>
+#include <boost/limits.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/math/special_functions/sign.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+
+#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
+
+namespace boost {
+ namespace detail
+ {
+ template <class CharT>
+ bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) BOOST_NOEXCEPT {
+ for( unsigned int i=0; i < len; ++i ) {
+ if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
+ }
+
+ return true;
+ }
+
+ /* Returns true and sets the correct value if found NaN or Inf. */
+ template <class CharT, class T>
+ inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
+ , const CharT* lc_NAN, const CharT* lc_nan
+ , const CharT* lc_INFINITY, const CharT* lc_infinity
+ , const CharT opening_brace, const CharT closing_brace) BOOST_NOEXCEPT
+ {
+ using namespace std;
+ if (begin == end) return false;
+ const CharT minus = lcast_char_constants<CharT>::minus;
+ const CharT plus = lcast_char_constants<CharT>::plus;
+ const int inifinity_size = 8; // == sizeof("infinity") - 1
+
+ /* Parsing +/- */
+ bool const has_minus = (*begin == minus);
+ if (has_minus || *begin == plus) {
+ ++ begin;
+ }
+
+ if (end - begin < 3) return false;
+ if (lc_iequal(begin, lc_nan, lc_NAN, 3)) {
+ begin += 3;
+ if (end != begin) {
+ /* It is 'nan(...)' or some bad input*/
+
+ if (end - begin < 2) return false; // bad input
+ -- end;
+ if (*begin != opening_brace || *end != closing_brace) return false; // bad input
+ }
+
+ if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
+ else value = (boost::math::changesign) (std::numeric_limits<T>::quiet_NaN());
+ return true;
+ } else if (
+ ( /* 'INF' or 'inf' */
+ end - begin == 3 // 3 == sizeof('inf') - 1
+ && lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
+ )
+ ||
+ ( /* 'INFINITY' or 'infinity' */
+ end - begin == inifinity_size
+ && lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
+ )
+ )
+ {
+ if( !has_minus ) value = std::numeric_limits<T>::infinity();
+ else value = (boost::math::changesign) (std::numeric_limits<T>::infinity());
+ return true;
+ }
+
+ return false;
+ }
+
+ template <class CharT, class T>
+ bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
+ , const CharT* lc_nan
+ , const CharT* lc_infinity) BOOST_NOEXCEPT
+ {
+ using namespace std;
+ const CharT minus = lcast_char_constants<CharT>::minus;
+ if ((boost::math::isnan)(value)) {
+ if ((boost::math::signbit)(value)) {
+ *begin = minus;
+ ++ begin;
+ }
+
+ memcpy(begin, lc_nan, 3 * sizeof(CharT));
+ end = begin + 3;
+ return true;
+ } else if ((boost::math::isinf)(value)) {
+ if ((boost::math::signbit)(value)) {
+ *begin = minus;
+ ++ begin;
+ }
+
+ memcpy(begin, lc_infinity, 3 * sizeof(CharT));
+ end = begin + 3;
+ return true;
+ }
+
+ return false;
+ }
+
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+ template <class T>
+ bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT {
+ return parse_inf_nan_impl(begin, end, value
+ , L"NAN", L"nan"
+ , L"INFINITY", L"infinity"
+ , L'(', L')');
+ }
+
+ template <class T>
+ bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT {
+ return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
+ }
+
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+ template <class T>
+ bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT {
+ return parse_inf_nan_impl(begin, end, value
+ , u"NAN", u"nan"
+ , u"INFINITY", u"infinity"
+ , u'(', u')');
+ }
+
+ template <class T>
+ bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT {
+ return put_inf_nan_impl(begin, end, value, u"nan", u"infinity");
+ }
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+ template <class T>
+ bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT {
+ return parse_inf_nan_impl(begin, end, value
+ , U"NAN", U"nan"
+ , U"INFINITY", U"infinity"
+ , U'(', U')');
+ }
+
+ template <class T>
+ bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT {
+ return put_inf_nan_impl(begin, end, value, U"nan", U"infinity");
+ }
+#endif
+
+ template <class CharT, class T>
+ bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT {
+ return parse_inf_nan_impl(begin, end, value
+ , "NAN", "nan"
+ , "INFINITY", "infinity"
+ , '(', ')');
+ }
+
+ template <class CharT, class T>
+ bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT {
+ return put_inf_nan_impl(begin, end, value, "nan", "infinity");
+ }
+ }
+} // namespace boost
+
+#undef BOOST_LCAST_NO_WCHAR_T
+
+#endif // BOOST_LEXICAL_CAST_DETAIL_INF_NAN_HPP
+
--- /dev/null
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2014.
+//
+// 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)
+//
+// what: lexical_cast custom keyword cast
+// who: contributed by Kevlin Henney,
+// enhanced with contributions from Terje Slettebo,
+// with additional fixes and suggestions from Gennaro Prota,
+// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
+// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
+// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+
+#ifndef BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP
+#define BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost {
+
+ namespace detail // is_character<...>
+ {
+ // returns true, if T is one of the character types
+ template < typename T >
+ struct is_character
+ {
+ typedef boost::type_traits::ice_or<
+ boost::is_same< T, char >::value,
+ #if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
+ boost::is_same< T, wchar_t >::value,
+ #endif
+ #ifndef BOOST_NO_CXX11_CHAR16_T
+ boost::is_same< T, char16_t >::value,
+ #endif
+ #ifndef BOOST_NO_CXX11_CHAR32_T
+ boost::is_same< T, char32_t >::value,
+ #endif
+ boost::is_same< T, unsigned char >::value,
+ boost::is_same< T, signed char >::value
+ > result_type;
+
+ BOOST_STATIC_CONSTANT(bool, value = (result_type::value) );
+ };
+ }
+}
+
+#endif // BOOST_LEXICAL_CAST_DETAIL_IS_CHARACTER_HPP
+
--- /dev/null
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2014.
+//
+// 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)
+//
+// what: lexical_cast custom keyword cast
+// who: contributed by Kevlin Henney,
+// enhanced with contributions from Terje Slettebo,
+// with additional fixes and suggestions from Gennaro Prota,
+// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
+// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
+// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+
+#ifndef BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP
+#define BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost
+{
+ namespace detail // '0', '-', '+', 'e', 'E' and '.' constants
+ {
+ template < typename Char >
+ struct lcast_char_constants {
+ // We check in tests assumption that static casted character is
+ // equal to correctly written C++ literal: U'0' == static_cast<char32_t>('0')
+ BOOST_STATIC_CONSTANT(Char, zero = static_cast<Char>('0'));
+ BOOST_STATIC_CONSTANT(Char, minus = static_cast<Char>('-'));
+ BOOST_STATIC_CONSTANT(Char, plus = static_cast<Char>('+'));
+ BOOST_STATIC_CONSTANT(Char, lowercase_e = static_cast<Char>('e'));
+ BOOST_STATIC_CONSTANT(Char, capital_e = static_cast<Char>('E'));
+ BOOST_STATIC_CONSTANT(Char, c_decimal_separator = static_cast<Char>('.'));
+ };
+ }
+} // namespace boost
+
+
+#endif // BOOST_LEXICAL_CAST_DETAIL_LCAST_CHAR_CONSTANTS_HPP
+
--- /dev/null
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2014.
+//
+// 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)
+//
+// what: lexical_cast custom keyword cast
+// who: contributed by Kevlin Henney,
+// enhanced with contributions from Terje Slettebo,
+// with additional fixes and suggestions from Gennaro Prota,
+// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
+// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
+// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+
+#ifndef BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP
+#define BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <climits>
+#include <cstddef>
+#include <string>
+#include <cstring>
+#include <cstdio>
+#include <boost/limits.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/detail/workaround.hpp>
+
+
+#ifndef BOOST_NO_STD_LOCALE
+# include <locale>
+#else
+# ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+ // Getting error at this point means, that your STL library is old/lame/misconfigured.
+ // If nothing can be done with STL library, define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE,
+ // but beware: lexical_cast will understand only 'C' locale delimeters and thousands
+ // separators.
+# error "Unable to use <locale> header. Define BOOST_LEXICAL_CAST_ASSUME_C_LOCALE to force "
+# error "boost::lexical_cast to use only 'C' locale during conversions."
+# endif
+#endif
+
+#include <boost/lexical_cast/detail/lcast_char_constants.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/noncopyable.hpp>
+
+namespace boost
+{
+ namespace detail // lcast_to_unsigned
+ {
+ template<class T>
+ inline
+ BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type lcast_to_unsigned(const T value) BOOST_NOEXCEPT {
+ typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type result_type;
+ return value < 0
+ ? static_cast<result_type>(0u - static_cast<result_type>(value))
+ : static_cast<result_type>(value);
+ }
+ }
+
+ namespace detail // lcast_put_unsigned
+ {
+ template <class Traits, class T, class CharT>
+ class lcast_put_unsigned: boost::noncopyable {
+ typedef BOOST_DEDUCED_TYPENAME Traits::int_type int_type;
+ BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+ (sizeof(int_type) > sizeof(T))
+ , int_type
+ , T
+ >::type m_value;
+ CharT* m_finish;
+ CharT const m_czero;
+ int_type const m_zero;
+
+ public:
+ lcast_put_unsigned(const T n_param, CharT* finish) BOOST_NOEXCEPT
+ : m_value(n_param), m_finish(finish)
+ , m_czero(lcast_char_constants<CharT>::zero), m_zero(Traits::to_int_type(m_czero))
+ {
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+ BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
+#endif
+ }
+
+ CharT* convert() {
+#ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+ std::locale loc;
+ if (loc == std::locale::classic()) {
+ return main_convert_loop();
+ }
+
+ typedef std::numpunct<CharT> numpunct;
+ numpunct const& np = BOOST_USE_FACET(numpunct, loc);
+ std::string const grouping = np.grouping();
+ std::string::size_type const grouping_size = grouping.size();
+
+ if (!grouping_size || grouping[0] <= 0) {
+ return main_convert_loop();
+ }
+
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+ // Check that ulimited group is unreachable:
+ BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX);
+#endif
+ CharT const thousands_sep = np.thousands_sep();
+ std::string::size_type group = 0; // current group number
+ char last_grp_size = grouping[0];
+ char left = last_grp_size;
+
+ do {
+ if (left == 0) {
+ ++group;
+ if (group < grouping_size) {
+ char const grp_size = grouping[group];
+ last_grp_size = (grp_size <= 0 ? static_cast<char>(CHAR_MAX) : grp_size);
+ }
+
+ left = last_grp_size;
+ --m_finish;
+ Traits::assign(*m_finish, thousands_sep);
+ }
+
+ --left;
+ } while (main_convert_iteration());
+
+ return m_finish;
+#else
+ return main_convert_loop();
+#endif
+ }
+
+ private:
+ inline bool main_convert_iteration() BOOST_NOEXCEPT {
+ --m_finish;
+ int_type const digit = static_cast<int_type>(m_value % 10U);
+ Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit));
+ m_value /= 10;
+ return !!m_value; // suppressing warnings
+ }
+
+ inline CharT* main_convert_loop() BOOST_NOEXCEPT {
+ while (main_convert_iteration());
+ return m_finish;
+ }
+ };
+ }
+
+ namespace detail // lcast_ret_unsigned
+ {
+ template <class Traits, class T, class CharT>
+ class lcast_ret_unsigned: boost::noncopyable {
+ bool m_multiplier_overflowed;
+ T m_multiplier;
+ T& m_value;
+ const CharT* const m_begin;
+ const CharT* m_end;
+
+ public:
+ lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) BOOST_NOEXCEPT
+ : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end)
+ {
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+ BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
+
+ // GCC when used with flag -std=c++0x may not have std::numeric_limits
+ // specializations for __int128 and unsigned __int128 types.
+ // Try compilation with -std=gnu++0x or -std=gnu++11.
+ //
+ // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856
+ BOOST_STATIC_ASSERT_MSG(std::numeric_limits<T>::is_specialized,
+ "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast"
+ );
+#endif
+ }
+
+ inline bool convert() {
+ CharT const czero = lcast_char_constants<CharT>::zero;
+ --m_end;
+ m_value = static_cast<T>(0);
+
+ if (m_begin > m_end || *m_end < czero || *m_end >= czero + 10)
+ return false;
+ m_value = static_cast<T>(*m_end - czero);
+ --m_end;
+
+#ifdef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
+ return main_convert_loop();
+#else
+ std::locale loc;
+ if (loc == std::locale::classic()) {
+ return main_convert_loop();
+ }
+
+ typedef std::numpunct<CharT> numpunct;
+ numpunct const& np = BOOST_USE_FACET(numpunct, loc);
+ std::string const& grouping = np.grouping();
+ std::string::size_type const grouping_size = grouping.size();
+
+ /* According to Programming languages - C++
+ * we MUST check for correct grouping
+ */
+ if (!grouping_size || grouping[0] <= 0) {
+ return main_convert_loop();
+ }
+
+ unsigned char current_grouping = 0;
+ CharT const thousands_sep = np.thousands_sep();
+ char remained = static_cast<char>(grouping[current_grouping] - 1);
+
+ for (;m_end >= m_begin; --m_end)
+ {
+ if (remained) {
+ if (!main_convert_iteration()) {
+ return false;
+ }
+ --remained;
+ } else {
+ if ( !Traits::eq(*m_end, thousands_sep) ) //|| begin == end ) return false;
+ {
+ /*
+ * According to Programming languages - C++
+ * Digit grouping is checked. That is, the positions of discarded
+ * separators is examined for consistency with
+ * use_facet<numpunct<charT> >(loc ).grouping()
+ *
+ * BUT what if there is no separators at all and grouping()
+ * is not empty? Well, we have no extraced separators, so we
+ * won`t check them for consistency. This will allow us to
+ * work with "C" locale from other locales
+ */
+ return main_convert_loop();
+ } else {
+ if (m_begin == m_end) return false;
+ if (current_grouping < grouping_size - 1) ++current_grouping;
+ remained = grouping[current_grouping];
+ }
+ }
+ } /*for*/
+
+ return true;
+#endif
+ }
+
+ private:
+ // Iteration that does not care about grouping/separators and assumes that all
+ // input characters are digits
+ inline bool main_convert_iteration() BOOST_NOEXCEPT {
+ CharT const czero = lcast_char_constants<CharT>::zero;
+ T const maxv = (std::numeric_limits<T>::max)();
+
+ m_multiplier_overflowed = m_multiplier_overflowed || (maxv/10 < m_multiplier);
+ m_multiplier = static_cast<T>(m_multiplier * 10);
+
+ T const dig_value = static_cast<T>(*m_end - czero);
+ T const new_sub_value = static_cast<T>(m_multiplier * dig_value);
+
+ // We must correctly handle situations like `000000000000000000000000000001`.
+ // So we take care of overflow only if `dig_value` is not '0'.
+ if (*m_end < czero || *m_end >= czero + 10 // checking for correct digit
+ || (dig_value && ( // checking for overflow of ...
+ m_multiplier_overflowed // ... multiplier
+ || static_cast<T>(maxv / dig_value) < m_multiplier // ... subvalue
+ || static_cast<T>(maxv - new_sub_value) < m_value // ... whole expression
+ ))
+ ) return false;
+
+ m_value = static_cast<T>(m_value + new_sub_value);
+
+ return true;
+ }
+
+ bool main_convert_loop() BOOST_NOEXCEPT {
+ for ( ; m_end >= m_begin; --m_end) {
+ if (!main_convert_iteration()) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+ };
+ }
+} // namespace boost
+
+#endif // BOOST_LEXICAL_CAST_DETAIL_LCAST_UNSIGNED_CONVERTERS_HPP
+
--- /dev/null
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2014.
+//
+// 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)
+//
+// what: lexical_cast custom keyword cast
+// who: contributed by Kevlin Henney,
+// enhanced with contributions from Terje Slettebo,
+// with additional fixes and suggestions from Gennaro Prota,
+// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
+// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
+// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+
+#ifndef BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
+#define BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace detail {
+
+ template <typename TargetChar, typename SourceChar>
+ struct widest_char {
+ typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+ (sizeof(TargetChar) > sizeof(SourceChar))
+ , TargetChar
+ , SourceChar
+ >::type type;
+ };
+
+}} // namespace boost::detail
+
+#endif // BOOST_LEXICAL_CAST_DETAIL_WIDEST_CHAR_HPP
+
--- /dev/null
+// Copyright Kevlin Henney, 2000-2005.
+// Copyright Alexander Nasonov, 2006-2010.
+// Copyright Antony Polukhin, 2011-2014.
+//
+// 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)
+//
+// what: lexical_cast custom keyword cast
+// who: contributed by Kevlin Henney,
+// enhanced with contributions from Terje Slettebo,
+// with additional fixes and suggestions from Gennaro Prota,
+// Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+// Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
+// Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
+// when: November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+
+#ifndef BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
+#define BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <string>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/ice.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+
+#include <boost/lexical_cast/detail/is_character.hpp>
+#include <boost/lexical_cast/detail/converter_numeric.hpp>
+#include <boost/lexical_cast/detail/converter_lexical.hpp>
+
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/container/container_fwd.hpp>
+
+namespace boost {
+ namespace detail
+ {
+ template<typename T>
+ struct is_stdstring
+ : boost::false_type
+ {};
+
+ template<typename CharT, typename Traits, typename Alloc>
+ struct is_stdstring< std::basic_string<CharT, Traits, Alloc> >
+ : boost::true_type
+ {};
+
+ template<typename CharT, typename Traits, typename Alloc>
+ struct is_stdstring< boost::container::basic_string<CharT, Traits, Alloc> >
+ : boost::true_type
+ {};
+
+ template<typename Target, typename Source>
+ struct is_arithmetic_and_not_xchars
+ {
+ BOOST_STATIC_CONSTANT(bool, value = (
+ boost::type_traits::ice_and<
+ boost::type_traits::ice_not<
+ boost::detail::is_character<Target>::value
+ >::value,
+ boost::type_traits::ice_not<
+ boost::detail::is_character<Source>::value
+ >::value,
+ boost::is_arithmetic<Source>::value,
+ boost::is_arithmetic<Target>::value
+ >::value
+ ));
+ };
+
+ /*
+ * is_xchar_to_xchar<Target, Source>::value is true,
+ * Target and Souce are char types of the same size 1 (char, signed char, unsigned char).
+ */
+ template<typename Target, typename Source>
+ struct is_xchar_to_xchar
+ {
+ BOOST_STATIC_CONSTANT(bool, value = (
+ boost::type_traits::ice_and<
+ boost::type_traits::ice_eq<sizeof(Source), sizeof(Target)>::value,
+ boost::type_traits::ice_eq<sizeof(Source), sizeof(char)>::value,
+ boost::detail::is_character<Target>::value,
+ boost::detail::is_character<Source>::value
+ >::value
+ ));
+ };
+
+ template<typename Target, typename Source>
+ struct is_char_array_to_stdstring
+ : boost::false_type
+ {};
+
+ template<typename CharT, typename Traits, typename Alloc>
+ struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, CharT* >
+ : boost::true_type
+ {};
+
+ template<typename CharT, typename Traits, typename Alloc>
+ struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, const CharT* >
+ : boost::true_type
+ {};
+
+ template<typename CharT, typename Traits, typename Alloc>
+ struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
+ : boost::true_type
+ {};
+
+ template<typename CharT, typename Traits, typename Alloc>
+ struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
+ : boost::true_type
+ {};
+
+ template <typename Target, typename Source>
+ struct copy_converter_impl
+ {
+// MSVC fail to forward an array (DevDiv#555157 "SILENT BAD CODEGEN triggered by perfect forwarding",
+// fixed in 2013 RTM).
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && (!defined(BOOST_MSVC) || BOOST_MSVC >= 1800)
+ template <class T>
+ static inline bool try_convert(T&& arg, Target& result) {
+ result = static_cast<T&&>(arg); // eqaul to `result = std::forward<T>(arg);`
+ return true;
+ }
+#else
+ static inline bool try_convert(const Source& arg, Target& result) {
+ result = arg;
+ return true;
+ }
+#endif
+ };
+ }
+
+ namespace conversion { namespace detail {
+
+ template <typename Target, typename Source>
+ inline bool try_lexical_convert(const Source& arg, Target& result)
+ {
+ typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src;
+
+ typedef BOOST_DEDUCED_TYPENAME boost::type_traits::ice_or<
+ boost::detail::is_xchar_to_xchar<Target, src >::value,
+ boost::detail::is_char_array_to_stdstring<Target, src >::value,
+ boost::type_traits::ice_and<
+ boost::is_same<Target, src >::value,
+ boost::detail::is_stdstring<Target >::value
+ >::value,
+ boost::type_traits::ice_and<
+ boost::is_same<Target, src >::value,
+ boost::detail::is_character<Target >::value
+ >::value
+ > shall_we_copy_t;
+
+ typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
+ shall_we_copy_with_dynamic_check_t;
+
+ // We do evaluate second `if_` lazily to avoid unnecessary instantiations
+ // of `shall_we_copy_with_dynamic_check_t` and improve compilation times.
+ typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+ shall_we_copy_t::value,
+ boost::mpl::identity<boost::detail::copy_converter_impl<Target, src > >,
+ boost::mpl::if_<
+ shall_we_copy_with_dynamic_check_t,
+ boost::detail::dynamic_num_converter_impl<Target, src >,
+ boost::detail::lexical_converter_impl<Target, src >
+ >
+ >::type caster_type_lazy;
+
+ typedef BOOST_DEDUCED_TYPENAME caster_type_lazy::type caster_type;
+
+ return caster_type::try_convert(arg, result);
+ }
+
+ template <typename Target, typename CharacterT>
+ inline bool try_lexical_convert(const CharacterT* chars, std::size_t count, Target& result)
+ {
+ BOOST_STATIC_ASSERT_MSG(
+ boost::detail::is_character<CharacterT>::value,
+ "This overload of try_lexical_convert is meant to be used only with arrays of characters."
+ );
+ return ::boost::conversion::detail::try_lexical_convert(
+ ::boost::iterator_range<const CharacterT*>(chars, chars + count), result
+ );
+ }
+
+ }} // namespace conversion::detail
+
+ namespace conversion {
+ // ADL barrier
+ using ::boost::conversion::detail::try_lexical_convert;
+ }
+
+} // namespace boost
+
+#endif // BOOST_LEXICAL_CAST_TRY_LEXICAL_CONVERT_HPP
+
#define BOOST_MATH_MAX_ROOT_ITERATION_POLICY 200
#endif
-#if !defined(__BORLANDC__) \
- && !(defined(__GNUC__) && (__GNUC__ == 3) && (__GNUC_MINOR__ <= 2))
+#if !defined(__BORLANDC__)
#define BOOST_MATH_META_INT(type, name, Default)\
template <type N = Default> struct name : public boost::mpl::int_<N>{};\
namespace detail{\
#ifdef BOOST_MATH_USE_FLOAT128
template <class Policy>
-struct precision<__float128, Policy>
+struct precision<BOOST_MATH_FLOAT128_TYPE, Policy>
{
typedef mpl::int_<113> type;
};
typedef mpl::bool_< std::numeric_limits<T>::is_specialized > tag_type;
return detail::digits_imp<T, Policy>(tag_type());
}
+template <class T, class Policy>
+inline int digits_base10(BOOST_MATH_EXPLICIT_TEMPLATE_TYPE(T))
+{
+ return boost::math::policies::digits<T, Policy>() * 301 / 1000L;
+}
template <class Policy>
inline unsigned long get_max_series_iterations()
// the Intel extended double precision format (80 bits) and
// the IEEE extended double precision format with 15 exponent bits (128 bits).
+#elif defined(__GNUC__) && (LDBL_MANT_DIG == 106)
+
+//
+// Define nothing here and fall though to generic_tag:
+// We have GCC's "double double" in effect, and any attempt
+// to handle it via bit-fiddling is pretty much doomed to fail...
+//
// long double (>64 bits), PowerPC ---------------------------------------------
&& !defined(__DECCXX)\
&& !defined(__osf__) \
&& !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)\
- && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)
+ && !defined(__FAST_MATH__)\
+ && !defined(BOOST_MATH_DISABLE_STD_FPCLASSIFY)\
+ && !defined(BOOST_INTEL)\
+ && !defined(sun)
# define BOOST_MATH_USE_STD_FPCLASSIFY
#endif
if(std::numeric_limits<T>::is_specialized)
return isfinite_impl(x, generic_tag<true>());
#endif
- (void)x; // warning supression.
+ (void)x; // warning suppression.
return true;
}
{ //!< \brief return true if floating-point type t is finite.
typedef detail::fp_traits<long double>::type traits;
typedef traits::method method;
- typedef boost::is_floating_point<long double>::type fp_tag;
+ //typedef boost::is_floating_point<long double>::type fp_tag;
typedef long double value_type;
return detail::isfinite_impl(static_cast<value_type>(x), method());
}
{
typedef detail::fp_traits<long double>::type traits;
typedef traits::method method;
- typedef boost::is_floating_point<long double>::type fp_tag;
+ //typedef boost::is_floating_point<long double>::type fp_tag;
typedef long double value_type;
return detail::isnormal_impl(static_cast<value_type>(x), method());
}
if(std::numeric_limits<T>::is_specialized)
return isinf_impl(x, generic_tag<true>());
#endif
- (void)x; // warning supression.
+ (void)x; // warning suppression.
return false;
}
{
typedef detail::fp_traits<long double>::type traits;
typedef traits::method method;
- typedef boost::is_floating_point<long double>::type fp_tag;
+ //typedef boost::is_floating_point<long double>::type fp_tag;
typedef long double value_type;
return detail::isinf_impl(static_cast<value_type>(x), method());
}
if(std::numeric_limits<T>::is_specialized)
return isnan_impl(x, generic_tag<true>());
#endif
- (void)x; // warning supression
+ (void)x; // warning suppression
return false;
}
{ //!< \brief return true if floating-point type t is NaN (Not A Number).
typedef detail::fp_traits<long double>::type traits;
typedef traits::method method;
- typedef boost::is_floating_point<long double>::type fp_tag;
+ //typedef boost::is_floating_point<long double>::type fp_tag;
return detail::isnan_impl(x, method());
}
#endif
#include <boost/math/tools/promotion.hpp> // for argument promotion.
#include <boost/math/policies/policy.hpp>
#include <boost/mpl/comparison.hpp>
+#include <boost/utility/enable_if.hpp>
#include <boost/config/no_tr1/complex.hpp>
#define BOOST_NO_MACRO_EXPAND /**/
typename tools::promote_args<RT1, RT2, RT3>::type
ibeta_derivative(RT1 a, RT2 b, RT3 x, const Policy& pol); // derivative of incomplete beta
+ // Binomial:
+ template <class T, class Policy>
+ T binomial_coefficient(unsigned n, unsigned k, const Policy& pol);
+ template <class T>
+ T binomial_coefficient(unsigned n, unsigned k);
+
// erf & erfc error functions.
template <class RT> // Error function.
typename tools::promote_args<RT>::type erf(RT z);
legendre_p(int l, T x);
template <class T, class Policy>
- typename tools::promote_args<T>::type
+ typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
legendre_p(int l, T x, const Policy& pol);
template <class T>
legendre_q(unsigned l, T x);
template <class T, class Policy>
- typename tools::promote_args<T>::type
+ typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
legendre_q(unsigned l, T x, const Policy& pol);
template <class T1, class T2, class T3>
typename tools::promote_args<T1, T2, T3, T4>::type
ellint_rj(T1 x, T2 y, T3 z, T4 p, const Policy& pol);
+ template <class T1, class T2, class T3>
+ typename tools::promote_args<T1, T2, T3>::type
+ ellint_rg(T1 x, T2 y, T3 z);
+
+ template <class T1, class T2, class T3, class Policy>
+ typename tools::promote_args<T1, T2, T3>::type
+ ellint_rg(T1 x, T2 y, T3 z, const Policy& pol);
+
template <typename T>
typename tools::promote_args<T>::type ellint_2(T k);
template <class T1, class T2, class Policy>
typename tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi, const Policy& pol);
+ template <typename T>
+ typename tools::promote_args<T>::type ellint_d(T k);
+
+ template <class T1, class T2>
+ typename tools::promote_args<T1, T2>::type ellint_d(T1 k, T2 phi);
+
+ template <class T1, class T2, class Policy>
+ typename tools::promote_args<T1, T2>::type ellint_d(T1 k, T2 phi, const Policy& pol);
+
+ template <class T1, class T2>
+ typename tools::promote_args<T1, T2>::type jacobi_zeta(T1 k, T2 phi);
+
+ template <class T1, class T2, class Policy>
+ typename tools::promote_args<T1, T2>::type jacobi_zeta(T1 k, T2 phi, const Policy& pol);
+
+ template <class T1, class T2>
+ typename tools::promote_args<T1, T2>::type heuman_lambda(T1 k, T2 phi);
+
+ template <class T1, class T2, class Policy>
+ typename tools::promote_args<T1, T2>::type heuman_lambda(T1 k, T2 phi, const Policy& pol);
+
namespace detail{
template <class T, class U, class V>
template <class T, class Policy>
typename tools::promote_args<T>::type digamma(T x, const Policy&);
+ // trigamma:
+ template <class T>
+ typename tools::promote_args<T>::type trigamma(T x);
+
+ template <class T, class Policy>
+ typename tools::promote_args<T>::type trigamma(T x, const Policy&);
+
+ // polygamma:
+ template <class T>
+ typename tools::promote_args<T>::type polygamma(int n, T x);
+
+ template <class T, class Policy>
+ typename tools::promote_args<T>::type polygamma(int n, T x, const Policy&);
+
// Hypotenuse function sqrt(x ^ 2 + y ^ 2).
template <class T1, class T2>
typename tools::promote_args<T1, T2>::type
// Bessel functions:
template <class T1, class T2, class Policy>
typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j(T1 v, T2 x, const Policy& pol);
+ template <class T1, class T2, class Policy>
+ typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j_prime(T1 v, T2 x, const Policy& pol);
template <class T1, class T2>
typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_j(T1 v, T2 x);
+ template <class T1, class T2>
+ typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_j_prime(T1 v, T2 x);
template <class T, class Policy>
typename detail::bessel_traits<T, T, Policy>::result_type sph_bessel(unsigned v, T x, const Policy& pol);
+ template <class T, class Policy>
+ typename detail::bessel_traits<T, T, Policy>::result_type sph_bessel_prime(unsigned v, T x, const Policy& pol);
template <class T>
typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_bessel(unsigned v, T x);
+ template <class T>
+ typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_bessel_prime(unsigned v, T x);
template <class T1, class T2, class Policy>
typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i(T1 v, T2 x, const Policy& pol);
+ template <class T1, class T2, class Policy>
+ typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i_prime(T1 v, T2 x, const Policy& pol);
template <class T1, class T2>
typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_i(T1 v, T2 x);
+ template <class T1, class T2>
+ typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_i_prime(T1 v, T2 x);
template <class T1, class T2, class Policy>
typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k(T1 v, T2 x, const Policy& pol);
+ template <class T1, class T2, class Policy>
+ typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k_prime(T1 v, T2 x, const Policy& pol);
template <class T1, class T2>
typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_k(T1 v, T2 x);
+ template <class T1, class T2>
+ typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_k_prime(T1 v, T2 x);
template <class T1, class T2, class Policy>
typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann(T1 v, T2 x, const Policy& pol);
+ template <class T1, class T2, class Policy>
+ typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann_prime(T1 v, T2 x, const Policy& pol);
template <class T1, class T2>
typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_neumann(T1 v, T2 x);
+ template <class T1, class T2>
+ typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_neumann_prime(T1 v, T2 x);
template <class T, class Policy>
typename detail::bessel_traits<T, T, Policy>::result_type sph_neumann(unsigned v, T x, const Policy& pol);
+ template <class T, class Policy>
+ typename detail::bessel_traits<T, T, Policy>::result_type sph_neumann_prime(unsigned v, T x, const Policy& pol);
template <class T>
typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann(unsigned v, T x);
+ template <class T>
+ typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann_prime(unsigned v, T x);
template <class T, class Policy>
typename detail::bessel_traits<T, T, Policy>::result_type cyl_bessel_j_zero(T v, int m, const Policy& pol);
typename tools::promote_args<T>::type airy_bi_prime(T x);
template <class T>
- T airy_ai_zero(unsigned m);
+ T airy_ai_zero(int m);
template <class T, class Policy>
- T airy_ai_zero(unsigned m, const Policy&);
+ T airy_ai_zero(int m, const Policy&);
template <class OutputIterator>
OutputIterator airy_ai_zero(
- unsigned start_index,
+ int start_index,
unsigned number_of_zeros,
OutputIterator out_it);
template <class OutputIterator, class Policy>
OutputIterator airy_ai_zero(
- unsigned start_index,
+ int start_index,
unsigned number_of_zeros,
OutputIterator out_it,
const Policy&);
template <class T>
- T airy_bi_zero(unsigned m);
+ T airy_bi_zero(int m);
template <class T, class Policy>
- T airy_bi_zero(unsigned m, const Policy&);
+ T airy_bi_zero(int m, const Policy&);
template <class OutputIterator>
OutputIterator airy_bi_zero(
- unsigned start_index,
+ int start_index,
unsigned number_of_zeros,
OutputIterator out_it);
template <class OutputIterator, class Policy>
OutputIterator airy_bi_zero(
- unsigned start_index,
+ int start_index,
unsigned number_of_zeros,
OutputIterator out_it,
const Policy&);
template <class T>
typename tools::promote_args<T>::type float_advance(const T& val, int distance);
+ template<class T>
+ T unchecked_bernoulli_b2n(const std::size_t n);
+ template <class T, class Policy>
+ T bernoulli_b2n(const int i, const Policy &pol);
+ template <class T>
+ T bernoulli_b2n(const int i);
+ template <class T, class OutputIterator, class Policy>
+ OutputIterator bernoulli_b2n(const int start_index,
+ const unsigned number_of_bernoullis_b2n,
+ OutputIterator out_it,
+ const Policy& pol);
+ template <class T, class OutputIterator>
+ OutputIterator bernoulli_b2n(const int start_index,
+ const unsigned number_of_bernoullis_b2n,
+ OutputIterator out_it);
+ template <class T, class Policy>
+ T tangent_t2n(const int i, const Policy &pol);
+ template <class T>
+ T tangent_t2n(const int i);
+ template <class T, class OutputIterator, class Policy>
+ OutputIterator tangent_t2n(const int start_index,
+ const unsigned number_of_bernoullis_b2n,
+ OutputIterator out_it,
+ const Policy& pol);
+ template <class T, class OutputIterator>
+ OutputIterator tangent_t2n(const int start_index,
+ const unsigned number_of_bernoullis_b2n,
+ OutputIterator out_it);
+
} // namespace math
} // namespace boost
template <class RT1, class RT2, class RT3>\
inline typename boost::math::tools::promote_args<RT1, RT2, RT3>::type \
ibeta_derivative(RT1 a, RT2 b, RT3 x){ return ::boost::math::ibeta_derivative(a, b, x, Policy()); }\
+\
+ template <class T> T binomial_coefficient(unsigned n, unsigned k){ return ::boost::math::binomial_coefficient<T, Policy>(n, k, Policy()); }\
\
template <class RT>\
inline typename boost::math::tools::promote_args<RT>::type erf(RT z) { return ::boost::math::erf(z, Policy()); }\
inline typename boost::math::tools::promote_args<T1, T2, T3, T4>::type \
ellint_rj(T1 x, T2 y, T3 z, T4 p){ return boost::math::ellint_rj(x, y, z, p, Policy()); }\
\
+ template <class T1, class T2, class T3>\
+ inline typename boost::math::tools::promote_args<T1, T2, T3>::type \
+ ellint_rg(T1 x, T2 y, T3 z){ return ::boost::math::ellint_rg(x, y, z, Policy()); }\
+ \
template <typename T>\
inline typename boost::math::tools::promote_args<T>::type ellint_2(T k){ return boost::math::ellint_2(k, Policy()); }\
\
template <class T1, class T2>\
inline typename boost::math::tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi){ return boost::math::ellint_2(k, phi, Policy()); }\
+\
+ template <typename T>\
+ inline typename boost::math::tools::promote_args<T>::type ellint_d(T k){ return boost::math::ellint_d(k, Policy()); }\
+\
+ template <class T1, class T2>\
+ inline typename boost::math::tools::promote_args<T1, T2>::type ellint_d(T1 k, T2 phi){ return boost::math::ellint_d(k, phi, Policy()); }\
+\
+ template <class T1, class T2>\
+ inline typename boost::math::tools::promote_args<T1, T2>::type jacobi_zeta(T1 k, T2 phi){ return boost::math::jacobi_zeta(k, phi, Policy()); }\
+\
+ template <class T1, class T2>\
+ inline typename boost::math::tools::promote_args<T1, T2>::type heuman_lambda(T1 k, T2 phi){ return boost::math::heuman_lambda(k, phi, Policy()); }\
\
template <typename T>\
inline typename boost::math::tools::promote_args<T>::type ellint_1(T k){ return boost::math::ellint_1(k, Policy()); }\
template <class T>\
inline typename boost::math::tools::promote_args<T>::type digamma(T x){ return boost::math::digamma(x, Policy()); }\
\
+ template <class T>\
+ inline typename boost::math::tools::promote_args<T>::type trigamma(T x){ return boost::math::trigamma(x, Policy()); }\
+\
+ template <class T>\
+ inline typename boost::math::tools::promote_args<T>::type polygamma(int n, T x){ return boost::math::polygamma(n, x, Policy()); }\
+ \
template <class T1, class T2>\
inline typename boost::math::tools::promote_args<T1, T2>::type \
hypot(T1 x, T2 y){ return boost::math::hypot(x, y, Policy()); }\
template <class T1, class T2>\
inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_j(T1 v, T2 x)\
{ return boost::math::cyl_bessel_j(v, x, Policy()); }\
+\
+ template <class T1, class T2>\
+ inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type cyl_bessel_j_prime(T1 v, T2 x)\
+ { return boost::math::cyl_bessel_j_prime(v, x, Policy()); }\
\
template <class T>\
inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type sph_bessel(unsigned v, T x)\
{ return boost::math::sph_bessel(v, x, Policy()); }\
+\
+ template <class T>\
+ inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type sph_bessel_prime(unsigned v, T x)\
+ { return boost::math::sph_bessel_prime(v, x, Policy()); }\
\
template <class T1, class T2>\
inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
cyl_bessel_i(T1 v, T2 x) { return boost::math::cyl_bessel_i(v, x, Policy()); }\
+\
+ template <class T1, class T2>\
+ inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
+ cyl_bessel_i_prime(T1 v, T2 x) { return boost::math::cyl_bessel_i_prime(v, x, Policy()); }\
\
template <class T1, class T2>\
inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
cyl_bessel_k(T1 v, T2 x) { return boost::math::cyl_bessel_k(v, x, Policy()); }\
+\
+ template <class T1, class T2>\
+ inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
+ cyl_bessel_k_prime(T1 v, T2 x) { return boost::math::cyl_bessel_k_prime(v, x, Policy()); }\
\
template <class T1, class T2>\
inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
cyl_neumann(T1 v, T2 x){ return boost::math::cyl_neumann(v, x, Policy()); }\
+\
+ template <class T1, class T2>\
+ inline typename boost::math::detail::bessel_traits<T1, T2, Policy >::result_type \
+ cyl_neumann_prime(T1 v, T2 x){ return boost::math::cyl_neumann_prime(v, x, Policy()); }\
\
template <class T>\
inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type \
sph_neumann(unsigned v, T x){ return boost::math::sph_neumann(v, x, Policy()); }\
+\
+ template <class T>\
+ inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type \
+ sph_neumann_prime(unsigned v, T x){ return boost::math::sph_neumann_prime(v, x, Policy()); }\
\
template <class T>\
inline typename boost::math::detail::bessel_traits<T, T, Policy >::result_type cyl_bessel_j_zero(T v, int m)\
OutputIterator airy_bi_zero(int start_index, unsigned number_of_zeros, OutputIterator out_it)\
{ return boost::math::airy_bi_zero<T>(start_index, number_of_zeros, out_it, Policy()); }\
\
+ template <class T>\
+ T bernoulli_b2n(const int i)\
+ { return boost::math::bernoulli_b2n<T>(i, Policy()); }\
+ template <class T, class OutputIterator>\
+ OutputIterator bernoulli_b2n(int start_index, unsigned number_of_bernoullis_b2n, OutputIterator out_it)\
+ { return boost::math::bernoulli_b2n<T>(start_index, number_of_bernoullis_b2n, out_it, Policy()); }\
+ \
+ template <class T>\
+ T tangent_t2n(const int i)\
+ { return boost::math::tangent_t2n<T>(i, Policy()); }\
+ template <class T, class OutputIterator>\
+ OutputIterator tangent_t2n(int start_index, unsigned number_of_bernoullis_b2n, OutputIterator out_it)\
+ { return boost::math::tangent_t2n<T>(start_index, number_of_bernoullis_b2n, out_it, Policy()); }\
+ \
}
#endif
- template<class T>
+ // Generic versions first, note that these do not handle
+ // signed zero or NaN.
+
+ template<class T>
inline int signbit_impl(T x, generic_tag<true> const&)
{
return x < 0;
return x < 0;
}
- template<class T>
+#if defined(__GNUC__) && (LDBL_MANT_DIG == 106)
+ //
+ // Special handling for GCC's "double double" type,
+ // in this case the sign is the same as the sign we
+ // get by casting to double, no overflow/underflow
+ // can occur since the exponents are the same magnitude
+ // for the two types:
+ //
+ inline int signbit_impl(long double x, generic_tag<true> const&)
+ {
+ return (boost::math::signbit)(static_cast<double>(x));
+ }
+ inline int signbit_impl(long double x, generic_tag<false> const&)
+ {
+ return (boost::math::signbit)(static_cast<double>(x));
+ }
+#endif
+
+ template<class T>
inline int signbit_impl(T x, ieee_copy_all_bits_tag const&)
{
typedef BOOST_DEDUCED_TYPENAME fp_traits<T>::type traits;
}
// Changesign
+
+ // Generic versions first, note that these do not handle
+ // signed zero or NaN.
template<class T>
inline T (changesign_impl)(T x, generic_tag<true> const&)
{
return -x;
}
-
+#if defined(__GNUC__) && (LDBL_MANT_DIG == 106)
+ //
+ // Special handling for GCC's "double double" type,
+ // in this case we need to change the sign of both
+ // components of the "double double":
+ //
+ inline long double (changesign_impl)(long double x, generic_tag<true> const&)
+ {
+ double* pd = reinterpret_cast<double*>(&x);
+ pd[0] = boost::math::changesign(pd[0]);
+ pd[1] = boost::math::changesign(pd[1]);
+ return x;
+ }
+ inline long double (changesign_impl)(long double x, generic_tag<false> const&)
+ {
+ double* pd = reinterpret_cast<double*>(&x);
+ pd[0] = boost::math::changesign(pd[0]);
+ pd[1] = boost::math::changesign(pd[1]);
+ return x;
+ }
+#endif
template<class T>
inline T changesign_impl(T x, ieee_copy_all_bits_tag const&)
#include <boost/config.hpp>
#include <boost/cstdint.hpp> // for boost::uintmax_t
#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/is_integral.hpp>
#include <algorithm> // for min and max
#include <boost/config/no_tr1/cmath.hpp>
#include <climits>
#if (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))
# include <math.h>
#endif
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+# include <limits>
+#endif
#include <boost/math/tools/user.hpp>
// are disabled for now. (JM 2012).
# define BOOST_MATH_NO_REAL_CONCEPT_TESTS
#endif
+#ifdef sun
+// Any use of __float128 in program startup code causes a segfault (tested JM 2015, Solaris 11).
+# define BOOST_MATH_DISABLE_FLOAT128
+#endif
#if (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)) && ((LDBL_MANT_DIG == 106) || (__LDBL_MANT_DIG__ == 106)) && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
//
// Darwin's rather strange "double double" is rather hard to
# define BOOST_MATH_NO_NATIVE_LONG_DOUBLE_FP_CLASSIFY
#endif
-#if defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590)
+#if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590)
# include "boost/type.hpp"
# include "boost/non_type.hpp"
# define BOOST_MATH_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
-#endif // defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
+#endif // __SUNPRO_CC
#if (defined(__SUNPRO_CC) || defined(__hppa) || defined(__GNUC__)) && !defined(BOOST_MATH_SMALL_CONSTANT)
// Sun's compiler emits a hard error if a constant underflows,
// as does aCC on PA-RISC, while gcc issues a large number of warnings:
-# define BOOST_MATH_SMALL_CONSTANT(x) 0
+# define BOOST_MATH_SMALL_CONSTANT(x) 0.0
#else
# define BOOST_MATH_SMALL_CONSTANT(x) x
#endif
//
// Test whether to support __float128:
//
-#if defined(_GLIBCXX_USE_FLOAT128) && defined(BOOST_GCC) && !defined(__STRICT_ANSI__)
+#if defined(_GLIBCXX_USE_FLOAT128) && defined(BOOST_GCC) && !defined(__STRICT_ANSI__) \
+ && !defined(BOOST_MATH_DISABLE_FLOAT128) || defined(BOOST_MATH_USE_FLOAT128)
//
// Only enable this when the compiler really is GCC as clang and probably
// intel too don't support __float128 yet :-(
//
+#ifndef BOOST_MATH_USE_FLOAT128
# define BOOST_MATH_USE_FLOAT128
#endif
+
+# if defined(BOOST_INTEL) && defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION >= 1310) && defined(__GNUC__)
+# if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6))
+# define BOOST_MATH_FLOAT128_TYPE __float128
+# endif
+# elif defined(__GNUC__)
+# define BOOST_MATH_FLOAT128_TYPE __float128
+# endif
+
+# ifndef BOOST_MATH_FLOAT128_TYPE
+# define BOOST_MATH_FLOAT128_TYPE _Quad
+# endif
+#endif
//
// Check for WinCE with no iostream support:
//
{
}
+namespace detail{
+
+template <class T>
+struct is_integer_for_rounding
+{
+ static const bool value = boost::is_integral<T>::value
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+ || (std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer)
+#endif
+ ;
+};
+
+}
+
}} // namespace boost namespace math
-#if ((defined(__linux__) && !defined(__UCLIBC__)) || defined(__QNX__) || defined(__IBMCPP__)) && !defined(BOOST_NO_FENV_H)
+#ifdef __GLIBC_PREREQ
+# if __GLIBC_PREREQ(2,14)
+# define BOOST_MATH_HAVE_FIXED_GLIBC
+# endif
+#endif
+
+#if ((defined(__linux__) && !defined(__UCLIBC__) && !defined(BOOST_MATH_HAVE_FIXED_GLIBC)) || defined(__QNX__) || defined(__IBMCPP__)) && !defined(BOOST_NO_FENV_H)
+//
+// This code was introduced in response to this glibc bug: http://sourceware.org/bugzilla/show_bug.cgi?id=2445
+// Basically powl and expl can return garbage when the result is small and certain exception flags are set
+// on entrance to these functions. This appears to have been fixed in Glibc 2.14 (May 2011).
+// Much more information in this message thread: https://groups.google.com/forum/#!topic/boost-list/ZT99wtIFlb4
+//
#include <boost/detail/fenv.hpp>
// Maximum root finding steps permitted:
//
// define BOOST_MATH_MAX_ROOT_ITERATION_POLICY 200
+//
+// Enable use of __float128 in numeric constants:
+//
+// #define BOOST_MATH_USE_FLOAT128
+//
+// Disable use of __float128 in numeric_constants even if the compiler looks to support it:
+//
+// #define BOOST_MATH_DISABLE_FLOAT128
#endif // BOOST_MATH_TOOLS_USER_HPP
+++ /dev/null
-#ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED
-#define BOOST_MEMORY_ORDER_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-// boost/memory_order.hpp
-//
-// Defines enum boost::memory_order per the C++0x working draft
-//
-// Copyright (c) 2008, 2009 Peter Dimov
-//
-// 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)
-
-
-namespace boost
-{
-
-//
-// Enum values are chosen so that code that needs to insert
-// a trailing fence for acquire semantics can use a single
-// test such as:
-//
-// if( mo & memory_order_acquire ) { ...fence... }
-//
-// For leading fences one can use:
-//
-// if( mo & memory_order_release ) { ...fence... }
-//
-// Architectures such as Alpha that need a fence on consume
-// can use:
-//
-// if( mo & ( memory_order_acquire | memory_order_consume ) ) { ...fence... }
-//
-
-enum memory_order
-{
- memory_order_relaxed = 0,
- memory_order_acquire = 1,
- memory_order_release = 2,
- memory_order_acq_rel = 3, // acquire | release
- memory_order_seq_cst = 7, // acq_rel | 4
- memory_order_consume = 8
-};
-
-} // namespace boost
-
-#endif // #ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2012.
+// 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+//! This header implements macros to define movable classes and
+//! move-aware functions
+
+#ifndef BOOST_MOVE_CORE_HPP
+#define BOOST_MOVE_CORE_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/detail/workaround.hpp>
+
+//boost_move_no_copy_constructor_or_assign typedef
+//used to detect noncopyable types for other Boost libraries.
+#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+ #define BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE) \
+ private:\
+ TYPE(TYPE &);\
+ TYPE& operator=(TYPE &);\
+ public:\
+ typedef int boost_move_no_copy_constructor_or_assign; \
+ private:\
+ //
+#else
+ #define BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE) \
+ public:\
+ TYPE(TYPE const &) = delete;\
+ TYPE& operator=(TYPE const &) = delete;\
+ public:\
+ typedef int boost_move_no_copy_constructor_or_assign; \
+ private:\
+ //
+#endif //BOOST_NO_CXX11_DELETED_FUNCTIONS
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+ #include <boost/move/detail/type_traits.hpp>
+
+ //Move emulation rv breaks standard aliasing rules so add workarounds for some compilers
+ #if defined(__GNUC__) && (__GNUC__ >= 4) && \
+ (\
+ defined(BOOST_GCC) || \
+ (defined(BOOST_INTEL) && (BOOST_INTEL_CXX_VERSION >= 1300)) \
+ )
+ #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__))
+ #else
+ #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS
+ #endif
+
+ namespace boost {
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // struct rv
+ //
+ //////////////////////////////////////////////////////////////////////////////
+ template <class T>
+ class rv
+ : public ::boost::move_detail::if_c
+ < ::boost::move_detail::is_class<T>::value
+ , T
+ , ::boost::move_detail::nat
+ >::type
+ {
+ rv();
+ ~rv() throw();
+ rv(rv const&);
+ void operator=(rv const&);
+ } BOOST_MOVE_ATTRIBUTE_MAY_ALIAS;
+
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // is_rv
+ //
+ //////////////////////////////////////////////////////////////////////////////
+
+ namespace move_detail {
+
+ template <class T>
+ struct is_rv
+ //Derive from integral constant because some Boost code assummes it has
+ //a "type" internal typedef
+ : integral_constant<bool, ::boost::move_detail::is_rv_impl<T>::value >
+ {};
+
+ } //namespace move_detail {
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // has_move_emulation_enabled
+ //
+ //////////////////////////////////////////////////////////////////////////////
+ template<class T>
+ struct has_move_emulation_enabled
+ : ::boost::move_detail::has_move_emulation_enabled_impl<T>
+ {};
+
+ } //namespace boost {
+
+ #define BOOST_RV_REF(TYPE)\
+ ::boost::rv< TYPE >& \
+ //
+
+ #define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
+ ::boost::rv< TYPE<ARG1, ARG2> >& \
+ //
+
+ #define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
+ ::boost::rv< TYPE<ARG1, ARG2, ARG3> >& \
+ //
+
+ #define BOOST_RV_REF_BEG\
+ ::boost::rv< \
+ //
+
+ #define BOOST_RV_REF_END\
+ >& \
+ //
+
+ #define BOOST_FWD_REF(TYPE)\
+ const TYPE & \
+ //
+
+ #define BOOST_COPY_ASSIGN_REF(TYPE)\
+ const ::boost::rv< TYPE >& \
+ //
+
+ #define BOOST_COPY_ASSIGN_REF_BEG \
+ const ::boost::rv< \
+ //
+
+ #define BOOST_COPY_ASSIGN_REF_END \
+ >& \
+ //
+
+ #define BOOST_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
+ const ::boost::rv< TYPE<ARG1, ARG2> >& \
+ //
+
+ #define BOOST_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
+ const ::boost::rv< TYPE<ARG1, ARG2, ARG3> >& \
+ //
+
+ #define BOOST_CATCH_CONST_RLVALUE(TYPE)\
+ const ::boost::rv< TYPE >& \
+ //
+
+ namespace boost {
+ namespace move_detail {
+
+ template <class Ret, class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < ::boost::move_detail::is_lvalue_reference<Ret>::value ||
+ !::boost::has_move_emulation_enabled<T>::value
+ , T&>::type
+ move_return(T& x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ template <class Ret, class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < !::boost::move_detail::is_lvalue_reference<Ret>::value &&
+ ::boost::has_move_emulation_enabled<T>::value
+ , ::boost::rv<T>&>::type
+ move_return(T& x) BOOST_NOEXCEPT
+ {
+ return *static_cast< ::boost::rv<T>* >(::boost::move_detail::addressof(x));
+ }
+
+ template <class Ret, class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < !::boost::move_detail::is_lvalue_reference<Ret>::value &&
+ ::boost::has_move_emulation_enabled<T>::value
+ , ::boost::rv<T>&>::type
+ move_return(::boost::rv<T>& x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ } //namespace move_detail {
+ } //namespace boost {
+
+ #define BOOST_MOVE_RET(RET_TYPE, REF)\
+ boost::move_detail::move_return< RET_TYPE >(REF)
+ //
+
+ #define BOOST_MOVE_BASE(BASE_TYPE, ARG) \
+ ::boost::move((BASE_TYPE&)(ARG))
+ //
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // BOOST_MOVABLE_BUT_NOT_COPYABLE
+ //
+ //////////////////////////////////////////////////////////////////////////////
+ #define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)\
+ BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE)\
+ public:\
+ operator ::boost::rv<TYPE>&() \
+ { return *static_cast< ::boost::rv<TYPE>* >(this); }\
+ operator const ::boost::rv<TYPE>&() const \
+ { return *static_cast<const ::boost::rv<TYPE>* >(this); }\
+ private:\
+ //
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // BOOST_COPYABLE_AND_MOVABLE
+ //
+ //////////////////////////////////////////////////////////////////////////////
+
+ #define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
+ public:\
+ TYPE& operator=(TYPE &t)\
+ { this->operator=(static_cast<const ::boost::rv<TYPE> &>(const_cast<const TYPE &>(t))); return *this;}\
+ public:\
+ operator ::boost::rv<TYPE>&() \
+ { return *static_cast< ::boost::rv<TYPE>* >(this); }\
+ operator const ::boost::rv<TYPE>&() const \
+ { return *static_cast<const ::boost::rv<TYPE>* >(this); }\
+ private:\
+ //
+
+ #define BOOST_COPYABLE_AND_MOVABLE_ALT(TYPE)\
+ public:\
+ operator ::boost::rv<TYPE>&() \
+ { return *static_cast< ::boost::rv<TYPE>* >(this); }\
+ operator const ::boost::rv<TYPE>&() const \
+ { return *static_cast<const ::boost::rv<TYPE>* >(this); }\
+ private:\
+ //
+
+ namespace boost{
+ namespace move_detail{
+
+ template< class T>
+ struct forward_type
+ { typedef const T &type; };
+
+ template< class T>
+ struct forward_type< boost::rv<T> >
+ { typedef T type; };
+
+ }}
+
+#else //BOOST_NO_CXX11_RVALUE_REFERENCES
+
+ //! This macro marks a type as movable but not copyable, disabling copy construction
+ //! and assignment. The user will need to write a move constructor/assignment as explained
+ //! in the documentation to fully write a movable but not copyable class.
+ #define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE)\
+ BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE)\
+ public:\
+ typedef int boost_move_emulation_t;\
+ //
+
+ //! This macro marks a type as copyable and movable.
+ //! The user will need to write a move constructor/assignment and a copy assignment
+ //! as explained in the documentation to fully write a copyable and movable class.
+ #define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
+ //
+
+ #if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ #define BOOST_COPYABLE_AND_MOVABLE_ALT(TYPE)\
+ //
+ #endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+ namespace boost {
+
+ //!This trait yields to a compile-time true boolean if T was marked as
+ //!BOOST_MOVABLE_BUT_NOT_COPYABLE or BOOST_COPYABLE_AND_MOVABLE and
+ //!rvalue references are not available on the platform. False otherwise.
+ template<class T>
+ struct has_move_emulation_enabled
+ {
+ static const bool value = false;
+ };
+
+ } //namespace boost{
+
+ //!This macro is used to achieve portable syntax in move
+ //!constructors and assignments for classes marked as
+ //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE
+ #define BOOST_RV_REF(TYPE)\
+ TYPE && \
+ //
+
+ //!This macro is used to achieve portable syntax in move
+ //!constructors and assignments for template classes marked as
+ //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE.
+ //!As macros have problems with comma-separated template arguments,
+ //!the template argument must be preceded with BOOST_RV_REF_BEG
+ //!and ended with BOOST_RV_REF_END
+ #define BOOST_RV_REF_BEG\
+ \
+ //
+
+ //!This macro is used to achieve portable syntax in move
+ //!constructors and assignments for template classes marked as
+ //!BOOST_COPYABLE_AND_MOVABLE or BOOST_MOVABLE_BUT_NOT_COPYABLE.
+ //!As macros have problems with comma-separated template arguments,
+ //!the template argument must be preceded with BOOST_RV_REF_BEG
+ //!and ended with BOOST_RV_REF_END
+ #define BOOST_RV_REF_END\
+ && \
+
+ //!This macro is used to achieve portable syntax in copy
+ //!assignment for classes marked as BOOST_COPYABLE_AND_MOVABLE.
+ #define BOOST_COPY_ASSIGN_REF(TYPE)\
+ const TYPE & \
+ //
+
+ //! This macro is used to implement portable perfect forwarding
+ //! as explained in the documentation.
+ #define BOOST_FWD_REF(TYPE)\
+ TYPE && \
+ //
+
+ #if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+ #define BOOST_RV_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
+ TYPE<ARG1, ARG2> && \
+ //
+
+ #define BOOST_RV_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
+ TYPE<ARG1, ARG2, ARG3> && \
+ //
+
+ #define BOOST_COPY_ASSIGN_REF_BEG \
+ const \
+ //
+
+ #define BOOST_COPY_ASSIGN_REF_END \
+ & \
+ //
+
+ #define BOOST_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE, ARG1, ARG2)\
+ const TYPE<ARG1, ARG2> & \
+ //
+
+ #define BOOST_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE, ARG1, ARG2, ARG3)\
+ const TYPE<ARG1, ARG2, ARG3>& \
+ //
+
+ #define BOOST_CATCH_CONST_RLVALUE(TYPE)\
+ const TYPE & \
+ //
+
+ #endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+ #if !defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+ //!This macro is used to achieve portable move return semantics.
+ //!The C++11 Standard allows implicit move returns when the object to be returned
+ //!is designated by a lvalue and:
+ //! - The criteria for elision of a copy operation are met OR
+ //! - The criteria would be met save for the fact that the source object is a function parameter
+ //!
+ //!For C++11 conforming compilers this macros only yields to REF:
+ //! <code>return BOOST_MOVE_RET(RET_TYPE, REF);</code> -> <code>return REF;</code>
+ //!
+ //!For compilers without rvalue references
+ //!this macro does an explicit move if the move emulation is activated
+ //!and the return type (RET_TYPE) is not a reference.
+ //!
+ //!For non-conforming compilers with rvalue references like Visual 2010 & 2012,
+ //!an explicit move is performed if RET_TYPE is not a reference.
+ //!
+ //! <b>Caution</b>: When using this macro in non-conforming or C++03
+ //!compilers, a move will be performed even if the C++11 standard does not allow it
+ //!(e.g. returning a static variable). The user is responsible for using this macro
+ //!only to return local objects that met C++11 criteria.
+ #define BOOST_MOVE_RET(RET_TYPE, REF)\
+ REF
+ //
+
+ #else //!defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+ #include <boost/move/detail/meta_utils.hpp>
+
+ namespace boost {
+ namespace move_detail {
+
+ template <class Ret, class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < ::boost::move_detail::is_lvalue_reference<Ret>::value
+ , T&>::type
+ move_return(T& x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ template <class Ret, class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < !::boost::move_detail::is_lvalue_reference<Ret>::value
+ , Ret && >::type
+ move_return(T&& t) BOOST_NOEXCEPT
+ {
+ return static_cast< Ret&& >(t);
+ }
+
+ } //namespace move_detail {
+ } //namespace boost {
+
+ #define BOOST_MOVE_RET(RET_TYPE, REF)\
+ boost::move_detail::move_return< RET_TYPE >(REF)
+ //
+
+ #endif //!defined(BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG) || defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+ //!This macro is used to achieve portable optimal move constructors.
+ //!
+ //!When implementing the move constructor, in C++03 compilers the moved-from argument must be
+ //!cast to the base type before calling `::boost::move()` due to rvalue reference limitations.
+ //!
+ //!In C++11 compilers the cast from a rvalue reference of a derived type to a rvalue reference of
+ //!a base type is implicit.
+ #define BOOST_MOVE_BASE(BASE_TYPE, ARG) \
+ ::boost::move((BASE_TYPE&)(ARG))
+ //
+
+ namespace boost {
+ namespace move_detail {
+
+ template< class T> struct forward_type { typedef T type; };
+
+ }}
+
+#endif //BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_MOVE_CORE_HPP
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2012. 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+
+#ifdef BOOST_MSVC
+# pragma warning (push)
+# pragma warning (disable : 4324) // structure was padded due to __declspec(align())
+# pragma warning (disable : 4675) // "function": resolved overload was found by argument-dependent lookup
+# pragma warning (disable : 4996) // "function": was declared deprecated (_CRT_SECURE_NO_DEPRECATE/_SCL_SECURE_NO_WARNINGS)
+#endif
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2012. 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#if defined BOOST_MSVC
+# pragma warning (pop)
+#endif
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2015.
+// 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+
+#ifndef BOOST_MOVE_DETAIL_META_UTILS_HPP
+#define BOOST_MOVE_DETAIL_META_UTILS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+#include <boost/move/detail/meta_utils_core.hpp>
+#include <cstddef> //for std::size_t
+
+//Small meta-typetraits to support move
+
+namespace boost {
+
+//Forward declare boost::rv
+template <class T> class rv;
+
+namespace move_detail {
+
+//////////////////////////////////////
+// nat
+//////////////////////////////////////
+struct nat{};
+
+//////////////////////////////////////
+// natify
+//////////////////////////////////////
+template <class T> struct natify{};
+
+//////////////////////////////////////
+// remove_reference
+//////////////////////////////////////
+template<class T>
+struct remove_reference
+{
+ typedef T type;
+};
+
+template<class T>
+struct remove_reference<T&>
+{
+ typedef T type;
+};
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template<class T>
+struct remove_reference<T&&>
+{
+ typedef T type;
+};
+
+#else
+
+template<class T>
+struct remove_reference< rv<T> >
+{
+ typedef T type;
+};
+
+template<class T>
+struct remove_reference< rv<T> &>
+{
+ typedef T type;
+};
+
+template<class T>
+struct remove_reference< const rv<T> &>
+{
+ typedef T type;
+};
+
+
+#endif
+
+//////////////////////////////////////
+// add_const
+//////////////////////////////////////
+template<class T>
+struct add_const
+{
+ typedef const T type;
+};
+
+template<class T>
+struct add_const<T&>
+{
+ typedef const T& type;
+};
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template<class T>
+struct add_const<T&&>
+{
+ typedef T&& type;
+};
+
+#endif
+
+//////////////////////////////////////
+// add_lvalue_reference
+//////////////////////////////////////
+template<class T>
+struct add_lvalue_reference
+{ typedef T& type; };
+
+template<class T> struct add_lvalue_reference<T&> { typedef T& type; };
+template<> struct add_lvalue_reference<void> { typedef void type; };
+template<> struct add_lvalue_reference<const void> { typedef const void type; };
+template<> struct add_lvalue_reference<volatile void> { typedef volatile void type; };
+template<> struct add_lvalue_reference<const volatile void>{ typedef const volatile void type; };
+
+template<class T>
+struct add_const_lvalue_reference
+{
+ typedef typename remove_reference<T>::type t_unreferenced;
+ typedef typename add_const<t_unreferenced>::type t_unreferenced_const;
+ typedef typename add_lvalue_reference
+ <t_unreferenced_const>::type type;
+};
+
+//////////////////////////////////////
+// is_lvalue_reference
+//////////////////////////////////////
+template<class T>
+struct is_lvalue_reference
+{
+ static const bool value = false;
+};
+
+template<class T>
+struct is_lvalue_reference<T&>
+{
+ static const bool value = true;
+};
+
+//////////////////////////////////////
+// is_class_or_union
+//////////////////////////////////////
+template<class T>
+struct is_class_or_union
+{
+ struct twochar { char dummy[2]; };
+ template <class U>
+ static char is_class_or_union_tester(void(U::*)(void));
+ template <class U>
+ static twochar is_class_or_union_tester(...);
+ static const bool value = sizeof(is_class_or_union_tester<T>(0)) == sizeof(char);
+};
+
+//////////////////////////////////////
+// addressof
+//////////////////////////////////////
+template<class T>
+struct addr_impl_ref
+{
+ T & v_;
+ inline addr_impl_ref( T & v ): v_( v ) {}
+ inline operator T& () const { return v_; }
+
+ private:
+ addr_impl_ref & operator=(const addr_impl_ref &);
+};
+
+template<class T>
+struct addressof_impl
+{
+ static inline T * f( T & v, long )
+ {
+ return reinterpret_cast<T*>(
+ &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+ }
+
+ static inline T * f( T * v, int )
+ { return v; }
+};
+
+template<class T>
+inline T * addressof( T & v )
+{
+ return ::boost::move_detail::addressof_impl<T>::f
+ ( ::boost::move_detail::addr_impl_ref<T>( v ), 0 );
+}
+
+//////////////////////////////////////
+// has_pointer_type
+//////////////////////////////////////
+template <class T>
+struct has_pointer_type
+{
+ struct two { char c[2]; };
+ template <class U> static two test(...);
+ template <class U> static char test(typename U::pointer* = 0);
+ static const bool value = sizeof(test<T>(0)) == 1;
+};
+
+//////////////////////////////////////
+// is_convertible
+//////////////////////////////////////
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+
+//use intrinsic since in MSVC
+//overaligned types can't go through ellipsis
+template <class T, class U>
+struct is_convertible
+{
+ static const bool value = __is_convertible_to(T, U);
+};
+
+#else
+
+template <class T, class U>
+class is_convertible
+{
+ typedef typename add_lvalue_reference<T>::type t_reference;
+ typedef char true_t;
+ class false_t { char dummy[2]; };
+ static false_t dispatch(...);
+ static true_t dispatch(U);
+ static t_reference trigger();
+ public:
+ static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
+};
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// has_move_emulation_enabled_impl
+//
+//////////////////////////////////////////////////////////////////////////////
+template<class T>
+struct has_move_emulation_enabled_impl
+ : is_convertible< T, ::boost::rv<T>& >
+{};
+
+template<class T>
+struct has_move_emulation_enabled_impl<T&>
+{ static const bool value = false; };
+
+template<class T>
+struct has_move_emulation_enabled_impl< ::boost::rv<T> >
+{ static const bool value = false; };
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// is_rv_impl
+//
+//////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+struct is_rv_impl
+{ static const bool value = false; };
+
+template <class T>
+struct is_rv_impl< rv<T> >
+{ static const bool value = true; };
+
+template <class T>
+struct is_rv_impl< const rv<T> >
+{ static const bool value = true; };
+
+// Code from Jeffrey Lee Hellrung, many thanks
+
+template< class T >
+struct is_rvalue_reference
+{ static const bool value = false; };
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template< class T >
+struct is_rvalue_reference< T&& >
+{ static const bool value = true; };
+
+#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template< class T >
+struct is_rvalue_reference< boost::rv<T>& >
+{ static const bool value = true; };
+
+template< class T >
+struct is_rvalue_reference< const boost::rv<T>& >
+{ static const bool value = true; };
+
+#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template< class T >
+struct add_rvalue_reference
+{ typedef T&& type; };
+
+#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+namespace detail_add_rvalue_reference
+{
+ template< class T
+ , bool emulation = has_move_emulation_enabled_impl<T>::value
+ , bool rv = is_rv_impl<T>::value >
+ struct add_rvalue_reference_impl { typedef T type; };
+
+ template< class T, bool emulation>
+ struct add_rvalue_reference_impl< T, emulation, true > { typedef T & type; };
+
+ template< class T, bool rv >
+ struct add_rvalue_reference_impl< T, true, rv > { typedef ::boost::rv<T>& type; };
+} // namespace detail_add_rvalue_reference
+
+template< class T >
+struct add_rvalue_reference
+ : detail_add_rvalue_reference::add_rvalue_reference_impl<T>
+{ };
+
+template< class T >
+struct add_rvalue_reference<T &>
+{ typedef T & type; };
+
+#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template< class T > struct remove_rvalue_reference { typedef T type; };
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+ template< class T > struct remove_rvalue_reference< T&& > { typedef T type; };
+#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+ template< class T > struct remove_rvalue_reference< rv<T> > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< const rv<T> > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< volatile rv<T> > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< const volatile rv<T> > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< rv<T>& > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< const rv<T>& > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< volatile rv<T>& > { typedef T type; };
+ template< class T > struct remove_rvalue_reference< const volatile rv<T>& >{ typedef T type; };
+#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+// Ideas from Boost.Move review, Jeffrey Lee Hellrung:
+//
+//- TypeTraits metafunctions is_lvalue_reference, add_lvalue_reference, and remove_lvalue_reference ?
+// Perhaps add_reference and remove_reference can be modified so that they behave wrt emulated rvalue
+// references the same as wrt real rvalue references, i.e., add_reference< rv<T>& > -> T& rather than
+// rv<T>& (since T&& & -> T&).
+//
+//- Add'l TypeTraits has_[trivial_]move_{constructor,assign}...?
+//
+//- An as_lvalue(T& x) function, which amounts to an identity operation in C++0x, but strips emulated
+// rvalue references in C++03. This may be necessary to prevent "accidental moves".
+
+} //namespace move_detail {
+} //namespace boost {
+
+#endif //#ifndef BOOST_MOVE_DETAIL_META_UTILS_HPP
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015.
+// 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+
+#ifndef BOOST_MOVE_DETAIL_META_UTILS_CORE_HPP
+#define BOOST_MOVE_DETAIL_META_UTILS_CORE_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+//Small meta-typetraits to support move
+
+namespace boost {
+namespace move_detail {
+
+//////////////////////////////////////
+// if_c
+//////////////////////////////////////
+template<bool C, typename T1, typename T2>
+struct if_c
+{
+ typedef T1 type;
+};
+
+template<typename T1, typename T2>
+struct if_c<false,T1,T2>
+{
+ typedef T2 type;
+};
+
+//////////////////////////////////////
+// if_
+//////////////////////////////////////
+template<typename T1, typename T2, typename T3>
+struct if_ : if_c<0 != T1::value, T2, T3>
+{};
+
+//enable_if_
+template <bool B, class T = void>
+struct enable_if_c
+{
+ typedef T type;
+};
+
+//////////////////////////////////////
+// enable_if_c
+//////////////////////////////////////
+template <class T>
+struct enable_if_c<false, T> {};
+
+//////////////////////////////////////
+// enable_if
+//////////////////////////////////////
+template <class Cond, class T = void>
+struct enable_if : enable_if_c<Cond::value, T> {};
+
+//////////////////////////////////////
+// disable_if
+//////////////////////////////////////
+template <class Cond, class T = void>
+struct disable_if : enable_if_c<!Cond::value, T> {};
+
+//////////////////////////////////////
+// integral_constant
+//////////////////////////////////////
+template<class T, T v>
+struct integral_constant
+{
+ static const T value = v;
+ typedef T value_type;
+ typedef integral_constant<T, v> type;
+};
+
+typedef integral_constant<bool, true > true_type;
+typedef integral_constant<bool, false > false_type;
+
+//////////////////////////////////////
+// identity
+//////////////////////////////////////
+template <class T>
+struct identity
+{
+ typedef T type;
+};
+
+//////////////////////////////////////
+// is_same
+//////////////////////////////////////
+template<class T, class U>
+struct is_same
+{
+ static const bool value = false;
+};
+
+template<class T>
+struct is_same<T, T>
+{
+ static const bool value = true;
+};
+
+} //namespace move_detail {
+} //namespace boost {
+
+#endif //#ifndef BOOST_MOVE_DETAIL_META_UTILS_CORE_HPP
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+// (C) Copyright John Maddock 2000.
+// (C) Copyright Ion Gaztanaga 2005-2015.
+//
+// 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/move for documentation.
+//
+// The alignment and Type traits implementation comes from
+// John Maddock's TypeTraits library.
+//
+// Some other tricks come from Howard Hinnant's papers and StackOverflow replies
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP
+#define BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/detail/workaround.hpp>
+
+// move/detail
+#include <boost/move/detail/meta_utils.hpp>
+// other
+#include <boost/assert.hpp>
+#include <boost/static_assert.hpp>
+// std
+#include <cstddef>
+
+//Use of Boost.TypeTraits leads to long preprocessed source code due to
+//MPL dependencies. We'll use intrinsics directly and make or own
+//simplified version of TypeTraits.
+//If someday Boost.TypeTraits dependencies are minimized, we should
+//revisit this file redirecting code to Boost.TypeTraits traits.
+
+//These traits don't care about volatile, reference or other checks
+//made by Boost.TypeTraits because no volatile or reference types
+//can be hold in Boost.Containers. This helps to avoid any Boost.TypeTraits
+//dependency.
+
+// Helper macros for builtin compiler support.
+// If your compiler has builtin support for any of the following
+// traits concepts, then redefine the appropriate macros to pick
+// up on the compiler support:
+//
+// (these should largely ignore cv-qualifiers)
+// BOOST_MOVE_IS_POD(T) should evaluate to true if T is a POD type
+// BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect
+// BOOST_MOVE_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy
+// BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) should evaluate to true if T(boost::move(t)) <==> memcpy
+// BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy
+// BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) should evaluate to true if t = boost::move(u) <==> memcpy
+// BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect
+// BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) should evaluate to true if "T x;" can not throw
+// BOOST_MOVE_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw
+// BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw
+// BOOST_MOVE_IS_ENUM(T) should evaluate to true it t is a union type.
+//
+// The following can also be defined: when detected our implementation is greatly simplified.
+//
+// BOOST_ALIGNMENT_OF(T) should evaluate to the alignment requirements of type T.
+
+#if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000)
+ // Metrowerks compiler is acquiring intrinsic type traits support
+ // post version 8. We hook into the published interface to pick up
+ // user defined specializations as well as compiler intrinsics as
+ // and when they become available:
+# include <msl_utility>
+# define BOOST_MOVE_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union<T>::value
+# define BOOST_MOVE_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD<T>::value
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor<T>::value
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor<T>::value
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment<T>::value
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor<T>::value
+#endif
+
+#if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\
+ || (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500))
+# define BOOST_MOVE_IS_UNION(T) __is_union(T)
+# define BOOST_MOVE_IS_POD(T) (__is_pod(T) && __has_trivial_constructor(T))
+# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T)|| ::boost::move_detail::is_pod<T>::value)
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) || ::boost::move_detail::is_pod<T>::value)
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) || ::boost::move_detail::is_pod<T>::value)
+# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) || ::boost::move_detail::is_trivially_default_constructible<T>::value)
+# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) || ::boost::move_detail::is_trivially_copy_constructible<T>::value)
+# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) || ::boost::move_detail::is_trivially_copy_assignable<T>::value)
+
+# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+# if defined(_MSC_VER) && (_MSC_VER >= 1700)
+# define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__has_trivial_move_constructor(T) || ::boost::move_detail::is_pod<T>::value)
+# define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) (__has_trivial_move_assign(T) || ::boost::move_detail::is_pod<T>::value)
+# endif
+#endif
+
+#if defined(BOOST_CLANG) && defined(__has_feature)
+
+# if __has_feature(is_union)
+# define BOOST_MOVE_IS_UNION(T) __is_union(T)
+# endif
+# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_pod)
+# define BOOST_MOVE_IS_POD(T) __is_pod(T)
+# endif
+# if (!defined(__GLIBCXX__) || (__GLIBCXX__ >= 20080306 && __GLIBCXX__ != 20080519)) && __has_feature(is_empty)
+# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
+# endif
+# if __has_feature(has_trivial_constructor)
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
+# endif
+# if __has_feature(has_trivial_copy)
+# //There are problems with deleted copy constructors detected as trivially copyable.
+# //http://stackoverflow.com/questions/12754886/has-trivial-copy-behaves-differently-in-clang-and-gcc-whos-right
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && ::boost::move_detail::is_copy_constructible<T>::value)
+# endif
+# if __has_feature(has_trivial_assign)
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) )
+# endif
+# if __has_feature(has_trivial_destructor)
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
+# endif
+# if __has_feature(has_nothrow_constructor)
+# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
+# endif
+# if __has_feature(has_nothrow_copy)
+# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T))
+# endif
+# if __has_feature(is_nothrow_copy_assignable)
+# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T))
+# endif
+# if __has_feature(is_enum)
+# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+# endif
+# if __has_feature(has_trivial_move_constructor)
+# define BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) __has_trivial_move_constructor(T)
+# endif
+# if __has_feature(has_trivial_move_assign)
+# define BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T) __has_trivial_move_assign(T)
+# endif
+# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof(T)
+#endif
+
+#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG)
+
+#ifdef BOOST_INTEL
+# define BOOST_MOVE_INTEL_TT_OPTS || ::boost::move_detail::is_pod<T>::value
+#else
+# define BOOST_MOVE_INTEL_TT_OPTS
+#endif
+
+# define BOOST_MOVE_IS_UNION(T) __is_union(T)
+# define BOOST_MOVE_IS_POD(T) __is_pod(T)
+# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_MOVE_INTEL_TT_OPTS))
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_MOVE_INTEL_TT_OPTS))
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_MOVE_INTEL_TT_OPTS) )
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_MOVE_INTEL_TT_OPTS)
+# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_MOVE_INTEL_TT_OPTS)
+# define BOOST_MOVE_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_MOVE_INTEL_TT_OPTS))
+# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_MOVE_INTEL_TT_OPTS))
+
+# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+# if (!defined(unix) && !defined(__unix__)) || defined(__LP64__)
+ // GCC sometimes lies about alignment requirements
+ // of type double on 32-bit unix platforms, use the
+ // old implementation instead in that case:
+# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T)
+# endif
+#endif
+
+#if defined(__ghs__) && (__GHS_VERSION_NUMBER >= 600)
+
+# define BOOST_MOVE_IS_UNION(T) __is_union(T)
+# define BOOST_MOVE_IS_POD(T) __is_pod(T)
+# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T))
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T))
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
+# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
+# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T))
+# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T))
+
+# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+# define BOOST_MOVE_ALIGNMENT_OF(T) __alignof__(T)
+#endif
+
+# if defined(__CODEGEARC__)
+# define BOOST_MOVE_IS_UNION(T) __is_union(T)
+# define BOOST_MOVE_IS_POD(T) __is_pod(T)
+# define BOOST_MOVE_IS_EMPTY(T) __is_empty(T)
+# define BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_default_constructor(T))
+# define BOOST_MOVE_HAS_TRIVIAL_COPY(T) (__has_trivial_copy_constructor(T))
+# define BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T))
+# define BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T))
+# define BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_default_constructor(T))
+# define BOOST_MOVE_HAS_NOTHROW_COPY(T) (__has_nothrow_copy_constructor(T))
+# define BOOST_MOVE_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T))
+
+# define BOOST_MOVE_IS_ENUM(T) __is_enum(T)
+# define BOOST_MOVE_ALIGNMENT_OF(T) alignof(T)
+
+#endif
+
+//Fallback definitions
+
+#ifdef BOOST_MOVE_IS_UNION
+ #define BOOST_MOVE_IS_UNION_IMPL(T) BOOST_MOVE_IS_UNION(T)
+#else
+ #define BOOST_MOVE_IS_UNION_IMPL(T) false
+#endif
+
+#ifdef BOOST_MOVE_IS_POD
+ #define BOOST_MOVE_IS_POD_IMPL(T) BOOST_MOVE_IS_POD(T)
+#else
+ #define BOOST_MOVE_IS_POD_IMPL(T) \
+ (::boost::move_detail::is_scalar<T>::value || ::boost::move_detail::is_void<T>::value)
+#endif
+
+#ifdef BOOST_MOVE_IS_EMPTY
+ #define BOOST_MOVE_IS_EMPTY_IMPL(T) BOOST_MOVE_IS_EMPTY(T)
+#else
+ #define BOOST_MOVE_IS_EMPTY_IMPL(T) ::boost::move_detail::is_empty_nonintrinsic<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_COPY
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_COPY(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR
+ #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_CONSTRUCTOR(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_COPY
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_COPY(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR
+ #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_ASSIGN
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_TRIVIAL_ASSIGN(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN
+ #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_TRIVIAL_MOVE_ASSIGN(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR
+ #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) BOOST_MOVE_HAS_TRIVIAL_DESTRUCTOR(T)
+#else
+ #define BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR
+ #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_CONSTRUCTOR(T)
+#else
+ #define BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_NOTHROW_COPY
+ #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_COPY(T)
+#else
+ #define BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_NOTHROW_MOVE
+ #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE(T)
+#else
+ #define BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_NOTHROW_ASSIGN
+ #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_ASSIGN(T)
+#else
+ #define BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN
+ #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) BOOST_MOVE_HAS_NOTHROW_MOVE_ASSIGN(T)
+#else
+ #define BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T) ::boost::move_detail::is_pod<T>::value
+#endif
+
+#ifdef BOOST_MOVE_IS_ENUM
+ #define BOOST_MOVE_IS_ENUM_IMPL(T) BOOST_MOVE_IS_ENUM(T)
+#else
+ #define BOOST_MOVE_IS_ENUM_IMPL(T) ::boost::move_detail::is_enum_nonintrinsic<T>::value
+#endif
+
+namespace boost {
+namespace move_detail {
+
+//////////////////////////
+// is_reference
+//////////////////////////
+template<class T>
+struct is_reference
+{ static const bool value = false; };
+
+template<class T>
+struct is_reference<T&>
+{ static const bool value = true; };
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+template<class T>
+struct is_reference<T&&>
+{ static const bool value = true; };
+#endif
+
+//////////////////////////
+// is_pointer
+//////////////////////////
+template<class T>
+struct is_pointer
+{ static const bool value = false; };
+
+template<class T>
+struct is_pointer<T*>
+{ static const bool value = true; };
+
+//////////////////////////
+// add_reference
+//////////////////////////
+template <typename T>
+struct add_reference
+{ typedef T& type; };
+
+template<class T>
+struct add_reference<T&>
+{ typedef T& type; };
+
+template<>
+struct add_reference<void>
+{ typedef nat &type; };
+
+template<>
+struct add_reference<const void>
+{ typedef const nat &type; };
+
+//////////////////////////
+// add_const_reference
+//////////////////////////
+template <class T>
+struct add_const_reference
+{ typedef const T &type; };
+
+template <class T>
+struct add_const_reference<T&>
+{ typedef T& type; };
+
+//////////////////////////
+// remove_const
+//////////////////////////
+template<class T>
+struct remove_const
+{ typedef T type; };
+
+template<class T>
+struct remove_const< const T>
+{ typedef T type; };
+
+//////////////////////////
+// remove_cv
+//////////////////////////
+template<typename T> struct remove_cv { typedef T type; };
+template<typename T> struct remove_cv<const T> { typedef T type; };
+template<typename T> struct remove_cv<const volatile T> { typedef T type; };
+template<typename T> struct remove_cv<volatile T> { typedef T type; };
+
+//////////////////////////
+// make_unsigned
+//////////////////////////
+template <class T>
+struct make_unsigned_impl { typedef T type; };
+template <> struct make_unsigned_impl<signed char> { typedef unsigned char type; };
+template <> struct make_unsigned_impl<signed short> { typedef unsigned short type; };
+template <> struct make_unsigned_impl<signed int> { typedef unsigned int type; };
+template <> struct make_unsigned_impl<signed long> { typedef unsigned long type; };
+#ifdef BOOST_HAS_LONG_LONG
+template <> struct make_unsigned_impl< ::boost::long_long_type > { typedef ::boost::ulong_long_type type; };
+#endif
+
+template <class T>
+struct make_unsigned
+ : make_unsigned_impl<typename remove_cv<T>::type>
+{};
+
+//////////////////////////
+// is_floating_point
+//////////////////////////
+template<class T> struct is_floating_point_cv { static const bool value = false; };
+template<> struct is_floating_point_cv<float> { static const bool value = true; };
+template<> struct is_floating_point_cv<double> { static const bool value = true; };
+template<> struct is_floating_point_cv<long double> { static const bool value = true; };
+
+template<class T>
+struct is_floating_point
+ : is_floating_point_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////
+// is_integral
+//////////////////////////
+template<class T> struct is_integral_cv { static const bool value = false; };
+template<> struct is_integral_cv< bool>{ static const bool value = true; };
+template<> struct is_integral_cv< char>{ static const bool value = true; };
+template<> struct is_integral_cv< unsigned char>{ static const bool value = true; };
+template<> struct is_integral_cv< signed char>{ static const bool value = true; };
+#ifndef BOOST_NO_CXX11_CHAR16_T
+template<> struct is_integral_cv< char16_t>{ static const bool value = true; };
+#endif
+#ifndef BOOST_NO_CXX11_CHAR32_T
+template<> struct is_integral_cv< char32_t>{ static const bool value = true; };
+#endif
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<> struct is_integral_cv< wchar_t>{ static const bool value = true; };
+#endif
+template<> struct is_integral_cv< short>{ static const bool value = true; };
+template<> struct is_integral_cv< unsigned short>{ static const bool value = true; };
+template<> struct is_integral_cv< int>{ static const bool value = true; };
+template<> struct is_integral_cv< unsigned int>{ static const bool value = true; };
+template<> struct is_integral_cv< long>{ static const bool value = true; };
+template<> struct is_integral_cv< unsigned long>{ static const bool value = true; };
+#ifdef BOOST_HAS_LONG_LONG
+template<> struct is_integral_cv< ::boost:: long_long_type>{ static const bool value = true; };
+template<> struct is_integral_cv< ::boost::ulong_long_type>{ static const bool value = true; };
+#endif
+
+template<class T>
+struct is_integral
+ : public is_integral_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////////////////
+// remove_all_extents
+//////////////////////////////////////
+template <class T>
+struct remove_all_extents
+{ typedef T type;};
+
+template <class T>
+struct remove_all_extents<T[]>
+{ typedef typename remove_all_extents<T>::type type; };
+
+template <class T, size_t N>
+struct remove_all_extents<T[N]>
+{ typedef typename remove_all_extents<T>::type type;};
+
+//////////////////////////
+// is_scalar
+//////////////////////////
+template<class T>
+struct is_scalar
+{ static const bool value = is_integral<T>::value || is_floating_point<T>::value; };
+
+//////////////////////////
+// is_void
+//////////////////////////
+template<class T>
+struct is_void_cv
+{ static const bool value = false; };
+
+template<>
+struct is_void_cv<void>
+{ static const bool value = true; };
+
+template<class T>
+struct is_void
+ : is_void_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////////////////
+// is_array
+//////////////////////////////////////
+template<class T>
+struct is_array
+{ static const bool value = false; };
+
+template<class T>
+struct is_array<T[]>
+{ static const bool value = true; };
+
+template<class T, std::size_t N>
+struct is_array<T[N]>
+{ static const bool value = true; };
+
+//////////////////////////////////////
+// is_member_pointer
+//////////////////////////////////////
+template <class T> struct is_member_pointer_cv { static const bool value = false; };
+template <class T, class U>struct is_member_pointer_cv<T U::*> { static const bool value = true; };
+
+template <class T>
+struct is_member_pointer
+ : is_member_pointer_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////////////////
+// is_nullptr_t
+//////////////////////////////////////
+template <class T>
+struct is_nullptr_t_cv
+{ static const bool value = false; };
+
+#if !defined(BOOST_NO_CXX11_NULLPTR)
+template <>
+struct is_nullptr_t_cv
+ #if !defined(BOOST_NO_CXX11_DECLTYPE)
+ <decltype(nullptr)>
+ #else
+ <std::nullptr_t>
+ #endif
+{ static const bool value = true; };
+#endif
+
+template <class T>
+struct is_nullptr_t
+ : is_nullptr_t_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////////////////
+// is_function
+//////////////////////////////////////
+//Inspired by libc++, thanks to Howard Hinnant
+//For a function to pointer an lvalue of function type T can be implicitly converted to a prvalue
+//pointer to that function. This does not apply to non-static member functions because lvalues
+//that refer to non-static member functions do not exist.
+template <class T>
+struct is_reference_convertible_to_pointer
+{
+ struct twochar { char dummy[2]; };
+ template <class U> static char test(U*);
+ template <class U> static twochar test(...);
+ static T& source();
+ static const bool value = sizeof(char) == sizeof(test<T>(source()));
+};
+//Filter out:
+// - class types that might have implicit conversions
+// - void (to avoid forming a reference to void later)
+// - references (e.g.: filtering reference to functions)
+// - nullptr_t (convertible to pointer)
+template < class T
+ , bool Filter = is_class_or_union<T>::value ||
+ is_void<T>::value ||
+ is_reference<T>::value ||
+ is_nullptr_t<T>::value >
+struct is_function_impl
+{ static const bool value = is_reference_convertible_to_pointer<T>::value; };
+
+template <class T>
+struct is_function_impl<T, true>
+{ static const bool value = false; };
+
+template <class T>
+struct is_function
+ : is_function_impl<T>
+{};
+
+//////////////////////////////////////
+// is_union
+//////////////////////////////////////
+template<class T>
+struct is_union_noextents_cv
+{ static const bool value = BOOST_MOVE_IS_UNION_IMPL(T); };
+
+template<class T>
+struct is_union
+ : is_union_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type>
+{};
+
+//////////////////////////////////////
+// is_class
+//////////////////////////////////////
+template <class T>
+struct is_class
+{
+ static const bool value = is_class_or_union<T>::value && ! is_union<T>::value;
+};
+
+
+//////////////////////////////////////
+// is_arithmetic
+//////////////////////////////////////
+template <class T>
+struct is_arithmetic
+{
+ static const bool value = is_floating_point<T>::value ||
+ is_integral<T>::value;
+};
+
+//////////////////////////////////////
+// is_member_function_pointer
+//////////////////////////////////////
+template <class T>
+struct is_member_function_pointer_cv
+{
+ static const bool value = false;
+};
+
+template <class T, class C>
+struct is_member_function_pointer_cv<T C::*>
+ : is_function<T>
+{};
+
+template <class T>
+struct is_member_function_pointer
+ : is_member_function_pointer_cv<typename remove_cv<T>::type>
+{};
+
+//////////////////////////////////////
+// is_enum
+//////////////////////////////////////
+#if !defined(BOOST_MOVE_IS_ENUM)
+//Based on (http://howardhinnant.github.io/TypeHiearchy.pdf)
+template <class T>
+struct is_enum_nonintrinsic
+{
+ static const bool value = !is_arithmetic<T>::value &&
+ !is_reference<T>::value &&
+ !is_class_or_union<T>::value &&
+ !is_array<T>::value &&
+ !is_void<T>::value &&
+ !is_nullptr_t<T>::value &&
+ !is_member_pointer<T>::value &&
+ !is_pointer<T>::value &&
+ !is_function<T>::value;
+};
+#endif
+
+template <class T>
+struct is_enum
+{ static const bool value = BOOST_MOVE_IS_ENUM_IMPL(T); };
+
+//////////////////////////////////////
+// is_pod
+//////////////////////////////////////
+template<class T>
+struct is_pod_noextents_cv //for non-c++11 compilers, a safe fallback
+{ static const bool value = BOOST_MOVE_IS_POD_IMPL(T); };
+
+template<class T>
+struct is_pod
+ : is_pod_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type>
+{};
+
+//////////////////////////////////////
+// is_empty
+//////////////////////////////////////
+#if !defined(BOOST_MOVE_IS_EMPTY)
+
+template <typename T>
+struct empty_helper_t1 : public T
+{
+ empty_helper_t1(); // hh compiler bug workaround
+ int i[256];
+ private:
+
+ empty_helper_t1(const empty_helper_t1&);
+ empty_helper_t1& operator=(const empty_helper_t1&);
+};
+
+struct empty_helper_t2 { int i[256]; };
+
+template <typename T, bool IsClass = is_class<T>::value >
+struct is_empty_nonintrinsic
+{
+ static const bool value = false;
+};
+
+template <typename T>
+struct is_empty_nonintrinsic<T, true>
+{
+ static const bool value = sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2);
+};
+#endif
+
+template <class T>
+struct is_empty
+{ static const bool value = BOOST_MOVE_IS_EMPTY_IMPL(T); };
+
+//////////////////////////////////////
+// is_copy_constructible
+//////////////////////////////////////
+template<class T>
+struct is_copy_constructible
+{
+ typedef char yes_type;
+ struct no_type { char dummy[2]; };
+ template<class U> static typename add_reference<U>::type source();
+
+ // Intel compiler has problems with SFINAE for copy constructors and deleted functions:
+ //
+ // error: function *function_name* cannot be referenced -- it is a deleted function
+ // static yes_type test(U&, decltype(U(boost::declval<U&>()))* = 0);
+ // ^
+ // MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See:
+ // https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken
+ #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_INTEL_CXX_VERSION) &&\
+ !(defined(BOOST_MSVC) && _MSC_VER == 1800)
+ static no_type test(...);
+ #ifdef BOOST_NO_CXX11_DECLTYPE
+ template <class U>
+ static yes_type test(U&, bool_<sizeof(U(source<U>()))>* = 0);
+ #else
+ template <class U>
+ static yes_type test(U&, decltype(U(source<U>()))* = 0);
+ #endif
+ #else
+ template <class U>
+ static no_type test(U&, typename U::boost_move_no_copy_constructor_or_assign* = 0);
+ static yes_type test(...);
+ #endif
+
+ static const bool value = sizeof(test(source<T>())) == sizeof(yes_type);
+};
+
+//////////////////////////////////////
+// is_trivially_destructible
+//////////////////////////////////////
+template<class T>
+struct is_trivially_destructible
+{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_DESTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_trivially_default_constructible
+//////////////////////////////////////
+template<class T>
+struct is_trivially_default_constructible
+{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_trivially_copy_constructible
+//////////////////////////////////////
+template<class T>
+struct is_trivially_copy_constructible
+{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_trivially_move_constructible
+//////////////////////////////////////
+template<class T>
+struct is_trivially_move_constructible
+{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_trivially_copy_assignable
+//////////////////////////////////////
+template<class T>
+struct is_trivially_copy_assignable
+{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_COPY_ASSIGNABLE(T); };
+
+//////////////////////////////////////
+// is_trivially_move_assignable
+//////////////////////////////////////
+template<class T>
+struct is_trivially_move_assignable
+{ static const bool value = BOOST_MOVE_IS_TRIVIALLY_MOVE_ASSIGNABLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_default_constructible
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_default_constructible
+ : is_pod<T>
+{ static const bool value = BOOST_MOVE_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_copy_constructible
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_copy_constructible
+{ static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_CONSTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_move_constructible
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_move_constructible
+{ static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_CONSTRUCTIBLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_copy_assignable
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_copy_assignable
+{ static const bool value = BOOST_MOVE_IS_NOTHROW_COPY_ASSIGNABLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_move_assignable
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_move_assignable
+{ static const bool value = BOOST_MOVE_IS_NOTHROW_MOVE_ASSIGNABLE(T); };
+
+//////////////////////////////////////
+// is_nothrow_swappable
+//////////////////////////////////////
+template<class T>
+struct is_nothrow_swappable
+{
+ static const bool value = is_empty<T>::value || is_pod<T>::value;
+};
+
+//////////////////////////////////////
+// alignment_of
+//////////////////////////////////////
+template <typename T>
+struct alignment_of_hack
+{
+ T t1;
+ char c;
+ T t2;
+ alignment_of_hack();
+};
+
+template <unsigned A, unsigned S>
+struct alignment_logic
+{ static const std::size_t value = A < S ? A : S; };
+
+template< typename T >
+struct alignment_of_impl
+#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400)
+ // With MSVC both the native __alignof operator
+ // and our own logic gets things wrong from time to time :-(
+ // Using a combination of the two seems to make the most of a bad job:
+ : alignment_logic< sizeof(alignment_of_hack<T>) - 2*sizeof(T), __alignof(T)>
+{};
+#elif !defined(BOOST_MOVE_ALIGNMENT_OF)
+ : alignment_logic< sizeof(alignment_of_hack<T>) - 2*sizeof(T), sizeof(T)>
+{};
+#else
+{ static const std::size_t value = BOOST_MOVE_ALIGNMENT_OF(T); };
+#endif
+
+template< typename T >
+struct alignment_of
+ : alignment_of_impl<T>
+{};
+
+class alignment_dummy;
+typedef void (*function_ptr)();
+typedef int (alignment_dummy::*member_ptr);
+typedef int (alignment_dummy::*member_function_ptr)();
+struct alignment_struct
+{ long double dummy[4]; };
+
+/////////////////////////////
+// max_align_t
+/////////////////////////////
+//This is not standard, but should work with all compilers
+union max_align
+{
+ char char_;
+ short short_;
+ int int_;
+ long long_;
+ #ifdef BOOST_HAS_LONG_LONG
+ ::boost::long_long_type long_long_;
+ #endif
+ float float_;
+ double double_;
+ void * void_ptr_;
+ long double long_double_[4];
+ alignment_dummy *unknown_class_ptr_;
+ function_ptr function_ptr_;
+ member_function_ptr member_function_ptr_;
+ alignment_struct alignment_struct_;
+};
+
+typedef union max_align max_align_t;
+
+/////////////////////////////
+// aligned_storage
+/////////////////////////////
+
+#if !defined(BOOST_NO_ALIGNMENT)
+
+template<std::size_t Len, std::size_t Align>
+struct aligned_storage_impl;
+
+#define BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(A)\
+template<std::size_t Len>\
+struct BOOST_ALIGNMENT(A) aligned_storage_impl<Len, A>\
+{\
+ char dummy[Len];\
+ typedef aligned_storage_impl<Len, A> type;\
+};\
+//
+
+//Up to 4K alignment (typical page size)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x2)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x4)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x8)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x10)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x20)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x40)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x80)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x100)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x200)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x400)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x800)
+BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1000)
+
+#undef BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT
+
+#else //BOOST_NO_ALIGNMENT
+
+template<class T, size_t Len>
+union aligned_union
+{
+ T aligner;
+ char dummy[Len];
+};
+
+template<std::size_t Len, std::size_t Align, class T, bool Ok>
+struct aligned_next;
+
+template<std::size_t Len, std::size_t Align, class T>
+struct aligned_next<Len, Align, T, true>
+{
+ BOOST_STATIC_ASSERT((alignment_of<T>::value == Align));
+ typedef aligned_union<T, Len> type;
+};
+
+//End of search defaults to max_align_t
+template<std::size_t Len, std::size_t Align>
+struct aligned_next<Len, Align, max_align_t, false>
+{ typedef aligned_union<max_align_t, Len> type; };
+
+//Now define a search list through types
+#define BOOST_MOVE_ALIGNED_NEXT_STEP(TYPE, NEXT_TYPE)\
+ template<std::size_t Len, std::size_t Align>\
+ struct aligned_next<Len, Align, TYPE, false>\
+ : aligned_next<Len, Align, NEXT_TYPE, Align == alignment_of<NEXT_TYPE>::value>\
+ {};\
+ //
+ BOOST_MOVE_ALIGNED_NEXT_STEP(long double, max_align_t)
+ BOOST_MOVE_ALIGNED_NEXT_STEP(double, long double)
+ #ifdef BOOST_HAS_LONG_LONG
+ BOOST_MOVE_ALIGNED_NEXT_STEP(::boost::long_long_type, double)
+ BOOST_MOVE_ALIGNED_NEXT_STEP(long, ::boost::long_long_type)
+ #else
+ BOOST_MOVE_ALIGNED_NEXT_STEP(long, double)
+ #endif
+ BOOST_MOVE_ALIGNED_NEXT_STEP(int, long)
+ BOOST_MOVE_ALIGNED_NEXT_STEP(short, int)
+ BOOST_MOVE_ALIGNED_NEXT_STEP(char, short)
+#undef BOOST_MOVE_ALIGNED_NEXT_STEP
+
+template<std::size_t Len, std::size_t Align>
+struct aligned_storage_impl
+ : aligned_next<Len, Align, char, Align == alignment_of<char>::value>
+{};
+
+#endif
+
+template<std::size_t Len, std::size_t Align = alignment_of<max_align_t>::value>
+struct aligned_storage
+{
+ //Sanity checks for input parameters
+ BOOST_STATIC_ASSERT(Align > 0);
+
+ //Sanity checks for output type
+ typedef typename aligned_storage_impl<Len ? Len : 1, Align>::type type;
+ static const std::size_t value = alignment_of<type>::value;
+ BOOST_STATIC_ASSERT(value >= Align);
+ BOOST_STATIC_ASSERT((value % Align) == 0);
+
+ //Just in case someone instantiates aligned_storage
+ //instead of aligned_storage::type (typical error).
+ private:
+ aligned_storage();
+};
+
+} //namespace move_detail {
+} //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_MOVE_DETAIL_TYPE_TRAITS_HPP
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014. 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/interprocess for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP
+#define BOOST_MOVE_DETAIL_WORKAROUND_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ #define BOOST_MOVE_PERFECT_FORWARDING
+#endif
+
+//Macros for documentation purposes. For code, expands to the argument
+#define BOOST_MOVE_IMPDEF(TYPE) TYPE
+#define BOOST_MOVE_SEEDOC(TYPE) TYPE
+#define BOOST_MOVE_DOC0PTR(TYPE) TYPE
+#define BOOST_MOVE_DOC1ST(TYPE1, TYPE2) TYPE2
+#define BOOST_MOVE_I ,
+#define BOOST_MOVE_DOCIGN(T1) T1
+
+#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 5) && !defined(__clang__)
+ //Pre-standard rvalue binding rules
+ #define BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+#elif defined(_MSC_VER) && (_MSC_VER == 1600)
+ //Standard rvalue binding rules but with some bugs
+ #define BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG
+ #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG
+#elif defined(_MSC_VER) && (_MSC_VER == 1700)
+ #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG
+#endif
+
+#endif //#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2009-2012.
+// 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+
+#ifndef BOOST_MOVE_TRAITS_HPP
+#define BOOST_MOVE_TRAITS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#include <boost/move/core.hpp>
+#endif
+#include <boost/move/detail/meta_utils.hpp>
+#include <boost/move/detail/type_traits.hpp>
+
+namespace boost {
+
+//! If this trait yields to true
+//! (<i>has_trivial_destructor_after_move <T>::value == true</i>)
+//! means that if T is used as argument of a move construction/assignment,
+//! there is no need to call T's destructor.
+//! This optimization tipically is used to improve containers' performance.
+//!
+//! By default this trait is true if the type has trivial destructor,
+//! every class should specialize this trait if it wants to improve performance
+//! when inserted in containers.
+template <class T>
+struct has_trivial_destructor_after_move
+ : ::boost::move_detail::is_trivially_destructible<T>
+{};
+
+//! By default this traits returns
+//! <pre>boost::is_nothrow_move_constructible<T>::value && boost::is_nothrow_move_assignable<T>::value </pre>.
+//! Classes with non-throwing move constructor
+//! and assignment can specialize this trait to obtain some performance improvements.
+template <class T>
+struct has_nothrow_move
+{
+ static const bool value = boost::move_detail::is_nothrow_move_constructible<T>::value &&
+ boost::move_detail::is_nothrow_move_assignable<T>::value;
+};
+
+namespace move_detail {
+
+template <class T>
+struct is_nothrow_move_constructible_or_uncopyable
+{
+ //The standard requires is_nothrow_move_constructible for move_if_noexcept
+ //but a user (usually in C++03) might specialize has_nothrow_move which includes it
+ static const bool value = is_nothrow_move_constructible<T>::value ||
+ has_nothrow_move<T>::value ||
+ !is_copy_constructible<T>::value;
+};
+
+} //move_detail {
+} //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_MOVE_TRAITS_HPP
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2012.
+// 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+//! This header includes core utilities from <tt><boost/move/utility_core.hpp></tt> and defines
+//! some more advanced utilities such as:
+
+#ifndef BOOST_MOVE_MOVE_UTILITY_HPP
+#define BOOST_MOVE_MOVE_UTILITY_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/move/traits.hpp>
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+ namespace boost {
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // move_if_noexcept()
+ //
+ //////////////////////////////////////////////////////////////////////////////
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value && !has_move_emulation_enabled<T>::value
+ , typename ::boost::move_detail::add_const<T>::type &
+ >::type
+ move_if_noexcept(T& x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
+ && ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, rv<T>&>::type
+ move_if_noexcept(T& x) BOOST_NOEXCEPT
+ {
+ return *static_cast<rv<T>* >(::boost::move_detail::addressof(x));
+ }
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
+ && ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value
+ , rv<T>&
+ >::type
+ move_if_noexcept(rv<T>& x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
+ && !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value
+ , typename ::boost::move_detail::add_const<T>::type &
+ >::type
+ move_if_noexcept(T& x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value
+ && !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value
+ , typename ::boost::move_detail::add_const<T>::type &
+ >::type
+ move_if_noexcept(rv<T>& x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ } //namespace boost
+
+#else //#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+ #if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
+ #include <utility>
+
+ namespace boost{
+
+ using ::std::move_if_noexcept;
+
+ } //namespace boost
+
+ #else //!BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE
+
+ namespace boost {
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // move_if_noexcept()
+ //
+ //////////////////////////////////////////////////////////////////////////////
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! This function provides a way to convert a reference into a rvalue reference
+ //! in compilers with rvalue references. For other compilers converts T & into
+ //! <i>::boost::rv<T> &</i> so that move emulation is activated. Reference
+ //! would be converted to rvalue reference only if input type is nothrow move
+ //! constructible or if it has no copy constructor. In all other cases const
+ //! reference would be returned
+ template <class T>
+ rvalue_reference_or_const_lvalue_reference move_if_noexcept(input_reference) noexcept;
+
+ #else //BOOST_MOVE_DOXYGEN_INVOKED
+
+ template <class T>
+ typename ::boost::move_detail::enable_if_c
+ < ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, T&&>::type
+ move_if_noexcept(T& x) BOOST_NOEXCEPT
+ { return ::boost::move(x); }
+
+ template <class T>
+ typename ::boost::move_detail::enable_if_c
+ < !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, const T&>::type
+ move_if_noexcept(T& x) BOOST_NOEXCEPT
+ { return x; }
+
+ #endif //BOOST_MOVE_DOXYGEN_INVOKED
+
+ } //namespace boost {
+
+ #endif //#if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
+
+#endif //BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_MOVE_MOVE_UTILITY_HPP
--- /dev/null
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2012.
+// 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/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+//! This header defines core utilities to ease the development
+//! of move-aware functions. This header minimizes dependencies
+//! from other libraries.
+
+#ifndef BOOST_MOVE_MOVE_UTILITY_CORE_HPP
+#define BOOST_MOVE_MOVE_UTILITY_CORE_HPP
+
+#ifndef BOOST_CONFIG_HPP
+# include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/core.hpp>
+#include <boost/move/detail/meta_utils.hpp>
+#include <boost/static_assert.hpp>
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+ namespace boost {
+
+ template<class T>
+ struct enable_move_utility_emulation
+ {
+ static const bool value = true;
+ };
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // move()
+ //
+ //////////////////////////////////////////////////////////////////////////////
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value && !has_move_emulation_enabled<T>::value, T&>::type
+ move(T& x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value, rv<T>&>::type
+ move(T& x) BOOST_NOEXCEPT
+ {
+ return *static_cast<rv<T>* >(::boost::move_detail::addressof(x));
+ }
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value, rv<T>&>::type
+ move(rv<T>& x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // forward()
+ //
+ //////////////////////////////////////////////////////////////////////////////
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value && ::boost::move_detail::is_rv<T>::value, T &>::type
+ forward(const typename ::boost::move_detail::identity<T>::type &x) BOOST_NOEXCEPT
+ {
+ return const_cast<T&>(x);
+ }
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value && !::boost::move_detail::is_rv<T>::value, const T &>::type
+ forward(const typename ::boost::move_detail::identity<T>::type &x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // move_if_not_lvalue_reference()
+ //
+ //////////////////////////////////////////////////////////////////////////////
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value &&
+ ::boost::move_detail::is_rv<T>::value
+ , T &>::type
+ move_if_not_lvalue_reference(const typename ::boost::move_detail::identity<T>::type &x) BOOST_NOEXCEPT
+ {
+ return const_cast<T&>(x);
+ }
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value &&
+ !::boost::move_detail::is_rv<T>::value &&
+ (::boost::move_detail::is_lvalue_reference<T>::value ||
+ !has_move_emulation_enabled<T>::value)
+ , typename ::boost::move_detail::add_lvalue_reference<T>::type
+ >::type
+ move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type &x) BOOST_NOEXCEPT
+ {
+ return x;
+ }
+
+ template <class T>
+ inline typename ::boost::move_detail::enable_if_c
+ < enable_move_utility_emulation<T>::value &&
+ !::boost::move_detail::is_rv<T>::value &&
+ (!::boost::move_detail::is_lvalue_reference<T>::value &&
+ has_move_emulation_enabled<T>::value)
+ , rv<T>&
+ >::type
+ move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type &x) BOOST_NOEXCEPT
+ {
+ return move(x);
+ }
+
+ } //namespace boost
+
+#else //#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+ #if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
+ #include <utility>
+
+ namespace boost{
+
+ using ::std::move;
+ using ::std::forward;
+
+ } //namespace boost
+
+ #else //!BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE
+
+ namespace boost {
+
+ //! This trait's internal boolean `value` is false in compilers with rvalue references
+ //! and true in compilers without rvalue references.
+ //!
+ //! A user can specialize this trait for a type T to false to SFINAE out `move` and `forward`
+ //! so that the user can define a different move emulation for that type in namespace boost
+ //! (e.g. another Boost library for its types) and avoid any overload ambiguity.
+ template<class T>
+ struct enable_move_utility_emulation
+ {
+ static const bool value = false;
+ };
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // move
+ //
+ //////////////////////////////////////////////////////////////////////////////
+
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! This function provides a way to convert a reference into a rvalue reference
+ //! in compilers with rvalue references. For other compilers if `T` is Boost.Move
+ //! enabled type then it converts `T&` into <tt>::boost::rv<T> &</tt> so that
+ //! move emulation is activated, else it returns `T &`.
+ template <class T>
+ rvalue_reference move(input_reference) noexcept;
+
+ #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
+
+ //Old move approach, lvalues could bind to rvalue references
+ template <class T>
+ inline typename ::boost::move_detail::remove_reference<T>::type && move(T&& t) BOOST_NOEXCEPT
+ { return t; }
+
+ #else //BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+
+ template <class T>
+ inline typename ::boost::move_detail::remove_reference<T>::type && move(T&& t) BOOST_NOEXCEPT
+ { return static_cast<typename ::boost::move_detail::remove_reference<T>::type &&>(t); }
+
+ #endif //BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // forward
+ //
+ //////////////////////////////////////////////////////////////////////////////
+
+
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ //! This function provides limited form of forwarding that is usually enough for
+ //! in-place construction and avoids the exponential overloading for
+ //! achieve the limited forwarding in C++03.
+ //!
+ //! For compilers with rvalue references this function provides perfect forwarding.
+ //!
+ //! Otherwise:
+ //! * If input_reference binds to const ::boost::rv<T> & then it output_reference is
+ //! ::boost::rv<T> &
+ //!
+ //! * Else, output_reference is equal to input_reference.
+ template <class T> output_reference forward(input_reference) noexcept;
+ #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
+
+ //Old move approach, lvalues could bind to rvalue references
+
+ template <class T>
+ inline T&& forward(typename ::boost::move_detail::identity<T>::type&& t) BOOST_NOEXCEPT
+ { return t; }
+
+ #else //Old move
+
+ template <class T>
+ inline T&& forward(typename ::boost::move_detail::remove_reference<T>::type& t) BOOST_NOEXCEPT
+ { return static_cast<T&&>(t); }
+
+ template <class T>
+ inline T&& forward(typename ::boost::move_detail::remove_reference<T>::type&& t) BOOST_NOEXCEPT
+ {
+ //"boost::forward<T> error: 'T' is a lvalue reference, can't forward as rvalue.";
+ BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value);
+ return static_cast<T&&>(t);
+ }
+
+ #endif //BOOST_MOVE_DOXYGEN_INVOKED
+
+ //////////////////////////////////////////////////////////////////////////////
+ //
+ // move_if_not_lvalue_reference
+ //
+ //////////////////////////////////////////////////////////////////////////////
+
+
+ #if defined(BOOST_MOVE_DOXYGEN_INVOKED)
+ template <class T> output_reference move_if_not_lvalue_reference(input_reference) noexcept;
+ #elif defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
+
+ //Old move approach, lvalues could bind to rvalue references
+
+ template <class T>
+ inline T&& move_if_not_lvalue_reference(typename ::boost::move_detail::identity<T>::type&& t) BOOST_NOEXCEPT
+ { return t; }
+
+ #else //Old move
+
+ template <class T>
+ inline T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type& t) BOOST_NOEXCEPT
+ { return static_cast<T&&>(t); }
+
+ template <class T>
+ inline T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type&& t) BOOST_NOEXCEPT
+ {
+ //"boost::forward<T> error: 'T' is a lvalue reference, can't forward as rvalue.";
+ BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value);
+ return static_cast<T&&>(t);
+ }
+
+ #endif //BOOST_MOVE_DOXYGEN_INVOKED
+
+ } //namespace boost {
+
+ #endif //#if defined(BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE)
+
+#endif //BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+namespace boost{
+namespace move_detail{
+
+template <typename T>
+typename boost::move_detail::add_rvalue_reference<T>::type declval();
+
+} //namespace move_detail{
+} //namespace boost{
+
+#endif //#if !defined(BOOST_MOVE_DOXYGEN_INVOKED)
+
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_MOVE_MOVE_UTILITY_CORE_HPP
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/O1_size_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: O1_size_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: advance.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/advance_fwd.hpp>
#include <boost/mpl/less.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: advance_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/common_name_wknd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: always.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
-#include <boost/mpl/aux_/preprocessor/def_params_tail.hpp>
+#include <boost/mpl/aux_/preprocessor/default_params.hpp>
#include <boost/mpl/aux_/na.hpp>
#include <boost/mpl/aux_/arity_spec.hpp>
template< typename Value > struct always
{
template<
- typename T
- BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(1, typename T, na)
+ BOOST_MPL_PP_DEFAULT_PARAMS(BOOST_MPL_LIMIT_METAFUNCTION_ARITY, typename T, na)
>
struct apply
{
};
};
-BOOST_MPL_AUX_ARITY_SPEC(1, always)
+BOOST_MPL_AUX_ARITY_SPEC(0, always)
}}
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: and.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/use_preprocessed.hpp>
// 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(and)'
// has to be checked in a separate condition, otherwise GCC complains
// about 'and' being an alternative token
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && !defined(__clang__)
#ifndef __GCCXML__
#if defined(and)
# pragma push_macro("and")
# define BOOST_MPL_PREPROCESSED_HEADER and.hpp
# include <boost/mpl/aux_/include_preprocessed.hpp>
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && !defined(__clang__)
#ifndef __GCCXML__
#if defined(and)
# pragma pop_macro("and")
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/apply_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: apply_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/aux_/na.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: apply_wrap.hpp 49272 2008-10-11 06:50:46Z agurtovoy $
-// $Date: 2008-10-10 23:50:46 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49272 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/aux_/arity.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: arg.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/arg_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: arg_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/adl_barrier.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: assert.hpp 86514 2013-10-29 13:15:03Z bemandawes $
-// $Date: 2013-10-29 06:15:03 -0700 (Tue, 29 Oct 2013) $
-// $Revision: 86514 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/not.hpp>
#include <boost/mpl/aux_/value_wknd.hpp>
#include <boost/mpl/aux_/config/dtp.hpp>
#include <boost/mpl/aux_/config/gcc.hpp>
#include <boost/mpl/aux_/config/msvc.hpp>
+#include <boost/mpl/aux_/config/gpu.hpp>
#include <boost/mpl/aux_/config/static_constant.hpp>
#include <boost/mpl/aux_/config/pp_counter.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
// and GCC (which issues "unused variable" warnings when static constants are used
// at a function scope)
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
- || (BOOST_MPL_CFG_GCC != 0)
+ || (BOOST_MPL_CFG_GCC != 0) || (BOOST_MPL_CFG_GPU != 0)
# define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) enum { expr }
#else
# define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) BOOST_STATIC_CONSTANT(T, expr)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: at.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/at_fwd.hpp>
#include <boost/mpl/aux_/at_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: at_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: O1_size_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/O1_size_fwd.hpp>
#include <boost/mpl/long.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: adl_barrier.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/adl.hpp>
#include <boost/mpl/aux_/config/gcc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: advance_backward.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: advance_forward.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/next.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: arg_typedef.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/lambda.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: arithmetic_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/integral_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: arity.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/dtp.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: arity_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/int.hpp>
#include <boost/mpl/limits/arity.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: at_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/advance.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: begin_end_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/begin_end_fwd.hpp>
#include <boost/mpl/sequence_tag_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: clear_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/clear_fwd.hpp>
#include <boost/mpl/aux_/traits_lambda_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: common_name_wknd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: comparison_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: adl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/intel.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: arrays.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: bcc.hpp 49272 2008-10-11 06:50:46Z agurtovoy $
+// $Id$
// $Date: 2004-09-02 10:41:37 -0500 (Thu, 02 Sep 2004) $
// $Revision: 24874 $
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: bind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: compiler.hpp 53189 2009-05-22 20:07:55Z hkaiser $
-// $Date: 2009-05-22 13:07:55 -0700 (Fri, 22 May 2009) $
-// $Revision: 53189 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_CFG_COMPILER_DIR)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/workaround.hpp>
#include <boost/config.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: dmc_ambiguous_ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: dtp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: eti.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: forwarding.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: gcc.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if defined(__GNUC__) && !defined(__EDG_VERSION__)
# define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__)
--- /dev/null
+
+#ifndef BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED
+#define BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED
+
+// Copyright Eric Niebler 2014
+//
+// 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/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_MPL_CFG_GPU_ENABLED) \
+
+# define BOOST_MPL_CFG_GPU_ENABLED BOOST_GPU_ENABLED
+
+#endif
+
+#if defined __CUDACC__
+
+# define BOOST_MPL_CFG_GPU 1
+
+#else
+
+# define BOOST_MPL_CFG_GPU 0
+
+#endif
+
+#endif // BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: has_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/has_xxx.hpp>
#include <boost/mpl/aux_/config/msvc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: has_xxx.hpp 63518 2010-07-02 08:32:03Z agurtovoy $
-// $Date: 2010-07-02 01:32:03 -0700 (Fri, 02 Jul 2010) $
-// $Revision: 63518 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/overload_resolution.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: integral.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: intel.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
// BOOST_INTEL_CXX_VERSION is defined here:
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: lambda.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/ttp.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: msvc.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
// BOOST_MSVC is defined here:
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: msvc_typename.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: nttp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: overload_resolution.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: pp_counter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_AUX_PP_COUNTER)
# include <boost/mpl/aux_/config/msvc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: preprocessor.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: static_constant.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
// BOOST_STATIC_CONSTANT is defined here:
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: ttp.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/gcc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: typeof.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/gcc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: use_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
// #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: workaround.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/detail/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: contains_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/contains_fwd.hpp>
#include <boost/mpl/begin_end.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: count_args.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/preprocessor/expr_if.hpp>
#include <boost/preprocessor/inc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: empty_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/begin_end.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: fold_impl_body.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
# include <boost/mpl/limits/unrolling.hpp>
# include <boost/mpl/aux_/preprocessor/repeat.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: full_lambda.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/lambda_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: has_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/has_xxx.hpp>
#include <boost/mpl/aux_/config/has_apply.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: has_begin.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/has_xxx.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: has_rebind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/intel.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: has_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/has_xxx.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: has_tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/has_xxx.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: has_type.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/has_xxx.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/compiler.hpp>
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: insert_range_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/copy.hpp>
#include <boost/mpl/clear.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: inserter_algorithm.hpp 55648 2009-08-18 05:16:53Z agurtovoy $
-// $Date: 2009-08-17 22:16:53 -0700 (Mon, 17 Aug 2009) $
-// $Revision: 55648 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/back_inserter.hpp>
#include <boost/mpl/front_inserter.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: integral_wrapper.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION!
// functions that return objects of both arithmetic ('int', 'long',
// 'double', etc.) and wrapped integral types (for an example, see
// "mpl/example/power.cpp")
- operator AUX_WRAPPER_VALUE_TYPE() const { return static_cast<AUX_WRAPPER_VALUE_TYPE>(this->value); }
+ BOOST_CONSTEXPR operator AUX_WRAPPER_VALUE_TYPE() const { return static_cast<AUX_WRAPPER_VALUE_TYPE>(this->value); }
};
#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: is_msvc_eti_arg.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/yes_no.hpp>
#include <boost/mpl/aux_/config/eti.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: iter_apply.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/apply.hpp>
#include <boost/mpl/deref.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: iter_fold_if_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/identity.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: iter_fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: iter_push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/deref.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: joint_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/next_prior.hpp>
#include <boost/mpl/deref.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: lambda_arity_param.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/ttp.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: lambda_no_ctps.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/lambda_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: lambda_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/void.hpp>
#include <boost/mpl/lambda_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: lambda_support.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/lambda.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: largest_int.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/if.hpp>
#include <boost/mpl/int.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: logical_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION!
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: msvc_dtw.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION!
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: msvc_eti_base.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/is_msvc_eti_arg.hpp>
#include <boost/mpl/aux_/config/eti.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: msvc_is_class.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/if.hpp>
#include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: msvc_never_true.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: msvc_type.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/eti.hpp>
#include <boost/mpl/aux_/is_msvc_eti_arg.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: na.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/bool.hpp>
#include <boost/mpl/aux_/na_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: na_assert.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/na.hpp>
#include <boost/mpl/aux_/config/msvc.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: na_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/adl_barrier.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: na_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/lambda_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: nested_type_wknd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/gcc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: nttp_decl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/nttp.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: numeric_cast_utils.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/numeric_cast.hpp>
#include <boost/mpl/apply_wrap.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: numeric_op.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/numeric_cast.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: add.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: def_params_tail.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/limits/arity.hpp>
#include <boost/mpl/aux_/config/dtp.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: default_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: enum.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: ext_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: filter_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#define BOOST_MPL_PP_FILTER_PARAMS_0(p1,p2,p3,p4,p5,p6,p7,p8,p9)
#define BOOST_MPL_PP_FILTER_PARAMS_1(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: partial_spec_params.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/limits/arity.hpp>
#include <boost/mpl/aux_/preprocessor/params.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: range.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/preprocessor/seq/subseq.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+
+#define BOOST_MPL_PP_RANGE_ITEM(z,n,_) (n)
#define BOOST_MPL_PP_RANGE(first, length) \
- BOOST_PP_SEQ_SUBSEQ((0)(1)(2)(3)(4)(5)(6)(7)(8)(9), first, length) \
+ BOOST_PP_SEQ_SUBSEQ( \
+ BOOST_PP_REPEAT(BOOST_PP_ADD(first,length), BOOST_MPL_PP_RANGE_ITEM, _), \
+ first, length \
+ ) \
/**/
#endif // BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: repeat.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: sub.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/preprocessor.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: tuple.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#define BOOST_MPL_PP_TUPLE_11_ELEM_0(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e0
#define BOOST_MPL_PP_TUPLE_11_ELEM_1(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e1
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: push_back_impl.hpp 55679 2009-08-20 07:50:16Z agurtovoy $
-// $Date: 2009-08-20 00:50:16 -0700 (Thu, 20 Aug 2009) $
-// $Revision: 55679 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/push_back_fwd.hpp>
#include <boost/mpl/assert.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: push_front_impl.hpp 55679 2009-08-20 07:50:16Z agurtovoy $
-// $Date: 2009-08-20 00:50:16 -0700 (Thu, 20 Aug 2009) $
-// $Revision: 55679 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/push_front_fwd.hpp>
#include <boost/mpl/assert.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: reverse_fold_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: reverse_fold_impl_body.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
# include <boost/mpl/limits/unrolling.hpp>
# include <boost/mpl/aux_/preprocessor/repeat.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: sequence_wrapper.hpp 49271 2008-10-11 06:46:00Z agurtovoy $
-// $Date: 2008-10-10 23:46:00 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49271 $
+// $Id$
+// $Date$
+// $Revision$
# include <boost/mpl/aux_/config/ctps.hpp>
# include <boost/mpl/aux_/config/static_constant.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: size_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/begin_end.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: static_cast.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: template_arity.hpp 61584 2010-04-26 18:48:26Z agurtovoy $
-// $Date: 2010-04-26 11:48:26 -0700 (Mon, 26 Apr 2010) $
-// $Revision: 61584 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/ttp.hpp>
#include <boost/mpl/aux_/config/lambda.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: template_arity_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl { namespace aux {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: traits_lambda_spec.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/sequence_tag_fwd.hpp>
#include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: type_wrapper.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/ctps.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: value_wknd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/static_cast.hpp>
#include <boost/mpl/aux_/config/integral.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: yes_no.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/nttp_decl.hpp>
#include <boost/mpl/aux_/config/arrays.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: back_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: back_inserter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/inserter.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: begin_end.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/begin_end_fwd.hpp>
#include <boost/mpl/aux_/begin_end_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: begin_end_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: bind.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/bind_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: bind_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/aux_/na.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: bool.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/bool_fwd.hpp>
#include <boost/mpl/integral_c_tag.hpp>
typedef integral_c_tag tag;
typedef bool_ type;
typedef bool value_type;
- operator bool() const { return this->value; }
+ BOOST_CONSTEXPR operator bool() const { return this->value; }
};
#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: bool_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/adl_barrier.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: clear.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/clear_fwd.hpp>
#include <boost/mpl/aux_/clear_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: clear_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: comparison.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/equal_to.hpp>
#include <boost/mpl/not_equal_to.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: contains.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/contains_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: contains_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: copy.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/fold.hpp>
#include <boost/mpl/reverse_fold.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: deref.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/msvc_type.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: distance.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/distance_fwd.hpp>
#include <boost/mpl/iter_fold.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: distance_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/common_name_wknd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: empty_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: equal_to.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#define AUX778076_OP_NAME equal_to
#define AUX778076_OP_TOKEN ==
// Copyright Aleksey Gurtovoy 2000-2004
//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// 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/mpl for documentation.
-// $Id: eval_if.hpp 61921 2010-05-11 21:33:24Z neilgroves $
-// $Date: 2010-05-11 14:33:24 -0700 (Tue, 11 May 2010) $
-// $Revision: 61921 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/if.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
BOOST_MPL_AUX_LAMBDA_SUPPORT(3,eval_if,(C,F1,F2))
};
-// (almost) copy & paste in order to save one more
+// (almost) copy & paste in order to save one more
// recursively nested template instantiation to user
template<
bool C
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: find.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/find_if.hpp>
#include <boost/mpl/same_as.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: find_if.hpp 49274 2008-10-11 07:22:05Z agurtovoy $
-// $Date: 2008-10-11 00:22:05 -0700 (Sat, 11 Oct 2008) $
-// $Revision: 49274 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/find_if_pred.hpp>
#include <boost/mpl/arg.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: fold.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/O1_size.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: front_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: front_inserter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/inserter.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: greater.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#define AUX778076_OP_NAME greater
#define AUX778076_OP_TOKEN >
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: greater_equal.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#define AUX778076_OP_NAME greater_equal
#define AUX778076_OP_TOKEN >=
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: has_xxx.hpp 64146 2010-07-19 00:46:31Z djwalker $
-// $Date: 2010-07-18 17:46:31 -0700 (Sun, 18 Jul 2010) $
-// $Revision: 64146 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/bool.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
// SFINAE-based implementations below are derived from a USENET newsgroup's
// posting by Rani Sharoni (comp.lang.c++.moderated, 2002-03-17 07:45:09 PST)
-# elif BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
+# elif BOOST_WORKAROUND(BOOST_MSVC, <= 1400) \
+ || (BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1800)) && defined(__CUDACC__)) \
|| BOOST_WORKAROUND(__IBMCPP__, <= 700)
-// MSVC 7.1+ & VACPP
+// MSVC 7.1 & MSVC 8.0 & VACPP
// agurt, 15/jun/05: replace overload-based SFINAE implementation with SFINAE
// applied to partial specialization to fix some apparently random failures
# if !defined(BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES)
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
# define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 1
+# else
+# define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 0
# endif
# endif
# if !defined(BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION)
# if (defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS))
# define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 1
+# else
+# define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 0
# endif
# endif
# if !defined(BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE)
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
# define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 1
+# else
+# define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 0
# endif
# endif
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: identity.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/value_wknd.hpp>
#include <boost/mpl/aux_/static_cast.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: insert_range.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/insert_range_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: insert_range_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: inserter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: int.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/int_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: int_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/adl_barrier.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: integral_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/integral_c_fwd.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: integral_c_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/workaround.hpp>
#include <boost/mpl/aux_/adl_barrier.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: integral_c_tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/adl_barrier.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: is_placeholder.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/arg_fwd.hpp>
#include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: iter_fold.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/O1_size.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: iter_fold_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/logical.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: iterator_range.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/na_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: iterator_tags.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/int.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: joint_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/joint_iter.hpp>
#include <boost/mpl/plus.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: lambda.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/lambda_fwd.hpp>
#include <boost/mpl/bind.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: lambda_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/void_fwd.hpp>
#include <boost/mpl/aux_/na.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: less.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#define AUX778076_OP_NAME less
#define AUX778076_OP_TOKEN <
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: less_equal.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#define AUX778076_OP_NAME less_equal
#define AUX778076_OP_TOKEN <=
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: arity.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_LIMIT_METAFUNCTION_ARITY)
# define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_LIMIT_LIST_SIZE)
# define BOOST_MPL_LIMIT_LIST_SIZE 20
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: unrolling.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_LIMIT_UNROLLING)
# define BOOST_MPL_LIMIT_UNROLLING 4
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_LIMIT_VECTOR_SIZE)
# define BOOST_MPL_LIMIT_VECTOR_SIZE 20
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/limits/list.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/O1_size_fwd.hpp>
#include <boost/mpl/list/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: begin_end.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/begin_end_fwd.hpp>
#include <boost/mpl/list/aux_/iterator.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: clear.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/clear_fwd.hpp>
#include <boost/mpl/list/aux_/item.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/not.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/front_fwd.hpp>
#include <boost/mpl/list/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION!
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/long.hpp>
#include <boost/mpl/list/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/iterator_tags.hpp>
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: numbered.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if defined(BOOST_PP_IS_ITERATING)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: numbered_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if defined(BOOST_PP_IS_ITERATING)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: pop_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/pop_front_fwd.hpp>
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: push_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/push_back_fwd.hpp>
#include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/push_front_fwd.hpp>
#include <boost/mpl/next.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/list/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl { namespace aux {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/long.hpp>
#include <boost/mpl/aux_/na.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list0_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/list/list0.hpp>
#include <boost/mpl/integral_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list10.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list0.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list10_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list0_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list20.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list10.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list20_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list10_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list30.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list20.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list30_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list20_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list40.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list30.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list40_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list30_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list50.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list40.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: list50_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/list/list40_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: logical.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/or.hpp>
#include <boost/mpl/and.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: long.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/long_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: long_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/adl_barrier.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: minus.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#define AUX778076_OP_NAME minus
#define AUX778076_OP_TOKEN -
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: multiplies.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/times.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: negate.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/aux_/msvc_eti_base.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: next.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: next_prior.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/common_name_wknd.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: not.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/bool.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: not_equal_to.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#define AUX778076_OP_NAME not_equal_to
#define AUX778076_OP_TOKEN !=
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: numeric_cast.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/msvc.hpp>
#include <boost/mpl/aux_/config/workaround.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: or.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/use_preprocessed.hpp>
// 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(or)'
// has to be checked in a separate condition, otherwise GCC complains
// about 'or' being an alternative token
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && !defined(__clang__)
#ifndef __GCCXML__
#if defined(or)
# pragma push_macro("or")
# define BOOST_MPL_PREPROCESSED_HEADER or.hpp
# include <boost/mpl/aux_/include_preprocessed.hpp>
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && !defined(__clang__)
#ifndef __GCCXML__
#if defined(or)
# pragma pop_macro("or")
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: pair.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/msvc_eti_base.hpp>
#include <boost/mpl/aux_/na_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: placeholders.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: plus.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#define AUX778076_OP_NAME plus
#define AUX778076_OP_TOKEN +
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: pop_back_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: pop_front_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: prior.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: protect.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/arity.hpp>
#include <boost/mpl/aux_/config/dtp.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: push_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/push_back_fwd.hpp>
#include <boost/mpl/aux_/push_back_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: push_back_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/push_front_fwd.hpp>
#include <boost/mpl/aux_/push_front_impl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: push_front_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: quote.hpp 49272 2008-10-11 06:50:46Z agurtovoy $
-// $Date: 2008-10-10 23:50:46 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49272 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: remove_if.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/fold.hpp>
#include <boost/mpl/reverse_fold.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: reverse_fold.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/O1_size.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: same_as.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/not.hpp>
#include <boost/mpl/aux_/lambda_spec.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: sequence_tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/sequence_tag_fwd.hpp>
#include <boost/mpl/aux_/has_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: sequence_tag_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/sequence_tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: size_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
namespace boost { namespace mpl {
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: size_t.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/size_t_fwd.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: size_t_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/adl_barrier.hpp>
#include <boost/config.hpp> // make sure 'size_t' is placed into 'std'
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
-#include <boost/detail/endian.hpp>
+#include <boost/predef/other/endian.h>
#include <boost/mpl/limits/string.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/char.hpp>
#define BOOST_MPL_MULTICHAR_LENGTH(c) \
(std::size_t)((c<CHAR_MIN) ? 4 : ((c>0xffffff)+(c>0xffff)+(c>0xff)+1))
- #if defined(BOOST_LITTLE_ENDIAN) && defined(__SUNPRO_CC)
+ #if defined(BOOST_ENDIAN_LITTLE_BYTE) && defined(__SUNPRO_CC)
#define BOOST_MPL_MULTICHAR_AT(c,i) \
(char)(0xff&((unsigned)(c)>>(8*(std::size_t)(i))))
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: times.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#define AUX778076_OP_NAME times
#define AUX778076_OP_TOKEN *
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/limits/vector.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: O1_size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/O1_size_fwd.hpp>
#include <boost/mpl/minus.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: at.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/at_fwd.hpp>
#include <boost/mpl/vector/aux_/tag.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/back_fwd.hpp>
#include <boost/mpl/next_prior.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: begin_end.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/typeof.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: clear.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/clear_fwd.hpp>
#include <boost/mpl/vector/aux_/vector0.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/empty_fwd.hpp>
#include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/front_fwd.hpp>
#include <boost/mpl/vector/aux_/at.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: include_preprocessed.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/config/ctps.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: item.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/long.hpp>
#include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: iterator.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/vector/aux_/at.hpp>
#include <boost/mpl/iterator_tags.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: numbered.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/preprocessor/enum_params.hpp>
#include <boost/preprocessor/enum_shifted_params.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: numbered_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/preprocessor/enum_params.hpp>
#include <boost/preprocessor/enum_shifted_params.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: pop_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/pop_back_fwd.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: pop_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/pop_front_fwd.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: push_back.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/push_back_fwd.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/push_front_fwd.hpp>
#include <boost/mpl/aux_/config/typeof.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: size.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/size_fwd.hpp>
#include <boost/mpl/vector/aux_/O1_size.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: tag.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/config/typeof.hpp>
#include <boost/mpl/aux_/nttp_decl.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/long.hpp>
#include <boost/mpl/void.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/vector/aux_/at.hpp>
#include <boost/mpl/vector/aux_/front.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector0_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/vector/vector0.hpp>
#include <boost/mpl/integral_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector10.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector0.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector10_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector0_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector20.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector10.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector20_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector10_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector30.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector20.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector30_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector20_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector40.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector30.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector40_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector30_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector50.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector40.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: vector50_c.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#if !defined(BOOST_MPL_PREPROCESSING_MODE)
# include <boost/mpl/vector/vector40_c.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: void.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/void_fwd.hpp>
#include <boost/mpl/bool.hpp>
//
// See http://www.boost.org/libs/mpl for documentation.
-// $Id: void_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
-// $Date: 2008-10-10 23:19:02 -0700 (Fri, 10 Oct 2008) $
-// $Revision: 49267 $
+// $Id$
+// $Date$
+// $Revision$
#include <boost/mpl/aux_/adl_barrier.hpp>
#define BOOST_NEXT_PRIOR_HPP_INCLUDED
#include <iterator>
+#if defined(_MSC_VER) && _MSC_VER <= 1310
+#include <boost/mpl/and.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#endif
+#include <boost/type_traits/is_unsigned.hpp>
+#include <boost/type_traits/integral_promotion.hpp>
+#include <boost/type_traits/make_signed.hpp>
+#include <boost/type_traits/has_plus.hpp>
+#include <boost/type_traits/has_plus_assign.hpp>
+#include <boost/type_traits/has_minus.hpp>
+#include <boost/type_traits/has_minus_assign.hpp>
namespace boost {
// Contributed by Dave Abrahams
+namespace next_prior_detail {
+
+template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
+struct next_impl2
+{
+ static T call(T x, Distance n)
+ {
+ std::advance(x, n);
+ return x;
+ }
+};
+
+template< typename T, typename Distance >
+struct next_impl2< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ return x + n;
+ }
+};
+
+
+template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
+struct next_impl1 :
+ public next_impl2< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct next_impl1< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ x += n;
+ return x;
+ }
+};
+
+
+template<
+ typename T,
+ typename Distance,
+ typename PromotedDistance = typename integral_promotion< Distance >::type,
+#if !defined(_MSC_VER) || _MSC_VER > 1310
+ bool IsUInt = is_unsigned< PromotedDistance >::value
+#else
+ // MSVC 7.1 has problems with applying is_unsigned to non-integral types
+ bool IsUInt = mpl::and_< is_integral< PromotedDistance >, is_unsigned< PromotedDistance > >::value
+#endif
+>
+struct prior_impl3
+{
+ static T call(T x, Distance n)
+ {
+ std::advance(x, -n);
+ return x;
+ }
+};
+
+template< typename T, typename Distance, typename PromotedDistance >
+struct prior_impl3< T, Distance, PromotedDistance, true >
+{
+ static T call(T x, Distance n)
+ {
+ typedef typename make_signed< PromotedDistance >::type signed_distance;
+ std::advance(x, -static_cast< signed_distance >(static_cast< PromotedDistance >(n)));
+ return x;
+ }
+};
+
+
+template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
+struct prior_impl2 :
+ public prior_impl3< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_impl2< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ return x - n;
+ }
+};
+
+
+template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
+struct prior_impl1 :
+ public prior_impl2< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_impl1< T, Distance, true >
+{
+ static T call(T x, Distance n)
+ {
+ x -= n;
+ return x;
+ }
+};
+
+} // namespace next_prior_detail
+
template <class T>
inline T next(T x) { return ++x; }
template <class T, class Distance>
inline T next(T x, Distance n)
{
- std::advance(x, n);
- return x;
+ return next_prior_detail::next_impl1< T, Distance >::call(x, n);
}
template <class T>
template <class T, class Distance>
inline T prior(T x, Distance n)
{
- std::advance(x, -n);
- return x;
+ return next_prior_detail::prior_impl1< T, Distance >::call(x, n);
}
} // namespace boost
-// Boost noncopyable.hpp header file --------------------------------------//
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * 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 Beman Dawes 1999-2003. 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)
+#ifndef BOOST_NONCOPYABLE_HPP
+#define BOOST_NONCOPYABLE_HPP
-// See http://www.boost.org/libs/utility for documentation.
+// The header file at this path is deprecated;
+// use boost/core/noncopyable.hpp instead.
-#ifndef BOOST_NONCOPYABLE_HPP_INCLUDED
-#define BOOST_NONCOPYABLE_HPP_INCLUDED
+#include <boost/core/noncopyable.hpp>
-#include <boost/config.hpp>
-
-namespace boost {
-
-// Private copy constructor and copy assignment ensure classes derived from
-// class noncopyable cannot be copied.
-
-// Contributed by Dave Abrahams
-
-namespace noncopyable_ // protection from unintended ADL
-{
- class noncopyable
- {
- protected:
-#ifndef BOOST_NO_DEFAULTED_FUNCTIONS
- BOOST_CONSTEXPR noncopyable() = default;
- ~noncopyable() = default;
-#else
- noncopyable() {}
- ~noncopyable() {}
#endif
-#ifndef BOOST_NO_DELETED_FUNCTIONS
- noncopyable( const noncopyable& ) = delete;
- noncopyable& operator=( const noncopyable& ) = delete;
-#else
- private: // emphasize the following members are private
- noncopyable( const noncopyable& );
- noncopyable& operator=( const noncopyable& );
-#endif
- };
-}
-
-typedef noncopyable_::noncopyable noncopyable;
-
-} // namespace boost
-
-#endif // BOOST_NONCOPYABLE_HPP_INCLUDED
// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2014 Andrzej Krzemienski.
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
namespace boost {
+#ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
none_t const none = (static_cast<none_t>(0)) ;
+#else
+
+namespace detail { namespace optional_detail {
+
+ // the trick here is to make boost::none defined once as a global but in a header file
+ template <typename T>
+ struct none_instance
+ {
+ static const T instance;
+ };
+
+ template <typename T>
+ const T none_instance<T>::instance = T(); // global, but because 'tis a template, no cpp file required
+
+} } // namespace detail::optional_detail
+
+
+namespace {
+ // TU-local
+ const none_t& none = detail::optional_detail::none_instance<none_t>::instance;
+}
+
+#endif
} // namespace boost
// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
+// Copyright (C) 2014 Andrzej Krzemienski.
//
// Use, modification, and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
namespace boost {
+#ifdef BOOST_OPTIONAL_USE_OLD_DEFINITION_OF_NONE
namespace detail { struct none_helper{}; }
-
typedef int detail::none_helper::*none_t ;
+#else
+class none_t {};
+#endif
} // namespace boost
namespace boost {
namespace detail {
-template <typename T> class empty_base {
-
-// Helmut Zeisel, empty base class optimization bug with GCC 3.0.0
-#if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0
- bool dummy;
-#endif
-
-};
+template <typename T> class empty_base {};
} // namespace detail
} // namespace boost
// the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
// necessary.
//
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
// is_chained_base<> - a traits class used to distinguish whether an operator
// template argument is being used for base class chaining, or is specifying a
BOOST_OPERATOR_TEMPLATE1(template_name##1)
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-# define BOOST_OPERATOR_TEMPLATE4(template_name4) \
- BOOST_IMPORT_TEMPLATE4(template_name4)
-# define BOOST_OPERATOR_TEMPLATE3(template_name3) \
- BOOST_IMPORT_TEMPLATE3(template_name3)
-# define BOOST_OPERATOR_TEMPLATE2(template_name2) \
- BOOST_IMPORT_TEMPLATE2(template_name2)
-# define BOOST_OPERATOR_TEMPLATE1(template_name1) \
- BOOST_IMPORT_TEMPLATE1(template_name1)
-
- // In this case we can only assume that template_name<> is equivalent to the
- // more commonly needed template_name1<> form.
-# define BOOST_OPERATOR_TEMPLATE(template_name) \
- template <class T, class B = ::boost::detail::empty_base<T> > \
- struct template_name : template_name##1<T, B> {};
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
namespace boost {
, bitwise2<T,U
> > > {};
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <class T, class U = T>
struct operators : operators2<T, U> {};
template <class T> struct operators<T, T>
-#else
-template <class T> struct operators
-#endif
: totally_ordered<T
, integer_arithmetic<T
, bitwise<T
--- /dev/null
+// Copyright (C) 2014, Andrzej Krzemienski.
+//
+// Use, modification, and distribution is subject to 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/optional for documentation.
+//
+// You are welcome to contact the author at:
+// akrzemi1@gmail.com
+//
+#ifndef BOOST_BAD_OPTIONAL_ACCESS_22MAY2014_HPP
+#define BOOST_BAD_OPTIONAL_ACCESS_22MAY2014_HPP
+
+#include <stdexcept>
+#if __cplusplus < 201103L
+#include <string> // to make converting-ctor std::string(char const*) visible
+#endif
+
+namespace boost {
+
+class bad_optional_access : public std::logic_error
+{
+public:
+ bad_optional_access()
+ : std::logic_error("Attempted to access the value of an uninitialized optional object.")
+ {}
+};
+
+} // namespace boost
+
+#endif
// Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
+// Copyright (C) 2014, 2015 Andrzej Krzemienski.
//
// Use, modification, and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
//
// Revisions:
// 27 Apr 2008 (improved swap) Fernando Cacciola, Niels Dekker, Thorsten Ottosen
+// 05 May 2014 (Added move semantics) Andrzej Krzemienski
//
#ifndef BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP
#define BOOST_OPTIONAL_OPTIONAL_FLC_19NOV2002_HPP
#include <new>
#include <algorithm>
+#include <iosfwd>
#include <boost/config.hpp>
#include <boost/assert.hpp>
+#include <boost/core/explicit_operator_bool.hpp>
+#include <boost/optional/bad_optional_access.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/throw_exception.hpp>
#include <boost/type.hpp>
#include <boost/type_traits/alignment_of.hpp>
#include <boost/type_traits/has_nothrow_constructor.hpp>
#include <boost/type_traits/type_with_alignment.hpp>
+#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/decay.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_lvalue_reference.hpp>
+#include <boost/type_traits/is_nothrow_move_assignable.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_rvalue_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/not.hpp>
#include <boost/detail/reference_content.hpp>
+#include <boost/move/utility.hpp>
#include <boost/none.hpp>
-#include <boost/utility/swap.hpp>
#include <boost/utility/addressof.hpp>
#include <boost/utility/compare_pointees.hpp>
+#include <boost/utility/enable_if.hpp>
#include <boost/utility/in_place_factory.hpp>
+#include <boost/utility/swap.hpp>
-#include <boost/optional/optional_fwd.hpp>
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
-// VC6.0 has the following bug:
-// When a templated assignment operator exist, an implicit conversion
-// constructing an optional<T> is used when assigment of the form:
-// optional<T> opt ; opt = T(...);
-// is compiled.
-// However, optional's ctor is _explicit_ and the assignemt shouldn't compile.
-// Therefore, for VC6.0 templated assignment is disabled.
-//
-#define BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
-#endif
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-// VC7.0 has the following bug:
-// When both a non-template and a template copy-ctor exist
-// and the templated version is made 'explicit', the explicit is also
-// given to the non-templated version, making the class non-implicitely-copyable.
-//
-#define BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
+#include <boost/optional/optional_fwd.hpp>
+
+#if (defined BOOST_NO_CXX11_RVALUE_REFERENCES) || (defined BOOST_OPTIONAL_CONFIG_NO_RVALUE_REFERENCES)
+#define BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
#endif
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION,<=700)
-// AFAICT only VC7.1 correctly resolves the overload set
+#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION,<=700)
+// AFAICT only Intel 7 correctly resolves the overload set
// that includes the in-place factory taking functions,
-// so for the other VC versions, in-place factory support
+// so for the other icc versions, in-place factory support
// is disabled
#define BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
#endif
#define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
#endif
-#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) > 302 \
- && !defined(__INTEL_COMPILER)
+#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. The optional< T > storage type is marked
// with this attribute in order to let the compiler know that it will alias objects of type T
template<class T> void swap ( optional<T>& x, optional<T>& y );
namespace optional_detail {
-
// This local class is used instead of that in "aligned_storage.hpp"
// because I've found the 'official' class to ICE BCB5.5
// when some types are used with optional<>
union
// This works around GCC warnings about breaking strict aliasing rules when casting storage address to T*
#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
- __attribute__((may_alias))
+ __attribute__((__may_alias__))
#endif
dummy_u
{
{
typedef T const& reference_const_type ;
typedef T & reference_type ;
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ typedef T && rval_reference_type ;
+ typedef T && reference_type_of_temporary_wrapper;
+#ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
+ // GCC 4.4 has support for an early draft of rvalue references. The conforming version below
+ // causes warnings about returning references to a temporary.
+ static T&& move(T&& r) { return r; }
+#else
+ static rval_reference_type move(reference_type r) { return boost::move(r); }
+#endif
+#endif
typedef T const* pointer_const_type ;
typedef T * pointer_type ;
typedef T const& argument_type ;
} ;
+
template<class T>
struct types_when_is_ref
{
typedef BOOST_DEDUCED_TYPENAME remove_reference<T>::type raw_type ;
- typedef raw_type& reference_const_type ;
- typedef raw_type& reference_type ;
- typedef raw_type* pointer_const_type ;
- typedef raw_type* pointer_type ;
- typedef raw_type& argument_type ;
+ typedef raw_type& reference_const_type ;
+ typedef raw_type& reference_type ;
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ typedef BOOST_DEDUCED_TYPENAME remove_const<raw_type>::type&& rval_reference_type ;
+ typedef raw_type& reference_type_of_temporary_wrapper;
+ static reference_type move(reference_type r) { return r; }
+#endif
+ typedef raw_type* pointer_const_type ;
+ typedef raw_type* pointer_type ;
+ typedef raw_type& argument_type ;
} ;
+template <class To, class From>
+void prevent_binding_rvalue_ref_to_optional_lvalue_ref()
+{
+#ifndef BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES
+ BOOST_STATIC_ASSERT_MSG(
+ !boost::is_lvalue_reference<To>::value || !boost::is_rvalue_reference<From>::value,
+ "binding rvalue references to optional lvalue references is disallowed");
+#endif
+}
+
struct optional_tag {} ;
template<class T>
typedef BOOST_DEDUCED_TYPENAME mpl::if_<is_reference_predicate,types_when_ref,types_when_not_ref>::type types ;
protected:
- typedef bool (this_type::*unspecified_bool_type)() const;
-
typedef BOOST_DEDUCED_TYPENAME types::reference_type reference_type ;
typedef BOOST_DEDUCED_TYPENAME types::reference_const_type reference_const_type ;
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ typedef BOOST_DEDUCED_TYPENAME types::rval_reference_type rval_reference_type ;
+ typedef BOOST_DEDUCED_TYPENAME types::reference_type_of_temporary_wrapper reference_type_of_temporary_wrapper ;
+#endif
typedef BOOST_DEDUCED_TYPENAME types::pointer_type pointer_type ;
typedef BOOST_DEDUCED_TYPENAME types::pointer_const_type pointer_const_type ;
typedef BOOST_DEDUCED_TYPENAME types::argument_type argument_type ;
construct(val);
}
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // move-construct an optional<T> initialized from an rvalue-ref to 'val'.
+ // Can throw if T::T(T&&) does
+ optional_base ( rval_reference_type val )
+ :
+ m_initialized(false)
+ {
+ construct( boost::move(val) );
+ }
+#endif
+
// Creates an optional<T> initialized with 'val' IFF cond is true, otherwise creates an uninitialzed optional<T>.
// Can throw if T::T(T const&) does
optional_base ( bool cond, argument_type val )
construct(rhs.get_impl());
}
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Creates a deep move of another optional<T>
+ // Can throw if T::T(T&&) does
+ optional_base ( optional_base&& rhs )
+ :
+ m_initialized(false)
+ {
+ if ( rhs.is_initialized() )
+ construct( boost::move(rhs.get_impl()) );
+ }
+#endif
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+
+ template<class Expr, class PtrExpr>
+ explicit optional_base ( Expr&& expr, PtrExpr const* tag )
+ :
+ m_initialized(false)
+ {
+ construct(boost::forward<Expr>(expr),tag);
+ }
+#else
// This is used for both converting and in-place constructions.
// Derived classes use the 'tag' to select the appropriate
// implementation (the correct 'construct()' overload)
construct(expr,tag);
}
+#endif
// No-throw (assuming T::~T() doesn't)
construct(rhs.get_impl());
}
}
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Assigns from another optional<T> (deep-moves the rhs value)
+ void assign ( optional_base&& rhs )
+ {
+ if (is_initialized())
+ {
+ if ( rhs.is_initialized() )
+ assign_value(boost::move(rhs.get_impl()), is_reference_predicate() );
+ else destroy();
+ }
+ else
+ {
+ if ( rhs.is_initialized() )
+ construct(boost::move(rhs.get_impl()));
+ }
+ }
+#endif
// Assigns from another _convertible_ optional<U> (deep-copies the rhs value)
template<class U>
if (is_initialized())
{
if ( rhs.is_initialized() )
- assign_value(static_cast<value_type>(rhs.get()), is_reference_predicate() );
+#ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES
+ assign_value(rhs.get(), is_reference_predicate() );
+#else
+ assign_value(static_cast<value_type>(rhs.get()), is_reference_predicate() );
+#endif
+
else destroy();
}
else
{
if ( rhs.is_initialized() )
+#ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES
+ construct(rhs.get());
+#else
construct(static_cast<value_type>(rhs.get()));
+#endif
}
}
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // move-assigns from another _convertible_ optional<U> (deep-moves from the rhs value)
+ template<class U>
+ void assign ( optional<U>&& rhs )
+ {
+ typedef BOOST_DEDUCED_TYPENAME optional<U>::rval_reference_type ref_type;
+ if (is_initialized())
+ {
+ if ( rhs.is_initialized() )
+ assign_value(static_cast<ref_type>(rhs.get()), is_reference_predicate() );
+ else destroy();
+ }
+ else
+ {
+ if ( rhs.is_initialized() )
+ construct(static_cast<ref_type>(rhs.get()));
+ }
+ }
+#endif
+
// Assigns from a T (deep-copies the rhs value)
void assign ( argument_type val )
{
assign_value(val, is_reference_predicate() );
else construct(val);
}
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Assigns from a T (deep-moves the rhs value)
+ void assign ( rval_reference_type val )
+ {
+ if (is_initialized())
+ assign_value( boost::move(val), is_reference_predicate() );
+ else construct( boost::move(val) );
+ }
+#endif
// Assigns from "none", destroying the current value, if any, leaving this UNINITIALIZED
// No-throw (assuming T::~T() doesn't)
- void assign ( none_t ) { destroy(); }
+ void assign ( none_t ) BOOST_NOEXCEPT { destroy(); }
#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ template<class Expr, class ExprPtr>
+ void assign_expr ( Expr&& expr, ExprPtr const* tag )
+ {
+ if (is_initialized())
+ assign_expr_to_initialized(boost::forward<Expr>(expr),tag);
+ else construct(boost::forward<Expr>(expr),tag);
+ }
+#else
template<class Expr>
void assign_expr ( Expr const& expr, Expr const* tag )
- {
- if (is_initialized())
- assign_expr_to_initialized(expr,tag);
- else construct(expr,tag);
- }
+ {
+ if (is_initialized())
+ assign_expr_to_initialized(expr,tag);
+ else construct(expr,tag);
+ }
+#endif
+
#endif
public :
- // Destroys the current value, if any, leaving this UNINITIALIZED
+ // **DEPPRECATED** Destroys the current value, if any, leaving this UNINITIALIZED
// No-throw (assuming T::~T() doesn't)
- void reset() { destroy(); }
+ void reset() BOOST_NOEXCEPT { destroy(); }
- // Replaces the current value -if any- with 'val'
+ // **DEPPRECATED** Replaces the current value -if any- with 'val'
void reset ( argument_type val ) { assign(val); }
// Returns a pointer to the value if this is initialized, otherwise,
void construct ( argument_type val )
{
- new (m_storage.address()) internal_type(val) ;
+ ::new (m_storage.address()) internal_type(val) ;
+ m_initialized = true ;
+ }
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ void construct ( rval_reference_type val )
+ {
+ ::new (m_storage.address()) internal_type( types::move(val) ) ;
m_initialized = true ;
}
+#endif
+
+
+#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ // Constructs in-place
+ // upon exception *this is always uninitialized
+ template<class... Args>
+ void emplace_assign ( Args&&... args )
+ {
+ destroy();
+ ::new (m_storage.address()) internal_type( boost::forward<Args>(args)... );
+ m_initialized = true ;
+ }
+#elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
+ template<class Arg>
+ void emplace_assign ( Arg&& arg )
+ {
+ destroy();
+ ::new (m_storage.address()) internal_type( boost::forward<Arg>(arg) );
+ m_initialized = true ;
+ }
+#else
+ template<class Arg>
+ void emplace_assign ( const Arg& arg )
+ {
+ destroy();
+ ::new (m_storage.address()) internal_type( arg );
+ m_initialized = true ;
+ }
+
+ template<class Arg>
+ void emplace_assign ( Arg& arg )
+ {
+ destroy();
+ ::new (m_storage.address()) internal_type( arg );
+ m_initialized = true ;
+ }
+#endif
#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Constructs in-place using the given factory
+ template<class Expr>
+ void construct ( Expr&& factory, in_place_factory_base const* )
+ {
+ BOOST_STATIC_ASSERT ( ::boost::mpl::not_<is_reference_predicate>::value ) ;
+ boost_optional_detail::construct<value_type>(factory, m_storage.address());
+ m_initialized = true ;
+ }
+
+ // Constructs in-place using the given typed factory
+ template<class Expr>
+ void construct ( Expr&& factory, typed_in_place_factory_base const* )
+ {
+ BOOST_STATIC_ASSERT ( ::boost::mpl::not_<is_reference_predicate>::value ) ;
+ factory.apply(m_storage.address()) ;
+ m_initialized = true ;
+ }
+
+ template<class Expr>
+ void assign_expr_to_initialized ( Expr&& factory, in_place_factory_base const* tag )
+ {
+ destroy();
+ construct(factory,tag);
+ }
+
+ // Constructs in-place using the given typed factory
+ template<class Expr>
+ void assign_expr_to_initialized ( Expr&& factory, typed_in_place_factory_base const* tag )
+ {
+ destroy();
+ construct(factory,tag);
+ }
+
+#else
// Constructs in-place using the given factory
template<class Expr>
void construct ( Expr const& factory, in_place_factory_base const* )
}
#endif
- // Constructs using any expression implicitely convertible to the single argument
+#endif
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Constructs using any expression implicitly convertible to the single argument
+ // of a one-argument T constructor.
+ // Converting constructions of optional<T> from optional<U> uses this function with
+ // 'Expr' being of type 'U' and relying on a converting constructor of T from U.
+ template<class Expr>
+ void construct ( Expr&& expr, void const* )
+ {
+ new (m_storage.address()) internal_type(boost::forward<Expr>(expr)) ;
+ m_initialized = true ;
+ }
+
+ // Assigns using a form any expression implicitly convertible to the single argument
+ // of a T's assignment operator.
+ // Converting assignments of optional<T> from optional<U> uses this function with
+ // 'Expr' being of type 'U' and relying on a converting assignment of T from U.
+ template<class Expr>
+ void assign_expr_to_initialized ( Expr&& expr, void const* )
+ {
+ assign_value(boost::forward<Expr>(expr), is_reference_predicate());
+ }
+#else
+ // Constructs using any expression implicitly convertible to the single argument
// of a one-argument T constructor.
// Converting constructions of optional<T> from optional<U> uses this function with
// 'Expr' being of type 'U' and relying on a converting constructor of T from U.
m_initialized = true ;
}
- // Assigns using a form any expression implicitely convertible to the single argument
+ // Assigns using a form any expression implicitly convertible to the single argument
// of a T's assignment operator.
// Converting assignments of optional<T> from optional<U> uses this function with
// 'Expr' being of type 'U' and relying on a converting assignment of T from U.
assign_value(expr, is_reference_predicate());
}
+#endif
+
#ifdef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
// BCB5.64 (and probably lower versions) workaround.
// The in-place factories are supported by means of catch-all constructors
// For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error
// instead of choosing the wrong overload
//
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Notice that 'Expr' will be optional<T> or optional<U> (but not optional_base<..>)
+ template<class Expr>
+ void construct ( Expr&& expr, optional_tag const* )
+ {
+ if ( expr.is_initialized() )
+ {
+ // An exception can be thrown here.
+ // It it happens, THIS will be left uninitialized.
+ new (m_storage.address()) internal_type(types::move(expr.get())) ;
+ m_initialized = true ;
+ }
+ }
+#else
// Notice that 'Expr' will be optional<T> or optional<U> (but not optional_base<..>)
template<class Expr>
void construct ( Expr const& expr, optional_tag const* )
}
}
#endif
+#endif // defined BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
void assign_value ( argument_type val, is_not_reference_tag ) { get_impl() = val; }
void assign_value ( argument_type val, is_reference_tag ) { construct(val); }
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ void assign_value ( rval_reference_type val, is_not_reference_tag ) { get_impl() = static_cast<rval_reference_type>(val); }
+ void assign_value ( rval_reference_type val, is_reference_tag ) { construct( static_cast<rval_reference_type>(val) ); }
+#endif
void destroy()
{
destroy_impl(is_reference_predicate()) ;
}
- unspecified_bool_type safe_bool() const { return m_initialized ? &this_type::is_initialized : 0 ; }
-
reference_const_type get_impl() const { return dereference(get_object(), is_reference_predicate() ) ; }
reference_type get_impl() { return dereference(get_object(), is_reference_predicate() ) ; }
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->internal_type::~internal_type() ; m_initialized = false ; }
#else
- void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->T::~T() ; m_initialized = false ; }
+ void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->~T() ; m_initialized = false ; }
#endif
void destroy_impl ( is_reference_tag ) { m_initialized = false ; }
{
typedef optional_detail::optional_base<T> base ;
- typedef BOOST_DEDUCED_TYPENAME base::unspecified_bool_type unspecified_bool_type ;
-
public :
typedef optional<T> this_type ;
typedef BOOST_DEDUCED_TYPENAME base::value_type value_type ;
typedef BOOST_DEDUCED_TYPENAME base::reference_type reference_type ;
typedef BOOST_DEDUCED_TYPENAME base::reference_const_type reference_const_type ;
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ typedef BOOST_DEDUCED_TYPENAME base::rval_reference_type rval_reference_type ;
+ typedef BOOST_DEDUCED_TYPENAME base::reference_type_of_temporary_wrapper reference_type_of_temporary_wrapper ;
+#endif
typedef BOOST_DEDUCED_TYPENAME base::pointer_type pointer_type ;
typedef BOOST_DEDUCED_TYPENAME base::pointer_const_type pointer_const_type ;
typedef BOOST_DEDUCED_TYPENAME base::argument_type argument_type ;
// Creates an optional<T> uninitialized.
// No-throw
- optional() : base() {}
+ optional() BOOST_NOEXCEPT : base() {}
// Creates an optional<T> uninitialized.
// No-throw
- optional( none_t none_ ) : base(none_) {}
+ optional( none_t none_ ) BOOST_NOEXCEPT : base(none_) {}
// Creates an optional<T> initialized with 'val'.
// Can throw if T::T(T const&) does
optional ( argument_type val ) : base(val) {}
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Creates an optional<T> initialized with 'move(val)'.
+ // Can throw if T::T(T &&) does
+ optional ( rval_reference_type val ) : base( boost::forward<T>(val) )
+ {optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref<T, rval_reference_type>();}
+#endif
+
// Creates an optional<T> initialized with 'val' IFF cond is true, otherwise creates an uninitialized optional.
// Can throw if T::T(T const&) does
optional ( bool cond, argument_type val ) : base(cond,val) {}
-#ifndef BOOST_OPTIONAL_NO_CONVERTING_COPY_CTOR
// NOTE: MSVC needs templated versions first
// Creates a deep copy of another convertible optional<U>
if ( rhs.is_initialized() )
this->construct(rhs.get());
}
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Creates a deep move of another convertible optional<U>
+ // Requires a valid conversion from U to T.
+ // Can throw if T::T(U&&) does
+ template<class U>
+ explicit optional ( optional<U> && rhs )
+ :
+ base()
+ {
+ if ( rhs.is_initialized() )
+ this->construct( boost::move(rhs.get()) );
+ }
#endif
#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
// Creates an optional<T> with an expression which can be either
// (a) An instance of InPlaceFactory (i.e. in_place(a,b,...,n);
// (b) An instance of TypedInPlaceFactory ( i.e. in_place<T>(a,b,...,n);
- // (c) Any expression implicitely convertible to the single type
+ // (c) Any expression implicitly convertible to the single type
// of a one-argument T's constructor.
// (d*) Weak compilers (BCB) might also resolved Expr as optional<T> and optional<U>
// even though explicit overloads are present for these.
// Depending on the above some T ctor is called.
- // Can throw is the resolved T ctor throws.
+ // Can throw if the resolved T ctor throws.
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+
+
+ template<class Expr>
+ explicit optional ( Expr&& expr,
+ BOOST_DEDUCED_TYPENAME boost::disable_if_c<
+ (boost::is_base_of<optional_detail::optional_tag, BOOST_DEDUCED_TYPENAME boost::decay<Expr>::type>::value) ||
+ boost::is_same<BOOST_DEDUCED_TYPENAME boost::decay<Expr>::type, none_t>::value >::type* = 0
+ )
+ : base(boost::forward<Expr>(expr),boost::addressof(expr))
+ {optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref<T, Expr&&>();}
+
+#else
template<class Expr>
explicit optional ( Expr const& expr ) : base(expr,boost::addressof(expr)) {}
-#endif
+#endif // !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+#endif // !defined BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
// Creates a deep copy of another optional<T>
// Can throw if T::T(T const&) does
optional ( optional const& rhs ) : base( static_cast<base const&>(rhs) ) {}
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Creates a deep move of another optional<T>
+ // Can throw if T::T(T&&) does
+ optional ( optional && rhs )
+ BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value)
+ : base( boost::move(rhs) )
+ {}
+
+#endif
// No-throw (assuming T::~T() doesn't)
~optional() {}
#if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION)
// Assigns from an expression. See corresponding constructor.
// Basic Guarantee: If the resolved T ctor throws, this is left UNINITIALIZED
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+
+ template<class Expr>
+ BOOST_DEDUCED_TYPENAME boost::disable_if_c<
+ boost::is_base_of<optional_detail::optional_tag, BOOST_DEDUCED_TYPENAME boost::decay<Expr>::type>::value ||
+ boost::is_same<BOOST_DEDUCED_TYPENAME boost::decay<Expr>::type, none_t>::value,
+ optional&
+ >::type
+ operator= ( Expr&& expr )
+ {
+ optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref<T, Expr&&>();
+ this->assign_expr(boost::forward<Expr>(expr),boost::addressof(expr));
+ return *this ;
+ }
+
+#else
template<class Expr>
optional& operator= ( Expr const& expr )
{
this->assign_expr(expr,boost::addressof(expr));
return *this ;
}
-#endif
+#endif // !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+#endif // !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION)
-
-#ifndef BOOST_OPTIONAL_NO_CONVERTING_ASSIGNMENT
- // Assigns from another convertible optional<U> (converts && deep-copies the rhs value)
+ // Copy-assigns from another convertible optional<U> (converts && deep-copies the rhs value)
// Requires a valid conversion from U to T.
// Basic Guarantee: If T::T( U const& ) throws, this is left UNINITIALIZED
template<class U>
this->assign(rhs);
return *this ;
}
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Move-assigns from another convertible optional<U> (converts && deep-moves the rhs value)
+ // Requires a valid conversion from U to T.
+ // Basic Guarantee: If T::T( U && ) throws, this is left UNINITIALIZED
+ template<class U>
+ optional& operator= ( optional<U> && rhs )
+ {
+ this->assign(boost::move(rhs));
+ return *this ;
+ }
#endif
// Assigns from another optional<T> (deep-copies the rhs value)
return *this ;
}
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Assigns from another optional<T> (deep-moves the rhs value)
+ optional& operator= ( optional && rhs )
+ BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
+ {
+ this->assign( static_cast<base &&>(rhs) ) ;
+ return *this ;
+ }
+#endif
+
// Assigns from a T (deep-copies the rhs value)
// Basic Guarantee: If T::( T const& ) throws, this is left UNINITIALIZED
optional& operator= ( argument_type val )
return *this ;
}
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ // Assigns from a T (deep-moves the rhs value)
+ optional& operator= ( rval_reference_type val )
+ {
+ optional_detail::prevent_binding_rvalue_ref_to_optional_lvalue_ref<T, rval_reference_type>();
+ this->assign( boost::move(val) ) ;
+ return *this ;
+ }
+#endif
+
// Assigns from a "none"
// Which destroys the current value, if any, leaving this UNINITIALIZED
// No-throw (assuming T::~T() doesn't)
- optional& operator= ( none_t none_ )
+ optional& operator= ( none_t none_ ) BOOST_NOEXCEPT
{
this->assign( none_ ) ;
return *this ;
}
+
+#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ // Constructs in-place
+ // upon exception *this is always uninitialized
+ template<class... Args>
+ void emplace ( Args&&... args )
+ {
+ this->emplace_assign( boost::forward<Args>(args)... );
+ }
+#elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
+ template<class Arg>
+ void emplace ( Arg&& arg )
+ {
+ this->emplace_assign( boost::forward<Arg>(arg) );
+ }
+#else
+ template<class Arg>
+ void emplace ( const Arg& arg )
+ {
+ this->emplace_assign( arg );
+ }
+
+ template<class Arg>
+ void emplace ( Arg& arg )
+ {
+ this->emplace_assign( arg );
+ }
+#endif
void swap( optional & arg )
+ BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
{
// allow for Koenig lookup
- using boost::swap;
- swap(*this, arg);
+ boost::swap(*this, arg);
}
// Returns a reference to the value if this is initialized, otherwise,
// the behaviour is UNDEFINED
// No-throw
+#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
+ reference_const_type operator *() const& { return this->get() ; }
+ reference_type operator *() & { return this->get() ; }
+ reference_type_of_temporary_wrapper operator *() && { return base::types::move(this->get()) ; }
+#else
reference_const_type operator *() const { return this->get() ; }
reference_type operator *() { return this->get() ; }
+#endif // !defined BOOST_NO_CXX11_REF_QUALIFIERS
+
+#if (!defined BOOST_NO_CXX11_REF_QUALIFIERS) && (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
+ reference_const_type value() const&
+ {
+ if (this->is_initialized())
+ return this->get() ;
+ else
+ throw_exception(bad_optional_access());
+ }
+
+ reference_type value() &
+ {
+ if (this->is_initialized())
+ return this->get() ;
+ else
+ throw_exception(bad_optional_access());
+ }
+
+ reference_type_of_temporary_wrapper value() &&
+ {
+ if (this->is_initialized())
+ return base::types::move(this->get()) ;
+ else
+ throw_exception(bad_optional_access());
+ }
- // implicit conversion to "bool"
- // No-throw
- operator unspecified_bool_type() const { return this->safe_bool() ; }
+#else
+ reference_const_type value() const
+ {
+ if (this->is_initialized())
+ return this->get() ;
+ else
+ throw_exception(bad_optional_access());
+ }
+
+ reference_type value()
+ {
+ if (this->is_initialized())
+ return this->get() ;
+ else
+ throw_exception(bad_optional_access());
+ }
+#endif
- // This is provided for those compilers which don't like the conversion to bool
- // on some contexts.
- bool operator!() const { return !this->is_initialized() ; }
+
+#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
+ template <class U>
+ value_type value_or ( U&& v ) const&
+ {
+ if (this->is_initialized())
+ return get();
+ else
+ return boost::forward<U>(v);
+ }
+
+ template <class U>
+ value_type value_or ( U&& v ) &&
+ {
+ if (this->is_initialized())
+ return base::types::move(get());
+ else
+ return boost::forward<U>(v);
+ }
+#elif !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+ template <class U>
+ value_type value_or ( U&& v ) const
+ {
+ if (this->is_initialized())
+ return get();
+ else
+ return boost::forward<U>(v);
+ }
+#else
+ template <class U>
+ value_type value_or ( U const& v ) const
+ {
+ if (this->is_initialized())
+ return get();
+ else
+ return v;
+ }
+
+ template <class U>
+ value_type value_or ( U& v ) const
+ {
+ if (this->is_initialized())
+ return get();
+ else
+ return v;
+ }
+#endif
+
+
+#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
+ template <typename F>
+ value_type value_or_eval ( F f ) const&
+ {
+ if (this->is_initialized())
+ return get();
+ else
+ return f();
+ }
+
+ template <typename F>
+ value_type value_or_eval ( F f ) &&
+ {
+ if (this->is_initialized())
+ return base::types::move(get());
+ else
+ return f();
+ }
+#else
+ template <typename F>
+ value_type value_or_eval ( F f ) const
+ {
+ if (this->is_initialized())
+ return get();
+ else
+ return f();
+ }
+#endif
+
+ bool operator!() const BOOST_NOEXCEPT { return !this->is_initialized() ; }
+
+ BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
+} ;
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+template<class T>
+class optional<T&&>
+{
+ BOOST_STATIC_ASSERT_MSG(sizeof(T) == 0, "Optional rvalue references are illegal.");
} ;
+#endif
// Returns optional<T>(v)
template<class T>
return opt.get_ptr() ;
}
+// The following declaration prevents a bug where operator safe-bool is used upon streaming optional object if you forget the IO header.
+template<class CharType, class CharTrait>
+std::basic_ostream<CharType, CharTrait>&
+operator<<(std::basic_ostream<CharType, CharTrait>& out, optional_detail::optional_tag const& v)
+{
+ BOOST_STATIC_ASSERT_MSG(sizeof(CharType) == 0, "If you want to output boost::optional, include header <boost/optional/optional_io.hpp>");
+}
+
// optional's relational operators ( ==, !=, <, >, <=, >= ) have deep-semantics (compare values).
// WARNING: This is UNLIKE pointers. Use equal_pointees()/less_pointess() in generic code instead.
template<class T>
inline
-bool operator == ( optional<T> const& x, none_t )
-{ return equal_pointees(x, optional<T>() ); }
+bool operator == ( optional<T> const& x, none_t ) BOOST_NOEXCEPT
+{ return !x; }
template<class T>
inline
template<class T>
inline
-bool operator != ( optional<T> const& x, none_t y )
-{ return !( x == y ) ; }
+bool operator != ( optional<T> const& x, none_t ) BOOST_NOEXCEPT
+{ return bool(x); }
template<class T>
inline
template<class T>
inline
-bool operator == ( none_t , optional<T> const& y )
-{ return equal_pointees(optional<T>() ,y); }
+bool operator == ( none_t , optional<T> const& y ) BOOST_NOEXCEPT
+{ return !y; }
template<class T>
inline
template<class T>
inline
-bool operator != ( none_t x, optional<T> const& y )
-{ return !( x == y ) ; }
+bool operator != ( none_t, optional<T> const& y ) BOOST_NOEXCEPT
+{ return bool(y); }
template<class T>
inline
}
};
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+template<>
+struct swap_selector<false>
+{
+ template<class T>
+ static void optional_swap ( optional<T>& x, optional<T>& y )
+ //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && BOOST_NOEXCEPT_EXPR(boost::swap(*x, *y)))
+ {
+ if(x)
+ {
+ if (y)
+ {
+ boost::swap(*x, *y);
+ }
+ else
+ {
+ y = boost::move(*x);
+ x = boost::none;
+ }
+ }
+ else
+ {
+ if (y)
+ {
+ x = boost::move(*y);
+ y = boost::none;
+ }
+ }
+ }
+};
+#else
template<>
struct swap_selector<false>
{
}
}
};
+#endif // !defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
} // namespace optional_detail
struct optional_swap_should_use_default_constructor : has_nothrow_default_constructor<T> {} ;
template<class T> inline void swap ( optional<T>& x, optional<T>& y )
+ //BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && BOOST_NOEXCEPT_EXPR(boost::swap(*x, *y)))
{
optional_detail::swap_selector<optional_swap_should_use_default_constructor<T>::value>::optional_swap(x, y);
}
//
// Revisions:
// 10 May 2008 (added swap related forward declaration) Niels Dekker
-//
+//
#ifndef BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP
#define BOOST_OPTIONAL_OPTIONAL_FWD_FLC_19NOV2002_HPP
+
namespace boost {
template<class T> class optional ;
-template<class T> void swap ( optional<T>& , optional<T>& ) ;
+template<class T> void swap ( optional<T>& , optional<T>& );
template<class T> struct optional_swap_should_use_default_constructor ;
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_H
+#define BOOST_PREDEF_H
+
+#include <boost/predef/language.h>
+#include <boost/predef/architecture.h>
+#include <boost/predef/compiler.h>
+#include <boost/predef/library.h>
+#include <boost/predef/os.h>
+#include <boost/predef/other.h>
+#include <boost/predef/platform.h>
+
+#endif
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
+Copyright Franz Detro 2014
+Copyright (c) Microsoft Corporation 2014
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)
[[__predef_symbol__] [__predef_version__]]
[[`__arm__`] [__predef_detection__]]
+ [[`__arm64`] [__predef_detection__]]
[[`__thumb__`] [__predef_detection__]]
[[`__TARGET_ARCH_ARM`] [__predef_detection__]]
[[`__TARGET_ARCH_THUMB`] [__predef_detection__]]
+ [[`_M_ARM`] [__predef_detection__]]
+ [[`__arm64`] [8.0.0]]
[[`__TARGET_ARCH_ARM`] [V.0.0]]
[[`__TARGET_ARCH_THUMB`] [V.0.0]]
+ [[`_M_ARM`] [V.0.0]]
]
*/
#define BOOST_ARCH_ARM BOOST_VERSION_NUMBER_NOT_AVAILABLE
-#if defined(__arm__) || defined(__thumb__) || \
- defined(__TARGET_ARCH_ARM) || defined(__TARGET_ARCH_THUMB)
+#if defined(__arm__) || defined(__arm64) || defined(__thumb__) || \
+ defined(__TARGET_ARCH_ARM) || defined(__TARGET_ARCH_THUMB) || \
+ defined(_M_ARM)
# undef BOOST_ARCH_ARM
+# if !defined(BOOST_ARCH_ARM) && defined(__arm64)
+# define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(8,0,0)
+# endif
# if !defined(BOOST_ARCH_ARM) && defined(__TARGET_ARCH_ARM)
# define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(__TARGET_ARCH_ARM,0,0)
# endif
# if !defined(BOOST_ARCH_ARM) && defined(__TARGET_ARCH_THUMB)
# define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(__TARGET_ARCH_THUMB,0,0)
# endif
+# if !defined(BOOST_ARCH_ARM) && defined(_M_ARM)
+# define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(_M_ARM,0,0)
+# endif
# if !defined(BOOST_ARCH_ARM)
# define BOOST_ARCH_ARM BOOST_VERSION_NUMBER_AVAILABLE
# endif
/*
-Copyright Redshift Software Inc 2013
+Copyright Rene Rivera 2013
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)
/*
-Copyright Redshift Software Inc 2011-2013
+Copyright Rene Rivera 2011-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software Inc 2011-2013
+Copyright Rene Rivera 2011-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2014
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_ARCH_SPARC) && defined(__sparcv9)
# define BOOST_ARCH_SPARC BOOST_VERSION_NUMBER(9,0,0)
# endif
-# if !defined(BOOST_ARCH_SPARC) && defined(__sparcv8)
+# if !defined(BOOST_ARCH_SPARC) && defined(__sparcv8)
# define BOOST_ARCH_SPARC BOOST_VERSION_NUMBER(8,0,0)
# endif
# if !defined(BOOST_ARCH_SPARC)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_H
+#define BOOST_PREDEF_COMPILER_H
+
+#include <boost/predef/compiler/borland.h>
+#include <boost/predef/compiler/clang.h>
+#include <boost/predef/compiler/comeau.h>
+#include <boost/predef/compiler/compaq.h>
+#include <boost/predef/compiler/diab.h>
+#include <boost/predef/compiler/digitalmars.h>
+#include <boost/predef/compiler/dignus.h>
+#include <boost/predef/compiler/edg.h>
+#include <boost/predef/compiler/ekopath.h>
+#include <boost/predef/compiler/gcc_xml.h>
+#include <boost/predef/compiler/gcc.h>
+#include <boost/predef/compiler/greenhills.h>
+#include <boost/predef/compiler/hp_acc.h>
+#include <boost/predef/compiler/iar.h>
+#include <boost/predef/compiler/ibm.h>
+#include <boost/predef/compiler/intel.h>
+#include <boost/predef/compiler/kai.h>
+#include <boost/predef/compiler/llvm.h>
+#include <boost/predef/compiler/metaware.h>
+#include <boost/predef/compiler/metrowerks.h>
+#include <boost/predef/compiler/microtec.h>
+#include <boost/predef/compiler/mpw.h>
+#include <boost/predef/compiler/palm.h>
+#include <boost/predef/compiler/pgi.h>
+#include <boost/predef/compiler/sgi_mipspro.h>
+#include <boost/predef/compiler/sunpro.h>
+#include <boost/predef/compiler/tendra.h>
+#include <boost/predef/compiler/visualc.h>
+#include <boost/predef/compiler/watcom.h>
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_BORLAND_H
+#define BOOST_PREDEF_COMPILER_BORLAND_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_BORLAND`]
+
+[@http://en.wikipedia.org/wiki/C_plus_plus_builder Borland C++] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__BORLANDC__`] [__predef_detection__]]
+ [[`__CODEGEARC__`] [__predef_detection__]]
+
+ [[`__BORLANDC__`] [V.R.P]]
+ [[`__CODEGEARC__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_BORLAND BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__BORLANDC__) || defined(__CODEGEARC__)
+# if !defined(BOOST_COMP_BORLAND_DETECTION) && (defined(__CODEGEARC__))
+# define BOOST_COMP_BORLAND_DETECTION BOOST_PREDEF_MAKE_0X_VVRP(__CODEGEARC__)
+# endif
+# if !defined(BOOST_COMP_BORLAND_DETECTION)
+# define BOOST_COMP_BORLAND_DETECTION BOOST_PREDEF_MAKE_0X_VVRP(__BORLANDC__)
+# endif
+#endif
+
+#ifdef BOOST_COMP_BORLAND_DETECTION
+# define BOOST_COMP_BORLAND_AVAILABLE
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_BORLAND_EMULATED BOOST_COMP_BORLAND_DETECTION
+# else
+# undef BOOST_COMP_BORLAND
+# define BOOST_COMP_BORLAND BOOST_COMP_BORLAND_DETECTION
+# endif
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_BORLAND_NAME "Borland C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_BORLAND,BOOST_COMP_BORLAND_NAME)
+
+#ifdef BOOST_COMP_BORLAND_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_BORLAND_EMULATED,BOOST_COMP_BORLAND_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_CLANG_H
+#define BOOST_PREDEF_COMPILER_CLANG_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_CLANG`]
+
+[@http://en.wikipedia.org/wiki/Clang Clang] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__clang__`] [__predef_detection__]]
+
+ [[`__clang_major__`, `__clang_minor__`, `__clang_patchlevel__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_CLANG BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__clang__)
+# define BOOST_COMP_CLANG_DETECTION BOOST_VERSION_NUMBER(__clang_major__,__clang_minor__,__clang_patchlevel__)
+#endif
+
+#ifdef BOOST_COMP_CLANG_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_CLANG_EMULATED BOOST_COMP_CLANG_DETECTION
+# else
+# undef BOOST_COMP_CLANG
+# define BOOST_COMP_CLANG BOOST_COMP_CLANG_DETECTION
+# endif
+# define BOOST_COMP_CLANG_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_CLANG_NAME "Clang"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_CLANG,BOOST_COMP_CLANG_NAME)
+
+#ifdef BOOST_COMP_CLANG_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_CLANG_EMULATED,BOOST_COMP_CLANG_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_COMEAU_H
+#define BOOST_PREDEF_COMPILER_COMEAU_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+#define BOOST_COMP_COMO BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+/*`
+[heading `BOOST_COMP_COMO`]
+
+[@http://en.wikipedia.org/wiki/Comeau_C/C%2B%2B Comeau C++] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__COMO__`] [__predef_detection__]]
+
+ [[`__COMO_VERSION__`] [V.R.P]]
+ ]
+ */
+
+#if defined(__COMO__)
+# if !defined(BOOST_COMP_COMO_DETECTION) && defined(__CONO_VERSION__)
+# define BOOST_COMP_COMO_DETECTION BOOST_PREDEF_MAKE_0X_VRP(__COMO_VERSION__)
+# endif
+# if !defined(BOOST_COMP_COMO_DETECTION)
+# define BOOST_COMP_COMO_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#ifdef BOOST_COMP_COMO_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_COMO_EMULATED BOOST_COMP_COMO_DETECTION
+# else
+# undef BOOST_COMP_COMO
+# define BOOST_COMP_COMO BOOST_COMP_COMO_DETECTION
+# endif
+# define BOOST_COMP_COMO_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_COMO_NAME "Comeau C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_COMO,BOOST_COMP_COMO_NAME)
+
+#ifdef BOOST_COMP_COMO_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_COMO_EMULATED,BOOST_COMP_COMO_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_COMPAQ_H
+#define BOOST_PREDEF_COMPILER_COMPAQ_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_DEC`]
+
+[@http://www.openvms.compaq.com/openvms/brochures/deccplus/ Compaq C/C++] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__DECCXX`] [__predef_detection__]]
+ [[`__DECC`] [__predef_detection__]]
+
+ [[`__DECCXX_VER`] [V.R.P]]
+ [[`__DECC_VER`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_DEC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__DECC) || defined(__DECCXX)
+# if !defined(BOOST_COMP_DEC_DETECTION) && defined(__DECCXX_VER)
+# define BOOST_COMP_DEC_DETECTION BOOST_PREDEF_MAKE_10_VVRR0PP00(__DECCXX_VER)
+# endif
+# if !defined(BOOST_COMP_DEC_DETECTION) && defined(__DECC_VER)
+# define BOOST_COMP_DEC_DETECTION BOOST_PREDEF_MAKE_10_VVRR0PP00(__DECC_VER)
+# endif
+# if !defined(BOOST_COMP_DEC_DETECTION)
+# define BOOST_COM_DEC_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#ifdef BOOST_COMP_DEC_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_DEC_EMULATED BOOST_COMP_DEC_DETECTION
+# else
+# undef BOOST_COMP_DEC
+# define BOOST_COMP_DEC BOOST_COMP_DEC_DETECTION
+# endif
+# define BOOST_COMP_DEC_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_DEC_NAME "Compaq C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DEC,BOOST_COMP_DEC_NAME)
+
+#ifdef BOOST_COMP_DEC_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DEC_EMULATED,BOOST_COMP_DEC_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_DIAB_H
+#define BOOST_PREDEF_COMPILER_DIAB_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_DIAB`]
+
+[@http://www.windriver.com/products/development_suite/wind_river_compiler/ Diab C/C++] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__DCC__`] [__predef_detection__]]
+
+ [[`__VERSION_NUMBER__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_DIAB BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__DCC__)
+# define BOOST_COMP_DIAB_DETECTION BOOST_PREDEF_MAKE_10_VRPP(__VERSION_NUMBER__)
+#endif
+
+#ifdef BOOST_COMP_DIAB_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_DIAB_EMULATED BOOST_COMP_DIAB_DETECTION
+# else
+# undef BOOST_COMP_DIAB
+# define BOOST_COMP_DIAB BOOST_COMP_DIAB_DETECTION
+# endif
+# define BOOST_COMP_DIAB_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_DIAB_NAME "Diab C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DIAB,BOOST_COMP_DIAB_NAME)
+
+#ifdef BOOST_COMP_DIAB_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DIAB_EMULATED,BOOST_COMP_DIAB_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_DIGITALMARS_H
+#define BOOST_PREDEF_COMPILER_DIGITALMARS_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_DMC`]
+
+[@http://en.wikipedia.org/wiki/Digital_Mars Digital Mars] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__DMC__`] [__predef_detection__]]
+
+ [[`__DMC__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_DMC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__DMC__)
+# define BOOST_COMP_DMC_DETECTION BOOST_PREDEF_MAKE_0X_VRP(__DMC__)
+#endif
+
+#ifdef BOOST_COMP_DMC_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_DMC_EMULATED BOOST_COMP_DMC_DETECTION
+# else
+# undef BOOST_COMP_DMC
+# define BOOST_COMP_DMC BOOST_COMP_DMC_DETECTION
+# endif
+# define BOOST_COMP_DMC_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_DMC_NAME "Digital Mars"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DMC,BOOST_COMP_DMC_NAME)
+
+#ifdef BOOST_COMP_DMC_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_DMC_EMULATED,BOOST_COMP_DMC_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_DIGNUS_H
+#define BOOST_PREDEF_COMPILER_DIGNUS_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_SYSC`]
+
+[@http://www.dignus.com/dcxx/ Dignus Systems/C++] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__SYSC__`] [__predef_detection__]]
+
+ [[`__SYSC_VER__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_SYSC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__SYSC__)
+# define BOOST_COMP_SYSC_DETECTION BOOST_PREDEF_MAKE_10_VRRPP(__SYSC_VER__)
+#endif
+
+#ifdef BOOST_COMP_SYSC_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_SYSC_EMULATED BOOST_COMP_SYSC_DETECTION
+# else
+# undef BOOST_COMP_SYSC
+# define BOOST_COMP_SYSC BOOST_COMP_SYSC_DETECTION
+# endif
+# define BOOST_COMP_SYSC_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_SYSC_NAME "Dignus Systems/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SYSC,BOOST_COMP_SYSC_NAME)
+
+#ifdef BOOST_COMP_SYSC_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SYSC_EMULATED,BOOST_COMP_SYSC_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_EDG_H
+#define BOOST_PREDEF_COMPILER_EDG_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_EDG`]
+
+[@http://en.wikipedia.org/wiki/Edison_Design_Group EDG C++ Frontend] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__EDG__`] [__predef_detection__]]
+
+ [[`__EDG_VERSION__`] [V.R.0]]
+ ]
+ */
+
+#define BOOST_COMP_EDG BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__EDG__)
+# define BOOST_COMP_EDG_DETECTION BOOST_PREDEF_MAKE_10_VRR(__EDG_VERSION__)
+#endif
+
+#ifdef BOOST_COMP_EDG_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_EDG_EMULATED BOOST_COMP_EDG_DETECTION
+# else
+# undef BOOST_COMP_EDG
+# define BOOST_COMP_EDG BOOST_COMP_EDG_DETECTION
+# endif
+# define BOOST_COMP_EDG_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_EDG_NAME "EDG C++ Frontend"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_EDG,BOOST_COMP_EDG_NAME)
+
+#ifdef BOOST_COMP_EDG_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_EDG_EMULATED,BOOST_COMP_EDG_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_EKOPATH_H
+#define BOOST_PREDEF_COMPILER_EKOPATH_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_PATH`]
+
+[@http://en.wikipedia.org/wiki/PathScale EKOpath] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__PATHCC__`] [__predef_detection__]]
+
+ [[`__PATHCC__`, `__PATHCC_MINOR__`, `__PATHCC_PATCHLEVEL__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_PATH BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__PATHCC__)
+# define BOOST_COMP_PATH_DETECTION \
+ BOOST_VERSION_NUMBER(__PATHCC__,__PATHCC_MINOR__,__PATHCC_PATCHLEVEL__)
+#endif
+
+#ifdef BOOST_COMP_PATH_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_PATH_EMULATED BOOST_COMP_PATH_DETECTION
+# else
+# undef BOOST_COMP_PATH
+# define BOOST_COMP_PATH BOOST_COMP_PATH_DETECTION
+# endif
+# define BOOST_COMP_PATH_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_PATH_NAME "EKOpath"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PATH,BOOST_COMP_PATH_NAME)
+
+#ifdef BOOST_COMP_PATH_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PATH_EMULATED,BOOST_COMP_PATH_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_GCC_H
+#define BOOST_PREDEF_COMPILER_GCC_H
+
+/* Other compilers that emulate this one need to be detected first. */
+
+#include <boost/predef/compiler/clang.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_GNUC`]
+
+[@http://en.wikipedia.org/wiki/GNU_Compiler_Collection Gnu GCC C/C++] compiler.
+Version number available as major, minor, and patch (if available).
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__GNUC__`] [__predef_detection__]]
+
+ [[`__GNUC__`, `__GNUC_MINOR__`, `__GNUC_PATCHLEVEL__`] [V.R.P]]
+ [[`__GNUC__`, `__GNUC_MINOR__`] [V.R.0]]
+ ]
+ */
+
+#define BOOST_COMP_GNUC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__GNUC__)
+# if !defined(BOOST_COMP_GNUC_DETECTION) && defined(__GNUC_PATCHLEVEL__)
+# define BOOST_COMP_GNUC_DETECTION \
+ BOOST_VERSION_NUMBER(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__)
+# endif
+# if !defined(BOOST_COMP_GNUC_DETECTION)
+# define BOOST_COMP_GNUC_DETECTION \
+ BOOST_VERSION_NUMBER(__GNUC__,__GNUC_MINOR__,0)
+# endif
+#endif
+
+#ifdef BOOST_COMP_GNUC_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_GNUC_EMULATED BOOST_COMP_GNUC_DETECTION
+# else
+# undef BOOST_COMP_GNUC
+# define BOOST_COMP_GNUC BOOST_COMP_GNUC_DETECTION
+# endif
+# define BOOST_COMP_GNUC_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_GNUC_NAME "Gnu GCC C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GNUC,BOOST_COMP_GNUC_NAME)
+
+#ifdef BOOST_COMP_GNUC_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GNUC_EMULATED,BOOST_COMP_GNUC_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_GCC_XML_H
+#define BOOST_PREDEF_COMPILER_GCC_XML_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_GCCXML`]
+
+[@http://www.gccxml.org/ GCC XML] compiler.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__GCCXML__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_COMP_GCCXML BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__GCCXML__)
+# define BOOST_COMP_GCCXML_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#ifdef BOOST_COMP_GCCXML_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_GCCXML_EMULATED BOOST_COMP_GCCXML_DETECTION
+# else
+# undef BOOST_COMP_GCCXML
+# define BOOST_COMP_GCCXML BOOST_COMP_GCCXML_DETECTION
+# endif
+# define BOOST_COMP_GCCXML_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_GCCXML_NAME "GCC XML"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GCCXML,BOOST_COMP_GCCXML_NAME)
+
+#ifdef BOOST_COMP_GCCXML_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GCCXML_EMULATED,BOOST_COMP_GCCXML_NAME)
+#endif
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_GREENHILLS_H
+#define BOOST_PREDEF_COMPILER_GREENHILLS_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_GHS`]
+
+[@http://en.wikipedia.org/wiki/Green_Hills_Software Green Hills C/C++] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__ghs`] [__predef_detection__]]
+ [[`__ghs__`] [__predef_detection__]]
+
+ [[`__GHS_VERSION_NUMBER__`] [V.R.P]]
+ [[`__ghs`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_GHS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__ghs) || defined(__ghs__)
+# if !defined(BOOST_COMP_GHS_DETECTION) && defined(__GHS_VERSION_NUMBER__)
+# define BOOST_COMP_GHS_DETECTION BOOST_PREDEF_MAKE_10_VRP(__GHS_VERSION_NUMBER__)
+# endif
+# if !defined(BOOST_COMP_GHS_DETECTION) && defined(__ghs)
+# define BOOST_COMP_GHS_DETECTION BOOST_PREDEF_MAKE_10_VRP(__ghs)
+# endif
+# if !defined(BOOST_COMP_GHS_DETECTION)
+# define BOOST_COMP_GHS_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#ifdef BOOST_COMP_GHS_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_GHS_EMULATED BOOST_COMP_GHS_DETECTION
+# else
+# undef BOOST_COMP_GHS
+# define BOOST_COMP_GHS BOOST_COMP_GHS_DETECTION
+# endif
+# define BOOST_COMP_GHS_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_GHS_NAME "Green Hills C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GHS,BOOST_COMP_GHS_NAME)
+
+#ifdef BOOST_COMP_GHS_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_GHS_EMULATED,BOOST_COMP_GHS_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_HP_ACC_H
+#define BOOST_PREDEF_COMPILER_HP_ACC_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_HPACC`]
+
+HP aC++ compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__HP_aCC`] [__predef_detection__]]
+
+ [[`__HP_aCC`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_HPACC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__HP_aCC)
+# if !defined(BOOST_COMP_HPACC_DETECTION) && (__HP_aCC > 1)
+# define BOOST_COMP_HPACC_DETECTION BOOST_PREDEF_MAKE_10_VVRRPP(__HP_aCC)
+# endif
+# if !defined(BOOST_COMP_HPACC_DETECTION)
+# define BOOST_COMP_HPACC_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#ifdef BOOST_COMP_HPACC_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_HPACC_EMULATED BOOST_COMP_HPACC_DETECTION
+# else
+# undef BOOST_COMP_HPACC
+# define BOOST_COMP_HPACC BOOST_COMP_HPACC_DETECTION
+# endif
+# define BOOST_COMP_HPACC_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_HPACC_NAME "HP aC++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_HPACC,BOOST_COMP_HPACC_NAME)
+
+#ifdef BOOST_COMP_HPACC_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_HPACC_EMULATED,BOOST_COMP_HPACC_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_IAR_H
+#define BOOST_PREDEF_COMPILER_IAR_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_IAR`]
+
+IAR C/C++ compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__IAR_SYSTEMS_ICC__`] [__predef_detection__]]
+
+ [[`__VER__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_IAR BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__IAR_SYSTEMS_ICC__)
+# define BOOST_COMP_IAR_DETECTION BOOST_PREDEF_MAKE_10_VVRR(__VER__)
+#endif
+
+#ifdef BOOST_COMP_IAR_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_IAR_EMULATED BOOST_COMP_IAR_DETECTION
+# else
+# undef BOOST_COMP_IAR
+# define BOOST_COMP_IAR BOOST_COMP_IAR_DETECTION
+# endif
+# define BOOST_COMP_IAR_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_IAR_NAME "IAR C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_IAR,BOOST_COMP_IAR_NAME)
+
+#ifdef BOOST_COMP_IAR_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_IAR_EMULATED,BOOST_COMP_IAR_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_IBM_H
+#define BOOST_PREDEF_COMPILER_IBM_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_IBM`]
+
+[@http://en.wikipedia.org/wiki/VisualAge IBM XL C/C++] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__IBMCPP__`] [__predef_detection__]]
+ [[`__xlC__`] [__predef_detection__]]
+ [[`__xlc__`] [__predef_detection__]]
+
+ [[`__COMPILER_VER__`] [V.R.P]]
+ [[`__xlC__`] [V.R.P]]
+ [[`__xlc__`] [V.R.P]]
+ [[`__IBMCPP__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_IBM BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__IBMCPP__) || defined(__xlC__) || defined(__xlc__)
+# if !defined(BOOST_COMP_IBM_DETECTION) && defined(__COMPILER_VER__)
+# define BOOST_COMP_IBM_DETECTION BOOST_PREDEF_MAKE_0X_VRRPPPP(__COMPILER_VER__)
+# endif
+# if !defined(BOOST_COMP_IBM_DETECTION) && defined(__xlC__)
+# define BOOST_COMP_IBM_DETECTION BOOST_PREDEF_MAKE_0X_VVRR(__xlC__)
+# endif
+# if !defined(BOOST_COMP_IBM_DETECTION) && defined(__xlc__)
+# define BOOST_COMP_IBM_DETECTION BOOST_PREDEF_MAKE_0X_VVRR(__xlc__)
+# endif
+# if !defined(BOOST_COMP_IBM_DETECTION)
+# define BOOST_COMP_IBM_DETECTION BOOST_PREDEF_MAKE_10_VRP(__IBMCPP__)
+# endif
+#endif
+
+#ifdef BOOST_COMP_IBM_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_IBM_EMULATED BOOST_COMP_IBM_DETECTION
+# else
+# undef BOOST_COMP_IBM
+# define BOOST_COMP_IBM BOOST_COMP_IBM_DETECTION
+# endif
+# define BOOST_COMP_IBM_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_IBM_NAME "IBM XL C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_IBM,BOOST_COMP_IBM_NAME)
+
+#ifdef BOOST_COMP_IBM_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_IBM_EMULATED,BOOST_COMP_IBM_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_INTEL_H
+#define BOOST_PREDEF_COMPILER_INTEL_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_INTEL`]
+
+[@http://en.wikipedia.org/wiki/Intel_C%2B%2B Intel C/C++] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__INTEL_COMPILER`] [__predef_detection__]]
+ [[`__ICL`] [__predef_detection__]]
+ [[`__ICC`] [__predef_detection__]]
+ [[`__ECC`] [__predef_detection__]]
+
+ [[`__INTEL_COMPILER`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_INTEL BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || \
+ defined(__ECC)
+# if !defined(BOOST_COMP_INTEL_DETECTION) && defined(__INTEL_COMPILER)
+# define BOOST_COMP_INTEL_DETECTION BOOST_PREDEF_MAKE_10_VRP(__INTEL_COMPILER)
+# endif
+# if !defined(BOOST_COMP_INTEL_DETECTION)
+# define BOOST_COMP_INTEL_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#ifdef BOOST_COMP_INTEL_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_INTEL_EMULATED BOOST_COMP_INTEL_DETECTION
+# else
+# undef BOOST_COMP_INTEL
+# define BOOST_COMP_INTEL BOOST_COMP_INTEL_DETECTION
+# endif
+# define BOOST_COMP_INTEL_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_INTEL_NAME "Intel C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_INTEL,BOOST_COMP_INTEL_NAME)
+
+#ifdef BOOST_COMP_INTEL_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_INTEL_EMULATED,BOOST_COMP_INTEL_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_KAI_H
+#define BOOST_PREDEF_COMPILER_KAI_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_KCC`]
+
+Kai C++ compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__KCC`] [__predef_detection__]]
+
+ [[`__KCC_VERSION`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_KCC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__KCC)
+# define BOOST_COMP_KCC_DETECTION BOOST_PREDEF_MAKE_0X_VRPP(__KCC_VERSION)
+#endif
+
+#ifdef BOOST_COMP_KCC_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_KCC_EMULATED BOOST_COMP_KCC_DETECTION
+# else
+# undef BOOST_COMP_KCC
+# define BOOST_COMP_KCC BOOST_COMP_KCC_DETECTION
+# endif
+# define BOOST_COMP_KCC_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_KCC_NAME "Kai C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_KCC,BOOST_COMP_KCC_NAME)
+
+#ifdef BOOST_COMP_KCC_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_KCC_EMULATED,BOOST_COMP_KCC_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_LLVM_H
+#define BOOST_PREDEF_COMPILER_LLVM_H
+
+/* Other compilers that emulate this one need to be detected first. */
+
+#include <boost/predef/compiler/clang.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_LLVM`]
+
+[@http://en.wikipedia.org/wiki/LLVM LLVM] compiler.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__llvm__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_COMP_LLVM BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__llvm__)
+# define BOOST_COMP_LLVM_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#ifdef BOOST_COMP_LLVM_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_LLVM_EMULATED BOOST_COMP_LLVM_DETECTION
+# else
+# undef BOOST_COMP_LLVM
+# define BOOST_COMP_LLVM BOOST_COMP_LLVM_DETECTION
+# endif
+# define BOOST_COMP_LLVM_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_LLVM_NAME "LLVM"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_LLVM,BOOST_COMP_LLVM_NAME)
+
+#ifdef BOOST_COMP_LLVM_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_LLVM_EMULATED,BOOST_COMP_LLVM_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_METAWARE_H
+#define BOOST_PREDEF_COMPILER_METAWARE_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_HIGHC`]
+
+MetaWare High C/C++ compiler.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__HIGHC__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_COMP_HIGHC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__HIGHC__)
+# define BOOST_COMP_HIGHC_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#ifdef BOOST_COMP_HIGHC_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_HIGHC_EMULATED BOOST_COMP_HIGHC_DETECTION
+# else
+# undef BOOST_COMP_HIGHC
+# define BOOST_COMP_HIGHC BOOST_COMP_HIGHC_DETECTION
+# endif
+# define BOOST_COMP_HIGHC_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_HIGHC_NAME "MetaWare High C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_HIGHC,BOOST_COMP_HIGHC_NAME)
+
+#ifdef BOOST_COMP_HIGHC_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_HIGHC_EMULATED,BOOST_COMP_HIGHC_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_METROWERKS_H
+#define BOOST_PREDEF_COMPILER_METROWERKS_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_MWERKS`]
+
+[@http://en.wikipedia.org/wiki/CodeWarrior Metrowerks CodeWarrior] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__MWERKS__`] [__predef_detection__]]
+ [[`__CWCC__`] [__predef_detection__]]
+
+ [[`__CWCC__`] [V.R.P]]
+ [[`__MWERKS__`] [V.R.P >= 4.2.0]]
+ [[`__MWERKS__`] [9.R.0]]
+ [[`__MWERKS__`] [8.R.0]]
+ ]
+ */
+
+#define BOOST_COMP_MWERKS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__MWERKS__) || defined(__CWCC__)
+# if !defined(BOOST_COMP_MWERKS_DETECTION) && defined(__CWCC__)
+# define BOOST_COMP_MWERKS_DETECTION BOOST_PREDEF_MAKE_0X_VRPP(__CWCC__)
+# endif
+# if !defined(BOOST_COMP_MWERKS_DETECTION) && (__MWERKS__ >= 0x4200)
+# define BOOST_COMP_MWERKS_DETECTION BOOST_PREDEF_MAKE_0X_VRPP(__MWERKS__)
+# endif
+# if !defined(BOOST_COMP_MWERKS_DETECTION) && (__MWERKS__ >= 0x3204) // note the "skip": 04->9.3
+# define BOOST_COMP_MWERKS_DETECTION BOOST_VERSION_NUMBER(9,(__MWERKS__)%100-1,0)
+# endif
+# if !defined(BOOST_COMP_MWERKS_DETECTION) && (__MWERKS__ >= 0x3200)
+# define BOOST_COMP_MWERKS_DETECTION BOOST_VERSION_NUMBER(9,(__MWERKS__)%100,0)
+# endif
+# if !defined(BOOST_COMP_MWERKS_DETECTION) && (__MWERKS__ >= 0x3000)
+# define BOOST_COMP_MWERKS_DETECTION BOOST_VERSION_NUMBER(8,(__MWERKS__)%100,0)
+# endif
+# if !defined(BOOST_COMP_MWERKS_DETECTION)
+# define BOOST_COMP_MWERKS_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#ifdef BOOST_COMP_MWERKS_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_MWERKS_EMULATED BOOST_COMP_MWERKS_DETECTION
+# else
+# undef BOOST_COMP_MWERKS
+# define BOOST_COMP_MWERKS BOOST_COMP_MWERKS_DETECTION
+# endif
+# define BOOST_COMP_MWERKS_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_MWERKS_NAME "Metrowerks CodeWarrior"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MWERKS,BOOST_COMP_MWERKS_NAME)
+
+#ifdef BOOST_COMP_MWERKS_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MWERKS_EMULATED,BOOST_COMP_MWERKS_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_MICROTEC_H
+#define BOOST_PREDEF_COMPILER_MICROTEC_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_MRI`]
+
+[@http://www.mentor.com/microtec/ Microtec C/C++] compiler.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`_MRI`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_COMP_MRI BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(_MRI)
+# define BOOST_COMP_MRI_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#ifdef BOOST_COMP_MRI_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_MRI_EMULATED BOOST_COMP_MRI_DETECTION
+# else
+# undef BOOST_COMP_MRI
+# define BOOST_COMP_MRI BOOST_COMP_MRI_DETECTION
+# endif
+# define BOOST_COMP_MRI_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_MRI_NAME "Microtec C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MRI,BOOST_COMP_MRI_NAME)
+
+#ifdef BOOST_COMP_MRI_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MRI_EMULATED,BOOST_COMP_MRI_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_MPW_H
+#define BOOST_PREDEF_COMPILER_MPW_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_MPW`]
+
+[@http://en.wikipedia.org/wiki/Macintosh_Programmer%27s_Workshop MPW C++] compiler.
+Version number available as major, and minor.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__MRC__`] [__predef_detection__]]
+ [[`MPW_C`] [__predef_detection__]]
+ [[`MPW_CPLUS`] [__predef_detection__]]
+
+ [[`__MRC__`] [V.R.0]]
+ ]
+ */
+
+#define BOOST_COMP_MPW BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__MRC__) || defined(MPW_C) || defined(MPW_CPLUS)
+# if !defined(BOOST_COMP_MPW_DETECTION) && defined(__MRC__)
+# define BOOST_COMP_MPW_DETECTION BOOST_PREDEF_MAKE_0X_VVRR(__MRC__)
+# endif
+# if !defined(BOOST_COMP_MPW_DETECTION)
+# define BOOST_COMP_MPW_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#ifdef BOOST_COMP_MPW_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_MPW_EMULATED BOOST_COMP_MPW_DETECTION
+# else
+# undef BOOST_COMP_MPW
+# define BOOST_COMP_MPW BOOST_COMP_MPW_DETECTION
+# endif
+# define BOOST_COMP_MPW_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_MPW_NAME "MPW C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MPW,BOOST_COMP_MPW_NAME)
+
+#ifdef BOOST_COMP_MPW_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MPW_EMULATED,BOOST_COMP_MPW_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_PALM_H
+#define BOOST_PREDEF_COMPILER_PALM_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_PALM`]
+
+Palm C/C++ compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`_PACC_VER`] [__predef_detection__]]
+
+ [[`_PACC_VER`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_PALM BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(_PACC_VER)
+# define BOOST_COMP_PALM_DETECTION BOOST_PREDEF_MAKE_0X_VRRPP000(_PACC_VER)
+#endif
+
+#ifdef BOOST_COMP_PALM_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_PALM_EMULATED BOOST_COMP_PALM_DETECTION
+# else
+# undef BOOST_COMP_PALM
+# define BOOST_COMP_PALM BOOST_COMP_PALM_DETECTION
+# endif
+# define BOOST_COMP_PALM_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_PALM_NAME "Palm C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PALM,BOOST_COMP_PALM_NAME)
+
+#ifdef BOOST_COMP_PALM_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PALM_EMULATED,BOOST_COMP_PALM_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_PGI_H
+#define BOOST_PREDEF_COMPILER_PGI_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_PGI`]
+
+[@http://en.wikipedia.org/wiki/The_Portland_Group Portland Group C/C++] compiler.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__PGI`] [__predef_detection__]]
+
+ [[`__PGIC__`, `__PGIC_MINOR__`, `__PGIC_PATCHLEVEL__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_PGI BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__PGI)
+# if !defined(BOOST_COMP_PGI_DETECTION) && (defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__))
+# define BOOST_COMP_PGI_DETECTION BOOST_VERSION_NUMBER(__PGIC__,__PGIC_MINOR__,__PGIC_PATCHLEVEL__)
+# endif
+# if !defined(BOOST_COMP_PGI_DETECTION)
+# define BOOST_COMP_PGI_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#ifdef BOOST_COMP_PGI_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_PGI_EMULATED BOOST_COMP_PGI_DETECTION
+# else
+# undef BOOST_COMP_PGI
+# define BOOST_COMP_PGI BOOST_COMP_PGI_DETECTION
+# endif
+# define BOOST_COMP_PGI_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_PGI_NAME "Portland Group C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PGI,BOOST_COMP_PGI_NAME)
+
+#ifdef BOOST_COMP_PGI_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_PGI_EMULATED,BOOST_COMP_PGI_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_SGI_MIPSPRO_H
+#define BOOST_PREDEF_COMPILER_SGI_MIPSPRO_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_SGI`]
+
+[@http://en.wikipedia.org/wiki/MIPSpro SGI MIPSpro] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__sgi`] [__predef_detection__]]
+ [[`sgi`] [__predef_detection__]]
+
+ [[`_SGI_COMPILER_VERSION`] [V.R.P]]
+ [[`_COMPILER_VERSION`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_SGI BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__sgi) || defined(sgi)
+# if !defined(BOOST_COMP_SGI_DETECTION) && defined(_SGI_COMPILER_VERSION)
+# define BOOST_COMP_SGI_DETECTION BOOST_PREDEF_MAKE_10_VRP(_SGI_COMPILER_VERSION)
+# endif
+# if !defined(BOOST_COMP_SGI_DETECTION) && defined(_COMPILER_VERSION)
+# define BOOST_COMP_SGI_DETECTION BOOST_PREDEF_MAKE_10_VRP(_COMPILER_VERSION)
+# endif
+# if !defined(BOOST_COMP_SGI_DETECTION)
+# define BOOST_COMP_SGI_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#ifdef BOOST_COMP_SGI_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_SGI_EMULATED BOOST_COMP_SGI_DETECTION
+# else
+# undef BOOST_COMP_SGI
+# define BOOST_COMP_SGI BOOST_COMP_SGI_DETECTION
+# endif
+# define BOOST_COMP_SGI_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_SGI_NAME "SGI MIPSpro"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SGI,BOOST_COMP_SGI_NAME)
+
+#ifdef BOOST_COMP_SGI_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SGI_EMULATED,BOOST_COMP_SGI_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_SUNPRO_H
+#define BOOST_PREDEF_COMPILER_SUNPRO_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_SUNPRO`]
+
+[@http://en.wikipedia.org/wiki/Sun_Studio_%28software%29 Sun Studio] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__SUNPRO_CC`] [__predef_detection__]]
+ [[`__SUNPRO_C`] [__predef_detection__]]
+
+ [[`__SUNPRO_CC`] [V.R.P]]
+ [[`__SUNPRO_C`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_SUNPRO BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__SUNPRO_CC) || defined(__SUNPRO_C)
+# if !defined(BOOST_COMP_SUNPRO_DETECTION) && defined(__SUNPRO_CC)
+# define BOOST_COMP_SUNPRO_DETECTION BOOST_PREDEF_MAKE_0X_VRP(__SUNPRO_CC)
+# endif
+# if !defined(BOOST_COMP_SUNPRO_DETECTION) && defined(__SUNPRO_C)
+# define BOOST_COMP_SUNPRO_DETECTION BOOST_PREDEF_MAKE_0X_VRP(__SUNPRO_C)
+# endif
+# if !defined(BOOST_COMP_SUNPRO_DETECTION)
+# define BOOST_COMP_SUNPRO_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#ifdef BOOST_COMP_SUNPRO_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_SUNPRO_EMULATED BOOST_COMP_SUNPRO_DETECTION
+# else
+# undef BOOST_COMP_SUNPRO
+# define BOOST_COMP_SUNPRO BOOST_COMP_SUNPRO_DETECTION
+# endif
+# define BOOST_COMP_SUNPRO_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_SUNPRO_NAME "Sun Studio"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SUNPRO,BOOST_COMP_SUNPRO_NAME)
+
+#ifdef BOOST_COMP_SUNPRO_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_SUNPRO_EMULATED,BOOST_COMP_SUNPRO_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_TENDRA_H
+#define BOOST_PREDEF_COMPILER_TENDRA_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_TENDRA`]
+
+[@http://en.wikipedia.org/wiki/TenDRA_Compiler TenDRA C/C++] compiler.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__TenDRA__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_COMP_TENDRA BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__TenDRA__)
+# define BOOST_COMP_TENDRA_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#ifdef BOOST_COMP_TENDRA_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_TENDRA_EMULATED BOOST_COMP_TENDRA_DETECTION
+# else
+# undef BOOST_COMP_TENDRA
+# define BOOST_COMP_TENDRA BOOST_COMP_TENDRA_DETECTION
+# endif
+# define BOOST_COMP_TENDRA_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_TENDRA_NAME "TenDRA C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_TENDRA,BOOST_COMP_TENDRA_NAME)
+
+#ifdef BOOST_COMP_TENDRA_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_TENDRA_EMULATED,BOOST_COMP_TENDRA_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_VISUALC_H
+#define BOOST_PREDEF_COMPILER_VISUALC_H
+
+/* Other compilers that emulate this one need to be detected first. */
+
+#include <boost/predef/compiler/clang.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_MSVC`]
+
+[@http://en.wikipedia.org/wiki/Visual_studio Microsoft Visual C/C++] compiler.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`_MSC_VER`] [__predef_detection__]]
+
+ [[`_MSC_FULL_VER`] [V.R.P]]
+ [[`_MSC_VER`] [V.R.0]]
+ ]
+ */
+
+#define BOOST_COMP_MSVC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(_MSC_VER)
+# if !defined (_MSC_FULL_VER)
+# define BOOST_COMP_MSVC_BUILD 0
+# else
+ /* how many digits does the build number have? */
+# if _MSC_FULL_VER / 10000 == _MSC_VER
+ /* four digits */
+# define BOOST_COMP_MSVC_BUILD (_MSC_FULL_VER % 10000)
+# elif _MSC_FULL_VER / 100000 == _MSC_VER
+ /* five digits */
+# define BOOST_COMP_MSVC_BUILD (_MSC_FULL_VER % 100000)
+# else
+# error "Cannot determine build number from _MSC_FULL_VER"
+# endif
+# endif
+ /*
+ VS2014 was skipped in the release sequence for MS. Which
+ means that the compiler and VS product versions are no longer
+ in sync. Hence we need to use different formulas for
+ mapping from MSC version to VS product version.
+ */
+# if (_MSC_VER >= 1900)
+# define BOOST_COMP_MSVC_DETECTION BOOST_VERSION_NUMBER(\
+ _MSC_VER/100-5,\
+ _MSC_VER%100,\
+ BOOST_COMP_MSVC_BUILD)
+# else
+# define BOOST_COMP_MSVC_DETECTION BOOST_VERSION_NUMBER(\
+ _MSC_VER/100-6,\
+ _MSC_VER%100,\
+ BOOST_COMP_MSVC_BUILD)
+# endif
+#endif
+
+#ifdef BOOST_COMP_MSVC_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_MSVC_EMULATED BOOST_COMP_MSVC_DETECTION
+# else
+# undef BOOST_COMP_MSVC
+# define BOOST_COMP_MSVC BOOST_COMP_MSVC_DETECTION
+# endif
+# define BOOST_COMP_MSVC_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_MSVC_NAME "Microsoft Visual C/C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MSVC,BOOST_COMP_MSVC_NAME)
+
+#ifdef BOOST_COMP_MSVC_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_MSVC_EMULATED,BOOST_COMP_MSVC_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_WATCOM_H
+#define BOOST_PREDEF_COMPILER_WATCOM_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_COMP_WATCOM`]
+
+[@http://en.wikipedia.org/wiki/Watcom Watcom C++] compiler.
+Version number available as major, and minor.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__WATCOMC__`] [__predef_detection__]]
+
+ [[`__WATCOMC__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_COMP_WATCOM BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__WATCOMC__)
+# define BOOST_COMP_WATCOM_DETECTION BOOST_PREDEF_MAKE_10_VVRR(__WATCOMC__)
+#endif
+
+#ifdef BOOST_COMP_WATCOM_DETECTION
+# if defined(BOOST_PREDEF_DETAIL_COMP_DETECTED)
+# define BOOST_COMP_WATCOM_EMULATED BOOST_COMP_WATCOM_DETECTION
+# else
+# undef BOOST_COMP_WATCOM
+# define BOOST_COMP_WATCOM BOOST_COMP_WATCOM_DETECTION
+# endif
+# define BOOST_COMP_WATCOM_AVAILABLE
+# include <boost/predef/detail/comp_detected.h>
+#endif
+
+#define BOOST_COMP_WATCOM_NAME "Watcom C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_WATCOM,BOOST_COMP_WATCOM_NAME)
+
+#ifdef BOOST_COMP_WATCOM_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_COMP_WATCOM_EMULATED,BOOST_COMP_WATCOM_NAME)
+#endif
+
+
+#endif
/*
-Copyright Redshift Software, Inc. 2011-2012
+Copyright Rene Rivera 2011-2012
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)
--- /dev/null
+/*
+Copyright Rene Rivera 2011-2012
+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)
+*/
+
+#ifndef BOOST_PREDEF_DETAIL__EXCEPTION_H
+#define BOOST_PREDEF_DETAIL__EXCEPTION_H
+
+#if defined(__cpluplus)
+#include <exception>
+#endif
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_DETAIL_COMP_DETECTED
+#define BOOST_PREDEF_DETAIL_COMP_DETECTED 1
+#endif
/*
-Copyright Redshift Software, Inc. 2013
+Copyright Rene Rivera 2013
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)
/*
-Copyright Redshift Software, Inc. 2013
+Copyright Rene Rivera 2013
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)
--- /dev/null
+/*
+Copyright Rene Rivera 2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_DETAIL_PLAT_DETECTED
+#define BOOST_PREDEF_DETAIL_PLAT_DETECTED 1
+#endif
/*
-Copyright Redshift Software Inc. 2011-2012
+Copyright Rene Rivera 2011-2012
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)
--- /dev/null
+/*
+Copyright Rene Rivera 2011-2012
+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)
+*/
+
+#ifndef BOOST_PREDEF_LANGUAGE_H
+#define BOOST_PREDEF_LANGUAGE_H
+
+#include <boost/predef/language/stdc.h>
+#include <boost/predef/language/stdcpp.h>
+#include <boost/predef/language/objc.h>
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2011-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LANGUAGE_OBJC_H
+#define BOOST_PREDEF_LANGUAGE_OBJC_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LANG_OBJC`]
+
+[@http://en.wikipedia.org/wiki/Objective-C Objective-C] language.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__OBJC__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_LANG_OBJC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__OBJC__)
+# undef BOOST_LANG_OBJC
+# define BOOST_LANG_OBJC BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_LANG_OBJC
+# define BOOST_LANG_OBJC_AVAILABLE
+#endif
+
+#define BOOST_LANG_OBJC_NAME "Objective-C"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LANG_OBJC,BOOST_LANG_OBJC_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2011-2012
+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)
+*/
+
+#ifndef BOOST_PREDEF_LANGUAGE_STDC_H
+#define BOOST_PREDEF_LANGUAGE_STDC_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LANG_STDC`]
+
+[@http://en.wikipedia.org/wiki/C_(programming_language) Standard C] language.
+If available, the year of the standard is detected as YYYY.MM.1 from the Epoc date.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__STDC__`] [__predef_detection__]]
+
+ [[`__STDC_VERSION__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_LANG_STDC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__STDC__)
+# undef BOOST_LANG_STDC
+# if defined(__STDC_VERSION__)
+# if (__STDC_VERSION__ > 100)
+# define BOOST_LANG_STDC BOOST_PREDEF_MAKE_YYYYMM(__STDC_VERSION__)
+# else
+# define BOOST_LANG_STDC BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+# else
+# define BOOST_LANG_STDC BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_LANG_STDC
+# define BOOST_LANG_STDC_AVAILABLE
+#endif
+
+#define BOOST_LANG_STDC_NAME "Standard C"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LANG_STDC,BOOST_LANG_STDC_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2011-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LANGUAGE_STDCPP_H
+#define BOOST_PREDEF_LANGUAGE_STDCPP_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LANG_STDCPP`]
+
+[@http://en.wikipedia.org/wiki/C%2B%2B Standard C++] language.
+If available, the year of the standard is detected as YYYY.MM.1 from the Epoc date.
+Because of the way the C++ standardization process works the
+defined version year will not be the commonly known year of the standard.
+Specifically the defined versions are:
+
+[table Detected Version Number vs. C++ Standard Year
+ [[Detected Version Number] [Standard Year] [C++ Standard]]
+ [[27.11.1] [1998] [ISO/IEC 14882:1998]]
+ [[41.12.1] [2011] [ISO/IEC 14882:2011]]
+]
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__cplusplus`] [__predef_detection__]]
+
+ [[`__cplusplus`] [YYYY.MM.1]]
+ ]
+ */
+
+#define BOOST_LANG_STDCPP BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__cplusplus)
+# undef BOOST_LANG_STDCPP
+# if (__cplusplus > 100)
+# define BOOST_LANG_STDCPP BOOST_PREDEF_MAKE_YYYYMM(__cplusplus)
+# else
+# define BOOST_LANG_STDCPP BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_LANG_STDCPP
+# define BOOST_LANG_STDCPP_AVAILABLE
+#endif
+
+#define BOOST_LANG_STDCPP_NAME "Standard C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LANG_STDCPP,BOOST_LANG_STDCPP_NAME)
+
+
+/*`
+[heading `BOOST_LANG_STDCPPCLI`]
+
+[@http://en.wikipedia.org/wiki/C%2B%2B/CLI Standard C++/CLI] language.
+If available, the year of the standard is detected as YYYY.MM.1 from the Epoc date.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__cplusplus_cli`] [__predef_detection__]]
+
+ [[`__cplusplus_cli`] [YYYY.MM.1]]
+ ]
+ */
+
+#define BOOST_LANG_STDCPPCLI BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__cplusplus_cli)
+# undef BOOST_LANG_STDCPPCLI
+# if (__cplusplus_cli > 100)
+# define BOOST_LANG_STDCPPCLI BOOST_PREDEF_MAKE_YYYYMM(__cplusplus_cli)
+# else
+# define BOOST_LANG_STDCPPCLI BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_LANG_STDCPPCLI
+# define BOOST_LANG_STDCPPCLI_AVAILABLE
+#endif
+
+#define BOOST_LANG_STDCPPCLI_NAME "Standard C++/CLI"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LANG_STDCPPCLI,BOOST_LANG_STDCPPCLI_NAME)
+
+
+/*`
+[heading `BOOST_LANG_STDECPP`]
+
+[@http://en.wikipedia.org/wiki/Embedded_C%2B%2B Standard Embedded C++] language.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__embedded_cplusplus`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_LANG_STDECPP BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__embedded_cplusplus)
+# undef BOOST_LANG_STDECPP
+# define BOOST_LANG_STDECPP BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_LANG_STDECPP
+# define BOOST_LANG_STDECPP_AVAILABLE
+#endif
+
+#define BOOST_LANG_STDECPP_NAME "Standard Embedded C++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LANG_STDECPP,BOOST_LANG_STDECPP_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2012
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_H
+#define BOOST_PREDEF_LIBRARY_H
+
+#include <boost/predef/library/c.h>
+#include <boost/predef/library/std.h>
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2012
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_C_H
+#define BOOST_PREDEF_LIBRARY_C_H
+
+#include <boost/predef/library/c/_prefix.h>
+
+#include <boost/predef/library/c/gnu.h>
+#include <boost/predef/library/c/uc.h>
+#include <boost/predef/library/c/vms.h>
+#include <boost/predef/library/c/zos.h>
+
+#endif
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_C_UC_H
+#define BOOST_PREDEF_LIBRARY_C_UC_H
+
+#include <boost/predef/library/c/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_C_UC`]
+
+[@http://en.wikipedia.org/wiki/Uclibc uClibc] Standard C library.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__UCLIBC__`] [__predef_detection__]]
+
+ [[`__UCLIBC_MAJOR__`, `__UCLIBC_MINOR__`, `__UCLIBC_SUBLEVEL__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_LIB_C_UC BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__UCLIBC__)
+# undef BOOST_LIB_C_UC
+# define BOOST_LIB_C_UC BOOST_VERSION_NUMBER(\
+ __UCLIBC_MAJOR__,__UCLIBC_MINOR__,__UCLIBC_SUBLEVEL__)
+#endif
+
+#if BOOST_LIB_C_UC
+# define BOOST_LIB_C_UC_AVAILABLE
+#endif
+
+#define BOOST_LIB_C_UC_NAME "uClibc"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_C_UC,BOOST_LIB_C_UC_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_C_VMS_H
+#define BOOST_PREDEF_LIBRARY_C_VMS_H
+
+#include <boost/predef/library/c/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_C_VMS`]
+
+VMS libc Standard C library.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__CRTL_VER`] [__predef_detection__]]
+
+ [[`__CRTL_VER`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_LIB_C_VMS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__CRTL_VER)
+# undef BOOST_LIB_C_VMS
+# define BOOST_LIB_C_VMS BOOST_PREDEF_MAKE_10_VVRR0PP00(__CRTL_VER)
+#endif
+
+#if BOOST_LIB_C_VMS
+# define BOOST_LIB_C_VMS_AVAILABLE
+#endif
+
+#define BOOST_LIB_C_VMS_NAME "VMS"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_C_VMS,BOOST_LIB_C_VMS_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_C_ZOS_H
+#define BOOST_PREDEF_LIBRARY_C_ZOS_H
+
+#include <boost/predef/library/c/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_C_ZOS`]
+
+z/OS libc Standard C library.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__LIBREL__`] [__predef_detection__]]
+
+ [[`__LIBREL__`] [V.R.P]]
+ [[`__TARGET_LIB__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_LIB_C_ZOS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__LIBREL__)
+# undef BOOST_LIB_C_ZOS
+# if !defined(BOOST_LIB_C_ZOS) && defined(__LIBREL__)
+# define BOOST_LIB_C_ZOS BOOST_PREDEF_MAKE_0X_VRRPPPP(__LIBREL__)
+# endif
+# if !defined(BOOST_LIB_C_ZOS) && defined(__TARGET_LIB__)
+# define BOOST_LIB_C_ZOS BOOST_PREDEF_MAKE_0X_VRRPPPP(__TARGET_LIB__)
+# endif
+# if !defined(BOOST_LIB_C_ZOS)
+# define BOOST_LIB_C_ZOS BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_LIB_C_ZOS
+# define BOOST_LIB_C_ZOS_AVAILABLE
+#endif
+
+#define BOOST_LIB_C_ZOS_NAME "z/OS"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_C_ZOS,BOOST_LIB_C_ZOS_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+#ifndef BOOST_PREDEF_LIBRARY_STD_H
+#define BOOST_PREDEF_LIBRARY_STD_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/library/std/cxx.h>
+#include <boost/predef/library/std/dinkumware.h>
+#include <boost/predef/library/std/libcomo.h>
+#include <boost/predef/library/std/modena.h>
+#include <boost/predef/library/std/msl.h>
+#include <boost/predef/library/std/roguewave.h>
+#include <boost/predef/library/std/sgi.h>
+#include <boost/predef/library/std/stdcpp3.h>
+#include <boost/predef/library/std/stlport.h>
+#include <boost/predef/library/std/vacpp.h>
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+#ifndef BOOST_PREDEF_LIBRARY_STD__PREFIX_H
+#define BOOST_PREDEF_LIBRARY_STD__PREFIX_H
+
+/*
+We need to include an STD header to gives us the context
+of which library we are using. The "smallest" code-wise header
+seems to be <exception>. Boost uses <utility> but as far
+as I can tell (RR) it's not a stand-alone header in most
+implementations. Using <exception> also has the benefit of
+being available in EC++, so we get a chance to make this work
+for embedded users. And since it's not a header impacted by TR1
+there's no magic needed for inclusion in the face of the
+Boost.TR1 library.
+*/
+#include <boost/predef/detail/_exception.h>
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2011-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_STD_CXX_H
+#define BOOST_PREDEF_LIBRARY_STD_CXX_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_STD_CXX`]
+
+[@http://libcxx.llvm.org/ libc++] C++ Standard Library.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`_LIBCPP_VERSION`] [__predef_detection__]]
+
+ [[`_LIBCPP_VERSION`] [V.0.P]]
+ ]
+ */
+
+#define BOOST_LIB_STD_CXX BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(_LIBCPP_VERSION)
+# undef BOOST_LIB_STD_CXX
+# define BOOST_LIB_STD_CXX BOOST_PREDEF_MAKE_10_VPPP(_LIBCPP_VERSION)
+#endif
+
+#if BOOST_LIB_STD_CXX
+# define BOOST_LIB_STD_CXX_AVAILABLE
+#endif
+
+#define BOOST_LIB_STD_CXX_NAME "libc++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_CXX,BOOST_LIB_STD_CXX_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_STD_DINKUMWARE_H
+#define BOOST_PREDEF_LIBRARY_STD_DINKUMWARE_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_STD_DINKUMWARE`]
+
+[@http://en.wikipedia.org/wiki/Dinkumware Dinkumware] Standard C++ Library.
+If available version number as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`_YVALS`, `__IBMCPP__`] [__predef_detection__]]
+ [[`_CPPLIB_VER`] [__predef_detection__]]
+
+ [[`_CPPLIB_VER`] [V.R.0]]
+ ]
+ */
+
+#define BOOST_LIB_STD_DINKUMWARE BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
+# undef BOOST_LIB_STD_DINKUMWARE
+# if defined(_CPPLIB_VER)
+# define BOOST_LIB_STD_DINKUMWARE BOOST_PREDEF_MAKE_10_VVRR(_CPPLIB_VER)
+# else
+# define BOOST_LIB_STD_DINKUMWARE BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_LIB_STD_DINKUMWARE
+# define BOOST_LIB_STD_DINKUMWARE_AVAILABLE
+#endif
+
+#define BOOST_LIB_STD_DINKUMWARE_NAME "Dinkumware"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_DINKUMWARE,BOOST_LIB_STD_DINKUMWARE_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_STD_LIBCOMO_H
+#define BOOST_PREDEF_LIBRARY_STD_LIBCOMO_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_STD_COMO`]
+
+[@http://www.comeaucomputing.com/libcomo/ Comeau Computing] Standard C++ Library.
+Version number available as major.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__LIBCOMO__`] [__predef_detection__]]
+
+ [[`__LIBCOMO_VERSION__`] [V.0.0]]
+ ]
+ */
+
+#define BOOST_LIB_STD_COMO BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__LIBCOMO__)
+# undef BOOST_LIB_STD_COMO
+# define BOOST_LIB_STD_COMO BOOST_VERSION_NUMBER(__LIBCOMO_VERSION__,0,0)
+#endif
+
+#if BOOST_LIB_STD_COMO
+# define BOOST_LIB_STD_COMO_AVAILABLE
+#endif
+
+#define BOOST_LIB_STD_COMO_NAME "Comeau Computing"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_COMO,BOOST_LIB_STD_COMO_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_STD_MODENA_H
+#define BOOST_PREDEF_LIBRARY_STD_MODENA_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_STD_MSIPL`]
+
+[@http://modena.us/ Modena Software Lib++] Standard C++ Library.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`MSIPL_COMPILE_H`] [__predef_detection__]]
+ [[`__MSIPL_COMPILE_H`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_LIB_STD_MSIPL BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(MSIPL_COMPILE_H) || defined(__MSIPL_COMPILE_H)
+# undef BOOST_LIB_STD_MSIPL
+# define BOOST_LIB_STD_MSIPL BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_LIB_STD_MSIPL
+# define BOOST_LIB_STD_MSIPL_AVAILABLE
+#endif
+
+#define BOOST_LIB_STD_MSIPL_NAME "Modena Software Lib++"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_MSIPL,BOOST_LIB_STD_MSIPL_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_STD_MSL_H
+#define BOOST_PREDEF_LIBRARY_STD_MSL_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_STD_MSL`]
+
+[@http://www.freescale.com/ Metrowerks] Standard C++ Library.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__MSL_CPP__`] [__predef_detection__]]
+ [[`__MSL__`] [__predef_detection__]]
+
+ [[`__MSL_CPP__`] [V.R.P]]
+ [[`__MSL__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_LIB_STD_MSL BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__MSL_CPP__) || defined(__MSL__)
+# undef BOOST_LIB_STD_MSL
+# if defined(__MSL_CPP__)
+# define BOOST_LIB_STD_MSL BOOST_PREDEF_MAKE_0X_VRPP(__MSL_CPP__)
+# else
+# define BOOST_LIB_STD_MSL BOOST_PREDEF_MAKE_0X_VRPP(__MSL__)
+# endif
+#endif
+
+#if BOOST_LIB_STD_MSL
+# define BOOST_LIB_STD_MSL_AVAILABLE
+#endif
+
+#define BOOST_LIB_STD_MSL_NAME "Metrowerks"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_MSL,BOOST_LIB_STD_MSL_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_STD_ROGUEWAVE_H
+#define BOOST_PREDEF_LIBRARY_STD_ROGUEWAVE_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_STD_RW`]
+
+[@http://stdcxx.apache.org/ Roguewave] Standard C++ library.
+If available version number as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__STD_RWCOMPILER_H__`] [__predef_detection__]]
+ [[`_RWSTD_VER`] [__predef_detection__]]
+
+ [[`_RWSTD_VER`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_LIB_STD_RW BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+# undef BOOST_LIB_STD_RW
+# if defined(_RWSTD_VER)
+# if _RWSTD_VER < 0x010000
+# define BOOST_LIB_STD_RW BOOST_PREDEF_MAKE_0X_VVRRP(_RWSTD_VER)
+# else
+# define BOOST_LIB_STD_RW BOOST_PREDEF_MAKE_0X_VVRRPP(_RWSTD_VER)
+# endif
+# else
+# define BOOST_LIB_STD_RW BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_LIB_STD_RW
+# define BOOST_LIB_STD_RW_AVAILABLE
+#endif
+
+#define BOOST_LIB_STD_RW_NAME "Roguewave"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_RW,BOOST_LIB_STD_RW_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_STD_SGI_H
+#define BOOST_PREDEF_LIBRARY_STD_SGI_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_STD_SGI`]
+
+[@http://www.sgi.com/tech/stl/ SGI] Standard C++ library.
+If available version number as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__STL_CONFIG_H`] [__predef_detection__]]
+
+ [[`__SGI_STL`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_LIB_STD_SGI BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__STL_CONFIG_H)
+# undef BOOST_LIB_STD_SGI
+# if defined(__SGI_STL)
+# define BOOST_LIB_STD_SGI BOOST_PREDEF_MAKE_0X_VRP(__SGI_STL)
+# else
+# define BOOST_LIB_STD_SGI BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_LIB_STD_SGI
+# define BOOST_LIB_STD_SGI_AVAILABLE
+#endif
+
+#define BOOST_LIB_STD_SGI_NAME "SGI"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_SGI,BOOST_LIB_STD_SGI_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_STD_STDCPP3_H
+#define BOOST_PREDEF_LIBRARY_STD_STDCPP3_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_STD_GNU`]
+
+[@http://gcc.gnu.org/libstdc++/ GNU libstdc++] Standard C++ library.
+Version number available as year (from 1970), month, and day.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__GLIBCXX__`] [__predef_detection__]]
+ [[`__GLIBCPP__`] [__predef_detection__]]
+
+ [[`__GLIBCXX__`] [V.R.P]]
+ [[`__GLIBCPP__`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_LIB_STD_GNU BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__GLIBCPP__) || defined(__GLIBCXX__)
+# undef BOOST_LIB_STD_GNU
+# if defined(__GLIBCXX__)
+# define BOOST_LIB_STD_GNU BOOST_PREDEF_MAKE_YYYYMMDD(__GLIBCXX__)
+# else
+# define BOOST_LIB_STD_GNU BOOST_PREDEF_MAKE_YYYYMMDD(__GLIBCPP__)
+# endif
+#endif
+
+#if BOOST_LIB_STD_GNU
+# define BOOST_LIB_STD_GNU_AVAILABLE
+#endif
+
+#define BOOST_LIB_STD_GNU_NAME "GNU"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_GNU,BOOST_LIB_STD_GNU_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_STD_STLPORT_H
+#define BOOST_PREDEF_LIBRARY_STD_STLPORT_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_STD_STLPORT`]
+
+[@http://sourceforge.net/projects/stlport/ STLport Standard C++] library.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__SGI_STL_PORT`] [__predef_detection__]]
+ [[`_STLPORT_VERSION`] [__predef_detection__]]
+
+ [[`_STLPORT_MAJOR`, `_STLPORT_MINOR`, `_STLPORT_PATCHLEVEL`] [V.R.P]]
+ [[`_STLPORT_VERSION`] [V.R.P]]
+ [[`__SGI_STL_PORT`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_LIB_STD_STLPORT BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+# undef BOOST_LIB_STD_STLPORT
+# if !defined(BOOST_LIB_STD_STLPORT) && defined(_STLPORT_MAJOR)
+# define BOOST_LIB_STD_STLPORT \
+ BOOST_VERSION_NUMBER(_STLPORT_MAJOR,_STLPORT_MINOR,_STLPORT_PATCHLEVEL)
+# endif
+# if !defined(BOOST_LIB_STD_STLPORT) && defined(_STLPORT_VERSION)
+# define BOOST_LIB_STD_STLPORT BOOST_PREDEF_MAKE_0X_VRP(_STLPORT_VERSION)
+# endif
+# if !defined(BOOST_LIB_STD_STLPORT)
+# define BOOST_LIB_STD_STLPORT BOOST_PREDEF_MAKE_0X_VRP(__SGI_STL_PORT)
+# endif
+#endif
+
+#if BOOST_LIB_STD_STLPORT
+# define BOOST_LIB_STD_STLPORT_AVAILABLE
+#endif
+
+#define BOOST_LIB_STD_STLPORT_NAME "STLport"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_STLPORT,BOOST_LIB_STD_STLPORT_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_LIBRARY_STD_VACPP_H
+#define BOOST_PREDEF_LIBRARY_STD_VACPP_H
+
+#include <boost/predef/library/std/_prefix.h>
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_LIB_STD_IBM`]
+
+[@http://www.ibm.com/software/awdtools/xlcpp/ IBM VACPP Standard C++] library.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__IBMCPP__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_LIB_STD_IBM BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__IBMCPP__)
+# undef BOOST_LIB_STD_IBM
+# define BOOST_LIB_STD_IBM BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_LIB_STD_IBM
+# define BOOST_LIB_STD_IBM_AVAILABLE
+#endif
+
+#define BOOST_LIB_STD_IBM_NAME "IBM VACPP"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_LIB_STD_IBM,BOOST_LIB_STD_IBM_NAME)
+
+
+#endif
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
#define BOOST_PREDEF_MAKE_0X_VVRRP(V) BOOST_VERSION_NUMBER((V&0xFF000)>>12,(V&0xFF0)>>4,(V&0xF))
/*` `BOOST_PREDEF_MAKE_0X_VRRPP000(V)` */
#define BOOST_PREDEF_MAKE_0X_VRRPP000(V) BOOST_VERSION_NUMBER((V&0xF0000000)>>28,(V&0xFF00000)>>20,(V&0xFF000)>>12)
+/*` `BOOST_PREDEF_MAKE_0X_VVRRPP(V)` */
+#define BOOST_PREDEF_MAKE_0X_VVRRPP(V) BOOST_VERSION_NUMBER((V&0xFF0000)>>16,(V&0xFF00)>>8,(V&0xFF))
/*` `BOOST_PREDEF_MAKE_10_VPPP(V)` */
#define BOOST_PREDEF_MAKE_10_VPPP(V) BOOST_VERSION_NUMBER(((V)/1000)%10,0,(V)%1000)
/*` `BOOST_PREDEF_MAKE_10_VRP(V)` */
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2012
+Copyright Franz Detro 2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_H
+#define BOOST_PREDEF_OS_H
+
+#include <boost/predef/os/aix.h>
+#include <boost/predef/os/amigaos.h>
+#include <boost/predef/os/android.h>
+#include <boost/predef/os/beos.h>
+#include <boost/predef/os/bsd.h>
+#include <boost/predef/os/cygwin.h>
+#include <boost/predef/os/haiku.h>
+#include <boost/predef/os/hpux.h>
+#include <boost/predef/os/irix.h>
+#include <boost/predef/os/ios.h>
+#include <boost/predef/os/linux.h>
+#include <boost/predef/os/macos.h>
+#include <boost/predef/os/os400.h>
+#include <boost/predef/os/qnxnto.h>
+#include <boost/predef/os/solaris.h>
+#include <boost/predef/os/unix.h>
+#include <boost/predef/os/vms.h>
+#include <boost/predef/os/windows.h>
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_AIX_H
+#define BOOST_PREDEF_OS_AIX_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_AIX`]
+
+[@http://en.wikipedia.org/wiki/AIX_operating_system IBM AIX] operating system.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`_AIX`] [__predef_detection__]]
+ [[`__TOS_AIX__`] [__predef_detection__]]
+
+ [[`_AIX43`] [4.3.0]]
+ [[`_AIX41`] [4.1.0]]
+ [[`_AIX32`] [3.2.0]]
+ [[`_AIX3`] [3.0.0]]
+ ]
+ */
+
+#define BOOST_OS_AIX BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(_AIX) || defined(__TOS_AIX__) \
+ )
+# undef BOOST_OS_AIX
+# if !defined(BOOST_OS_AIX) && defined(_AIX43)
+# define BOOST_OS_AIX BOOST_VERSION_NUMBER(4,3,0)
+# endif
+# if !defined(BOOST_OS_AIX) && defined(_AIX41)
+# define BOOST_OS_AIX BOOST_VERSION_NUMBER(4,1,0)
+# endif
+# if !defined(BOOST_OS_AIX) && defined(_AIX32)
+# define BOOST_OS_AIX BOOST_VERSION_NUMBER(3,2,0)
+# endif
+# if !defined(BOOST_OS_AIX) && defined(_AIX3)
+# define BOOST_OS_AIX BOOST_VERSION_NUMBER(3,0,0)
+# endif
+# if !defined(BOOST_OS_AIX)
+# define BOOST_OS_AIX BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_OS_AIX
+# define BOOST_OS_AIX_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_AIX_NAME "IBM AIX"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_AIX,BOOST_OS_AIX_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_AMIGAOS_H
+#define BOOST_PREDEF_OS_AMIGAOS_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_AMIGAOS`]
+
+[@http://en.wikipedia.org/wiki/AmigaOS AmigaOS] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`AMIGA`] [__predef_detection__]]
+ [[`__amigaos__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_AMIGAOS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(AMIGA) || defined(__amigaos__) \
+ )
+# undef BOOST_OS_AMIGAOS
+# define BOOST_OS_AMIGAOS BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_AMIGAOS
+# define BOOST_OS_AMIGAOS_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_AMIGAOS_NAME "AmigaOS"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_AMIGAOS,BOOST_OS_AMIGAOS_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_ADROID_H
+#define BOOST_PREDEF_OS_ADROID_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_ANDROID`]
+
+[@http://en.wikipedia.org/wiki/Android_%28operating_system%29 Android] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__ANDROID__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_ANDROID BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__ANDROID__) \
+ )
+# undef BOOST_OS_ANDROID
+# define BOOST_OS_ANDROID BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_ANDROID
+# define BOOST_OS_ANDROID_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_ANDROID_NAME "Android"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_ANDROID,BOOST_OS_ANDROID_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_BEOS_H
+#define BOOST_PREDEF_OS_BEOS_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_BEOS`]
+
+[@http://en.wikipedia.org/wiki/BeOS BeOS] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__BEOS__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_BEOS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__BEOS__) \
+ )
+# undef BOOST_OS_BEOS
+# define BOOST_OS_BEOS BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_BEOS
+# define BOOST_OS_BEOS_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_BEOS_NAME "BeOS"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_BEOS,BOOST_OS_BEOS_NAME)
+
+
+#endif
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
#define BOOST_OS_BSD BOOST_VERSION_NUMBER_NOT_AVAILABLE
#endif
-#if !BOOST_PREDEF_DETAIL_OS_DETECTED && ( \
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
defined(BSD) || \
defined(_SYSTYPE_BSD) \
)
/*
-Copyright Redshift Software, Inc. 2012-2013
+Copyright Rene Rivera 2012-2013
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)
#define BOOST_OS_BSD_BSDI BOOST_VERSION_NUMBER_NOT_AVAILABLE
-#if !BOOST_PREDEF_DETAIL_OS_DETECTED && ( \
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
defined(__bsdi__) \
)
# ifndef BOOST_OS_BSD_AVAILABLE
/*
-Copyright Redshift Software, Inc. 2012-2013
+Copyright Rene Rivera 2012-2013
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)
#define BOOST_OS_BSD_DRAGONFLY BOOST_VERSION_NUMBER_NOT_AVAILABLE
-#if !BOOST_PREDEF_DETAIL_OS_DETECTED && ( \
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
defined(__DragonFly__) \
)
# ifndef BOOST_OS_BSD_AVAILABLE
/*
-Copyright Redshift Software, Inc. 2012-2013
+Copyright Rene Rivera 2012-2013
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)
#define BOOST_OS_BSD_FREE BOOST_VERSION_NUMBER_NOT_AVAILABLE
-#if !BOOST_PREDEF_DETAIL_OS_DETECTED && ( \
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
defined(__FreeBSD__) \
)
# ifndef BOOST_OS_BSD_AVAILABLE
/*
-Copyright Redshift Software, Inc. 2012-2013
+Copyright Rene Rivera 2012-2013
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)
#define BOOST_OS_BSD_NET BOOST_VERSION_NUMBER_NOT_AVAILABLE
-#if !BOOST_PREDEF_DETAIL_OS_DETECTED && ( \
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
defined(__NETBSD__) || defined(__NetBSD__) \
)
# ifndef BOOST_OS_BSD_AVAILABLE
/*
-Copyright Redshift Software, Inc. 2012-2013
+Copyright Rene Rivera 2012-2013
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)
#define BOOST_OS_BSD_OPEN BOOST_VERSION_NUMBER_NOT_AVAILABLE
-#if !BOOST_PREDEF_DETAIL_OS_DETECTED && ( \
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
defined(__OpenBSD__) \
)
# ifndef BOOST_OS_BSD_AVAILABLE
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_CYGWIN_H
+#define BOOST_PREDEF_OS_CYGWIN_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_CYGWIN`]
+
+[@http://en.wikipedia.org/wiki/Cygwin Cygwin] evironment.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__CYGWIN__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_CYGWIN BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__CYGWIN__) \
+ )
+# undef BOOST_OS_CYGWIN
+# define BOOST_OS_CGYWIN BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_CYGWIN
+# define BOOST_OS_CYGWIN_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_CYGWIN_NAME "Cygwin"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_CYGWIN,BOOST_OS_CYGWIN_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Jessica Hamilton 2014
+Copyright Rene Rivera 2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_HAIKU_H
+#define BOOST_PREDEF_OS_HAIKU_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_HAIKU`]
+
+[@http://en.wikipedia.org/wiki/Haiku_(operating_system) Haiku] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__HAIKU__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_HAIKU BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__HAIKU__) \
+ )
+# undef BOOST_OS_HAIKU
+# define BOOST_OS_HAIKU BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_HAIKU
+# define BOOST_OS_HAIKU_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_HAIKU_NAME "Haiku"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_HAIKU,BOOST_OS_HAIKU_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_HPUX_H
+#define BOOST_PREDEF_OS_HPUX_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_HPUX`]
+
+[@http://en.wikipedia.org/wiki/HP-UX HP-UX] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`hpux`] [__predef_detection__]]
+ [[`_hpux`] [__predef_detection__]]
+ [[`__hpux`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_HPUX BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(hpux) || defined(_hpux) || defined(__hpux) \
+ )
+# undef BOOST_OS_HPUX
+# define BOOST_OS_HPUX BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_HPUX
+# define BOOST_OS_HPUX_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_HPUX_NAME "HP-UX"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_HPUX,BOOST_OS_HPUX_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Franz Detro 2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_IOS_H
+#define BOOST_PREDEF_OS_IOS_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_IOS`]
+
+[@http://en.wikipedia.org/wiki/iOS iOS] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__APPLE__`] [__predef_detection__]]
+ [[`__MACH__`] [__predef_detection__]]
+ [[`__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__`] [__predef_detection__]]
+
+ [[`__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__`] [__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__*1000]]
+ ]
+ */
+
+#define BOOST_OS_IOS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__APPLE__) && defined(__MACH__) && \
+ defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) \
+ )
+# undef BOOST_OS_IOS
+# define BOOST_OS_IOS (__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__*1000)
+#endif
+
+#if BOOST_OS_IOS
+# define BOOST_OS_IOS_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_IOS_NAME "iOS"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_IOS,BOOST_OS_IOS_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_IRIX_H
+#define BOOST_PREDEF_OS_IRIX_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_IRIX`]
+
+[@http://en.wikipedia.org/wiki/Irix IRIX] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`sgi`] [__predef_detection__]]
+ [[`__sgi`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_IRIX BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(sgi) || defined(__sgi) \
+ )
+# undef BOOST_OS_IRIX
+# define BOOST_OS_IRIX BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_IRIX
+# define BOOST_OS_IRIX_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_IRIX_NAME "IRIX"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_IRIX,BOOST_OS_IRIX_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_LINUX_H
+#define BOOST_PREDEF_OS_LINUX_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_LINUX`]
+
+[@http://en.wikipedia.org/wiki/Linux Linux] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`linux`] [__predef_detection__]]
+ [[`__linux`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_LINUX BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(linux) || defined(__linux) \
+ )
+# undef BOOST_OS_LINUX
+# define BOOST_OS_LINUX BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_LINUX
+# define BOOST_OS_LINUX_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_LINUX_NAME "Linux"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_LINUX,BOOST_OS_LINUX_NAME)
+
+
+#endif
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
+Copyright Franz Detro 2014
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)
#ifndef BOOST_PREDEF_OS_MACOS_H
#define BOOST_PREDEF_OS_MACOS_H
+/* Special case: iOS will define the same predefs as MacOS, and additionally
+ '__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__'. We can guard against that,
+ but only if we detect iOS first. Hence we will force include iOS detection
+ * before doing any MacOS detection.
+ */
+#include <boost/predef/os/ios.h>
+
#include <boost/predef/version_number.h>
#include <boost/predef/make.h>
#define BOOST_OS_MACOS BOOST_VERSION_NUMBER_NOT_AVAILABLE
-#if !BOOST_PREDEF_DETAIL_OS_DETECTED && ( \
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
defined(macintosh) || defined(Macintosh) || \
(defined(__APPLE__) && defined(__MACH__)) \
)
--- /dev/null
+/*
+Copyright Rene Rivera 2011-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_OS400_H
+#define BOOST_PREDEF_OS_OS400_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_OS400`]
+
+[@http://en.wikipedia.org/wiki/IBM_i IBM OS/400] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__OS400__`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_OS400 BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__OS400__) \
+ )
+# undef BOOST_OS_OS400
+# define BOOST_OS_OS400 BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_OS400
+# define BOOST_OS_OS400_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_OS400_NAME "IBM OS/400"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_OS400,BOOST_OS_OS400_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_QNXNTO_H
+#define BOOST_PREDEF_OS_QNXNTO_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_QNX`]
+
+[@http://en.wikipedia.org/wiki/QNX QNX] operating system.
+Version number available as major, and minor if possible. And
+version 4 is specifically detected.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__QNX__`] [__predef_detection__]]
+ [[`__QNXNTO__`] [__predef_detection__]]
+
+ [[`_NTO_VERSION`] [V.R.0]]
+ [[`__QNX__`] [4.0.0]]
+ ]
+ */
+
+#define BOOST_OS_QNX BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(__QNX__) || defined(__QNXNTO__) \
+ )
+# undef BOOST_OS_QNX
+# if !defined(BOOST_OS_QNX) && defined(_NTO_VERSION)
+# define BOOST_OS_QNX BOOST_PREDEF_MAKE_10_VVRR(_NTO_VERSION)
+# endif
+# if !defined(BOOST_OS_QNX) && defined(__QNX__)
+# define BOOST_OS_QNX BOOST_VERSION_NUMBER(4,0,0)
+# endif
+# if !defined(BOOST_OS_QNX)
+# define BOOST_OS_QNX BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_OS_QNX
+# define BOOST_OS_QNX_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_QNX_NAME "QNX"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_QNX,BOOST_OS_QNX_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_SOLARIS_H
+#define BOOST_PREDEF_OS_SOLARIS_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_SOLARIS`]
+
+[@http://en.wikipedia.org/wiki/Solaris_Operating_Environment Solaris] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`sun`] [__predef_detection__]]
+ [[`__sun`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_SOLARIS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(sun) || defined(__sun) \
+ )
+# undef BOOST_OS_SOLARIS
+# define BOOST_OS_SOLARIS BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_SOLARIS
+# define BOOST_OS_SOLARIS_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_SOLARIS_NAME "Solaris"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_SOLARIS,BOOST_OS_SOLARIS_NAME)
+
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_UNIX_H
+#define BOOST_PREDEF_OS_UNIX_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_UNIX`]
+
+[@http://en.wikipedia.org/wiki/Unix Unix Environment] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`unix`] [__predef_detection__]]
+ [[`__unix`] [__predef_detection__]]
+ [[`_XOPEN_SOURCE`] [__predef_detection__]]
+ [[`_POSIX_SOURCE`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_UNIX BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(unix) || defined(__unix) || \
+ defined(_XOPEN_SOURCE) || defined(_POSIX_SOURCE)
+# undef BOOST_OS_UNIX
+# define BOOST_OS_UNIX BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_UNIX
+# define BOOST_OS_UNIX_AVAILABLE
+#endif
+
+#define BOOST_OS_UNIX_NAME "Unix Environment"
+
+/*`
+[heading `BOOST_OS_SVR4`]
+
+[@http://en.wikipedia.org/wiki/UNIX_System_V SVR4 Environment] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__sysv__`] [__predef_detection__]]
+ [[`__SVR4`] [__predef_detection__]]
+ [[`__svr4__`] [__predef_detection__]]
+ [[`_SYSTYPE_SVR4`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_OS_SVR4 BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__sysv__) || defined(__SVR4) || \
+ defined(__svr4__) || defined(_SYSTYPE_SVR4)
+# undef BOOST_OS_SVR4
+# define BOOST_OS_SVR4 BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_OS_SVR4
+# define BOOST_OS_SVR4_AVAILABLE
+#endif
+
+#define BOOST_OS_SVR4_NAME "SVR4 Environment"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_UNIX,BOOST_OS_UNIX_NAME)
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_SVR4,BOOST_OS_SVR4_NAME)
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2011-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OS_VMS_H
+#define BOOST_PREDEF_OS_VMS_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_OS_VMS`]
+
+[@http://en.wikipedia.org/wiki/Vms VMS] operating system.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`VMS`] [__predef_detection__]]
+ [[`__VMS`] [__predef_detection__]]
+
+ [[`__VMS_VER`] [V.R.P]]
+ ]
+ */
+
+#define BOOST_OS_VMS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
+ defined(VMS) || defined(__VMS) \
+ )
+# undef BOOST_OS_VMS
+# if defined(__VMS_VER)
+# define BOOST_OS_VMS BOOST_PREDEF_MAKE_10_VVRR00PP00(__VMS_VER)
+# else
+# define BOOST_OS_VMS BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#if BOOST_OS_VMS
+# define BOOST_OS_VMS_AVAILABLE
+# include <boost/predef/detail/os_detected.h>
+#endif
+
+#define BOOST_OS_VMS_NAME "VMS"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_OS_VMS,BOOST_OS_VMS_NAME)
+
+
+#endif
/*
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
#define BOOST_OS_WINDOWS BOOST_VERSION_NUMBER_NOT_AVAILABLE
-#if !BOOST_PREDEF_DETAIL_OS_DETECTED && ( \
+#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
defined(_WIN32) || defined(_WIN64) || \
defined(__WIN32__) || defined(__TOS_WIN__) || \
defined(__WINDOWS__) \
--- /dev/null
+/*
+Copyright Rene Rivera 2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_OTHER_H
+#define BOOST_PREDEF_OTHER_H
+
+#include <boost/predef/other/endian.h>
+/*#include <boost/predef/other/.h>*/
+
+#endif
/*
-Copyright Redshift Software, Inc. 2013
+Copyright Rene Rivera 2013-2014
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/predef/library/c/gnu.h>
#include <boost/predef/os/macos.h>
#include <boost/predef/os/bsd.h>
+#include <boost/predef/os/android.h>
/*`
[heading `BOOST_ENDIAN_*`]
*/
#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \
!BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD
-# if BOOST_LIB_C_GNU
+# if BOOST_LIB_C_GNU || BOOST_OS_ANDROID
# include <endian.h>
# else
# if BOOST_OS_MACOS
# endif
# endif
# if defined(__BYTE_ORDER)
-# if (__BYTE_ORDER == __BIG_ENDIAN)
+# if defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN)
# undef BOOST_ENDIAN_BIG_BYTE
# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE
# endif
-# if (__BYTE_ORDER == __LITTLE_ENDIAN)
+# if defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN)
# undef BOOST_ENDIAN_LITTLE_BYTE
# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE
# endif
-# if (__BYTE_ORDER == __PDP_ENDIAN)
+# if defined(__PDP_ENDIAN) && (__BYTE_ORDER == __PDP_ENDIAN)
# undef BOOST_ENDIAN_LITTLE_WORD
# define BOOST_ENDIAN_LITTLE_WORD BOOST_VERSION_NUMBER_AVAILABLE
# endif
# endif
# if !defined(__BYTE_ORDER) && defined(_BYTE_ORDER)
-# if (_BYTE_ORDER == _BIG_ENDIAN)
+# if defined(_BIG_ENDIAN) && (_BYTE_ORDER == _BIG_ENDIAN)
# undef BOOST_ENDIAN_BIG_BYTE
# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE
# endif
-# if (_BYTE_ORDER == _LITTLE_ENDIAN)
+# if defined(_LITTLE_ENDIAN) && (_BYTE_ORDER == _LITTLE_ENDIAN)
# undef BOOST_ENDIAN_LITTLE_BYTE
# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE
# endif
-# if (_BYTE_ORDER == _PDP_ENDIAN)
+# if defined(_PDP_ENDIAN) && (_BYTE_ORDER == _PDP_ENDIAN)
# undef BOOST_ENDIAN_LITTLE_WORD
# define BOOST_ENDIAN_LITTLE_WORD BOOST_VERSION_NUMBER_AVAILABLE
# endif
*/
#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \
!BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD
-# if !BOOST_ENDIAN_BIG_BYTE
-# if (defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)) || \
- defined(__ARMEB__) || \
- defined(__THUMBEB__) || \
- defined(__AARCH64EB__) || \
- defined(_MIPSEB) || \
- defined(__MIPSEB) || \
- defined(__MIPSEB__)
-# undef BOOST_ENDIAN_BIG_BYTE
-# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE
-# endif
+# if (defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)) || \
+ (defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)) || \
+ defined(__ARMEB__) || \
+ defined(__THUMBEB__) || \
+ defined(__AARCH64EB__) || \
+ defined(_MIPSEB) || \
+ defined(__MIPSEB) || \
+ defined(__MIPSEB__)
+# undef BOOST_ENDIAN_BIG_BYTE
+# define BOOST_ENDIAN_BIG_BYTE BOOST_VERSION_NUMBER_AVAILABLE
# endif
#endif
*/
#if !BOOST_ENDIAN_BIG_BYTE && !BOOST_ENDIAN_BIG_WORD && \
!BOOST_ENDIAN_LITTLE_BYTE && !BOOST_ENDIAN_LITTLE_WORD
-# if !BOOST_ENDIAN_LITTLE_BYTE
-# if (defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || \
- defined(__ARMEL__) || \
- defined(__THUMBEL__) || \
- defined(__AARCH64EL__) || \
- defined(_MIPSEL) || \
- defined(__MIPSEL) || \
- defined(__MIPSEL__)
-# undef BOOST_ENDIAN_LITTLE_BYTE
-# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE
-# endif
+# if (defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || \
+ (defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)) || \
+ defined(__ARMEL__) || \
+ defined(__THUMBEL__) || \
+ defined(__AARCH64EL__) || \
+ defined(_MIPSEL) || \
+ defined(__MIPSEL) || \
+ defined(__MIPSEL__)
+# undef BOOST_ENDIAN_LITTLE_BYTE
+# define BOOST_ENDIAN_LITTLE_BYTE BOOST_VERSION_NUMBER_AVAILABLE
# endif
#endif
# include <boost/predef/architecture.h>
# if BOOST_ARCH_M68K || \
BOOST_ARCH_PARISK || \
+ BOOST_ARCH_SPARC || \
BOOST_ARCH_SYS370 || \
BOOST_ARCH_SYS390 || \
BOOST_ARCH_Z
--- /dev/null
+/*
+Copyright Rene Rivera 2013
+Copyright (c) Microsoft Corporation 2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_PLATFORM_H
+#define BOOST_PREDEF_PLATFORM_H
+
+#include <boost/predef/platform/mingw.h>
+#include <boost/predef/platform/windows_desktop.h>
+#include <boost/predef/platform/windows_store.h>
+#include <boost/predef/platform/windows_phone.h>
+#include <boost/predef/platform/windows_runtime.h>
+/*#include <boost/predef/platform/.h>*/
+
+#endif
--- /dev/null
+/*
+Copyright Rene Rivera 2008-2013
+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)
+*/
+
+#ifndef BOOST_PREDEF_COMPILER_MINGW_H
+#define BOOST_PREDEF_COMPILER_MINGW_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+
+/*`
+[heading `BOOST_PLAT_MINGW`]
+
+[@http://en.wikipedia.org/wiki/MinGW MinGW] platform.
+Version number available as major, minor, and patch.
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`__MINGW32__`] [__predef_detection__]]
+ [[`__MINGW64__`] [__predef_detection__]]
+
+ [[`__MINGW64_VERSION_MAJOR`, `__MINGW64_VERSION_MINOR`] [V.R.0]]
+ [[`__MINGW32_VERSION_MAJOR`, `__MINGW32_VERSION_MINOR`] [V.R.0]]
+ ]
+ */
+
+#define BOOST_PLAT_MINGW BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if defined(__MINGW32__) || defined(__MINGW64__)
+# include <_mingw.h>
+# if !defined(BOOST_PLAT_MINGW_DETECTION) && (defined(__MINGW64_VERSION_MAJOR) && defined(__MINGW64_VERSION_MINOR))
+# define BOOST_PLAT_MINGW_DETECTION \
+ BOOST_VERSION_NUMBER(__MINGW64_VERSION_MAJOR,__MINGW64_VERSION_MINOR,0)
+# endif
+# if !defined(BOOST_PLAT_MINGW_DETECTION) && (defined(__MINGW32_VERSION_MAJOR) && defined(__MINGW32_VERSION_MINOR))
+# define BOOST_PLAT_MINGW_DETECTION \
+ BOOST_VERSION_NUMBER(__MINGW32_MAJOR_VERSION,__MINGW32_MINOR_VERSION,0)
+# endif
+# if !defined(BOOST_PLAT_MINGW_DETECTION)
+# define BOOST_PLAT_MINGW_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
+# endif
+#endif
+
+#ifdef BOOST_PLAT_MINGW_DETECTION
+# define BOOST_PLAT_MINGW_AVAILABLE
+# if defined(BOOST_PREDEF_DETAIL_PLAT_DETECTED)
+# define BOOST_PLAT_MINGW_EMULATED BOOST_PLAT_MINGW_DETECTION
+# else
+# undef BOOST_PLAT_MINGW
+# define BOOST_PLAT_MINGW BOOST_PLAT_MINGW_DETECTION
+# endif
+# include <boost/predef/detail/platform_detected.h>
+#endif
+
+#define BOOST_PLAT_MINGW_NAME "MinGW"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_MINGW,BOOST_PLAT_MINGW_NAME)
+
+#ifdef BOOST_PLAT_MINGW_EMULATED
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_MINGW_EMULATED,BOOST_PLAT_MINGW_NAME)
+#endif
+
+
+#endif
--- /dev/null
+/*
+Copyright (c) Microsoft Corporation 2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_PLAT_WINDOWS_DESKTOP_H
+#define BOOST_PREDEF_PLAT_WINDOWS_DESKTOP_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+#include <boost/predef/os/windows.h>
+
+/*`
+[heading `BOOST_PLAT_WINDOWS_DESKTOP`]
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`!WINAPI_FAMILY`] [__predef_detection__]]
+ [[`WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_PLAT_WINDOWS_DESKTOP BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if BOOST_OS_WINDOWS && \
+ ( !defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP) )
+# undef BOOST_PLAT_WINDOWS_DESKTOP
+# define BOOST_PLAT_WINDOWS_DESKTOP BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_PLAT_WINDOWS_DESKTOP
+# define BOOST_PLAT_WINDOWS_DESKTOP_AVALIABLE
+# include <boost/predef/detail/platform_detected.h>
+#endif
+
+#define BOOST_PLAT_WINDOWS_DESKTOP_NAME "Windows Desktop"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_DESKTOP,BOOST_PLAT_WINDOWS_DESKTOP_NAME)
+
+#endif
--- /dev/null
+/*
+Copyright (c) Microsoft Corporation 2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_PLAT_WINDOWS_PHONE_H
+#define BOOST_PREDEF_PLAT_WINDOWS_PHONE_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+#include <boost/predef/os/windows.h>
+
+/*`
+[heading `BOOST_PLAT_WINDOWS_PHONE`]
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_PLAT_WINDOWS_PHONE BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if BOOST_OS_WINDOWS && defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
+# undef BOOST_PLAT_WINDOWS_PHONE
+# define BOOST_PLAT_WINDOWS_PHONE BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_PLAT_WINDOWS_PHONE
+# define BOOST_PLAT_WINDOWS_PHONE_AVALIABLE
+# include <boost/predef/detail/platform_detected.h>
+#endif
+
+#define BOOST_PLAT_WINDOWS_PHONE_NAME "Windows Phone"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_PHONE,BOOST_PLAT_WINDOWS_PHONE_NAME)
+
+#endif
--- /dev/null
+/*
+Copyright (c) Microsoft Corporation 2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_PLAT_WINDOWS_RUNTIME_H
+#define BOOST_PREDEF_PLAT_WINDOWS_RUNTIME_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+#include <boost/predef/os/windows.h>
+
+/*`
+[heading `BOOST_PLAT_WINDOWS_RUNTIME`]
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`WINAPI_FAMILY == WINAPI_FAMILY_APP`] [__predef_detection__]]
+ [[`WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_PLAT_WINDOWS_RUNTIME BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if BOOST_OS_WINDOWS && defined(WINAPI_FAMILY) && \
+ ( WINAPI_FAMILY == WINAPI_FAMILY_APP || WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP )
+# undef BOOST_PLAT_WINDOWS_RUNTIME
+# define BOOST_PLAT_WINDOWS_RUNTIME BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_PLAT_WINDOWS_RUNTIME
+# define BOOST_PLAT_WINDOWS_RUNTIME_AVALIABLE
+# include <boost/predef/detail/platform_detected.h>
+#endif
+
+#define BOOST_PLAT_WINDOWS_RUNTIME_NAME "Windows Runtime"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_RUNTIME,BOOST_PLAT_WINDOWS_RUNTIME_NAME)
+
+#endif
--- /dev/null
+/*
+Copyright (c) Microsoft Corporation 2014
+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)
+*/
+
+#ifndef BOOST_PREDEF_PLAT_WINDOWS_STORE_H
+#define BOOST_PREDEF_PLAT_WINDOWS_STORE_H
+
+#include <boost/predef/version_number.h>
+#include <boost/predef/make.h>
+#include <boost/predef/os/windows.h>
+
+/*`
+[heading `BOOST_PLAT_WINDOWS_STORE`]
+
+[table
+ [[__predef_symbol__] [__predef_version__]]
+
+ [[`WINAPI_FAMILY == WINAPI_FAMILY_APP`] [__predef_detection__]]
+ ]
+ */
+
+#define BOOST_PLAT_WINDOWS_STORE BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+#if BOOST_OS_WINDOWS && defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_APP
+# undef BOOST_PLAT_WINDOWS_STORE
+# define BOOST_PLAT_WINDOWS_STORE BOOST_VERSION_NUMBER_AVAILABLE
+#endif
+
+#if BOOST_PLAT_WINDOWS_STORE
+# define BOOST_PLAT_WINDOWS_STORE_AVALIABLE
+# include <boost/predef/detail/platform_detected.h>
+#endif
+
+#define BOOST_PLAT_WINDOWS_STORE_NAME "Windows Store"
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_WINDOWS_STORE,BOOST_PLAT_WINDOWS_STORE_NAME)
+
+#endif
/*
Copyright Rene Rivera 2005
-Copyright Redshift Software, Inc. 2008-2013
+Copyright Rene Rivera 2008-2013
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)
# elif defined(__MWERKS__) && __MWERKS__ >= 0x3200
# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
# elif defined(__EDG__) || defined(__EDG_VERSION__)
-# if defined(_MSC_VER) && __EDG_VERSION__ >= 308
+# if defined(_MSC_VER) && (defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308)
# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MSVC())
# else
# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_EDG() | BOOST_PP_CONFIG_STRICT())
# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
# elif defined(__BORLANDC__) || defined(__IBMC__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_BCC())
-# elif defined(_MSC_VER)
+# elif defined(_MSC_VER) && !defined(__clang__)
# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MSVC())
# else
# define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
#
# if !defined BOOST_PP_VARIADICS
# /* variadic support explicitly disabled for all untested compilers */
-# if defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __clang__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC && !defined __EDG__ || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI
+# if defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC && !defined __EDG__ || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI
# define BOOST_PP_VARIADICS 0
# /* VC++ (C/C++) */
-# elif defined _MSC_VER && _MSC_VER >= 1400 && !defined __EDG__
-# if _MSC_VER >= 1400
-# define BOOST_PP_VARIADICS 1
-# define BOOST_PP_VARIADICS_MSVC 1
-# else
-# define BOOST_PP_VARIADICS 0
-# endif
+# elif defined _MSC_VER && _MSC_VER >= 1400 && (!defined __EDG__ || defined(__INTELLISENSE__)) && !defined __clang__
+# define BOOST_PP_VARIADICS 1
+# define BOOST_PP_VARIADICS_MSVC 1
# /* Wave (C/C++), GCC (C++) */
# elif defined __WAVE__ && __WAVE_HAS_VARIADICS__ || defined __GNUC__ && __GXX_EXPERIMENTAL_CXX0X__
# define BOOST_PP_VARIADICS 1
# elif !BOOST_PP_VARIADICS + 1 < 2
# undef BOOST_PP_VARIADICS
# define BOOST_PP_VARIADICS 1
-# if defined _MSC_VER && _MSC_VER >= 1400 && !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __clang__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI)
+# if defined _MSC_VER && _MSC_VER >= 1400 && (defined(__INTELLISENSE__) || !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __clang__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI))
# define BOOST_PP_VARIADICS_MSVC 1
# endif
# else
--- /dev/null
+# /* **************************************************************************
+# * *
+# * (C) Copyright Paul Mensonides 2002.
+# * 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)
+# * *
+# ************************************************************************** */
+#
+# ifndef BOOST_PREPROCESSOR_DETAIL_SPLIT_HPP
+# define BOOST_PREPROCESSOR_DETAIL_SPLIT_HPP
+#
+# include <boost/preprocessor/config/config.hpp>
+#
+# /* BOOST_PP_SPLIT */
+#
+# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC()
+# define BOOST_PP_SPLIT(n, im) BOOST_PP_SPLIT_I((n, im))
+# define BOOST_PP_SPLIT_I(par) BOOST_PP_SPLIT_II ## par
+# define BOOST_PP_SPLIT_II(n, a, b) BOOST_PP_SPLIT_ ## n(a, b)
+# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
+# define BOOST_PP_SPLIT(n, im) BOOST_PP_SPLIT_I(n((im)))
+# define BOOST_PP_SPLIT_I(n) BOOST_PP_SPLIT_ID(BOOST_PP_SPLIT_II_ ## n)
+# define BOOST_PP_SPLIT_II_0(s) BOOST_PP_SPLIT_ID(BOOST_PP_SPLIT_0 s)
+# define BOOST_PP_SPLIT_II_1(s) BOOST_PP_SPLIT_ID(BOOST_PP_SPLIT_1 s)
+# define BOOST_PP_SPLIT_ID(id) id
+# else
+# define BOOST_PP_SPLIT(n, im) BOOST_PP_SPLIT_I(n)(im)
+# define BOOST_PP_SPLIT_I(n) BOOST_PP_SPLIT_ ## n
+# endif
+#
+# define BOOST_PP_SPLIT_0(a, b) a
+# define BOOST_PP_SPLIT_1(a, b) b
+#
+# endif
--- /dev/null
+# /* **************************************************************************
+# * *
+# * (C) Copyright Edward Diener 2014.
+# * 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 for most recent version. */
+#
+#ifndef BOOST_PREPROCESSOR_DETAIL_IS_EMPTY_HPP
+#define BOOST_PREPROCESSOR_DETAIL_IS_EMPTY_HPP
+
+#include <boost/preprocessor/punctuation/is_begin_parens.hpp>
+
+#if BOOST_PP_VARIADICS_MSVC
+
+# pragma warning(once:4002)
+
+#define BOOST_PP_DETAIL_IS_EMPTY_IIF_0(t, b) b
+#define BOOST_PP_DETAIL_IS_EMPTY_IIF_1(t, b) t
+
+#else
+
+#define BOOST_PP_DETAIL_IS_EMPTY_IIF_0(t, ...) __VA_ARGS__
+#define BOOST_PP_DETAIL_IS_EMPTY_IIF_1(t, ...) t
+
+#endif
+
+#if BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400
+
+#define BOOST_PP_DETAIL_IS_EMPTY_PROCESS(param) \
+ BOOST_PP_IS_BEGIN_PARENS \
+ ( \
+ BOOST_PP_DETAIL_IS_EMPTY_NON_FUNCTION_C param () \
+ ) \
+/**/
+
+#else
+
+#define BOOST_PP_DETAIL_IS_EMPTY_PROCESS(...) \
+ BOOST_PP_IS_BEGIN_PARENS \
+ ( \
+ BOOST_PP_DETAIL_IS_EMPTY_NON_FUNCTION_C __VA_ARGS__ () \
+ ) \
+/**/
+
+#endif
+
+#define BOOST_PP_DETAIL_IS_EMPTY_PRIMITIVE_CAT(a, b) a ## b
+#define BOOST_PP_DETAIL_IS_EMPTY_IIF(bit) BOOST_PP_DETAIL_IS_EMPTY_PRIMITIVE_CAT(BOOST_PP_DETAIL_IS_EMPTY_IIF_,bit)
+#define BOOST_PP_DETAIL_IS_EMPTY_NON_FUNCTION_C(...) ()
+
+#endif /* BOOST_PREPROCESSOR_DETAIL_IS_EMPTY_HPP */
# ifndef BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP
# define BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP
#
+# include <boost/preprocessor/config/config.hpp>
+#
# /* BOOST_PP_EMPTY */
#
# define BOOST_PP_EMPTY()
--- /dev/null
+# /* Copyright (C) 2001
+# * Housemarque Oy
+# * http://www.housemarque.com
+# *
+# * 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)
+# */
+#
+# /* Revised by Paul Mensonides (2002) */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_FACILITIES_EXPAND_HPP
+# define BOOST_PREPROCESSOR_FACILITIES_EXPAND_HPP
+#
+# include <boost/preprocessor/config/config.hpp>
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC()
+# define BOOST_PP_EXPAND(x) BOOST_PP_EXPAND_I(x)
+# else
+# define BOOST_PP_EXPAND(x) BOOST_PP_EXPAND_OO((x))
+# define BOOST_PP_EXPAND_OO(par) BOOST_PP_EXPAND_I ## par
+# endif
+#
+# define BOOST_PP_EXPAND_I(x) x
+#
+# endif
--- /dev/null
+# /* **************************************************************************
+# * *
+# * (C) Copyright Paul Mensonides 2003.
+# * 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 for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_FACILITIES_IS_1_HPP
+# define BOOST_PREPROCESSOR_FACILITIES_IS_1_HPP
+#
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/facilities/is_empty.hpp>
+#
+# /* BOOST_PP_IS_1 */
+#
+# define BOOST_PP_IS_1(x) BOOST_PP_IS_EMPTY(BOOST_PP_CAT(BOOST_PP_IS_1_HELPER_, x))
+# define BOOST_PP_IS_1_HELPER_1
+#
+# endif
--- /dev/null
+# /* **************************************************************************
+# * *
+# * (C) Copyright Paul Mensonides 2003.
+# * (C) Copyright Edward Diener 2014.
+# * 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 for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_HPP
+# define BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_HPP
+#
+# include <boost/preprocessor/config/config.hpp>
+#
+# if BOOST_PP_VARIADICS
+#
+# include <boost/preprocessor/facilities/is_empty_variadic.hpp>
+#
+# else
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC()
+# include <boost/preprocessor/tuple/elem.hpp>
+# include <boost/preprocessor/facilities/identity.hpp>
+# else
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/detail/split.hpp>
+# endif
+#
+# /* BOOST_PP_IS_EMPTY */
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC()
+# define BOOST_PP_IS_EMPTY(x) BOOST_PP_IS_EMPTY_I(x BOOST_PP_IS_EMPTY_HELPER)
+# define BOOST_PP_IS_EMPTY_I(contents) BOOST_PP_TUPLE_ELEM(2, 1, (BOOST_PP_IS_EMPTY_DEF_ ## contents()))
+# define BOOST_PP_IS_EMPTY_DEF_BOOST_PP_IS_EMPTY_HELPER 1, BOOST_PP_IDENTITY(1)
+# define BOOST_PP_IS_EMPTY_HELPER() , 0
+# else
+# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
+# define BOOST_PP_IS_EMPTY(x) BOOST_PP_IS_EMPTY_I(BOOST_PP_IS_EMPTY_HELPER x ())
+# define BOOST_PP_IS_EMPTY_I(test) BOOST_PP_IS_EMPTY_II(BOOST_PP_SPLIT(0, BOOST_PP_CAT(BOOST_PP_IS_EMPTY_DEF_, test)))
+# define BOOST_PP_IS_EMPTY_II(id) id
+# else
+# define BOOST_PP_IS_EMPTY(x) BOOST_PP_IS_EMPTY_I((BOOST_PP_IS_EMPTY_HELPER x ()))
+# define BOOST_PP_IS_EMPTY_I(par) BOOST_PP_IS_EMPTY_II ## par
+# define BOOST_PP_IS_EMPTY_II(test) BOOST_PP_SPLIT(0, BOOST_PP_CAT(BOOST_PP_IS_EMPTY_DEF_, test))
+# endif
+# define BOOST_PP_IS_EMPTY_HELPER() 1
+# define BOOST_PP_IS_EMPTY_DEF_1 1, BOOST_PP_NIL
+# define BOOST_PP_IS_EMPTY_DEF_BOOST_PP_IS_EMPTY_HELPER 0, BOOST_PP_NIL
+# endif
+#
+# endif /* BOOST_PP_VARIADICS */
+#
+# endif /* BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_HPP */
--- /dev/null
+# /* **************************************************************************
+# * *
+# * (C) Copyright Edward Diener 2014.
+# * 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 for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_VARIADIC_HPP
+# define BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_VARIADIC_HPP
+#
+# include <boost/preprocessor/config/config.hpp>
+#
+# if BOOST_PP_VARIADICS
+#
+# include <boost/preprocessor/punctuation/is_begin_parens.hpp>
+# include <boost/preprocessor/facilities/detail/is_empty.hpp>
+#
+#if BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400
+#
+#define BOOST_PP_IS_EMPTY(param) \
+ BOOST_PP_DETAIL_IS_EMPTY_IIF \
+ ( \
+ BOOST_PP_IS_BEGIN_PARENS \
+ ( \
+ param \
+ ) \
+ ) \
+ ( \
+ BOOST_PP_IS_EMPTY_ZERO, \
+ BOOST_PP_DETAIL_IS_EMPTY_PROCESS \
+ ) \
+ (param) \
+/**/
+#define BOOST_PP_IS_EMPTY_ZERO(param) 0
+# else
+#define BOOST_PP_IS_EMPTY(...) \
+ BOOST_PP_DETAIL_IS_EMPTY_IIF \
+ ( \
+ BOOST_PP_IS_BEGIN_PARENS \
+ ( \
+ __VA_ARGS__ \
+ ) \
+ ) \
+ ( \
+ BOOST_PP_IS_EMPTY_ZERO, \
+ BOOST_PP_DETAIL_IS_EMPTY_PROCESS \
+ ) \
+ (__VA_ARGS__) \
+/**/
+#define BOOST_PP_IS_EMPTY_ZERO(...) 0
+# endif /* BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400 */
+# endif /* BOOST_PP_VARIADICS */
+# endif /* BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_VARIADIC_HPP */
--- /dev/null
+# /* **************************************************************************
+# * *
+# * (C) Copyright Edward Diener 2014.
+# * 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 for most recent version. */
+#
+#ifndef BOOST_PREPROCESSOR_DETAIL_IS_BEGIN_PARENS_HPP
+#define BOOST_PREPROCESSOR_DETAIL_IS_BEGIN_PARENS_HPP
+
+#if BOOST_PP_VARIADICS_MSVC
+
+#include <boost/preprocessor/facilities/empty.hpp>
+
+#define BOOST_PP_DETAIL_VD_IBP_CAT(a, b) BOOST_PP_DETAIL_VD_IBP_CAT_I(a, b)
+#define BOOST_PP_DETAIL_VD_IBP_CAT_I(a, b) BOOST_PP_DETAIL_VD_IBP_CAT_II(a ## b)
+#define BOOST_PP_DETAIL_VD_IBP_CAT_II(res) res
+
+#define BOOST_PP_DETAIL_IBP_SPLIT(i, ...) \
+ BOOST_PP_DETAIL_VD_IBP_CAT(BOOST_PP_DETAIL_IBP_PRIMITIVE_CAT(BOOST_PP_DETAIL_IBP_SPLIT_,i)(__VA_ARGS__),BOOST_PP_EMPTY()) \
+/**/
+
+#define BOOST_PP_DETAIL_IBP_IS_VARIADIC_C(...) 1 1
+
+#else
+
+#define BOOST_PP_DETAIL_IBP_SPLIT(i, ...) \
+ BOOST_PP_DETAIL_IBP_PRIMITIVE_CAT(BOOST_PP_DETAIL_IBP_SPLIT_,i)(__VA_ARGS__) \
+/**/
+
+#define BOOST_PP_DETAIL_IBP_IS_VARIADIC_C(...) 1
+
+#endif /* BOOST_PP_VARIADICS_MSVC */
+
+#define BOOST_PP_DETAIL_IBP_SPLIT_0(a, ...) a
+#define BOOST_PP_DETAIL_IBP_SPLIT_1(a, ...) __VA_ARGS__
+
+#define BOOST_PP_DETAIL_IBP_CAT(a, ...) BOOST_PP_DETAIL_IBP_PRIMITIVE_CAT(a,__VA_ARGS__)
+#define BOOST_PP_DETAIL_IBP_PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__
+
+#define BOOST_PP_DETAIL_IBP_IS_VARIADIC_R_1 1,
+#define BOOST_PP_DETAIL_IBP_IS_VARIADIC_R_BOOST_PP_DETAIL_IBP_IS_VARIADIC_C 0,
+
+#endif /* BOOST_PREPROCESSOR_DETAIL_IS_BEGIN_PARENS_HPP */
--- /dev/null
+# /* **************************************************************************
+# * *
+# * (C) Copyright Edward Diener 2014.
+# * 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 for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_IS_BEGIN_PARENS_HPP
+# define BOOST_PREPROCESSOR_IS_BEGIN_PARENS_HPP
+
+# include <boost/preprocessor/config/config.hpp>
+
+#if BOOST_PP_VARIADICS
+
+#include <boost/preprocessor/punctuation/detail/is_begin_parens.hpp>
+
+#if BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400
+
+#define BOOST_PP_IS_BEGIN_PARENS(param) \
+ BOOST_PP_DETAIL_IBP_SPLIT \
+ ( \
+ 0, \
+ BOOST_PP_DETAIL_IBP_CAT \
+ ( \
+ BOOST_PP_DETAIL_IBP_IS_VARIADIC_R_, \
+ BOOST_PP_DETAIL_IBP_IS_VARIADIC_C param \
+ ) \
+ ) \
+/**/
+
+#else
+
+#define BOOST_PP_IS_BEGIN_PARENS(...) \
+ BOOST_PP_DETAIL_IBP_SPLIT \
+ ( \
+ 0, \
+ BOOST_PP_DETAIL_IBP_CAT \
+ ( \
+ BOOST_PP_DETAIL_IBP_IS_VARIADIC_R_, \
+ BOOST_PP_DETAIL_IBP_IS_VARIADIC_C __VA_ARGS__ \
+ ) \
+ ) \
+/**/
+
+#endif /* BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400 */
+#endif /* BOOST_PP_VARIADICS */
+#endif /* BOOST_PREPROCESSOR_IS_BEGIN_PARENS_HPP */
#
# include <boost/preprocessor/arithmetic/inc.hpp>
# include <boost/preprocessor/config/config.hpp>
-# include <boost/preprocessor/facilities/empty.hpp>
+# include <boost/preprocessor/facilities/identity.hpp>
# include <boost/preprocessor/seq/detail/split.hpp>
# include <boost/preprocessor/tuple/elem.hpp>
#
# /* BOOST_PP_SEQ_REST_N */
#
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
-# define BOOST_PP_SEQ_REST_N(n, seq) BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_SEQ_SPLIT(BOOST_PP_INC(n), (nil) seq BOOST_PP_EMPTY))()
+# define BOOST_PP_SEQ_REST_N(n, seq) BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_SEQ_SPLIT(BOOST_PP_INC(n), BOOST_PP_IDENTITY( (nil) seq )))()
# else
# define BOOST_PP_SEQ_REST_N(n, seq) BOOST_PP_SEQ_REST_N_I(n, seq)
-# define BOOST_PP_SEQ_REST_N_I(n, seq) BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_SEQ_SPLIT(BOOST_PP_INC(n), (nil) seq BOOST_PP_EMPTY))()
+# define BOOST_PP_SEQ_REST_N_I(n, seq) BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_SEQ_SPLIT(BOOST_PP_INC(n), BOOST_PP_IDENTITY( (nil) seq )))()
# endif
#
# endif
--- /dev/null
+# /* **************************************************************************
+# * *
+# * (C) Copyright Edward Diener 2014. *
+# * 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 for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_TUPLE_DETAIL_IS_SINGLE_RETURN_HPP
+# define BOOST_PREPROCESSOR_TUPLE_DETAIL_IS_SINGLE_RETURN_HPP
+#
+# include <boost/preprocessor/config/config.hpp>
+#
+# /* BOOST_PP_TUPLE_IS_SINGLE_RETURN */
+#
+# if BOOST_PP_VARIADICS && BOOST_PP_VARIADICS_MSVC
+# include <boost/preprocessor/control/iif.hpp>
+# include <boost/preprocessor/facilities/is_1.hpp>
+# include <boost/preprocessor/tuple/size.hpp>
+# define BOOST_PP_TUPLE_IS_SINGLE_RETURN(sr,nsr,tuple) \
+ BOOST_PP_IIF(BOOST_PP_IS_1(BOOST_PP_TUPLE_SIZE(tuple)),sr,nsr) \
+ /**/
+# endif /* BOOST_PP_VARIADICS && BOOST_PP_VARIADICS_MSVC */
+#
+# endif /* BOOST_PREPROCESSOR_TUPLE_DETAIL_IS_SINGLE_RETURN_HPP */
# */
#
# /* Revised by Paul Mensonides (2002-2011) */
-# /* Revised by Edward Diener (2011) */
+# /* Revised by Edward Diener (2011,2014) */
#
# /* See http://www.boost.org for most recent version. */
#
#
# include <boost/preprocessor/cat.hpp>
# include <boost/preprocessor/config/config.hpp>
+# include <boost/preprocessor/facilities/expand.hpp>
# include <boost/preprocessor/facilities/overload.hpp>
# include <boost/preprocessor/tuple/rem.hpp>
# include <boost/preprocessor/variadic/elem.hpp>
+# include <boost/preprocessor/tuple/detail/is_single_return.hpp>
#
# if BOOST_PP_VARIADICS
# if BOOST_PP_VARIADICS_MSVC
# define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_TUPLE_ELEM_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__), (__VA_ARGS__))
# define BOOST_PP_TUPLE_ELEM_I(m, args) BOOST_PP_TUPLE_ELEM_II(m, args)
# define BOOST_PP_TUPLE_ELEM_II(m, args) BOOST_PP_CAT(m ## args,)
+/*
+ Use BOOST_PP_REM_CAT if it is a single element tuple ( which might be empty )
+ else use BOOST_PP_REM. This fixes a VC++ problem with an empty tuple and BOOST_PP_TUPLE_ELEM
+ functionality. See tuple_elem_bug_test.cxx.
+*/
+# define BOOST_PP_TUPLE_ELEM_O_2(n, tuple) \
+ BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_EXPAND(BOOST_PP_TUPLE_IS_SINGLE_RETURN(BOOST_PP_REM_CAT,BOOST_PP_REM,tuple) tuple)) \
+ /**/
# else
# define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__)(__VA_ARGS__)
+# define BOOST_PP_TUPLE_ELEM_O_2(n, tuple) BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_REM tuple)
# endif
-# define BOOST_PP_TUPLE_ELEM_O_2(n, tuple) BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_REM tuple)
# define BOOST_PP_TUPLE_ELEM_O_3(size, n, tuple) BOOST_PP_TUPLE_ELEM_O_2(n, tuple)
# else
# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
# /* **************************************************************************
# * *
# * (C) Copyright Paul Mensonides 2002-2011. *
-# * (C) Copyright Edward Diener 2011. *
+# * (C) Copyright Edward Diener 2011,2013. *
# * 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/preprocessor/cat.hpp>
# include <boost/preprocessor/config/config.hpp>
+# include <boost/preprocessor/facilities/expand.hpp>
# include <boost/preprocessor/facilities/overload.hpp>
+# include <boost/preprocessor/tuple/detail/is_single_return.hpp>
#
# /* BOOST_PP_REM */
#
# if BOOST_PP_VARIADICS
+# if BOOST_PP_VARIADICS_MSVC
+ /* To be used internally when __VA_ARGS__ could be empty ( or is a single element ) */
+# define BOOST_PP_REM_CAT(...) BOOST_PP_CAT(__VA_ARGS__,)
+# endif
# define BOOST_PP_REM(...) __VA_ARGS__
# else
# define BOOST_PP_REM(x) x
#
# /* BOOST_PP_TUPLE_REM */
#
-# if BOOST_PP_VARIADICS
+/*
+ VC++8.0 cannot handle the variadic version of BOOST_PP_TUPLE_REM(size)
+*/
+# if BOOST_PP_VARIADICS && !(BOOST_PP_VARIADICS_MSVC && _MSC_VER <= 1400)
+# if BOOST_PP_VARIADICS_MSVC
+ /* To be used internally when the size could be 0 ( or 1 ) */
+# define BOOST_PP_TUPLE_REM_CAT(size) BOOST_PP_REM_CAT
+# endif
# define BOOST_PP_TUPLE_REM(size) BOOST_PP_REM
# else
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC()
# define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__), (__VA_ARGS__))
# define BOOST_PP_TUPLE_REM_CTOR_I(m, args) BOOST_PP_TUPLE_REM_CTOR_II(m, args)
# define BOOST_PP_TUPLE_REM_CTOR_II(m, args) BOOST_PP_CAT(m ## args,)
+# define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_EXPAND(BOOST_PP_TUPLE_IS_SINGLE_RETURN(BOOST_PP_REM_CAT,BOOST_PP_REM,tuple) tuple)
# else
# define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__)(__VA_ARGS__)
+# define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_REM tuple
# endif
-# define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_REM tuple
# define BOOST_PP_TUPLE_REM_CTOR_O_2(size, tuple) BOOST_PP_TUPLE_REM_CTOR_O_1(tuple)
# else
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
--- /dev/null
+# /* **************************************************************************
+# * *
+# * (C) Copyright Edward Diener 2011. *
+# * (C) Copyright Paul Mensonides 2011. *
+# * 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 for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_TUPLE_SIZE_HPP
+# define BOOST_PREPROCESSOR_TUPLE_SIZE_HPP
+#
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/config/config.hpp>
+# include <boost/preprocessor/variadic/size.hpp>
+#
+# if BOOST_PP_VARIADICS
+# if BOOST_PP_VARIADICS_MSVC
+# define BOOST_PP_TUPLE_SIZE(tuple) BOOST_PP_CAT(BOOST_PP_VARIADIC_SIZE tuple,)
+# else
+# define BOOST_PP_TUPLE_SIZE(tuple) BOOST_PP_VARIADIC_SIZE tuple
+# endif
+# endif
+#
+# endif
# include <boost/preprocessor/cat.hpp>
# include <boost/preprocessor/config/config.hpp>
# include <boost/preprocessor/facilities/overload.hpp>
+# include <boost/preprocessor/tuple/size.hpp>
# include <boost/preprocessor/variadic/size.hpp>
#
# /* BOOST_PP_TUPLE_TO_LIST */
# define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_TUPLE_TO_LIST_I(BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__), (__VA_ARGS__))
# define BOOST_PP_TUPLE_TO_LIST_I(m, args) BOOST_PP_TUPLE_TO_LIST_II(m, args)
# define BOOST_PP_TUPLE_TO_LIST_II(m, args) BOOST_PP_CAT(m ## args,)
+# define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_TUPLE_SIZE(tuple)) tuple
# else
# define BOOST_PP_TUPLE_TO_LIST(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_LIST_O_, __VA_ARGS__)(__VA_ARGS__)
+# define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_VARIADIC_SIZE tuple) tuple
# endif
-# define BOOST_PP_TUPLE_TO_LIST_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_LIST_, BOOST_PP_VARIADIC_SIZE tuple) tuple
# define BOOST_PP_TUPLE_TO_LIST_O_2(size, tuple) BOOST_PP_TUPLE_TO_LIST_O_1(tuple)
# else
# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC()
IteratorCategoryTag1,
IteratorCategoryTag2 )
{
- while (true)
+ for (;;)
{
// If we have reached the end of the left range then this is
// the end of the loop. They are equal if and only if we have
IteratorCategoryTag1,
IteratorCategoryTag2 )
{
- while (true)
+ for (;;)
{
// If we have reached the end of the left range then this is
// the end of the loop. They are equal if and only if we have
RandomAccessTraversalReadableIterator1 last1,
RandomAccessTraversalReadableIterator2 first2,
RandomAccessTraversalReadableIterator2 last2,
- BinaryPredicate pred )
+ BinaryPredicate pred,
+ std::random_access_iterator_tag,
+ std::random_access_iterator_tag )
{
return ((last1 - first1) == (last2 - first2))
&& std::equal(first1, last1, first2, pred);
#ifndef BOOST_RANGE_BEGIN_HPP
#define BOOST_RANGE_BEGIN_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
namespace boost
{
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
- !BOOST_WORKAROUND(__GNUC__, < 3) \
- /**/
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
namespace range_detail
{
#endif
}
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
- !BOOST_WORKAROUND(__GNUC__, < 3) \
- /**/
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
} // namespace 'range_detail'
#endif
template< class T >
inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
{
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
- !BOOST_WORKAROUND(__GNUC__, < 3) \
- /**/
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
using namespace range_detail;
#endif
return range_begin( r );
template< class T >
inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r )
{
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
- !BOOST_WORKAROUND(__GNUC__, < 3) \
- /**/
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
using namespace range_detail;
#endif
return range_begin( r );
#include <boost/range/iterator.hpp>
#include <boost/range/value_type.hpp>
#include <boost/range/detail/misc_concept.hpp>
+#include <boost/type_traits/remove_reference.hpp>
/*!
* \file
#ifndef BOOST_RANGE_ENABLE_CONCEPT_ASSERT
// List broken compiler versions here:
+#ifndef __clang__
#ifdef __GNUC__
// GNUC 4.2 has strange issues correctly detecting compliance with the Concepts
// hence the least disruptive approach is to turn-off the concept checking for
#endif
#endif
+ #ifdef __GCCXML__
+ // GCC XML, unsurprisingly, has the same issues
+ #if __GCCXML_GNUC__ == 4 && __GCCXML_GNUC_MINOR__ == 2
+ #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
+ #endif
+ #endif
+#endif
+
#ifdef __BORLANDC__
#define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
#endif
struct SinglePassRangeConcept
{
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
- typedef BOOST_DEDUCED_TYPENAME range_iterator<T const>::type const_iterator;
- typedef BOOST_DEDUCED_TYPENAME range_iterator<T>::type iterator;
+ // A few compilers don't like the rvalue reference T types so just
+ // remove it.
+ typedef BOOST_DEDUCED_TYPENAME remove_reference<T>::type Rng;
- BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>));
- BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>));
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<
+ Rng const
+ >::type const_iterator;
- BOOST_CONCEPT_USAGE(SinglePassRangeConcept)
- {
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type iterator;
+
+ BOOST_RANGE_CONCEPT_ASSERT((
+ range_detail::SinglePassIteratorConcept<iterator>));
+
+ BOOST_RANGE_CONCEPT_ASSERT((
+ range_detail::SinglePassIteratorConcept<const_iterator>));
+
+ BOOST_CONCEPT_USAGE(SinglePassRangeConcept)
+ {
// This has been modified from assigning to this->i
// (where i was a member variable) to improve
// compatibility with Boost.Lambda
iterator i1 = boost::begin(*m_range);
iterator i2 = boost::end(*m_range);
- ignore_unused_variable_warning(i1);
- ignore_unused_variable_warning(i2);
+ boost::ignore_unused_variable_warning(i1);
+ boost::ignore_unused_variable_warning(i2);
const_constraints(*m_range);
}
private:
- void const_constraints(const T& const_range)
+ void const_constraints(const Rng& const_range)
{
const_iterator ci1 = boost::begin(const_range);
const_iterator ci2 = boost::end(const_range);
- ignore_unused_variable_warning(ci1);
- ignore_unused_variable_warning(ci2);
+ boost::ignore_unused_variable_warning(ci1);
+ boost::ignore_unused_variable_warning(ci2);
}
// Rationale:
// The type of m_range is T* rather than T because it allows
// T to be an abstract class. The other obvious alternative of
// T& produces a warning on some compilers.
- T* m_range;
+ Rng* m_range;
#endif
};
#endif
};
- template<class Range>
+ template<class T>
struct WriteableRangeConcept
{
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
- typedef BOOST_DEDUCED_TYPENAME range_iterator<Range>::type iterator;
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<T>::type iterator;
BOOST_CONCEPT_USAGE(WriteableRangeConcept)
{
}
private:
iterator i;
- BOOST_DEDUCED_TYPENAME range_value<Range>::type v;
+ BOOST_DEDUCED_TYPENAME range_value<T>::type v;
#endif
};
#include <boost/detail/workaround.hpp>
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
# define BOOST_RANGE_DEDUCED_TYPENAME typename
#else
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) && !defined(_MSC_EXTENSIONS)
-# define BOOST_RANGE_DEDUCED_TYPENAME typename
-# else
-# define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME
-# endif
+#define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME
#endif
#ifdef BOOST_RANGE_NO_ARRAY_SUPPORT
#error "macro already defined!"
#endif
-#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || BOOST_WORKAROUND( __MWERKS__, <= 0x3003 )
+#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 )
#define BOOST_RANGE_NO_ARRAY_SUPPORT 1
#endif
#define BOOST_RANGE_ARRAY_REF() (&boost_range_array)
#endif
+#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)))
+# define BOOST_RANGE_UNUSED __attribute__((unused))
+#else
+# define BOOST_RANGE_UNUSED
+#endif
+
#endif
#ifndef BOOST_RANGE_CONST_ITERATOR_HPP
#define BOOST_RANGE_CONST_ITERATOR_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/range/config.hpp>
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/range/detail/const_iterator.hpp>
-#else
-
+#include <boost/range/range_fwd.hpp>
#include <boost/range/detail/extract_optional_type.hpp>
#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
#include <cstddef>
#include <utility>
// default
//////////////////////////////////////////////////////////////////////////
- namespace range_detail {
- BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator )
- }
+ namespace range_detail
+ {
- template< typename C >
- struct range_const_iterator : range_detail::extract_const_iterator<C>
- {};
-
- //////////////////////////////////////////////////////////////////////////
- // pair
- //////////////////////////////////////////////////////////////////////////
+BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator )
- template< typename Iterator >
- struct range_const_iterator< std::pair<Iterator,Iterator> >
- {
- typedef Iterator type;
- };
-
- //////////////////////////////////////////////////////////////////////////
- // array
- //////////////////////////////////////////////////////////////////////////
+template< typename C >
+struct range_const_iterator
+ : extract_const_iterator<C>
+{};
- template< typename T, std::size_t sz >
- struct range_const_iterator< T[sz] >
- {
- typedef const T* type;
- };
+//////////////////////////////////////////////////////////////////////////
+// pair
+//////////////////////////////////////////////////////////////////////////
+
+template< typename Iterator >
+struct range_const_iterator<std::pair<Iterator,Iterator> >
+{
+ typedef Iterator type;
+};
+
+//////////////////////////////////////////////////////////////////////////
+// array
+//////////////////////////////////////////////////////////////////////////
+
+template< typename T, std::size_t sz >
+struct range_const_iterator< T[sz] >
+{
+ typedef const T* type;
+};
+
+ } // namespace range_detail
+
+template<typename C, typename Enabler=void>
+struct range_const_iterator
+ : range_detail::range_const_iterator<
+ BOOST_DEDUCED_TYPENAME remove_reference<C>::type
+ >
+{
+};
} // namespace boost
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif
#include <boost/detail/workaround.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/detail/common.hpp>
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
-# include <boost/range/value_type.hpp>
-#endif
namespace boost
{
template<>
struct range_begin<array_>
{
- #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
- template< typename T, std::size_t sz >
- static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
- {
- return boost_range_array;
- }
- #else
template<typename T>
static BOOST_RANGE_DEDUCED_TYPENAME range_value<T>::type* fun(T& t)
{
return t;
}
- #endif
};
} // namespace 'range_detail'
#ifndef BOOST_RANGE_DETAIL_COMMON_HPP
#define BOOST_RANGE_DETAIL_COMMON_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
+++ /dev/null
-// Boost.Range library
-//
-// Copyright Thorsten Ottosen 2003-2004. Use, modification and
-// distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/range/
-//
-
-#ifndef BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP
-#define BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP
-
-#include <boost/range/detail/common.hpp>
-#include <boost/range/detail/remove_extent.hpp>
-
-//////////////////////////////////////////////////////////////////////////////
-// missing partial specialization workaround.
-//////////////////////////////////////////////////////////////////////////////
-
-namespace boost
-{
- namespace range_detail
- {
- template< typename T >
- struct range_const_iterator_;
-
- template<>
- struct range_const_iterator_<std_container_>
- {
- template< typename C >
- struct pts
- {
- typedef BOOST_RANGE_DEDUCED_TYPENAME C::const_iterator type;
- };
- };
-
- template<>
- struct range_const_iterator_<std_pair_>
- {
- template< typename P >
- struct pts
- {
- typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type;
- };
- };
-
-
- template<>
- struct range_const_iterator_<array_>
- {
- template< typename T >
- struct pts
- {
- typedef const BOOST_RANGE_DEDUCED_TYPENAME
- remove_extent<T>::type* type;
- };
- };
- }
-
- template< typename C >
- class range_const_iterator
- {
- typedef BOOST_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
- public:
- typedef BOOST_DEDUCED_TYPENAME range_detail::range_const_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type;
- };
-
-}
-
-#endif
#include <boost/config.hpp> // BOOST_MSVC
#include <boost/detail/workaround.hpp>
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-# include <boost/range/detail/vc6/end.hpp>
-#else
-# include <boost/range/detail/implementation_help.hpp>
-# include <boost/range/iterator.hpp>
-# include <boost/range/detail/common.hpp>
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
-# include <boost/range/detail/remove_extent.hpp>
-# endif
+#include <boost/range/detail/implementation_help.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/detail/common.hpp>
namespace boost
{
template<>
struct range_end<array_>
{
- #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
- template< typename T, std::size_t sz >
- static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
- {
- return boost::range_detail::array_end( boost_range_array );
- }
- #else
template<typename T>
static BOOST_RANGE_DEDUCED_TYPENAME remove_extent<T>::type* fun(T& t)
{
return t + remove_extent<T>::size;
}
- #endif
};
} // namespace 'range_detail'
} // namespace 'boost'
-# endif // VC6
#endif
#ifndef BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
#define BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/config.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/mpl/has_xxx.hpp>
-#ifdef BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
+#if !defined(BOOST_MPL_CFG_NO_HAS_XXX)
-#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \
- template< typename C > \
- struct extract_ ## a_typedef \
- { \
- typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \
+// Defines extract_some_typedef<T> which exposes T::some_typedef as
+// extract_some_typedef<T>::type if T::some_typedef exists. Otherwise
+// extract_some_typedef<T> is empty.
+#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \
+ BOOST_MPL_HAS_XXX_TRAIT_DEF(a_typedef) \
+ template< typename C, bool B = BOOST_PP_CAT(has_, a_typedef)<C>::value > \
+ struct BOOST_PP_CAT(extract_, a_typedef) \
+ {}; \
+ template< typename C > \
+ struct BOOST_PP_CAT(extract_, a_typedef)< C, true > \
+ { \
+ typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \
};
#else
-namespace boost {
- namespace range_detail {
- template< typename T > struct exists { typedef void type; };
- }
-}
-
-// Defines extract_some_typedef<T> which exposes T::some_typedef as
-// extract_some_typedef<T>::type if T::some_typedef exists. Otherwise
-// extract_some_typedef<T> is empty.
-#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \
- template< typename C, typename Enable=void > \
- struct extract_ ## a_typedef \
- {}; \
- template< typename C > \
- struct extract_ ## a_typedef< C \
- , BOOST_DEDUCED_TYPENAME boost::range_detail::exists< BOOST_DEDUCED_TYPENAME C::a_typedef >::type \
- > { \
- typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \
+#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \
+ template< typename C > \
+ struct BOOST_PP_CAT(extract_, a_typedef) \
+ { \
+ typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \
};
#endif
--- /dev/null
+// Boost.Range library
+//
+// Copyright Neil Groves 2014.
+//
+// Use, modification and distribution are subject to 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).
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#ifndef BOOST_RANGE_DETAIL_HAS_MEMBER_SIZE_HPP
+#define BOOST_RANGE_DETAIL_HAS_MEMBER_SIZE_HPP
+
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/cstdint.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+
+template<class T>
+class has_member_size_impl
+{
+private:
+ template<class U, U>
+ class check
+ {
+ };
+
+ template<class C>
+ static boost::uint8_t f(check<std::size_t(C::*)(void) const, &C::size>*);
+
+ template<class C>
+ static boost::uint16_t f(...);
+
+public:
+ static const bool value =
+ (sizeof(f<T>(0)) == sizeof(boost::uint8_t));
+
+ typedef typename mpl::if_c<
+ (sizeof(f<T>(0)) == sizeof(boost::uint8_t)),
+ mpl::true_,
+ mpl::false_
+ >::type type;
+};
+
+template<class T>
+struct has_member_size
+{
+ typedef typename mpl::and_<
+ typename is_class<T>::type,
+ typename has_member_size_impl<const T>::type
+ >::type type;
+
+ static const bool value =
+ is_class<T>::value && has_member_size_impl<const T>::value;
+};
+
+ } // namespace range_detail
+}// namespace boost
+
+#endif // include guard
return sz;
}
+ inline bool is_same_address(const void* l, const void* r)
+ {
+ return l == r;
+ }
+
+ template<class T1, class T2>
+ inline bool is_same_object(const T1& l, const T2& r)
+ {
+ return range_detail::is_same_address(&l, &r);
+ }
+
} // namespace 'range_detail'
} // namespace 'boost'
+++ /dev/null
-// Boost.Range library
-//
-// Copyright Thorsten Ottosen 2003-2004. Use, modification and
-// distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/range/
-//
-
-#ifndef BOOST_RANGE_DETAIL_ITERATOR_HPP
-#define BOOST_RANGE_DETAIL_ITERATOR_HPP
-
-#include <boost/range/detail/common.hpp>
-#include <boost/range/detail/remove_extent.hpp>
-
-#include <boost/static_assert.hpp>
-
-//////////////////////////////////////////////////////////////////////////////
-// missing partial specialization workaround.
-//////////////////////////////////////////////////////////////////////////////
-
-namespace boost
-{
- namespace range_detail
- {
- template< typename T >
- struct range_iterator_ {
- template< typename C >
- struct pts
- {
- typedef int type;
- };
- };
-
- template<>
- struct range_iterator_<std_container_>
- {
- template< typename C >
- struct pts
- {
- typedef BOOST_RANGE_DEDUCED_TYPENAME C::iterator type;
- };
- };
-
- template<>
- struct range_iterator_<std_pair_>
- {
- template< typename P >
- struct pts
- {
- typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type;
- };
- };
-
- template<>
- struct range_iterator_<array_>
- {
- template< typename T >
- struct pts
- {
- typedef BOOST_RANGE_DEDUCED_TYPENAME
- remove_extent<T>::type* type;
- };
- };
-
- }
-
- template< typename C >
- class range_mutable_iterator
- {
- typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
- public:
- typedef typename range_detail::range_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type;
- };
-}
-
-#endif
--- /dev/null
+// Boost.Range library
+//
+// Copyright Eric Niebler 2014. Use, modification and
+// distribution is subject to 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)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_MSVC_HAS_ITERATOR_WORKAROUND_HPP
+#define BOOST_RANGE_DETAIL_MSVC_HAS_ITERATOR_WORKAROUND_HPP
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP
+# error This file should only be included from <boost/range/mutable_iterator.hpp>
+#endif
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1600)
+namespace boost
+{
+namespace cb_details
+{
+ template <class Buff, class Traits>
+ struct iterator;
+}
+
+namespace python
+{
+ template <class Container
+ , class NextPolicies /*= objects::default_iterator_call_policies*/>
+ struct iterator;
+}
+
+namespace type_erasure
+{
+ template<
+ class Traversal,
+ class T /*= _self*/,
+ class Reference /*= ::boost::use_default*/,
+ class DifferenceType /*= ::std::ptrdiff_t*/,
+ class ValueType /*= typename deduced<iterator_value_type<T> >::type*/
+ >
+ struct iterator;
+}
+
+namespace unordered { namespace iterator_detail
+{
+ template <typename Node>
+ struct iterator;
+}}
+
+namespace container { namespace container_detail
+{
+ template<class IIterator, bool IsConst>
+ class iterator;
+}}
+
+namespace spirit { namespace lex { namespace lexertl
+{
+ template <typename Functor>
+ class iterator;
+}}}
+
+namespace range_detail
+{
+ template <class Buff, class Traits>
+ struct has_iterator< ::boost::cb_details::iterator<Buff, Traits> >
+ : mpl::false_
+ {};
+
+ template <class Buff, class Traits>
+ struct has_iterator< ::boost::cb_details::iterator<Buff, Traits> const>
+ : mpl::false_
+ {};
+
+ template <class Container, class NextPolicies>
+ struct has_iterator< ::boost::python::iterator<Container, NextPolicies> >
+ : mpl::false_
+ {};
+
+ template <class Container, class NextPolicies>
+ struct has_iterator< ::boost::python::iterator<Container, NextPolicies> const>
+ : mpl::false_
+ {};
+
+ template<class Traversal, class T, class Reference, class DifferenceType, class ValueType>
+ struct has_iterator< ::boost::type_erasure::iterator<Traversal, T, Reference, DifferenceType, ValueType> >
+ : mpl::false_
+ {};
+
+ template<class Traversal, class T, class Reference, class DifferenceType, class ValueType>
+ struct has_iterator< ::boost::type_erasure::iterator<Traversal, T, Reference, DifferenceType, ValueType> const>
+ : mpl::false_
+ {};
+
+ template <typename Node>
+ struct has_iterator< ::boost::unordered::iterator_detail::iterator<Node> >
+ : mpl::false_
+ {};
+
+ template <typename Node>
+ struct has_iterator< ::boost::unordered::iterator_detail::iterator<Node> const>
+ : mpl::false_
+ {};
+
+ template<class IIterator, bool IsConst>
+ struct has_iterator< ::boost::container::container_detail::iterator<IIterator, IsConst> >
+ : mpl::false_
+ {};
+
+ template<class IIterator, bool IsConst>
+ struct has_iterator< ::boost::container::container_detail::iterator<IIterator, IsConst> const>
+ : mpl::false_
+ {};
+
+ template <typename Functor>
+ struct has_iterator< ::boost::spirit::lex::lexertl::iterator<Functor> >
+ : mpl::false_
+ {};
+
+ template <typename Functor>
+ struct has_iterator< ::boost::spirit::lex::lexertl::iterator<Functor> const>
+ : mpl::false_
+ {};
+}
+}
+#endif
+#endif
+++ /dev/null
-// Boost.Range library
-//
-// Copyright Jonathan Turkanis 2005. Use, modification and
-// distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/range/
-//
-
-
-#ifndef BOOST_RANGE_DETAIL_REMOVE_BOUNDS_HPP
-#define BOOST_RANGE_DETAIL_REMOVE_BOUNDS_HPP
-
-#include <boost/config.hpp> // MSVC, NO_INTRINSIC_WCHAR_T, put size_t in std.
-#include <cstddef>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-namespace boost
-{
- namespace range_detail
- {
-
- template< typename Case1 = mpl::true_,
- typename Type1 = mpl::void_,
- typename Case2 = mpl::true_,
- typename Type2 = mpl::void_,
- typename Case3 = mpl::true_,
- typename Type3 = mpl::void_,
- typename Case4 = mpl::true_,
- typename Type4 = mpl::void_,
- typename Case5 = mpl::true_,
- typename Type5 = mpl::void_,
- typename Case6 = mpl::true_,
- typename Type6 = mpl::void_,
- typename Case7 = mpl::true_,
- typename Type7 = mpl::void_,
- typename Case8 = mpl::true_,
- typename Type8 = mpl::void_,
- typename Case9 = mpl::true_,
- typename Type9 = mpl::void_,
- typename Case10 = mpl::true_,
- typename Type10 = mpl::void_,
- typename Case11 = mpl::true_,
- typename Type11 = mpl::void_,
- typename Case12 = mpl::true_,
- typename Type12 = mpl::void_,
- typename Case13 = mpl::true_,
- typename Type13 = mpl::void_,
- typename Case14 = mpl::true_,
- typename Type14 = mpl::void_,
- typename Case15 = mpl::true_,
- typename Type15 = mpl::void_,
- typename Case16 = mpl::true_,
- typename Type16 = mpl::void_,
- typename Case17 = mpl::true_,
- typename Type17 = mpl::void_,
- typename Case18 = mpl::true_,
- typename Type18 = mpl::void_,
- typename Case19 = mpl::true_,
- typename Type19 = mpl::void_,
- typename Case20 = mpl::true_,
- typename Type20 = mpl::void_>
- struct select {
- typedef typename
- mpl::eval_if<
- Case1, mpl::identity<Type1>, mpl::eval_if<
- Case2, mpl::identity<Type2>, mpl::eval_if<
- Case3, mpl::identity<Type3>, mpl::eval_if<
- Case4, mpl::identity<Type4>, mpl::eval_if<
- Case5, mpl::identity<Type5>, mpl::eval_if<
- Case6, mpl::identity<Type6>, mpl::eval_if<
- Case7, mpl::identity<Type7>, mpl::eval_if<
- Case8, mpl::identity<Type8>, mpl::eval_if<
- Case9, mpl::identity<Type9>, mpl::if_<
- Case10, Type10, mpl::void_ > > > > > > > > >
- >::type result1;
- typedef typename
- mpl::eval_if<
- Case11, mpl::identity<Type11>, mpl::eval_if<
- Case12, mpl::identity<Type12>, mpl::eval_if<
- Case13, mpl::identity<Type13>, mpl::eval_if<
- Case14, mpl::identity<Type14>, mpl::eval_if<
- Case15, mpl::identity<Type15>, mpl::eval_if<
- Case16, mpl::identity<Type16>, mpl::eval_if<
- Case17, mpl::identity<Type17>, mpl::eval_if<
- Case18, mpl::identity<Type18>, mpl::eval_if<
- Case19, mpl::identity<Type19>, mpl::if_<
- Case20, Type20, mpl::void_ > > > > > > > > >
- > result2;
- typedef typename
- mpl::eval_if<
- is_same<result1, mpl::void_>,
- result2,
- mpl::identity<result1>
- >::type type;
- };
-
- template<typename T>
- struct remove_extent {
- static T* ar;
- BOOST_STATIC_CONSTANT(std::size_t, size = sizeof(*ar) / sizeof((*ar)[0]));
-
- typedef typename
- select<
- is_same<T, bool[size]>, bool,
- is_same<T, char[size]>, char,
- is_same<T, signed char[size]>, signed char,
- is_same<T, unsigned char[size]>, unsigned char,
- #ifndef BOOST_NO_INTRINSIC_WCHAR_T
- is_same<T, wchar_t[size]>, wchar_t,
- #endif
- is_same<T, short[size]>, short,
- is_same<T, unsigned short[size]>, unsigned short,
- is_same<T, int[size]>, int,
- is_same<T, unsigned int[size]>, unsigned int,
- is_same<T, long[size]>, long,
- is_same<T, unsigned long[size]>, unsigned long,
- is_same<T, float[size]>, float,
- is_same<T, double[size]>, double,
- is_same<T, long double[size]>, long double
- >::type result1;
- typedef typename
- select<
- is_same<T, const bool[size]>, const bool,
- is_same<T, const char[size]>, const char,
- is_same<T, const signed char[size]>, const signed char,
- is_same<T, const unsigned char[size]>, const unsigned char,
- #ifndef BOOST_NO_INTRINSIC_WCHAR_T
- is_same<T, const wchar_t[size]>, const wchar_t,
- #endif
- is_same<T, const short[size]>, const short,
- is_same<T, const unsigned short[size]>, const unsigned short,
- is_same<T, const int[size]>, const int,
- is_same<T, const unsigned int[size]>, const unsigned int,
- is_same<T, const long[size]>, const long,
- is_same<T, const unsigned long[size]>, const unsigned long,
- is_same<T, const float[size]>, const float,
- is_same<T, const double[size]>, const double,
- is_same<T, const long double[size]>, const long double
- > result2;
- typedef typename
- mpl::eval_if<
- is_same<result1, mpl::void_>,
- result2,
- mpl::identity<result1>
- >::type type;
- };
-
- } // namespace 'range_detail'
-
-} // namespace 'boost'
-
-
-#endif
+++ /dev/null
-// Boost.Range library
-//
-// Copyright Thorsten Ottosen 2003-2004. Use, modification and
-// distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/range/
-//
-
-#ifndef BOOST_RANGE_DETAIL_SIZE_TYPE_HPP
-#define BOOST_RANGE_DETAIL_SIZE_TYPE_HPP
-
-#include <boost/range/detail/common.hpp>
-
-//////////////////////////////////////////////////////////////////////////////
-// missing partial specialization workaround.
-//////////////////////////////////////////////////////////////////////////////
-
-namespace boost
-{
- namespace range_detail
- {
- template< typename T >
- struct range_size_type_
- {
- template< typename C >
- struct pts
- {
- typedef std::size_t type;
- };
- };
-
- template<>
- struct range_size_type_<std_container_>
- {
- template< typename C >
- struct pts
- {
- typedef BOOST_RANGE_DEDUCED_TYPENAME C::size_type type;
- };
- };
- }
-
- template< typename C >
- class range_size
- {
- typedef typename range_detail::range<C>::type c_type;
- public:
- typedef typename range_detail::range_size_type_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type;
- };
-}
-
-#endif
-
+++ /dev/null
-// Boost.Range library
-//
-// Copyright Thorsten Ottosen 2003-2004. Use, modification and
-// distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/range/
-//
-
-#ifndef BOOST_RANGE_DETAIL_VC6_END_HPP
-#define BOOST_RANGE_DETAIL_VC6_END_HPP
-
-#include <boost/range/detail/implementation_help.hpp>
-#include <boost/range/detail/implementation_help.hpp>
-#include <boost/range/result_iterator.hpp>
-#include <boost/range/detail/common.hpp>
-#include <boost/range/detail/remove_extent.hpp>
-
-namespace boost
-{
- namespace range_detail
- {
- template< typename T >
- struct range_end;
-
- //////////////////////////////////////////////////////////////////////
- // default
- //////////////////////////////////////////////////////////////////////
-
- template<>
- struct range_end<std_container_>
- {
- template< typename C >
- struct inner {
- static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type
- fun( C& c )
- {
- return c.end();
- };
- };
- };
-
- //////////////////////////////////////////////////////////////////////
- // pair
- //////////////////////////////////////////////////////////////////////
-
- template<>
- struct range_end<std_pair_>
- {
- template< typename P >
- struct inner {
- static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type
- fun( const P& p )
- {
- return p.second;
- }
- };
- };
-
- //////////////////////////////////////////////////////////////////////
- // array
- //////////////////////////////////////////////////////////////////////
-
- template<>
- struct range_end<array_>
- {
- template< typename T >
- struct inner {
- static BOOST_DEDUCED_TYPENAME remove_extent<T>::type*
- fun(T& t)
- {
- return t + remove_extent<T>::size;
- }
- };
- };
-
-
- template<>
- struct range_end<char_array_>
- {
- template< typename T >
- struct inner {
- static BOOST_DEDUCED_TYPENAME remove_extent<T>::type*
- fun(T& t)
- {
- return t + remove_extent<T>::size;
- }
- };
- };
-
- template<>
- struct range_end<wchar_t_array_>
- {
- template< typename T >
- struct inner {
- static BOOST_DEDUCED_TYPENAME remove_extent<T>::type*
- fun(T& t)
- {
- return t + remove_extent<T>::size;
- }
- };
- };
-
- //////////////////////////////////////////////////////////////////////
- // string
- //////////////////////////////////////////////////////////////////////
-
- template<>
- struct range_end<char_ptr_>
- {
- template< typename T >
- struct inner {
- static char* fun( char* s )
- {
- return boost::range_detail::str_end( s );
- }
- };
- };
-
- template<>
- struct range_end<const_char_ptr_>
- {
- template< typename T >
- struct inner {
- static const char* fun( const char* s )
- {
- return boost::range_detail::str_end( s );
- }
- };
- };
-
- template<>
- struct range_end<wchar_t_ptr_>
- {
- template< typename T >
- struct inner {
- static wchar_t* fun( wchar_t* s )
- {
- return boost::range_detail::str_end( s );
- }
- };
- };
-
-
- template<>
- struct range_end<const_wchar_t_ptr_>
- {
- template< typename T >
- struct inner {
- static const wchar_t* fun( const wchar_t* s )
- {
- return boost::range_detail::str_end( s );
- }
- };
- };
-
- } // namespace 'range_detail'
-
- template< typename C >
- inline BOOST_DEDUCED_TYPENAME range_result_iterator<C>::type
- end( C& c )
- {
- return range_detail::range_end<range_detail::range<C>::type>::inner<C>::fun( c );
- }
-
-} // namespace 'boost'
-
-
-#endif
#ifndef BOOST_RANGE_DIFFERENCE_TYPE_HPP
#define BOOST_RANGE_DIFFERENCE_TYPE_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/range/config.hpp>
#include <boost/range/iterator.hpp>
#include <boost/iterator/iterator_traits.hpp>
+#include <boost/type_traits/remove_reference.hpp>
namespace boost
{
template< class T >
- struct range_difference : iterator_difference< typename range_iterator<T>::type >
+ struct range_difference
+ : iterator_difference<
+ BOOST_DEDUCED_TYPENAME range_iterator<
+ BOOST_DEDUCED_TYPENAME remove_reference<T>::type
+ >::type
+ >
{ };
}
#ifndef BOOST_RANGE_DISTANCE_HPP
#define BOOST_RANGE_DISTANCE_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
#ifndef BOOST_RANGE_EMPTY_HPP
#define BOOST_RANGE_EMPTY_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
#ifndef BOOST_RANGE_END_HPP
#define BOOST_RANGE_END_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
namespace boost
{
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
- !BOOST_WORKAROUND(__GNUC__, < 3) \
- /**/
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
namespace range_detail
{
#endif
return range_detail::array_end<T,sz>( a );
}
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
- !BOOST_WORKAROUND(__GNUC__, < 3) \
- /**/
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
} // namespace 'range_detail'
#endif
template< class T >
inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
{
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
- !BOOST_WORKAROUND(__GNUC__, < 3) \
- /**/
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
using namespace range_detail;
#endif
return range_end( r );
template< class T >
inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type end( const T& r )
{
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
- !BOOST_WORKAROUND(__GNUC__, < 3) \
- /**/
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
using namespace range_detail;
#endif
return range_end( r );
#ifndef BOOST_RANGE_FUNCTIONS_HPP
#define BOOST_RANGE_FUNCTIONS_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
--- /dev/null
+// Boost.Range library
+//
+// Copyright Neil Groves 2010. Use, modification and
+// distribution is subject to 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)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+// Acknowledgments:
+// Ticket #8341: Arno Schoedl - improved handling of has_range_iterator upon
+// use-cases where T was const.
+#ifndef BOOST_RANGE_HAS_ITERATOR_HPP_INCLUDED
+#define BOOST_RANGE_HAS_ITERATOR_HPP_INCLUDED
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ BOOST_MPL_HAS_XXX_TRAIT_DEF(type)
+
+ template<class T, class Enabler = void>
+ struct has_range_iterator_impl
+ : boost::mpl::false_
+ {
+ };
+
+ template<class T>
+ struct has_range_iterator_impl<
+ T,
+ BOOST_DEDUCED_TYPENAME ::boost::enable_if<
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<is_const<T>,
+ has_type<range_const_iterator<
+ BOOST_DEDUCED_TYPENAME remove_const<T>::type> >,
+ has_type<range_mutable_iterator<T> >
+ >::type
+ >::type
+ >
+ : boost::mpl::true_
+ {
+ };
+
+ template<class T, class Enabler = void>
+ struct has_range_const_iterator_impl
+ : boost::mpl::false_
+ {
+ };
+
+ template<class T>
+ struct has_range_const_iterator_impl<
+ T,
+ BOOST_DEDUCED_TYPENAME ::boost::enable_if<
+ has_type<range_const_iterator<T> >
+ >::type
+ >
+ : boost::mpl::true_
+ {
+ };
+
+ } // namespace range_detail
+
+ template<class T>
+ struct has_range_iterator
+ : range_detail::has_range_iterator_impl<
+ BOOST_DEDUCED_TYPENAME remove_reference<T>::type>
+ {};
+
+ template<class T>
+ struct has_range_const_iterator
+ : range_detail::has_range_const_iterator_impl<
+ BOOST_DEDUCED_TYPENAME remove_reference<T>::type>
+ {};
+} // namespace boost
+
+#endif // include guard
+
#ifndef BOOST_RANGE_ITERATOR_HPP
#define BOOST_RANGE_ITERATOR_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/range/config.hpp>
+#include <boost/range/range_fwd.hpp>
#include <boost/range/mutable_iterator.hpp>
#include <boost/range/const_iterator.hpp>
#include <boost/type_traits/is_const.hpp>
namespace boost
{
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
-
- namespace range_detail_vc7_1
- {
- template< typename C, typename Sig = void(C) >
- struct range_iterator
- {
- typedef BOOST_RANGE_DEDUCED_TYPENAME
- mpl::eval_if_c< is_const<C>::value,
- range_const_iterator< typename remove_const<C>::type >,
- range_mutable_iterator<C> >::type type;
- };
-
- template< typename C, typename T >
- struct range_iterator< C, void(T[]) >
- {
- typedef T* type;
- };
- }
-
-#endif
-
- template< typename C >
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+
+ namespace range_detail_vc7_1
+ {
+ template< typename C, typename Sig = void(C) >
+ struct range_iterator
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME
+ mpl::eval_if_c< is_const<C>::value,
+ range_const_iterator< typename remove_const<C>::type >,
+ range_mutable_iterator<C> >::type type;
+ };
+
+ template< typename C, typename T >
+ struct range_iterator< C, void(T[]) >
+ {
+ typedef T* type;
+ };
+ }
+
+#endif
+
+ template< typename C, typename Enabler=void >
struct range_iterator
{
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
-
- typedef BOOST_RANGE_DEDUCED_TYPENAME
- range_detail_vc7_1::range_iterator<C>::type type;
-
-#else
-
- typedef BOOST_RANGE_DEDUCED_TYPENAME
- mpl::eval_if_c< is_const<C>::value,
- range_const_iterator< typename remove_const<C>::type >,
- range_mutable_iterator<C> >::type type;
-
-#endif
+
+ typedef BOOST_RANGE_DEDUCED_TYPENAME
+ range_detail_vc7_1::range_iterator<C>::type type;
+
+#else
+
+ private:
+ typedef typename remove_reference<C>::type param_t;
+
+ public:
+ typedef typename mpl::eval_if_c<
+ is_const<param_t>::value,
+ range_const_iterator<typename remove_const<param_t>::type>,
+ range_mutable_iterator<param_t>
+ >::type type;
+
+#endif
};
-
+
} // namespace boost
-//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
#endif
//
// For more information, see http://www.boost.org/libs/range/
//
+// Credits:
+// 'michel' reported Trac 9072 which included a patch for allowing references
+// to function types.
+//
#ifndef BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
#define BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
#include <boost/assert.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <boost/iterator/iterator_facade.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/not.hpp>
#include <boost/mpl/or.hpp>
#include <boost/type_traits/is_abstract.hpp>
#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_function.hpp>
#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_same.hpp>
#include <boost/range/functions.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/difference_type.hpp>
+#include <boost/range/has_range_iterator.hpp>
#include <boost/range/algorithm/equal.hpp>
#include <boost/range/detail/safe_bool.hpp>
#include <boost/utility/enable_if.hpp>
template< class Left, class Right >
inline bool greater_than( const Left& l, const Right& r )
{
- return less_than(r,l);
+ return iterator_range_detail::less_than(r,l);
}
template< class Left, class Right >
return boost::equal(l, r);
}
- struct range_tag { };
- struct const_range_tag { };
+struct range_tag
+{
+};
+
+struct const_range_tag
+{
+};
+
+struct iterator_range_tag
+{
+};
+
+typedef char (&incrementable_t)[1];
+typedef char (&bidirectional_t)[2];
+typedef char (&random_access_t)[3];
+
+incrementable_t test_traversal_tag(boost::incrementable_traversal_tag);
+bidirectional_t test_traversal_tag(boost::bidirectional_traversal_tag);
+random_access_t test_traversal_tag(boost::random_access_traversal_tag);
+
+template<std::size_t S>
+struct pure_iterator_traversal_impl
+{
+ typedef boost::incrementable_traversal_tag type;
+};
+
+template<>
+struct pure_iterator_traversal_impl<sizeof(bidirectional_t)>
+{
+ typedef boost::bidirectional_traversal_tag type;
+};
+
+template<>
+struct pure_iterator_traversal_impl<sizeof(random_access_t)>
+{
+ typedef boost::random_access_traversal_tag type;
+};
+
+template<typename IteratorT>
+struct pure_iterator_traversal
+{
+ typedef
+ BOOST_DEDUCED_TYPENAME iterator_traversal<IteratorT>::type
+ traversal_t;
+ BOOST_STATIC_CONSTANT(
+ std::size_t,
+ traversal_i = sizeof(iterator_range_detail::test_traversal_tag((traversal_t())))
+ );
+ typedef
+ BOOST_DEDUCED_TYPENAME pure_iterator_traversal_impl<traversal_i>::type
+ type;
+};
+
+template<class IteratorT, class TraversalTag>
+class iterator_range_base
+ : public iterator_range_tag
+{
+ typedef range_detail::safe_bool<
+ IteratorT iterator_range_base<IteratorT, TraversalTag>::*
+ > safe_bool_t;
+
+ typedef iterator_range_base<IteratorT, TraversalTag> type;
+
+protected:
+ typedef iterator_range_impl<IteratorT> impl;
+
+public:
+ typedef BOOST_DEDUCED_TYPENAME
+ safe_bool_t::unspecified_bool_type unspecified_bool_type;
+
+ typedef BOOST_DEDUCED_TYPENAME
+ iterator_value<IteratorT>::type value_type;
+
+ typedef BOOST_DEDUCED_TYPENAME
+ iterator_difference<IteratorT>::type difference_type;
+
+ typedef std::size_t size_type; // note: must be unsigned
+
+ // Needed because value-type is the same for
+ // const and non-const iterators
+ typedef BOOST_DEDUCED_TYPENAME
+ iterator_reference<IteratorT>::type reference;
+
+ //! const_iterator type
+ /*!
+ There is no distinction between const_iterator and iterator.
+ These typedefs are provides to fulfill container interface
+ */
+ typedef IteratorT const_iterator;
+ //! iterator type
+ typedef IteratorT iterator;
+
+protected:
+ iterator_range_base()
+ : m_Begin()
+ , m_End()
+ {
+ }
+
+ template<class Iterator>
+ iterator_range_base(Iterator Begin, Iterator End)
+ : m_Begin(Begin)
+ , m_End(End)
+ {
+ }
+
+public:
+ IteratorT begin() const
+ {
+ return m_Begin;
+ }
+
+ IteratorT end() const
+ {
+ return m_End;
+ }
+
+ bool empty() const
+ {
+ return m_Begin == m_End;
+ }
+
+ operator unspecified_bool_type() const
+ {
+ return safe_bool_t::to_unspecified_bool(
+ m_Begin != m_End, &iterator_range_base::m_Begin);
+ }
+
+ bool operator!() const
+ {
+ return empty();
+ }
+
+ bool equal(const iterator_range_base& r) const
+ {
+ return m_Begin == r.m_Begin && m_End == r.m_End;
+ }
+
+ reference front() const
+ {
+ BOOST_ASSERT(!empty());
+ return *m_Begin;
+ }
+
+ void drop_front()
+ {
+ BOOST_ASSERT(!empty());
+ ++m_Begin;
+ }
+
+ void drop_front(difference_type n)
+ {
+ BOOST_ASSERT(n >= difference_type());
+ std::advance(this->m_Begin, n);
+ }
+
+ // Deprecated
+ void pop_front() { drop_front(); }
+
+protected:
+ template<class Iterator>
+ void assign(Iterator first, Iterator last)
+ {
+ m_Begin = first;
+ m_End = last;
+ }
+
+ template<class SinglePassRange>
+ void assign(const SinglePassRange& r)
+ {
+ m_Begin = impl::adl_begin(r);
+ m_End = impl::adl_end(r);
+ }
+
+ template<class SinglePassRange>
+ void assign(SinglePassRange& r)
+ {
+ m_Begin = impl::adl_begin(r);
+ m_End = impl::adl_end(r);
+ }
+
+ IteratorT m_Begin;
+ IteratorT m_End;
+};
+
+template<class IteratorT>
+class iterator_range_base<IteratorT, bidirectional_traversal_tag>
+ : public iterator_range_base<IteratorT, incrementable_traversal_tag>
+{
+ typedef iterator_range_base<IteratorT, incrementable_traversal_tag> base_type;
+
+protected:
+ iterator_range_base()
+ {
+ }
+
+ template<class Iterator>
+ iterator_range_base(Iterator first, Iterator last)
+ : base_type(first, last)
+ {
+ }
+
+public:
+ typedef BOOST_DEDUCED_TYPENAME base_type::difference_type difference_type;
+ typedef BOOST_DEDUCED_TYPENAME base_type::reference reference;
+
+ reference back() const
+ {
+ BOOST_ASSERT(!this->empty());
+ return *boost::prior(this->m_End);
+ }
+
+ void drop_back()
+ {
+ BOOST_ASSERT(!this->empty());
+ --this->m_End;
+ }
+
+ void drop_back(difference_type n)
+ {
+ BOOST_ASSERT(n >= difference_type());
+ std::advance(this->m_End, -n);
+ }
+
+ // Deprecated
+ void pop_back() { drop_back(); }
+};
+
+template<class IteratorT>
+class iterator_range_base<IteratorT, random_access_traversal_tag>
+ : public iterator_range_base<IteratorT, bidirectional_traversal_tag>
+{
+ typedef iterator_range_base<
+ IteratorT, bidirectional_traversal_tag> base_type;
+
+public:
+ typedef BOOST_DEDUCED_TYPENAME
+ boost::mpl::if_<
+ boost::mpl::or_<
+ boost::is_abstract<
+ BOOST_DEDUCED_TYPENAME base_type::value_type
+ >,
+ boost::is_array<
+ BOOST_DEDUCED_TYPENAME base_type::value_type
+ >,
+ boost::is_function<
+ BOOST_DEDUCED_TYPENAME base_type::value_type
+ >
+ >,
+ BOOST_DEDUCED_TYPENAME base_type::reference,
+ BOOST_DEDUCED_TYPENAME base_type::value_type
+ >::type abstract_value_type;
+
+ // Rationale:
+ // typedef these here to reduce verbiage in the implementation of this
+ // type.
+ typedef BOOST_DEDUCED_TYPENAME base_type::difference_type difference_type;
+ typedef BOOST_DEDUCED_TYPENAME base_type::size_type size_type;
+ typedef BOOST_DEDUCED_TYPENAME base_type::reference reference;
+
+protected:
+ iterator_range_base()
+ {
+ }
+
+ template<class Iterator>
+ iterator_range_base(Iterator first, Iterator last)
+ : base_type(first, last)
+ {
+ }
+
+public:
+ reference operator[](difference_type at) const
+ {
+ BOOST_ASSERT(at >= 0);
+ BOOST_ASSERT(static_cast<typename base_type::size_type>(at) < size());
+ return this->m_Begin[at];
+ }
+
+ //
+ // When storing transform iterators, operator[]()
+ // fails because it returns by reference. Therefore
+ // operator()() is provided for these cases.
+ //
+ abstract_value_type operator()(difference_type at) const
+ {
+ BOOST_ASSERT(at >= 0);
+ BOOST_ASSERT(static_cast<typename base_type::size_type>(at) < size());
+ return this->m_Begin[at];
+ }
+
+ BOOST_DEDUCED_TYPENAME base_type::size_type size() const
+ {
+ return this->m_End - this->m_Begin;
+ }
+};
+
}
// iterator range template class -----------------------------------------//
*/
template<class IteratorT>
class iterator_range
- {
- typedef range_detail::safe_bool< IteratorT iterator_range<IteratorT>::* > safe_bool_t;
- protected: // Used by sub_range
- //! implementation class
- typedef iterator_range_detail::iterator_range_impl<IteratorT> impl;
- public:
- //! this type
- typedef iterator_range<IteratorT> type;
- typedef BOOST_DEDUCED_TYPENAME safe_bool_t::unspecified_bool_type unspecified_bool_type;
- //BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(value_type);
-
- //! Encapsulated value type
- typedef BOOST_DEDUCED_TYPENAME
- iterator_value<IteratorT>::type value_type;
-
- //! Difference type
- typedef BOOST_DEDUCED_TYPENAME
- iterator_difference<IteratorT>::type difference_type;
-
- //! Size type
- typedef std::size_t size_type; // note: must be unsigned
-
- //! This type
- typedef iterator_range<IteratorT> this_type;
-
- //! Reference type
- //
- // Needed because value-type is the same for
- // const and non-const iterators
- //
- typedef BOOST_DEDUCED_TYPENAME
- iterator_reference<IteratorT>::type reference;
+ : public iterator_range_detail::iterator_range_base<
+ IteratorT,
+ BOOST_DEDUCED_TYPENAME iterator_range_detail::pure_iterator_traversal<IteratorT>::type
+ >
+ {
+ typedef iterator_range_detail::iterator_range_base<
+ IteratorT,
+ BOOST_DEDUCED_TYPENAME iterator_range_detail::pure_iterator_traversal<IteratorT>::type
+ > base_type;
+
+ template<class Source>
+ struct is_compatible_range_
+ : is_convertible<
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ has_range_iterator<Source>,
+ range_iterator<Source>,
+ mpl::identity<void>
+ >::type,
+ BOOST_DEDUCED_TYPENAME base_type::iterator
+ >
+ {
+ };
+
+ template<class Source>
+ struct is_compatible_range
+ : mpl::and_<
+ mpl::not_<
+ is_convertible<
+ Source,
+ BOOST_DEDUCED_TYPENAME base_type::iterator
+ >
+ >,
+ is_compatible_range_<Source>
+ >
+ {
+ };
- //! const_iterator type
- /*!
- There is no distinction between const_iterator and iterator.
- These typedefs are provides to fulfill container interface
- */
- typedef IteratorT const_iterator;
- //! iterator type
- typedef IteratorT iterator;
-
- private: // for return value of operator()()
- typedef BOOST_DEDUCED_TYPENAME
- boost::mpl::if_< boost::mpl::or_< boost::is_abstract< value_type >,
- boost::is_array< value_type > >,
- reference, value_type >::type abstract_value_type;
+ protected:
+ typedef iterator_range_detail::iterator_range_impl<IteratorT> impl;
public:
- iterator_range() : m_Begin( iterator() ), m_End( iterator() )
- { }
-
- //! Constructor from a pair of iterators
- template< class Iterator >
- iterator_range( Iterator Begin, Iterator End ) :
- m_Begin(Begin), m_End(End)
- {}
-
- //! Constructor from a Range
- template< class Range >
- iterator_range( const Range& r ) :
- m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
- {}
-
- //! Constructor from a Range
- template< class Range >
- iterator_range( Range& r ) :
- m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
- {}
-
- //! Constructor from a Range
- template< class Range >
- iterator_range( const Range& r, iterator_range_detail::const_range_tag ) :
- m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
- {}
-
- //! Constructor from a Range
- template< class Range >
- iterator_range( Range& r, iterator_range_detail::range_tag ) :
- m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
- {}
-
- #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- this_type& operator=( const this_type& r )
- {
- m_Begin = r.begin();
- m_End = r.end();
- return *this;
- }
- #endif
+ typedef iterator_range<IteratorT> type;
- template< class Iterator >
- iterator_range& operator=( const iterator_range<Iterator>& r )
+ iterator_range()
{
- m_Begin = r.begin();
- m_End = r.end();
- return *this;
}
- template< class ForwardRange >
- iterator_range& operator=( ForwardRange& r )
+ template<class Iterator>
+ iterator_range(Iterator first, Iterator last)
+ : base_type(first, last)
{
- m_Begin = impl::adl_begin( r );
- m_End = impl::adl_end( r );
- return *this;
}
- template< class ForwardRange >
- iterator_range& operator=( const ForwardRange& r )
+ template<class SinglePassRange>
+ iterator_range(
+ const SinglePassRange& r,
+ BOOST_DEDUCED_TYPENAME ::boost::enable_if<
+ is_compatible_range<const SinglePassRange>
+ >::type* = 0
+ )
+ : base_type(impl::adl_begin(r), impl::adl_end(r))
{
- m_Begin = impl::adl_begin( r );
- m_End = impl::adl_end( r );
- return *this;
}
- IteratorT begin() const
+ template<class SinglePassRange>
+ iterator_range(
+ SinglePassRange& r,
+ BOOST_DEDUCED_TYPENAME ::boost::enable_if<
+ is_compatible_range<SinglePassRange>
+ >::type* = 0
+ )
+ : base_type(impl::adl_begin(r), impl::adl_end(r))
{
- return m_Begin;
}
- IteratorT end() const
+ template<class SinglePassRange>
+ iterator_range(const SinglePassRange& r,
+ iterator_range_detail::const_range_tag)
+ : base_type(impl::adl_begin(r), impl::adl_end(r))
{
- return m_End;
}
- difference_type size() const
+ template<class SinglePassRange>
+ iterator_range(SinglePassRange& r,
+ iterator_range_detail::range_tag)
+ : base_type(impl::adl_begin(r), impl::adl_end(r))
{
- return m_End - m_Begin;
}
- bool empty() const
+ template<class Iterator>
+ iterator_range& operator=(const iterator_range<Iterator>& other)
{
- return m_Begin == m_End;
+ this->assign(other.begin(), other.end());
+ return *this;
}
- operator unspecified_bool_type() const
+ template<class Iterator>
+ iterator_range& operator=(iterator_range<Iterator>& other)
{
- return safe_bool_t::to_unspecified_bool(m_Begin != m_End, &iterator_range::m_Begin);
+ this->assign(other.begin(), other.end());
+ return *this;
}
- bool operator!() const
+ template<class SinglePassRange>
+ iterator_range& operator=(SinglePassRange& r)
{
- return empty();
+ this->assign(r);
+ return *this;
}
- bool equal( const iterator_range& r ) const
+ template<class SinglePassRange>
+ iterator_range& operator=(const SinglePassRange& r)
{
- return m_Begin == r.m_Begin && m_End == r.m_End;
+ this->assign(r);
+ return *this;
}
-
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
- bool operator==( const iterator_range& r ) const
+ iterator_range& advance_begin(
+ BOOST_DEDUCED_TYPENAME base_type::difference_type n)
{
- return boost::equal( *this, r );
+ std::advance(this->m_Begin, n);
+ return *this;
}
- bool operator!=( const iterator_range& r ) const
+ iterator_range& advance_end(
+ BOOST_DEDUCED_TYPENAME base_type::difference_type n)
{
- return !operator==(r);
+ std::advance(this->m_End, n);
+ return *this;
}
- bool operator<( const iterator_range& r ) const
- {
- return iterator_range_detail::less_than( *this, r );
- }
-
- bool operator>( const iterator_range& r ) const
- {
- return iterator_range_detail::greater_than( *this, r );
- }
-
- bool operator<=( const iterator_range& r ) const
- {
- return iterator_range_detail::less_or_equal_than( *this, r );
- }
-
- bool operator>=( const iterator_range& r ) const
- {
- return iterator_range_detail::greater_or_equal_than( *this, r );
- }
-
-#endif
-
- public: // convenience
- reference front() const
- {
- BOOST_ASSERT( !empty() );
- return *m_Begin;
- }
-
- reference back() const
- {
- BOOST_ASSERT( !empty() );
- IteratorT last( m_End );
- return *--last;
- }
-
- // pop_front() - added to model the SinglePassRangePrimitiveConcept
- void pop_front()
- {
- BOOST_ASSERT( !empty() );
- ++m_Begin;
- }
-
- // pop_back() - added to model the BidirectionalRangePrimitiveConcept
- void pop_back()
- {
- BOOST_ASSERT( !empty() );
- --m_End;
- }
-
- reference operator[]( difference_type at ) const
- {
- BOOST_ASSERT( at >= 0 && at < size() );
- return m_Begin[at];
- }
-
- //
- // When storing transform iterators, operator[]()
- // fails because it returns by reference. Therefore
- // operator()() is provided for these cases.
- //
- abstract_value_type operator()( difference_type at ) const
- {
- BOOST_ASSERT( at >= 0 && at < size() );
- return m_Begin[at];
- }
-
- iterator_range& advance_begin( difference_type n )
- {
- std::advance( m_Begin, n );
- return *this;
- }
-
- iterator_range& advance_end( difference_type n )
- {
- std::advance( m_End, n );
- return *this;
- }
-
- private:
- // begin and end iterators
- IteratorT m_Begin;
- IteratorT m_End;
-
protected:
//
// Allow subclasses an easy way to access the
/////////////////////////////////////////////////////////////////////
template< class IteratorT, class ForwardRange >
- inline bool operator==( const ForwardRange& l,
- const iterator_range<IteratorT>& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator==( const ForwardRange& l, const iterator_range<IteratorT>& r )
{
return boost::equal( l, r );
}
template< class IteratorT, class ForwardRange >
- inline bool operator!=( const ForwardRange& l,
- const iterator_range<IteratorT>& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator!=( const ForwardRange& l, const iterator_range<IteratorT>& r )
{
return !boost::equal( l, r );
}
template< class IteratorT, class ForwardRange >
- inline bool operator<( const ForwardRange& l,
- const iterator_range<IteratorT>& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator<( const ForwardRange& l, const iterator_range<IteratorT>& r )
{
return iterator_range_detail::less_than( l, r );
}
template< class IteratorT, class ForwardRange >
- inline bool operator<=( const ForwardRange& l,
- const iterator_range<IteratorT>& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator<=( const ForwardRange& l, const iterator_range<IteratorT>& r )
{
return iterator_range_detail::less_or_equal_than( l, r );
}
template< class IteratorT, class ForwardRange >
- inline bool operator>( const ForwardRange& l,
- const iterator_range<IteratorT>& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator>( const ForwardRange& l, const iterator_range<IteratorT>& r )
{
return iterator_range_detail::greater_than( l, r );
}
template< class IteratorT, class ForwardRange >
- inline bool operator>=( const ForwardRange& l,
- const iterator_range<IteratorT>& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator>=( const ForwardRange& l, const iterator_range<IteratorT>& r )
{
return iterator_range_detail::greater_or_equal_than( l, r );
}
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#else
template< class Iterator1T, class Iterator2T >
- inline bool operator==( const iterator_range<Iterator1T>& l,
- const iterator_range<Iterator2T>& r )
+ inline bool
+ operator==( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
{
return boost::equal( l, r );
}
template< class IteratorT, class ForwardRange >
- inline bool operator==( const iterator_range<IteratorT>& l,
- const ForwardRange& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator==( const iterator_range<IteratorT>& l, const ForwardRange& r )
{
return boost::equal( l, r );
}
template< class Iterator1T, class Iterator2T >
- inline bool operator!=( const iterator_range<Iterator1T>& l,
- const iterator_range<Iterator2T>& r )
+ inline bool
+ operator!=( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
{
return !boost::equal( l, r );
}
template< class IteratorT, class ForwardRange >
- inline bool operator!=( const iterator_range<IteratorT>& l,
- const ForwardRange& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator!=( const iterator_range<IteratorT>& l, const ForwardRange& r )
{
return !boost::equal( l, r );
}
template< class Iterator1T, class Iterator2T >
- inline bool operator<( const iterator_range<Iterator1T>& l,
- const iterator_range<Iterator2T>& r )
+ inline bool
+ operator<( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
{
return iterator_range_detail::less_than( l, r );
}
template< class IteratorT, class ForwardRange >
- inline bool operator<( const iterator_range<IteratorT>& l,
- const ForwardRange& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator<( const iterator_range<IteratorT>& l, const ForwardRange& r )
{
return iterator_range_detail::less_than( l, r );
}
template< class Iterator1T, class Iterator2T >
- inline bool operator<=( const iterator_range<Iterator1T>& l,
- const iterator_range<Iterator2T>& r )
+ inline bool
+ operator<=( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
{
return iterator_range_detail::less_or_equal_than( l, r );
}
template< class IteratorT, class ForwardRange >
- inline bool operator<=( const iterator_range<IteratorT>& l,
- const ForwardRange& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator<=( const iterator_range<IteratorT>& l, const ForwardRange& r )
{
return iterator_range_detail::less_or_equal_than( l, r );
}
template< class Iterator1T, class Iterator2T >
- inline bool operator>( const iterator_range<Iterator1T>& l,
- const iterator_range<Iterator2T>& r )
+ inline bool
+ operator>( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
{
return iterator_range_detail::greater_than( l, r );
}
template< class IteratorT, class ForwardRange >
- inline bool operator>( const iterator_range<IteratorT>& l,
- const ForwardRange& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator>( const iterator_range<IteratorT>& l, const ForwardRange& r )
{
return iterator_range_detail::greater_than( l, r );
}
template< class Iterator1T, class Iterator2T >
- inline bool operator>=( const iterator_range<Iterator1T>& l,
- const iterator_range<Iterator2T>& r )
+ inline bool
+ operator>=( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
{
return iterator_range_detail::greater_or_equal_than( l, r );
}
template< class IteratorT, class ForwardRange >
- inline bool operator>=( const iterator_range<IteratorT>& l,
- const ForwardRange& r )
+ inline BOOST_DEDUCED_TYPENAME boost::enable_if<
+ mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
+ bool
+ >::type
+ operator>=( const iterator_range<IteratorT>& l, const ForwardRange& r )
{
return iterator_range_detail::greater_or_equal_than( l, r );
}
return iterator_range<IteratorT>( Begin, End );
}
+ template<typename IteratorT, typename IntegerT>
+ inline iterator_range<IteratorT>
+ make_iterator_range_n(IteratorT first, IntegerT n)
+ {
+ return iterator_range<IteratorT>(first, boost::next(first, n));
+ }
+
#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
template< typename Range >
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
{
- //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
}
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
{
- //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
}
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
{
- //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
}
#ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP
#define BOOST_RANGE_MUTABLE_ITERATOR_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/range/config.hpp>
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/range/detail/iterator.hpp>
-#else
-
+#include <boost/range/range_fwd.hpp>
#include <boost/range/detail/extract_optional_type.hpp>
+#include <boost/type_traits/remove_reference.hpp>
#include <boost/iterator/iterator_traits.hpp>
#include <cstddef>
#include <utility>
namespace boost
{
+
//////////////////////////////////////////////////////////////////////////
// default
//////////////////////////////////////////////////////////////////////////
- namespace range_detail {
- BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( iterator )
- }
+ namespace range_detail
+ {
- template< typename C >
- struct range_mutable_iterator : range_detail::extract_iterator<C>
- {};
-
- //////////////////////////////////////////////////////////////////////////
- // pair
- //////////////////////////////////////////////////////////////////////////
+BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( iterator )
- template< typename Iterator >
- struct range_mutable_iterator< std::pair<Iterator,Iterator> >
- {
- typedef Iterator type;
- };
+template< typename C >
+struct range_mutable_iterator
+ : range_detail::extract_iterator<
+ BOOST_DEDUCED_TYPENAME remove_reference<C>::type>
+{};
- //////////////////////////////////////////////////////////////////////////
- // array
- //////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+// pair
+//////////////////////////////////////////////////////////////////////////
- template< typename T, std::size_t sz >
- struct range_mutable_iterator< T[sz] >
- {
- typedef T* type;
- };
+template< typename Iterator >
+struct range_mutable_iterator< std::pair<Iterator,Iterator> >
+{
+ typedef Iterator type;
+};
+
+//////////////////////////////////////////////////////////////////////////
+// array
+//////////////////////////////////////////////////////////////////////////
+
+template< typename T, std::size_t sz >
+struct range_mutable_iterator< T[sz] >
+{
+ typedef T* type;
+};
+
+ } // namespace range_detail
+
+template<typename C, typename Enabler=void>
+struct range_mutable_iterator
+ : range_detail::range_mutable_iterator<
+ BOOST_DEDUCED_TYPENAME remove_reference<C>::type
+ >
+{
+};
} // namespace boost
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#include <boost/range/detail/msvc_has_iterator_workaround.hpp>
#endif
--- /dev/null
+// Boost.Range library
+//
+// Copyright Neil Groves 2003-2004.
+// Use, modification and distribution is subject to 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)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#ifndef BOOST_RANGE_RANGE_FWD_HPP_INCLUDED
+#define BOOST_RANGE_RANGE_FWD_HPP_INCLUDED
+
+namespace boost
+{
+
+// Extension points
+ template<typename C, typename Enabler>
+ struct range_iterator;
+
+ template<typename C, typename Enabler>
+ struct range_mutable_iterator;
+
+ template<typename C, typename Enabler>
+ struct range_const_iterator;
+
+// Core classes
+ template<typename IteratorT>
+ class iterator_range;
+
+ template<typename ForwardRange>
+ class sub_range;
+
+// Meta-functions
+ template<typename T>
+ struct range_category;
+
+ template<typename T>
+ struct range_difference;
+
+ template<typename T>
+ struct range_pointer;
+
+ template<typename T>
+ struct range_reference;
+
+ template<typename T>
+ struct range_reverse_iterator;
+
+ template<typename T>
+ struct range_size;
+
+ template<typename T>
+ struct range_value;
+
+ template<typename T>
+ struct has_range_iterator;
+
+ template<typename T>
+ struct has_range_const_iterator;
+
+} // namespace boost
+
+#endif // include guard
#ifndef BOOST_RANGE_RBEGIN_HPP
#define BOOST_RANGE_RBEGIN_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
#ifndef BOOST_RANGE_REND_HPP
#define BOOST_RANGE_REND_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
+++ /dev/null
-// Boost.Range library
-//
-// Copyright Thorsten Ottosen 2003-2004. Use, modification and
-// distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/range/
-//
-
-#ifndef BOOST_RANGE_RESULT_ITERATOR_HPP
-#define BOOST_RANGE_RESULT_ITERATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include <boost/range/iterator.hpp>
-
-namespace boost
-{
- //
- // This interface is deprecated, use range_iterator<T>
- //
-
- template< typename C >
- struct range_result_iterator : range_iterator<C>
- { };
-
-} // namespace boost
-
-
-#endif
#ifndef BOOST_RANGE_REVERSE_ITERATOR_HPP
#define BOOST_RANGE_REVERSE_ITERATOR_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/range/config.hpp>
#include <boost/range/iterator.hpp>
+#include <boost/type_traits/remove_reference.hpp>
#include <boost/iterator/reverse_iterator.hpp>
// default
//////////////////////////////////////////////////////////////////////////
- template< typename C >
+ template< typename T >
struct range_reverse_iterator
{
typedef reverse_iterator<
- BOOST_DEDUCED_TYPENAME range_iterator<C>::type > type;
+ BOOST_DEDUCED_TYPENAME range_iterator<
+ BOOST_DEDUCED_TYPENAME remove_reference<T>::type>::type > type;
};
#ifndef BOOST_RANGE_SIZE_HPP
#define BOOST_RANGE_SIZE_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/size_type.hpp>
+#include <boost/range/detail/has_member_size.hpp>
#include <boost/assert.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/utility.hpp>
namespace boost
{
namespace range_detail
{
+
+ template<class SinglePassRange>
+ inline typename ::boost::enable_if<
+ has_member_size<SinglePassRange>,
+ typename range_size<const SinglePassRange>::type
+ >::type
+ range_calculate_size(const SinglePassRange& rng)
+ {
+ return rng.size();
+ }
+
template<class SinglePassRange>
- inline BOOST_DEDUCED_TYPENAME range_size<const SinglePassRange>::type
+ inline typename disable_if<
+ has_member_size<SinglePassRange>,
+ typename range_size<const SinglePassRange>::type
+ >::type
range_calculate_size(const SinglePassRange& rng)
{
- BOOST_ASSERT( (boost::end(rng) - boost::begin(rng)) >= 0 &&
- "reachability invariant broken!" );
- return boost::end(rng) - boost::begin(rng);
+ return std::distance(boost::begin(rng), boost::end(rng));
}
}
template<class SinglePassRange>
- inline BOOST_DEDUCED_TYPENAME range_size<const SinglePassRange>::type
+ inline typename range_size<const SinglePassRange>::type
size(const SinglePassRange& rng)
{
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
#ifndef BOOST_RANGE_SIZE_TYPE_HPP
#define BOOST_RANGE_SIZE_TYPE_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/range/config.hpp>
#include <boost/range/difference_type.hpp>
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/range/detail/size_type.hpp>
-#else
+#include <boost/range/concepts.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/make_unsigned.hpp>
template<typename C>
static yes_type test(BOOST_DEDUCED_TYPENAME C::size_type x);
- template<typename C, typename Arg>
- static no_type test(Arg x);
+ template<typename C>
+ static no_type test(...);
public:
static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
template<typename C>
struct range_size<
C,
- BOOST_DEDUCED_TYPENAME enable_if<has_size_type<C>, void>::type
+ BOOST_DEDUCED_TYPENAME ::boost::enable_if<has_size_type<C>, void>::type
>
{
typedef BOOST_DEDUCED_TYPENAME C::size_type type;
template< class T >
struct range_size :
detail::range_size<T>
- { };
+ {
+// Very strange things happen on some compilers that have the range concept
+// asserts disabled. This preprocessor condition is clearly redundant on a
+// working compiler but is vital for at least some compilers such as clang 4.2
+// but only on the Mac!
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT == 1
+ BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<T>));
+#endif
+ };
template< class T >
struct range_size<const T >
: detail::range_size<T>
- { };
+ {
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT == 1
+ BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<T>));
+#endif
+ };
} // namespace boost
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif
#ifndef BOOST_RANGE_VALUE_TYPE_HPP
#define BOOST_RANGE_VALUE_TYPE_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER)
# pragma once
#endif
#include <boost/range/config.hpp>
#include <boost/range/iterator.hpp>
-//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//#include <boost/range/detail/value_type.hpp>
-//#else
-
#include <boost/iterator/iterator_traits.hpp>
namespace boost
-#ifndef BOOST_REF_HPP_INCLUDED
-#define BOOST_REF_HPP_INCLUDED
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * 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)
+ */
-// MS compatible compilers support #pragma once
+#ifndef BOOST_REF_HPP
+#define BOOST_REF_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/utility/addressof.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/detail/workaround.hpp>
-
-//
-// ref.hpp - ref/cref, useful helper functions
-//
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2001, 2002 Peter Dimov
-// Copyright (C) 2002 David Abrahams
-//
-// 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/bind/ref.html for documentation.
-//
-
-namespace boost
-{
-
-template<class T> class reference_wrapper
-{
-public:
- typedef T type;
+// The header file at this path is deprecated;
+// use boost/core/ref.hpp instead.
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1300 )
-
- explicit reference_wrapper(T& t): t_(&t) {}
-
-#else
-
- explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+#include <boost/core/ref.hpp>
#endif
-
- operator T& () const { return *t_; }
-
- T& get() const { return *t_; }
-
- T* get_pointer() const { return t_; }
-
-private:
-
- T* t_;
-};
-
-# if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
-# define BOOST_REF_CONST
-# else
-# define BOOST_REF_CONST const
-# endif
-
-template<class T> inline reference_wrapper<T> BOOST_REF_CONST ref(T & t)
-{
- return reference_wrapper<T>(t);
-}
-
-template<class T> inline reference_wrapper<T const> BOOST_REF_CONST cref(T const & t)
-{
- return reference_wrapper<T const>(t);
-}
-
-# undef BOOST_REF_CONST
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-template<typename T>
-class is_reference_wrapper
- : public mpl::false_
-{
-};
-
-template<typename T>
-class unwrap_reference
-{
- public:
- typedef T type;
-};
-
-# define AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(X) \
-template<typename T> \
-class is_reference_wrapper< X > \
- : public mpl::true_ \
-{ \
-}; \
-\
-template<typename T> \
-class unwrap_reference< X > \
-{ \
- public: \
- typedef T type; \
-}; \
-/**/
-
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T>)
-#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const)
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> volatile)
-AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const volatile)
-#endif
-
-# undef AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF
-
-# else // no partial specialization
-
-} // namespace boost
-
-#include <boost/type.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
- typedef char (&yes_reference_wrapper_t)[1];
- typedef char (&no_reference_wrapper_t)[2];
-
- no_reference_wrapper_t is_reference_wrapper_test(...);
-
- template<typename T>
- yes_reference_wrapper_t is_reference_wrapper_test(type< reference_wrapper<T> >);
-
- template<bool wrapped>
- struct reference_unwrapper
- {
- template <class T>
- struct apply
- {
- typedef T type;
- };
- };
-
- template<>
- struct reference_unwrapper<true>
- {
- template <class T>
- struct apply
- {
- typedef typename T::type type;
- };
- };
-}
-
-template<typename T>
-class is_reference_wrapper
-{
- public:
- BOOST_STATIC_CONSTANT(
- bool, value = (
- sizeof(detail::is_reference_wrapper_test(type<T>()))
- == sizeof(detail::yes_reference_wrapper_t)));
-
- typedef ::boost::mpl::bool_<value> type;
-};
-
-template <typename T>
-class unwrap_reference
- : public detail::reference_unwrapper<
- is_reference_wrapper<T>::value
- >::template apply<T>
-{};
-
-# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-template <class T> inline typename unwrap_reference<T>::type&
-unwrap_ref(T& t)
-{
- return t;
-}
-
-template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
-{
- return r.get_pointer();
-}
-
-} // namespace boost
-
-#endif // #ifndef BOOST_REF_HPP_INCLUDED
*
****************************************************************************/
-#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1200) && defined(_MSC_EXTENSIONS)
+#if defined(BOOST_MSVC) && defined(_MSC_EXTENSIONS)
#if defined(_DEBUG) || defined(__MSVC_RUNTIME_CHECKS) || defined(_MANAGED) || defined(BOOST_REGEX_NO_FASTCALL)
# define BOOST_REGEX_CALL __cdecl
#else
out.set_base(in.base().base());
for(int i = 0; i < (int)in.size(); ++i)
{
- if(in[i].matched)
+ if(in[i].matched || !i)
{
out.set_first(in[i].first.base(), i);
- out.set_second(in[i].second.base(), i);
+ out.set_second(in[i].second.base(), i, in[i].matched);
}
}
}
match_flag_type flags = match_default)
{
return re_detail::extract_output_base
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
- <OutputIterator>
-#endif
(
re_detail::do_regex_replace(
re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
match_flag_type flags = match_default)
{
return re_detail::extract_output_base
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
- <OutputIterator>
-#endif
(
re_detail::do_regex_replace(
re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
match_flag_type flags = match_default)
{
return re_detail::extract_output_base
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
- <OutputIterator>
-#endif
(
re_detail::do_regex_replace(
re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
// Since this preprocessor path is almost never taken, we hide these header
// dependencies so that build tools don't find them.
//
-#define B1 <boost/thread/once.hpp>
-#define B2 <boost/thread/recursive_mutex.hpp>
-#include B1
-#include B2
-#undef B1
-#undef B2
+#define BOOST_REGEX_H1 <boost/thread/once.hpp>
+#define BOOST_REGEX_H2 <boost/thread/recursive_mutex.hpp>
+#define BOOST_REGEX_H3 <boost/thread/lock_types.hpp>
+#include BOOST_REGEX_H1
+#include BOOST_REGEX_H2
+#include BOOST_REGEX_H3
+#undef BOOST_REGEX_H1
+#undef BOOST_REGEX_H2
+#undef BOOST_REGEX_H3
namespace boost{
void lock();
void unlock();
private:
- boost::recursive_mutex::scoped_lock* m_plock;
+ boost::unique_lock<boost::recursive_mutex>* m_plock;
bool m_have_lock;
};
{
typedef boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type> base_type;
-#if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if !defined(BOOST_NO_STD_ITERATOR_TRAITS)
typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 32);
// special values for pending iterator reads:
BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);
-#if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if !defined(BOOST_NO_STD_ITERATOR_TRAITS)
typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 16);
{
typedef boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type> base_type;
-#if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if !defined(BOOST_NO_STD_ITERATOR_TRAITS)
typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 32);
// special values for pending iterator reads:
BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);
-#if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if !defined(BOOST_NO_STD_ITERATOR_TRAITS)
typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 8);
0x1FFFFFu,
};
m_value &= masks[extra];
- // check the result:
+ // check the result is in range:
if(m_value > static_cast<U32Type>(0x10FFFFu))
invalid_sequence();
+ // The result must not be a surrogate:
+ if((m_value >= static_cast<U32Type>(0xD800)) && (m_value <= static_cast<U32Type>(0xDFFF)))
+ invalid_sequence();
+ // We should not have had an invalidly encoded UTF8 sequence:
+ if((extra > 0) && (m_value <= static_cast<U32Type>(masks[extra - 1])))
+ invalid_sequence();
}
BaseIterator m_position;
mutable U32Type m_value;
}
std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const
{
- if(n == 0)
- boost::throw_exception(std::out_of_range("0 is not a valid subexpression index."));
- const std::pair<std::size_t, std::size_t>& pi = this->m_subs.at(n - 1);
+ const std::pair<std::size_t, std::size_t>& pi = this->m_subs.at(n);
std::pair<const_iterator, const_iterator> p(expression() + pi.first, expression() + pi.second);
return p;
}
}
size_type BOOST_REGEX_CALL mark_count()const
{
- return this->m_mark_count;
+ return this->m_mark_count - 1;
}
const re_detail::re_syntax_base* get_first_state()const
{
digraph(charT c1) : std::pair<charT, charT>(c1, 0){}
digraph(charT c1, charT c2) : std::pair<charT, charT>(c1, c2)
{}
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
digraph(const digraph<charT>& d) : std::pair<charT, charT>(d.first, d.second){}
-#endif
template <class Seq>
digraph(const Seq& s) : std::pair<charT, charT>()
{
m_last_state = result = static_cast<re_literal*>(getaddress(off));
charT* characters = static_cast<charT*>(static_cast<void*>(result+1));
characters[result->length] = m_traits.translate(c, m_icase);
- ++(result->length);
+ result->length += 1;
}
return result;
}
if(flags() & regex_constants::collate)
{
// we need to transform our range into sort keys:
-#if BOOST_WORKAROUND(__GNUC__, < 3)
- string_type in(3, charT(0));
- in[0] = c1.first;
- in[1] = c1.second;
- s1 = this->m_traits.transform(in.c_str(), (in[1] ? in.c_str()+2 : in.c_str()+1));
- in[0] = c2.first;
- in[1] = c2.second;
- s2 = this->m_traits.transform(in.c_str(), (in[1] ? in.c_str()+2 : in.c_str()+1));
-#else
charT a1[3] = { c1.first, c1.second, charT(0), };
charT a2[3] = { c2.first, c2.second, charT(0), };
s1 = this->m_traits.transform(a1, (a1[1] ? a1+2 : a1+1));
s2 = this->m_traits.transform(a2, (a2[1] ? a2+2 : a2+1));
-#endif
if(s1.size() == 0)
s1 = string_type(1, charT(0));
if(s2.size() == 0)
string_type s;
if(first->second)
{
-#if BOOST_WORKAROUND(__GNUC__, < 3)
- string_type in(3, charT(0));
- in[0] = first->first;
- in[1] = first->second;
- s = m_traits.transform_primary(in.c_str(), in.c_str()+2);
-#else
charT cs[3] = { first->first, first->second, charT(0), };
s = m_traits.transform_primary(cs, cs+2);
-#endif
}
else
s = m_traits.transform_primary(&first->first, &first->first+1);
++m_position;
return parse_repeat_range(false);
case regex_constants::syntax_close_brace:
- fail(regex_constants::error_brace, this->m_position - this->m_base, "Found a closing repetition operator } with no corresponding {.");
- return false;
+ if((this->flags() & regbase::no_perl_ex) == regbase::no_perl_ex)
+ {
+ fail(regex_constants::error_brace, this->m_position - this->m_base, "Found a closing repetition operator } with no corresponding {.");
+ return false;
+ }
+ result = parse_literal();
+ break;
case regex_constants::syntax_or:
return parse_alt();
case regex_constants::syntax_open_set:
// the last state was a literal with more than one character, split it in two:
re_literal* lit = static_cast<re_literal*>(this->m_last_state);
charT c = (static_cast<charT*>(static_cast<void*>(lit+1)))[lit->length - 1];
- --(lit->length);
+ lit->length -= 1;
// now append new state:
lit = static_cast<re_literal*>(this->append_state(syntax_element_literal, sizeof(re_literal) + sizeof(charT)));
lit->length = 1;
)
)
{
- fail(regex_constants::error_empty, this->m_position - this->m_base, "A regular expression can start with the alternation operator |.");
+ fail(regex_constants::error_empty, this->m_position - this->m_base, "A regular expression cannot start with the alternation operator |.");
return false;
}
//
#include <boost/config.hpp>
#include <boost/integer.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
#ifndef BOOST_NO_STD_LOCALE
// we adhere to gcc's (buggy) preconditions...
//
BOOST_ASSERT(*p2 == 0);
-
string_type result;
+#if defined(_CPPLIB_VER)
+ //
+ // A bug in VC11 and 12 causes the program to hang if we pass a null-string
+ // to std::collate::transform, but only for certain locales :-(
+ // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).
+ //
+ if(*p1 == 0)
+ {
+ return string_type(1, charT(0));
+ }
+#endif
//
// swallowing all exceptions here is a bad idea
// however at least one std lib will always throw
// however at least one std lib will always throw
// std::bad_alloc for certain arguments...
//
- string_type result;
+ string_type result, result2;
+#if defined(_CPPLIB_VER)
+ //
+ // A bug in VC11 and 12 causes the program to hang if we pass a null-string
+ // to std::collate::transform, but only for certain locales :-(
+ // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).
+ //
+ if(*p1 == 0)
+ {
+ return result;
+ }
+#endif
#ifndef BOOST_NO_EXCEPTIONS
try{
#endif
while(result.size() && (charT(0) == *result.rbegin()))
result.erase(result.size() - 1);
#endif
- BOOST_ASSERT(std::find(result.begin(), result.end(), charT(0)) == result.end());
+ //
+ // We may have NULL's used as separators between sections of the collate string,
+ // an example would be Boost.Locale. We have no way to detect this case via
+ // #defines since this can be used with any compiler/platform combination.
+ // Unfortunately our state machine (which was devised when all implementations
+ // used underlying C language API's) can't cope with that case. One workaround
+ // is to replace each character with 2, fortunately this code isn't used that
+ // much as this is now slower than before :-(
+ //
+ typedef typename make_unsigned<charT>::type uchar_type;
+ result2.reserve(result.size() * 2 + 2);
+ for(unsigned i = 0; i < result.size(); ++i)
+ {
+ if(static_cast<uchar_type>(result[i]) == (std::numeric_limits<uchar_type>::max)())
+ {
+ result2.append(1, charT((std::numeric_limits<uchar_type>::max)())).append(1, charT('b'));
+ }
+ else
+ {
+ result2.append(1, static_cast<charT>(1 + static_cast<uchar_type>(result[i]))).append(1, charT('b') - 1);
+ }
+ }
+ BOOST_ASSERT(std::find(result2.begin(), result2.end(), charT(0)) == result2.end());
#ifndef BOOST_NO_EXCEPTIONS
}
catch(...)
{
}
#endif
- return result;
+ return result2;
}
return pos->second;
}
#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
- && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\
&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)
std::string name(p1, p2);
#else
#endif
name = lookup_default_collate_name(name);
#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
- && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\
&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)
if(name.size())
return string_type(name.begin(), name.end());
template <class charT>
-inline boost::shared_ptr<const cpp_regex_traits_implementation<charT> > create_cpp_regex_traits(const std::locale& l BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(charT))
+inline boost::shared_ptr<const cpp_regex_traits_implementation<charT> > create_cpp_regex_traits(const std::locale& l)
{
cpp_regex_traits_base<charT> key(l);
return ::boost::object_cache<cpp_regex_traits_base<charT>, cpp_regex_traits_implementation<charT> >::get(key, 5);
template class BOOST_REGEX_TEMPLATE_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >;
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
template class BOOST_REGEX_TEMPLATE_DECL match_results< const BOOST_REGEX_CHAR_T* >;
-#endif
#ifndef BOOST_NO_STD_ALLOCATOR
template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >;
#endif
&& !(defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION <= 800))\
&& !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))\
&& !defined(BOOST_REGEX_ICU_INSTANCES)
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
template class BOOST_REGEX_TEMPLATE_DECL match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >;
-#endif
#ifndef BOOST_NO_STD_ALLOCATOR
template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator, match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >::allocator_type, boost::regex_traits<BOOST_REGEX_CHAR_T > >;
#endif
namespace boost{
namespace re_detail{
-#if defined(BOOST_NO_STD_ITERATOR_TRAITS) || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if defined(BOOST_NO_STD_ITERATOR_TRAITS)
template <class T>
struct regex_iterator_traits
} match_flags;
-#if (defined(_MSC_VER) && (_MSC_VER < 1300)) || defined(__BORLANDC__)
+#if defined(__BORLANDC__)
typedef unsigned long match_flag_type;
#else
typedef match_flags match_flag_type;
// construct/copy/destroy:
explicit match_results(const Allocator& a = Allocator())
#ifndef BOOST_NO_STD_ALLOCATOR
- : m_subs(a), m_base(), m_last_closed_paren(0), m_is_singular(true) {}
+ : m_subs(a), m_base(), m_null(), m_last_closed_paren(0), m_is_singular(true) {}
#else
- : m_subs(), m_base(), m_last_closed_paren(0), m_is_singular(true) { (void)a; }
+ : m_subs(), m_base(), m_null(), m_last_closed_paren(0), m_is_singular(true) { (void)a; }
#endif
+ //
+ // IMPORTANT: in the code below, the crazy looking checks around m_is_singular are
+ // all required because it is illegal to copy a singular iterator.
+ // See https://svn.boost.org/trac/boost/ticket/3632.
+ //
match_results(const match_results& m)
: m_subs(m.m_subs), m_named_subs(m.m_named_subs), m_last_closed_paren(m.m_last_closed_paren), m_is_singular(m.m_is_singular)
{
// which succeeds when it should not.
//
#ifndef _RWSTD_VER
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
template <class C, class T, class A>
inline int string_compare(const std::basic_string<C,T,A>& s, const C* p)
{
}
return s.compare(p);
}
-#endif
#else
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
template <class C, class T, class A>
inline int string_compare(const std::basic_string<C,T,A>& s, const C* p)
{
}
return s.compare(p);
}
-#endif
inline int string_compare(const std::string& s, const char* p)
{ return std::strcmp(s.c_str(), p); }
# ifndef BOOST_NO_WREGEX
std::size_t count; // the number of iterations so far
BidiIterator start_pos; // where the last repeat started
public:
- repeater_count(repeater_count** s)
- {
- stack = s;
- next = 0;
- state_id = -1;
- count = 0;
- }
+ repeater_count(repeater_count** s) : stack(s), next(0), state_id(-1), count(0), start_pos() {}
+
repeater_count(int i, repeater_count** s, BidiIterator start)
: start_pos(start)
{
search_base = base;
state_count = 0;
m_match_flags |= regex_constants::match_all;
- m_presult->set_size((m_match_flags & match_nosubs) ? 1 : re.mark_count(), search_base, last);
+ m_presult->set_size((m_match_flags & match_nosubs) ? 1 : 1 + re.mark_count(), search_base, last);
m_presult->set_base(base);
m_presult->set_named_subs(this->re.get_named_subs());
if(m_match_flags & match_posix)
// reset our state machine:
search_base = position = base;
pstate = re.get_first_state();
- m_presult->set_size((m_match_flags & match_nosubs) ? 1 : re.mark_count(), base, last);
+ m_presult->set_size((m_match_flags & match_nosubs) ? 1 : 1 + re.mark_count(), base, last);
m_presult->set_base(base);
m_presult->set_named_subs(this->re.get_named_subs());
m_match_flags |= regex_constants::match_init;
++position;
}
// reset $` start:
- m_presult->set_size((m_match_flags & match_nosubs) ? 1 : re.mark_count(), search_base, last);
+ m_presult->set_size((m_match_flags & match_nosubs) ? 1 : 1 + re.mark_count(), search_base, last);
//if((base != search_base) && (base == backstop))
// m_match_flags |= match_prev_avail;
}
if(m_match_flags & match_posix)
{
- m_result.set_size(re.mark_count(), base, last);
+ m_result.set_size(1 + re.mark_count(), base, last);
m_result.set_base(base);
}
if(position != last)
{
// prev and this character must be opposites:
- #if defined(BOOST_REGEX_USE_C_LOCALE) && defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ < 95)
- b = traits::isctype(*position, m_word_mask);
- #else
b = traits_inst.isctype(*position, m_word_mask);
- #endif
}
else
{
public:
typedef typename traits::char_type char_type;
basic_regex_formatter(OutputIterator o, const Results& r, const traits& t)
- : m_traits(t), m_results(r), m_out(o), m_state(output_copy), m_restore_state(output_copy), m_have_conditional(false) {}
+ : m_traits(t), m_results(r), m_out(o), m_position(), m_end(), m_flags(), m_state(output_copy), m_restore_state(output_copy), m_have_conditional(false) {}
OutputIterator format(ForwardIter p1, ForwardIter p2, match_flag_type f);
OutputIterator format(ForwardIter p1, match_flag_type f)
{
{
if(size_type(last - end) < n)
resize(n + (end - start));
- register pointer result = end;
+ pointer result = end;
end += n;
return result;
}
// if there is still input left, do a final push as long as max_split
// is not exhausted, and we're not splitting sub-expressions rather
// than whitespace:
- if(max_split && (last != s.end()) && (e.mark_count() == 1))
+ if(max_split && (last != s.end()) && (e.mark_count() == 0))
{
*out = std::basic_string<charT, Traits1, Alloc1>((ci_t)last, (ci_t)s.end());
++out;
#include <boost/shared_ptr.hpp>
#include <boost/detail/workaround.hpp>
#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
- || BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
//
// Borland C++ Builder 6, and Visual C++ 6,
#endif
#ifdef BOOST_MSVC
#pragma warning(pop)
-#endif
-#if BOOST_WORKAROUND(BOOST_MSVC, > 1300)
-# pragma warning(push)
-# pragma warning(disable:4700)
+#pragma warning(push)
+#pragma warning(disable:4700)
#endif
template <class BidirectionalIterator,
: end(last), re(*p), flags(f), subs(v){}
#if !BOOST_WORKAROUND(__HP_aCC, < 60700)
#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
- || BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \
|| BOOST_WORKAROUND(__HP_aCC, < 60700)
template <class T>
}
#if !BOOST_WORKAROUND(__HP_aCC, < 60700)
#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
- || BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \
|| BOOST_WORKAROUND(__HP_aCC, < 60700)
template <class T>
{
return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
}
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
template <class charT, class traits, std::size_t N>
inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
{
{
return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
}
-#endif
template <class charT, class traits>
inline regex_token_iterator<const charT*, charT, traits> make_regex_token_iterator(const charT* p, const basic_regex<charT, traits>& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
{
return regex_token_iterator<typename std::basic_string<charT, ST, SA>::const_iterator, charT, traits>(p.begin(), p.end(), e, submatch, m);
}
-#if BOOST_WORKAROUND(BOOST_MSVC, > 1300)
-# pragma warning(pop)
-#endif
#ifdef BOOST_MSVC
+#pragma warning(pop)
#pragma warning(push)
#pragma warning(disable: 4103)
#endif
// required "standard" ones:
//
namespace re_detail{
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__HP_aCC, < 60000)
+#if !BOOST_WORKAROUND(__HP_aCC, < 60000)
BOOST_MPL_HAS_XXX_TRAIT_DEF(boost_extensions_tag)
#else
template<class T>
{
typedef BaseT type;
};
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__HP_aCC, < 60000)
+#if !BOOST_WORKAROUND(__HP_aCC, < 60000)
template <class BaseT>
struct compute_wrapper_base<BaseT, false>
{
/*****************************************************************************
*
- * Fix broken broken namespace support:
+ * Fix broken namespace support:
*
****************************************************************************/
struct sub_match : public std::pair<BidiIterator, BidiIterator>
{
typedef typename re_detail::regex_iterator_traits<BidiIterator>::value_type value_type;
-#if defined(BOOST_NO_STD_ITERATOR_TRAITS) || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if defined(BOOST_NO_STD_ITERATOR_TRAITS)
typedef std::ptrdiff_t difference_type;
#else
typedef typename re_detail::regex_iterator_traits<BidiIterator>::difference_type difference_type;
sub_match() : std::pair<BidiIterator, BidiIterator>(), matched(false) {}
sub_match(BidiIterator i) : std::pair<BidiIterator, BidiIterator>(i, i), matched(false) {}
#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
- && !BOOST_WORKAROUND(BOOST_MSVC, < 1310)\
&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)\
&& !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
template <class T, class A>
#define BOOST_REGEX_V4_U32REGEX_TOKEN_ITERATOR_HPP
#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
- || BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
//
// Borland C++ Builder 6, and Visual C++ 6,
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
-#if BOOST_WORKAROUND(BOOST_MSVC, > 1300)
+#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable:4700)
#endif
: end(last), re(*p), flags(f){ subs.push_back(sub); }
u32regex_token_iterator_implementation(const regex_type* p, BidirectionalIterator last, const std::vector<int>& v, match_flag_type f)
: end(last), re(*p), flags(f), subs(v){}
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- // can't reliably get this to work....
-#elif (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
- || BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
+#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \
|| BOOST_WORKAROUND(__HP_aCC, < 60700)
template <class T>
if(!pdata->init(a))
pdata.reset();
}
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- // can't reliably get this to work....
-#elif (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
- || BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
+#if (BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)))\
|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) \
|| BOOST_WORKAROUND(__HP_aCC, < 60700)
template <class T>
return u32regex_token_iterator<const UChar*>(s.getBuffer(), s.getBuffer() + s.length(), e, submatch, m);
}
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
// construction from a reference to an array:
template <std::size_t N>
inline u32regex_token_iterator<const char*> make_u32regex_token_iterator(const char* p, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default)
{
return u32regex_token_iterator<const UChar*>(s.getBuffer(), s.getBuffer() + s.length(), e, submatch, m);
}
-#endif // BOOST_MSVC < 1300
// construction from a vector of sub_match state_id's:
inline u32regex_token_iterator<const char*> make_u32regex_token_iterator(const char* p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
return u32regex_token_iterator<const UChar*>(s.getBuffer(), s.getBuffer() + s.length(), e, submatch, m);
}
-#if BOOST_WORKAROUND(BOOST_MSVC, > 1300)
+#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
#ifdef BOOST_HAS_ABI_HEADERS
return pos->second;
}
#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
- && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\
&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)
std::string name(p1, p2);
#else
#endif
name = lookup_default_collate_name(name);
#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
- && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\
&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)
if(name.size())
return string_type(name.begin(), name.end());
template <class charT>
-boost::shared_ptr<const w32_regex_traits_implementation<charT> > create_w32_regex_traits(::boost::re_detail::lcid_type l BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(charT))
+boost::shared_ptr<const w32_regex_traits_implementation<charT> > create_w32_regex_traits(::boost::re_detail::lcid_type l)
{
// TODO: create a cache for previously constructed objects.
return boost::object_cache< ::boost::re_detail::lcid_type, w32_regex_traits_implementation<charT> >::get(l, 5);
#include <boost/signals/detail/config.hpp>
#include <boost/signals/detail/signals_common.hpp>
#include <boost/signals/connection.hpp>
-#include <boost/utility.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/function/function2.hpp>
#include <boost/iterator/iterator_facade.hpp>
typedef const stored_group& first_argument_type;
typedef const stored_group& second_argument_type;
- group_bridge_compare(const Compare& c) : comp(c)
+ group_bridge_compare(const Compare& c) : comp(c)
{ }
bool operator()(const stored_group& k1, const stored_group& k2) const
connection_slot_pair,
forward_traversal_tag> inherited;
public:
- named_slot_map_iterator() : slot_assigned(false)
+ named_slot_map_iterator() : slot_assigned(false)
{ }
- named_slot_map_iterator(const named_slot_map_iterator& other)
+ named_slot_map_iterator(const named_slot_map_iterator& other)
: group(other.group), last_group(other.last_group),
slot_assigned(other.slot_assigned)
{
if (slot_assigned) slot_ = other.slot_;
}
- named_slot_map_iterator& operator=(const named_slot_map_iterator& other)
+ named_slot_map_iterator& operator=(const named_slot_map_iterator& other)
{
slot_assigned = other.slot_assigned;
group = other.group;
if (slot_assigned) slot_ = other.slot_;
return *this;
}
- connection_slot_pair& dereference() const
+ connection_slot_pair& dereference() const
{
return *slot_;
}
- void increment()
+ void increment()
{
++slot_;
if (slot_ == group->second.end()) {
|| slot_ == other.slot_));
}
-#if BOOST_WORKAROUND(_MSC_VER, <= 1700)
+#if BOOST_WORKAROUND(_MSC_VER, <= 1900)
void decrement();
void advance(difference_type);
#endif
#include <boost/signals/trackable.hpp>
#include <boost/signals/slot.hpp>
#include <boost/smart_ptr.hpp>
-#include <boost/utility.hpp>
+#include <boost/noncopyable.hpp>
#include <boost/function/function2.hpp>
#include <utility>
#include <vector>
};
// Determine if the incoming argument is a reference_wrapper
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template<typename T>
struct is_ref
{
{
BOOST_STATIC_CONSTANT(bool, value = true);
};
-#else // no partial specialization
- typedef char yes_type;
- typedef double no_type;
-
- no_type is_ref_tester(...);
-
- template<typename T>
- yes_type is_ref_tester(reference_wrapper<T>*);
-
- template<typename T>
- struct is_ref
- {
- static T* t;
- BOOST_STATIC_CONSTANT(bool,
- value = (sizeof(is_ref_tester(t)) == sizeof(yes_type)));
- };
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
// A slot can be a signal, a reference to a function object, or a
// function object.
#define BOOST_SIGNALS_SIGNAL_TEMPLATE_HEADER_INCLUDED
# include <boost/config.hpp>
# include <boost/signals/connection.hpp>
-# include <boost/utility.hpp>
# include <boost/ref.hpp>
# include <boost/signals/slot.hpp>
# include <boost/last_value.hpp>
BOOST_SIGNALS_NAMESPACE::connect_position at
= BOOST_SIGNALS_NAMESPACE::at_back);
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
- // MSVC 6.0 and 7.0 don't handle the is_convertible test well
- void disconnect(const group_type& group)
- {
- impl->disconnect(group);
- }
-#else
template<typename T>
void disconnect(const T& t)
{
if (s == f) i->first.disconnect();
}
}
-#endif
public:
/*
- * Copyright (c) 2012 Glen Joseph Fernandes
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes
* glenfe at live dot com
*
* Distributed under the Boost Software License,
#ifndef BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
#define BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/detail/allocate_array_helper.hpp>
-#include <boost/smart_ptr/detail/array_deleter.hpp>
-#include <boost/smart_ptr/detail/array_traits.hpp>
+#include <boost/smart_ptr/detail/array_count_impl.hpp>
#include <boost/smart_ptr/detail/sp_if_array.hpp>
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
namespace boost {
- template<typename T, typename A>
+ template<class T, class A>
inline typename boost::detail::sp_if_array<T>::type
allocate_shared(const A& allocator, std::size_t size) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
- T1* p1 = 0;
- T2* p2 = 0;
+ typedef boost::detail::ms_init_tag R1;
+ typedef boost::detail::as_allocator<A, T, R1> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
std::size_t n1 = size * boost::detail::array_total<T1>::size;
- boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
- p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init(p2);
- return boost::shared_ptr<T>(s1, p1);
- }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
- template<typename T, typename A, typename... Args>
- inline typename boost::detail::sp_if_array<T>::type
- allocate_shared(const A& allocator, std::size_t size, Args&&... args) {
- typedef typename boost::detail::array_inner<T>::type T1;
- typedef typename boost::detail::array_base<T1>::type T2;
T1* p1 = 0;
T2* p2 = 0;
- std::size_t n1 = size * boost::detail::array_total<T1>::size;
- boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
+ D1 d1;
+ A1 a1(allocator, size, &p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+ boost::detail::as_init(allocator, p2, n1);
+#else
+ boost::detail::ms_init(p2, n1);
+#endif
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init(p2, boost::detail::sp_forward<Args>(args)...);
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
- template<typename T, typename A, typename... Args>
+
+ template<class T, class A>
inline typename boost::detail::sp_if_size_array<T>::type
- allocate_shared(const A& allocator, Args&&... args) {
+ allocate_shared(const A& allocator) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
+ typedef boost::detail::ms_init_tag R1;
+ typedef boost::detail::as_allocator<A, T, R1> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
enum {
N = boost::detail::array_total<T>::size
};
T1* p1 = 0;
T2* p2 = 0;
- boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
- boost::detail::array_deleter<T2[N]> d1;
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[N]>* D2;
- p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init(p2, boost::detail::sp_forward<Args>(args)...);
- return boost::shared_ptr<T>(s1, p1);
- }
+ D1 d1;
+ A1 a1(allocator, &p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+ boost::detail::as_init(allocator, p2, N);
+#else
+ boost::detail::ms_init(p2, N);
#endif
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
- template<typename T, typename A>
- inline typename boost::detail::sp_if_size_array<T>::type
- allocate_shared(const A& allocator, const T& list) {
- typedef typename boost::detail::array_inner<T>::type T1;
- typedef typename boost::detail::array_base<T1>::type T2;
- typedef const T2 T3;
- enum {
- N = boost::detail::array_total<T>::size
- };
- T1* p1 = 0;
- T2* p2 = 0;
- T3* p3 = 0;
- boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
- boost::detail::array_deleter<T2[N]> d1;
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[N]>* D2;
- p3 = reinterpret_cast<T3*>(list);
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init_list(p2, p3);
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
- template<typename T, typename A>
+
+ template<class T, class A>
inline typename boost::detail::sp_if_array<T>::type
allocate_shared(const A& allocator, std::size_t size,
- const typename boost::detail::array_inner<T>::type& list) {
+ const typename boost::detail::array_inner<T>::type& value) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
typedef const T2 T3;
+ typedef boost::detail::ms_init_tag R1;
+ typedef boost::detail::as_allocator<A, T, R1> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
enum {
M = boost::detail::array_total<T1>::size
};
- T1* p1 = 0;
- T2* p2 = 0;
- T3* p3 = 0;
std::size_t n1 = M * size;
- boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
- p3 = reinterpret_cast<T3*>(list);
- p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->template init_list<M>(p2, p3);
- return boost::shared_ptr<T>(s1, p1);
- }
- template<typename T, typename A>
- inline typename boost::detail::sp_if_size_array<T>::type
- allocate_shared(const A& allocator,
- const typename boost::detail::array_inner<T>::type& list) {
- typedef typename boost::detail::array_inner<T>::type T1;
- typedef typename boost::detail::array_base<T1>::type T2;
- typedef const T2 T3;
- enum {
- M = boost::detail::array_total<T1>::size,
- N = boost::detail::array_total<T>::size
- };
- T1* p1 = 0;
- T2* p2 = 0;
- T3* p3 = 0;
- boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
- boost::detail::array_deleter<T2[N]> d1;
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[N]>* D2;
- p3 = reinterpret_cast<T3*>(list);
- p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->template init_list<M>(p2, p3);
- return boost::shared_ptr<T>(s1, p1);
- }
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
- template<typename T, typename A>
- inline typename boost::detail::sp_if_array<T>::type
- allocate_shared(const A& allocator,
- std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
- typedef typename boost::detail::array_inner<T>::type T1;
- typedef typename boost::detail::array_base<T1>::type T2;
- typedef const T2 T3;
T1* p1 = 0;
T2* p2 = 0;
- T3* p3 = 0;
- std::size_t n1 = list.size() * boost::detail::array_total<T1>::size;
- boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
- p3 = reinterpret_cast<T3*>(list.begin());
- p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init_list(p2, p3);
- return boost::shared_ptr<T>(s1, p1);
- }
+ T3* p3 = reinterpret_cast<T3*>(&value);
+ D1 d1;
+ A1 a1(allocator, size, &p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+ boost::detail::as_init<T2, A, M>(allocator, p2, n1, p3);
+#else
+ boost::detail::ms_init<T2, M>(p2, n1, p3);
#endif
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
- template<typename T, typename A>
- inline typename boost::detail::sp_if_array<T>::type
- allocate_shared(const A& allocator, std::size_t size,
- typename boost::detail::array_base<T>::type&& value) {
- typedef typename boost::detail::array_inner<T>::type T1;
- typedef typename boost::detail::array_base<T1>::type T2;
- T1* p1 = 0;
- T2* p2 = 0;
- std::size_t n1 = size * boost::detail::array_total<T1>::size;
- boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init(p2, boost::detail::sp_forward<T2>(value));
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
- template<typename T, typename A>
+
+ template<class T, class A>
inline typename boost::detail::sp_if_size_array<T>::type
- allocate_shared(const A& allocator,
- typename boost::detail::array_base<T>::type&& value) {
+ allocate_shared(const A& allocator,
+ const typename boost::detail::array_inner<T>::type& value) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
+ typedef const T2 T3;
+ typedef boost::detail::ms_init_tag R1;
+ typedef boost::detail::as_allocator<A, T, R1> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
enum {
- N = boost::detail::array_total<T>::size
+ N = boost::detail::array_total<T>::size,
+ M = boost::detail::array_total<T1>::size
};
T1* p1 = 0;
T2* p2 = 0;
- boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
- boost::detail::array_deleter<T2[N]> d1;
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[N]>* D2;
+ T3* p3 = reinterpret_cast<T3*>(&value);
+ D1 d1;
+ A1 a1(allocator, &p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+ boost::detail::as_init<T2, A, M>(allocator, p2, N, p3);
+#else
+ boost::detail::ms_init<T2, M>(p2, N, p3);
+#endif
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init(p2, boost::detail::sp_forward<T2>(value));
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
-#endif
-#endif
- template<typename T, typename A>
+
+ template<class T, class A>
inline typename boost::detail::sp_if_array<T>::type
allocate_shared_noinit(const A& allocator, std::size_t size) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
+ typedef boost::detail::ms_noinit_tag R1;
+ typedef boost::detail::as_allocator<A, T, R1> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
+ std::size_t n1 = size * boost::detail::array_total<T1>::size;
T1* p1 = 0;
T2* p2 = 0;
- std::size_t n1 = size * boost::detail::array_total<T1>::size;
- boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
+ D1 d1;
+ A1 a1(allocator, size, &p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+ boost::detail::ms_noinit(p2, n1);
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->noinit(p2);
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
- template<typename T, typename A>
+
+ template<class T, class A>
inline typename boost::detail::sp_if_size_array<T>::type
allocate_shared_noinit(const A& allocator) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
+ typedef boost::detail::ms_noinit_tag R1;
+ typedef boost::detail::as_allocator<A, T, R1> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
enum {
N = boost::detail::array_total<T>::size
};
T1* p1 = 0;
T2* p2 = 0;
- boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
- boost::detail::array_deleter<T2[N]> d1;
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[N]>* D2;
+ D1 d1;
+ A1 a1(allocator, &p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+ boost::detail::ms_noinit(p2, N);
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->noinit(p2);
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
}
+++ /dev/null
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_ALLOCATE_ARRAY_HELPER_HPP
-#define BOOST_SMART_PTR_DETAIL_ALLOCATE_ARRAY_HELPER_HPP
-
-#include <boost/type_traits/alignment_of.hpp>
-
-namespace boost {
- namespace detail {
- template<typename A, typename T, typename Y = char>
- class allocate_array_helper;
- template<typename A, typename T, typename Y>
- class allocate_array_helper<A, T[], Y> {
- template<typename A9, typename T9, typename Y9>
- friend class allocate_array_helper;
- typedef typename A::template rebind<Y> ::other A2;
- typedef typename A::template rebind<char>::other A3;
- public:
- typedef typename A2::value_type value_type;
- typedef typename A2::pointer pointer;
- typedef typename A2::const_pointer const_pointer;
- typedef typename A2::reference reference;
- typedef typename A2::const_reference const_reference;
- typedef typename A2::size_type size_type;
- typedef typename A2::difference_type difference_type;
- template<typename U>
- struct rebind {
- typedef allocate_array_helper<A, T[], U> other;
- };
- allocate_array_helper(const A& allocator_, std::size_t size_, T** data_)
- : allocator(allocator_),
- size(sizeof(T) * size_),
- data(data_) {
- }
- template<class U>
- allocate_array_helper(const allocate_array_helper<A, T[], U>& other)
- : allocator(other.allocator),
- size(other.size),
- data(other.data) {
- }
- pointer address(reference value) const {
- return allocator.address(value);
- }
- const_pointer address(const_reference value) const {
- return allocator.address(value);
- }
- size_type max_size() const {
- return allocator.max_size();
- }
- pointer allocate(size_type count, const void* value = 0) {
- std::size_t a1 = boost::alignment_of<T>::value;
- std::size_t n1 = count * sizeof(Y) + a1 - 1;
- char* p1 = A3(allocator).allocate(n1 + size, value);
- char* p2 = p1 + n1;
- while (std::size_t(p2) % a1 != 0) {
- p2--;
- }
- *data = reinterpret_cast<T*>(p2);
- return reinterpret_cast<Y*>(p1);
- }
- void deallocate(pointer memory, size_type count) {
- std::size_t a1 = boost::alignment_of<T>::value;
- std::size_t n1 = count * sizeof(Y) + a1 - 1;
- char* p1 = reinterpret_cast<char*>(memory);
- A3(allocator).deallocate(p1, n1 + size);
- }
- void construct(pointer memory, const Y& value) {
- allocator.construct(memory, value);
- }
- void destroy(pointer memory) {
- allocator.destroy(memory);
- }
- template<typename U>
- bool operator==(const allocate_array_helper<A, T[], U>& other) const {
- return allocator == other.allocator;
- }
- template<typename U>
- bool operator!=(const allocate_array_helper<A, T[], U>& other) const {
- return !(*this == other);
- }
- private:
- A2 allocator;
- std::size_t size;
- T** data;
- };
- template<typename A, typename T, std::size_t N, typename Y>
- class allocate_array_helper<A, T[N], Y> {
- template<typename A9, typename T9, typename Y9>
- friend class allocate_array_helper;
- typedef typename A::template rebind<Y> ::other A2;
- typedef typename A::template rebind<char>::other A3;
- public:
- typedef typename A2::value_type value_type;
- typedef typename A2::pointer pointer;
- typedef typename A2::const_pointer const_pointer;
- typedef typename A2::reference reference;
- typedef typename A2::const_reference const_reference;
- typedef typename A2::size_type size_type;
- typedef typename A2::difference_type difference_type;
- template<typename U>
- struct rebind {
- typedef allocate_array_helper<A, T[N], U> other;
- };
- allocate_array_helper(const A& allocator_, T** data_)
- : allocator(allocator_),
- data(data_) {
- }
- template<class U>
- allocate_array_helper(const allocate_array_helper<A, T[N], U>& other)
- : allocator(other.allocator),
- data(other.data) {
- }
- pointer address(reference value) const {
- return allocator.address(value);
- }
- const_pointer address(const_reference value) const {
- return allocator.address(value);
- }
- size_type max_size() const {
- return allocator.max_size();
- }
- pointer allocate(size_type count, const void* value = 0) {
- std::size_t a1 = boost::alignment_of<T>::value;
- std::size_t n1 = count * sizeof(Y) + a1 - 1;
- char* p1 = A3(allocator).allocate(n1 + N1, value);
- char* p2 = p1 + n1;
- while (std::size_t(p2) % a1 != 0) {
- p2--;
- }
- *data = reinterpret_cast<T*>(p2);
- return reinterpret_cast<Y*>(p1);
- }
- void deallocate(pointer memory, size_type count) {
- std::size_t a1 = boost::alignment_of<T>::value;
- std::size_t n1 = count * sizeof(Y) + a1 - 1;
- char* p1 = reinterpret_cast<char*>(memory);
- A3(allocator).deallocate(p1, n1 + N1);
- }
- void construct(pointer memory, const Y& value) {
- allocator.construct(memory, value);
- }
- void destroy(pointer memory) {
- allocator.destroy(memory);
- }
- template<typename U>
- bool operator==(const allocate_array_helper<A, T[N], U>& other) const {
- return allocator == other.allocator;
- }
- template<typename U>
- bool operator!=(const allocate_array_helper<A, T[N], U>& other) const {
- return !(*this == other);
- }
- private:
- enum {
- N1 = N * sizeof(T)
- };
- A2 allocator;
- T** data;
- };
- }
-}
-
-#endif
--- /dev/null
+/*
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes
+ * glenfe at live dot com
+ *
+ * Distributed under the Boost Software License,
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt
+ * or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP
+#define BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP
+
+#include <boost/align/align.hpp>
+#include <boost/smart_ptr/detail/array_traits.hpp>
+#include <boost/smart_ptr/detail/array_utility.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+
+namespace boost {
+ namespace detail {
+ struct ms_init_tag { };
+ struct ms_noinit_tag { };
+
+ template<class T>
+ struct ms_allocator_state;
+
+ template<class T>
+ struct ms_allocator_state<T[]> {
+ typedef typename array_base<T>::type type;
+
+ ms_allocator_state(std::size_t size_,
+ type** result_)
+ : size(size_ * array_total<T>::size),
+ result(result_) {
+ }
+
+ std::size_t size;
+
+ union {
+ type** result;
+ type* object;
+ };
+ };
+
+ template<class T, std::size_t N>
+ struct ms_allocator_state<T[N]> {
+ typedef typename array_base<T>::type type;
+
+ ms_allocator_state(type** result_)
+ : result(result_) {
+ }
+
+ enum {
+ size = array_total<T[N]>::size
+ };
+
+ union {
+ type** result;
+ type* object;
+ };
+ };
+
+ template<class A, class T, class R>
+ class as_allocator
+ : public A {
+ template<class A_, class T_, class R_>
+ friend class as_allocator;
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+ typedef std::allocator_traits<A> AT;
+ typedef typename AT::template rebind_alloc<char> CA;
+ typedef typename AT::template rebind_traits<char> CT;
+#else
+ typedef typename A::template rebind<char>::other CA;
+#endif
+
+ public:
+ typedef A allocator_type;
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+ typedef typename AT::value_type value_type;
+ typedef typename AT::pointer pointer;
+ typedef typename AT::const_pointer const_pointer;
+ typedef typename AT::void_pointer void_pointer;
+ typedef typename AT::const_void_pointer const_void_pointer;
+ typedef typename AT::size_type size_type;
+ typedef typename AT::difference_type difference_type;
+#else
+ typedef typename A::value_type value_type;
+ typedef typename A::pointer pointer;
+ typedef typename A::const_pointer const_pointer;
+ typedef typename A::size_type size_type;
+ typedef typename A::difference_type difference_type;
+ typedef typename A::reference reference;
+ typedef typename A::const_reference const_reference;
+ typedef void* void_pointer;
+ typedef const void* const_void_pointer;
+#endif
+
+ template<class U>
+ struct rebind {
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+ typedef as_allocator<typename AT::
+ template rebind_alloc<U>, T, R> other;
+#else
+ typedef as_allocator<typename A::
+ template rebind<U>::other, T, R> other;
+#endif
+ };
+
+ typedef typename array_base<T>::type type;
+
+ as_allocator(const A& allocator_, type** result)
+ : A(allocator_),
+ data(result) {
+ }
+
+ as_allocator(const A& allocator_, std::size_t size,
+ type** result)
+ : A(allocator_),
+ data(size, result) {
+ }
+
+ template<class U>
+ as_allocator(const as_allocator<U, T, R>& other)
+ : A(other.allocator()),
+ data(other.data) {
+ }
+
+ pointer allocate(size_type count, const_void_pointer = 0) {
+ enum {
+ M = boost::alignment_of<type>::value
+ };
+ std::size_t n1 = count * sizeof(value_type);
+ std::size_t n2 = data.size * sizeof(type);
+ std::size_t n3 = n2 + M;
+ CA ca(allocator());
+ void* p1 = ca.allocate(n1 + n3);
+ void* p2 = static_cast<char*>(p1) + n1;
+ (void)boost::alignment::align(M, n2, p2, n3);
+ *data.result = static_cast<type*>(p2);
+ return static_cast<value_type*>(p1);
+ }
+
+ void deallocate(pointer memory, size_type count) {
+ enum {
+ M = boost::alignment_of<type>::value
+ };
+ std::size_t n1 = count * sizeof(value_type);
+ std::size_t n2 = data.size * sizeof(type) + M;
+ char* p1 = reinterpret_cast<char*>(memory);
+ CA ca(allocator());
+ ca.deallocate(p1, n1 + n2);
+ }
+
+ const A& allocator() const {
+ return static_cast<const A&>(*this);
+ }
+
+ A& allocator() {
+ return static_cast<A&>(*this);
+ }
+
+ void set(type* memory) {
+ data.object = memory;
+ }
+
+ void operator()() {
+ if (data.object) {
+ R tag;
+ release(tag);
+ }
+ }
+
+ private:
+ void release(ms_init_tag) {
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+ as_destroy(allocator(), data.object, data.size);
+#else
+ ms_destroy(data.object, data.size);
+#endif
+ }
+
+ void release(ms_noinit_tag) {
+ ms_destroy(data.object, data.size);
+ }
+
+ ms_allocator_state<T> data;
+ };
+
+ template<class A1, class A2, class T, class R>
+ bool operator==(const as_allocator<A1, T, R>& a1,
+ const as_allocator<A2, T, R>& a2) {
+ return a1.allocator() == a2.allocator();
+ }
+
+ template<class A1, class A2, class T, class R>
+ bool operator!=(const as_allocator<A1, T, R>& a1,
+ const as_allocator<A2, T, R>& a2) {
+ return a1.allocator() != a2.allocator();
+ }
+
+ template<class T, class Y = char>
+ class ms_allocator;
+
+ template<class T, class Y>
+ class ms_allocator {
+ template<class T_, class Y_>
+ friend class ms_allocator;
+
+ public:
+ typedef typename array_base<T>::type type;
+
+ typedef Y value_type;
+ typedef Y* pointer;
+ typedef const Y* const_pointer;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef Y& reference;
+ typedef const Y& const_reference;
+
+ template<class U>
+ struct rebind {
+ typedef ms_allocator<T, U> other;
+ };
+
+ ms_allocator(type** result)
+ : data(result) {
+ }
+
+ ms_allocator(std::size_t size, type** result)
+ : data(size, result) {
+ }
+
+ template<class U>
+ ms_allocator(const ms_allocator<T, U>& other)
+ : data(other.data) {
+ }
+
+ pointer allocate(size_type count, const void* = 0) {
+ enum {
+ M = boost::alignment_of<type>::value
+ };
+ std::size_t n1 = count * sizeof(Y);
+ std::size_t n2 = data.size * sizeof(type);
+ std::size_t n3 = n2 + M;
+ void* p1 = ::operator new(n1 + n3);
+ void* p2 = static_cast<char*>(p1) + n1;
+ (void)boost::alignment::align(M, n2, p2, n3);
+ *data.result = static_cast<type*>(p2);
+ return static_cast<Y*>(p1);
+ }
+
+ void deallocate(pointer memory, size_type) {
+ void* p1 = memory;
+ ::operator delete(p1);
+ }
+
+#if defined(BOOST_NO_CXX11_ALLOCATOR)
+ pointer address(reference value) const {
+ return &value;
+ }
+
+ const_pointer address(const_reference value) const {
+ return &value;
+ }
+
+ size_type max_size() const {
+ enum {
+ N = static_cast<std::size_t>(-1) / sizeof(Y)
+ };
+ return N;
+ }
+
+ void construct(pointer memory, const_reference value) {
+ void* p1 = memory;
+ ::new(p1) Y(value);
+ }
+
+ void destroy(pointer memory) {
+ (void)memory;
+ memory->~Y();
+ }
+#endif
+
+ void set(type* memory) {
+ data.object = memory;
+ }
+
+ void operator()() {
+ if (data.object) {
+ ms_destroy(data.object, data.size);
+ }
+ }
+
+ private:
+ ms_allocator_state<T> data;
+ };
+
+ template<class T, class Y1, class Y2>
+ bool operator==(const ms_allocator<T, Y1>&,
+ const ms_allocator<T, Y2>&) {
+ return true;
+ }
+
+ template<class T, class Y1, class Y2>
+ bool operator!=(const ms_allocator<T, Y1>&,
+ const ms_allocator<T, Y2>&) {
+ return false;
+ }
+
+ class ms_in_allocator_tag {
+ public:
+ void operator()(const void*) {
+ }
+ };
+ }
+}
+
+#endif
--- /dev/null
+/*
+ * Copyright (c) 2014 Glen Joseph Fernandes
+ * glenfe at live dot com
+ *
+ * Distributed under the Boost Software License,
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt
+ * or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_COUNT_IMPL_HPP
+#define BOOST_SMART_PTR_DETAIL_ARRAY_COUNT_IMPL_HPP
+
+#include <boost/smart_ptr/detail/array_allocator.hpp>
+#include <boost/smart_ptr/detail/sp_counted_impl.hpp>
+
+namespace boost {
+ namespace detail {
+ template<class P, class A>
+ class sp_counted_impl_pda<P, ms_in_allocator_tag, A>
+ : public sp_counted_base {
+ typedef ms_in_allocator_tag D;
+ typedef sp_counted_impl_pda<P, D, A> Y;
+ public:
+ sp_counted_impl_pda(P, D, const A& allocator_)
+ : allocator(allocator_) {
+ }
+
+ virtual void dispose() {
+ allocator();
+ }
+
+ virtual void destroy() {
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+ typedef typename std::allocator_traits<A>::
+ template rebind_alloc<Y> YA;
+ typedef typename std::allocator_traits<A>::
+ template rebind_traits<Y> YT;
+#else
+ typedef typename A::template rebind<Y>::other YA;
+#endif
+ YA a1(allocator);
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+ YT::destroy(a1, this);
+ YT::deallocate(a1, this, 1);
+#else
+ this->~Y();
+ a1.deallocate(this, 1);
+#endif
+ }
+
+ virtual void* get_deleter(const sp_typeinfo&) {
+ return &reinterpret_cast<char&>(allocator);
+ }
+
+ virtual void* get_untyped_deleter() {
+ return &reinterpret_cast<char&>(allocator);
+ }
+
+ private:
+ sp_counted_impl_pda(const sp_counted_impl_pda&);
+ sp_counted_impl_pda& operator=(const sp_counted_impl_pda&);
+
+ A allocator;
+ };
+ }
+}
+
+#endif
+++ /dev/null
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP
-
-#include <boost/smart_ptr/detail/array_utility.hpp>
-#include <boost/smart_ptr/detail/sp_forward.hpp>
-
-namespace boost {
- namespace detail {
- template<typename T>
- class array_deleter;
- template<typename T>
- class array_deleter<T[]> {
- public:
- array_deleter(std::size_t size_)
- : size(size_),
- object(0) {
- }
- ~array_deleter() {
- if (object) {
- array_destroy(object, size);
- }
- }
- void init(T* memory) {
- array_init(memory, size);
- object = memory;
- }
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
- void init(T* memory, T&& value) {
- array_init_value(memory, size, sp_forward<T>(value));
- object = memory;
- }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
- template<typename... Args>
- void init(T* memory, Args&&... args) {
- array_init_args(memory, size, sp_forward<Args>(args)...);
- object = memory;
- }
-#endif
-#endif
- void init_list(T* memory, const T* list) {
- array_init_list(memory, size, list);
- object = memory;
- }
- template<std::size_t M>
- void init_list(T* memory, const T* list) {
- array_init_list<T, M>(memory, size, list);
- object = memory;
- }
- void noinit(T* memory) {
- array_noinit(memory, size);
- object = memory;
- }
- void operator()(const void*) {
- if (object) {
- array_destroy(object, size);
- object = 0;
- }
- }
- private:
- std::size_t size;
- T* object;
- };
- template<typename T, std::size_t N>
- class array_deleter<T[N]> {
- public:
- array_deleter()
- : object(0) {
- }
- ~array_deleter() {
- if (object) {
- array_destroy(object, N);
- }
- }
- void init(T* memory) {
- array_init(memory, N);
- object = memory;
- }
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
- void init(T* memory, T&& value) {
- array_init_value(memory, N, sp_forward<T>(value));
- object = memory;
- }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
- template<typename... Args>
- void init(T* memory, Args&&... args) {
- array_init_args(memory, N, sp_forward<Args>(args)...);
- object = memory;
- }
-#endif
-#endif
- void init_list(T* memory, const T* list) {
- array_init_list(memory, N, list);
- object = memory;
- }
- template<std::size_t M>
- void init_list(T* memory, const T* list) {
- array_init_list<T, M>(memory, N, list);
- object = memory;
- }
- void noinit(T* memory) {
- array_noinit(memory, N);
- object = memory;
- }
- void operator()(const void*) {
- if (object) {
- array_destroy(object, N);
- object = 0;
- }
- }
- private:
- T* object;
- };
- }
-}
-
-#endif
/*
- * Copyright (c) 2012 Glen Joseph Fernandes
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes
* glenfe at live dot com
*
* Distributed under the Boost Software License,
namespace boost {
namespace detail {
- template<typename T>
+ template<class T>
struct array_base {
typedef typename boost::remove_cv<T>::type type;
};
- template<typename T>
+
+ template<class T>
struct array_base<T[]> {
typedef typename array_base<T>::type type;
};
- template<typename T, std::size_t N>
+
+ template<class T, std::size_t N>
struct array_base<T[N]> {
typedef typename array_base<T>::type type;
};
- template<typename T>
+
+ template<class T>
struct array_total {
enum {
size = 1
};
};
- template<typename T, std::size_t N>
+
+ template<class T, std::size_t N>
struct array_total<T[N]> {
enum {
size = N * array_total<T>::size
};
};
- template<typename T>
+
+ template<class T>
struct array_inner;
- template<typename T>
+
+ template<class T>
struct array_inner<T[]> {
typedef T type;
};
- template<typename T, std::size_t N>
+
+ template<class T, std::size_t N>
struct array_inner<T[N]> {
typedef T type;
};
/*
- * Copyright (c) 2012 Glen Joseph Fernandes
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes
* glenfe at live dot com
*
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
+ * Distributed under the Boost Software License,
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt
* or copy at http://boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_UTILITY_HPP
#include <boost/config.hpp>
#include <boost/type_traits/has_trivial_constructor.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#include <memory>
+#endif
namespace boost {
namespace detail {
- template<typename T>
- inline void array_destroy(T*, std::size_t, boost::true_type) {
+ typedef boost::true_type ms_is_trivial;
+ typedef boost::false_type ms_no_trivial;
+
+ template<class T>
+ inline void ms_destroy(T*, std::size_t, ms_is_trivial) {
}
- template<typename T>
- inline void array_destroy(T* memory, std::size_t size, boost::false_type) {
- for (std::size_t i = size; i > 0; ) {
+
+ template<class T>
+ inline void ms_destroy(T* memory, std::size_t size, ms_no_trivial) {
+ for (std::size_t i = size; i > 0;) {
memory[--i].~T();
}
}
- template<typename T>
- inline void array_destroy(T* memory, std::size_t size) {
- boost::has_trivial_destructor<T> type;
- array_destroy(memory, size, type);
+
+ template<class T>
+ inline void ms_destroy(T* memory, std::size_t size) {
+ boost::has_trivial_destructor<T> trivial;
+ ms_destroy(memory, size, trivial);
}
- template<typename T>
- inline void array_init(T* memory, std::size_t size, boost::true_type) {
+
+ template<class T>
+ inline void ms_init(T* memory, std::size_t size, ms_is_trivial) {
for (std::size_t i = 0; i < size; i++) {
- memory[i] = T();
+ void* p1 = memory + i;
+ ::new(p1) T();
}
}
- template<typename T>
- inline void array_init(T* memory, std::size_t size, boost::false_type) {
+
+ template<class T>
+ inline void ms_init(T* memory, std::size_t size, ms_no_trivial) {
#if !defined(BOOST_NO_EXCEPTIONS)
std::size_t i = 0;
try {
::new(p1) T();
}
} catch (...) {
- array_destroy(memory, i);
+ ms_destroy(memory, i);
throw;
}
#else
}
#endif
}
- template<typename T>
- inline void array_init(T* memory, std::size_t size) {
- boost::has_trivial_default_constructor<T> type;
- array_init(memory, size, type);
+
+ template<class T>
+ inline void ms_init(T* memory, std::size_t size) {
+ boost::has_trivial_default_constructor<T> trivial;
+ ms_init(memory, size, trivial);
}
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
- template<typename T>
- inline void array_init_value(T* memory, std::size_t size, T&& value) {
+
+ template<class T, std::size_t N>
+ inline void ms_init(T* memory, std::size_t size, const T* list) {
#if !defined(BOOST_NO_EXCEPTIONS)
std::size_t i = 0;
try {
for (; i < size; i++) {
void* p1 = memory + i;
- ::new(p1) T(value);
+ ::new(p1) T(list[i % N]);
}
} catch (...) {
- array_destroy(memory, i);
+ ms_destroy(memory, i);
throw;
}
#else
for (std::size_t i = 0; i < size; i++) {
void* p1 = memory + i;
- ::new(p1) T(value);
+ ::new(p1) T(list[i % N]);
}
#endif
}
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
- template<typename T, typename... Args>
- inline void array_init_args(T* memory, std::size_t size, Args&&... args) {
-#if !defined(BOOST_NO_EXCEPTIONS)
- std::size_t i = 0;
- try {
- for (; i < size; i++) {
- void* p1 = memory + i;
- ::new(p1) T(args...);
- }
- } catch (...) {
- array_destroy(memory, i);
- throw;
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+ template<class T, class A>
+ inline void as_destroy(const A& allocator, T* memory,
+ std::size_t size) {
+ typedef typename std::allocator_traits<A>::
+ template rebind_alloc<T> TA;
+ typedef typename std::allocator_traits<A>::
+ template rebind_traits<T> TT;
+ TA a2(allocator);
+ for (std::size_t i = size; i > 0;) {
+ TT::destroy(a2, &memory[--i]);
}
-#else
+ }
+
+ template<class T, class A>
+ inline void as_init(const A& allocator, T* memory, std::size_t size,
+ ms_is_trivial) {
+ typedef typename std::allocator_traits<A>::
+ template rebind_alloc<T> TA;
+ typedef typename std::allocator_traits<A>::
+ template rebind_traits<T> TT;
+ TA a2(allocator);
for (std::size_t i = 0; i < size; i++) {
- void* p1 = memory + i;
- ::new(p1) T(args...);
+ TT::construct(a2, memory + i);
}
-#endif
}
-#endif
-#endif
- template<typename T>
- inline void array_init_list(T* memory, std::size_t size, const T* list) {
+
+ template<class T, class A>
+ inline void as_init(const A& allocator, T* memory, std::size_t size,
+ ms_no_trivial) {
+ typedef typename std::allocator_traits<A>::
+ template rebind_alloc<T> TA;
+ typedef typename std::allocator_traits<A>::
+ template rebind_traits<T> TT;
+ TA a2(allocator);
#if !defined(BOOST_NO_EXCEPTIONS)
std::size_t i = 0;
try {
for (; i < size; i++) {
- void* p1 = memory + i;
- ::new(p1) T(list[i]);
+ TT::construct(a2, memory + i);
}
} catch (...) {
- array_destroy(memory, i);
+ as_destroy(a2, memory, i);
throw;
}
#else
for (std::size_t i = 0; i < size; i++) {
- void* p1 = memory + i;
- ::new(p1) T(list[i]);
+ TT::construct(a2, memory + i);
}
#endif
}
- template<typename T, std::size_t N>
- inline void array_init_list(T* memory, std::size_t size, const T* list) {
+
+ template<class T, class A>
+ inline void as_init(const A& allocator, T* memory, std::size_t size) {
+ boost::has_trivial_default_constructor<T> trivial;
+ as_init(allocator, memory, size, trivial);
+ }
+
+ template<class T, class A, std::size_t N>
+ inline void as_init(const A& allocator, T* memory, std::size_t size,
+ const T* list) {
+ typedef typename std::allocator_traits<A>::
+ template rebind_alloc<T> TA;
+ typedef typename std::allocator_traits<A>::
+ template rebind_traits<T> TT;
+ TA a2(allocator);
#if !defined(BOOST_NO_EXCEPTIONS)
std::size_t i = 0;
try {
for (; i < size; i++) {
- void* p1 = memory + i;
- ::new(p1) T(list[i % N]);
+ TT::construct(a2, memory + i, list[i % N]);
}
} catch (...) {
- array_destroy(memory, i);
+ as_destroy(a2, memory, i);
throw;
}
#else
for (std::size_t i = 0; i < size; i++) {
- void* p1 = memory + i;
- ::new(p1) T(list[i % N]);
+ TT::construct(a2, memory + i, list[i % N]);
}
#endif
}
- template<typename T>
- inline void array_noinit(T*, std::size_t, boost::true_type) {
+#endif
+
+ template<class T>
+ inline void ms_noinit(T*, std::size_t, ms_is_trivial) {
}
- template<typename T>
- inline void array_noinit(T* memory, std::size_t size, boost::false_type) {
+
+ template<class T>
+ inline void ms_noinit(T* memory, std::size_t size, ms_no_trivial) {
#if !defined(BOOST_NO_EXCEPTIONS)
std::size_t i = 0;
try {
::new(p1) T;
}
} catch (...) {
- array_destroy(memory, i);
+ ms_destroy(memory, i);
throw;
}
#else
}
#endif
}
- template<typename T>
- inline void array_noinit(T* memory, std::size_t size) {
- boost::has_trivial_default_constructor<T> type;
- array_noinit(memory, size, type);
+
+ template<class T>
+ inline void ms_noinit(T* memory, std::size_t size) {
+ boost::has_trivial_default_constructor<T> trivial;
+ ms_noinit(memory, size, trivial);
}
}
}
+++ /dev/null
-#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// boost/detail/atomic_count.hpp - thread/SMP safe reference counter
-//
-// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-//
-// 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)
-//
-// typedef <implementation-defined> boost::detail::atomic_count;
-//
-// atomic_count a(n);
-//
-// (n is convertible to long)
-//
-// Effects: Constructs an atomic_count with an initial value of n
-//
-// a;
-//
-// Returns: (long) the current value of a
-//
-// ++a;
-//
-// Effects: Atomically increments the value of a
-// Returns: (long) the new value of a
-//
-// --a;
-//
-// Effects: Atomically decrements the value of a
-// Returns: (long) the new value of a
-//
-// Important note: when --a returns zero, it must act as a
-// read memory barrier (RMB); i.e. the calling thread must
-// have a synchronized view of the memory
-//
-// On Intel IA-32 (x86) memory is always synchronized, so this
-// is not a problem.
-//
-// On many architectures the atomic instructions already act as
-// a memory barrier.
-//
-// This property is necessary for proper reference counting, since
-// a thread can update the contents of a shared object, then
-// release its reference, and another thread may immediately
-// release the last reference causing object destruction.
-//
-// The destructor needs to have a synchronized view of the
-// object to perform proper cleanup.
-//
-// Original example by Alexander Terekhov:
-//
-// Given:
-//
-// - a mutable shared object OBJ;
-// - two threads THREAD1 and THREAD2 each holding
-// a private smart_ptr object pointing to that OBJ.
-//
-// t1: THREAD1 updates OBJ (thread-safe via some synchronization)
-// and a few cycles later (after "unlock") destroys smart_ptr;
-//
-// t2: THREAD2 destroys smart_ptr WITHOUT doing any synchronization
-// with respect to shared mutable object OBJ; OBJ destructors
-// are called driven by smart_ptr interface...
-//
-
-#include <boost/config.hpp>
-#include <boost/smart_ptr/detail/sp_has_sync.hpp>
-
-#ifndef BOOST_HAS_THREADS
-
-namespace boost
-{
-
-namespace detail
-{
-
-typedef long atomic_count;
-
-}
-
-}
-
-#elif defined(BOOST_AC_USE_PTHREADS)
-# include <boost/smart_ptr/detail/atomic_count_pthreads.hpp>
-
-#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
-# include <boost/smart_ptr/detail/atomic_count_gcc_x86.hpp>
-
-#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
-# include <boost/smart_ptr/detail/atomic_count_win32.hpp>
-
-#elif defined( BOOST_SP_HAS_SYNC )
-# include <boost/smart_ptr/detail/atomic_count_sync.hpp>
-
-#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
-# include <boost/smart_ptr/detail/atomic_count_gcc.hpp>
-
-#elif defined(BOOST_HAS_PTHREADS)
-
-# define BOOST_AC_USE_PTHREADS
-# include <boost/smart_ptr/detail/atomic_count_pthreads.hpp>
-
-#else
-
-// Use #define BOOST_DISABLE_THREADS to avoid the error
-#error Unrecognized threading platform
-
-#endif
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
+++ /dev/null
-#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
-
-//
-// boost/detail/atomic_count_gcc.hpp
-//
-// atomic_count for GNU libstdc++ v3
-//
-// http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html
-//
-// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-// Copyright (c) 2002 Lars Gullik Bjønnes <larsbj@lyx.org>
-// Copyright 2003-2005 Peter Dimov
-//
-// 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 __GNUC__ * 100 + __GNUC_MINOR__ >= 402
-# include <ext/atomicity.h>
-#else
-# include <bits/atomicity.h>
-#endif
-
-namespace boost
-{
-
-namespace detail
-{
-
-#if defined(__GLIBCXX__) // g++ 3.4+
-
-using __gnu_cxx::__atomic_add;
-using __gnu_cxx::__exchange_and_add;
-
-#endif
-
-class atomic_count
-{
-public:
-
- explicit atomic_count( long v ) : value_( v ) {}
-
- long operator++()
- {
- return __exchange_and_add( &value_, +1 ) + 1;
- }
-
- long operator--()
- {
- return __exchange_and_add( &value_, -1 ) - 1;
- }
-
- operator long() const
- {
- return __exchange_and_add( &value_, 0 );
- }
-
-private:
-
- atomic_count(atomic_count const &);
- atomic_count & operator=(atomic_count const &);
-
- mutable _Atomic_word value_;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
+++ /dev/null
-#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
-
-//
-// boost/detail/atomic_count_gcc_x86.hpp
-//
-// atomic_count for g++ on 486+/AMD64
-//
-// Copyright 2007 Peter Dimov
-//
-// 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)
-//
-
-namespace boost
-{
-
-namespace detail
-{
-
-class atomic_count
-{
-public:
-
- explicit atomic_count( long v ) : value_( static_cast< int >( v ) ) {}
-
- long operator++()
- {
- return atomic_exchange_and_add( &value_, +1 ) + 1;
- }
-
- long operator--()
- {
- return atomic_exchange_and_add( &value_, -1 ) - 1;
- }
-
- operator long() const
- {
- return atomic_exchange_and_add( &value_, 0 );
- }
-
-private:
-
- atomic_count(atomic_count const &);
- atomic_count & operator=(atomic_count const &);
-
- mutable int value_;
-
-private:
-
- static int atomic_exchange_and_add( int * pw, int dv )
- {
- // int r = *pw;
- // *pw += dv;
- // return r;
-
- int r;
-
- __asm__ __volatile__
- (
- "lock\n\t"
- "xadd %1, %0":
- "+m"( *pw ), "=r"( r ): // outputs (%0, %1)
- "1"( dv ): // inputs (%2 == %1)
- "memory", "cc" // clobbers
- );
-
- return r;
- }
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
+++ /dev/null
-#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
-
-//
-// boost/detail/atomic_count_pthreads.hpp
-//
-// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-//
-// 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 <pthread.h>
-
-//
-// The generic pthread_mutex-based implementation sometimes leads to
-// inefficiencies. Example: a class with two atomic_count members
-// can get away with a single mutex.
-//
-// Users can detect this situation by checking BOOST_AC_USE_PTHREADS.
-//
-
-namespace boost
-{
-
-namespace detail
-{
-
-class atomic_count
-{
-private:
-
- class scoped_lock
- {
- public:
-
- scoped_lock(pthread_mutex_t & m): m_(m)
- {
- pthread_mutex_lock(&m_);
- }
-
- ~scoped_lock()
- {
- pthread_mutex_unlock(&m_);
- }
-
- private:
-
- pthread_mutex_t & m_;
- };
-
-public:
-
- explicit atomic_count(long v): value_(v)
- {
- pthread_mutex_init(&mutex_, 0);
- }
-
- ~atomic_count()
- {
- pthread_mutex_destroy(&mutex_);
- }
-
- long operator++()
- {
- scoped_lock lock(mutex_);
- return ++value_;
- }
-
- long operator--()
- {
- scoped_lock lock(mutex_);
- return --value_;
- }
-
- operator long() const
- {
- scoped_lock lock(mutex_);
- return value_;
- }
-
-private:
-
- atomic_count(atomic_count const &);
- atomic_count & operator=(atomic_count const &);
-
- mutable pthread_mutex_t mutex_;
- long value_;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
+++ /dev/null
-#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
-
-//
-// boost/detail/atomic_count_sync.hpp
-//
-// atomic_count for g++ 4.1+
-//
-// http://gcc.gnu.org/onlinedocs/gcc-4.1.1/gcc/Atomic-Builtins.html
-//
-// Copyright 2007 Peter Dimov
-//
-// 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( __ia64__ ) && defined( __INTEL_COMPILER )
-# include <ia64intrin.h>
-#endif
-
-namespace boost
-{
-
-namespace detail
-{
-
-class atomic_count
-{
-public:
-
- explicit atomic_count( long v ) : value_( v ) {}
-
- long operator++()
- {
- return __sync_add_and_fetch( &value_, 1 );
- }
-
- long operator--()
- {
- return __sync_add_and_fetch( &value_, -1 );
- }
-
- operator long() const
- {
- return __sync_fetch_and_add( &value_, 0 );
- }
-
-private:
-
- atomic_count(atomic_count const &);
- atomic_count & operator=(atomic_count const &);
-
- mutable long value_;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
+++ /dev/null
-#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-// boost/detail/atomic_count_win32.hpp
-//
-// Copyright (c) 2001-2005 Peter Dimov
-//
-// 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/detail/interlocked.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-class atomic_count
-{
-public:
-
- explicit atomic_count( long v ): value_( v )
- {
- }
-
- long operator++()
- {
- return BOOST_INTERLOCKED_INCREMENT( &value_ );
- }
-
- long operator--()
- {
- return BOOST_INTERLOCKED_DECREMENT( &value_ );
- }
-
- operator long() const
- {
- return static_cast<long const volatile &>( value_ );
- }
-
-private:
-
- atomic_count( atomic_count const & );
- atomic_count & operator=( atomic_count const & );
-
- long value_;
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
// boost/detail/lwm_win32_cs.hpp
//
// Copyright (c) 2002, 2003 Peter Dimov
+// Copyright (c) Microsoft Corporation 2014
//
// 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/predef.h>
+
#ifdef BOOST_USE_WINDOWS_H
# include <windows.h>
#endif
#endif
};
+#if BOOST_PLAT_WINDOWS_RUNTIME
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(critical_section *, unsigned long, unsigned long);
+#else
extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(critical_section *);
+#endif
extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(critical_section *);
extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(critical_section *);
extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(critical_section *);
lightweight_mutex()
{
+#if BOOST_PLAT_WINDOWS_RUNTIME
+ InitializeCriticalSectionEx(&cs_, 4000, 0);
+#else
InitializeCriticalSection(&cs_);
+#endif
}
~lightweight_mutex()
+++ /dev/null
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_MAKE_ARRAY_HELPER_HPP
-#define BOOST_SMART_PTR_DETAIL_MAKE_ARRAY_HELPER_HPP
-
-#include <boost/type_traits/alignment_of.hpp>
-
-namespace boost {
- namespace detail {
- template<typename T, typename Y = char>
- class make_array_helper;
- template<typename T, typename Y>
- class make_array_helper<T[], Y> {
- template<typename T2, typename Y2>
- friend class make_array_helper;
- public:
- typedef Y value_type;
- typedef Y* pointer;
- typedef const Y* const_pointer;
- typedef Y& reference;
- typedef const Y& const_reference;
- typedef std::size_t size_type;
- typedef ptrdiff_t difference_type;
- template<typename U>
- struct rebind {
- typedef make_array_helper<T[], U> other;
- };
- make_array_helper(std::size_t size_, T** data_)
- : size(sizeof(T) * size_),
- data(data_) {
- }
- template<class U>
- make_array_helper(const make_array_helper<T[], U>& other)
- : size(other.size),
- data(other.data) {
- }
- pointer address(reference value) const {
- return &value;
- }
- const_pointer address(const_reference value) const {
- return &value;
- }
- size_type max_size() const {
- return static_cast<std::size_t>(-1) / sizeof(Y);
- }
- pointer allocate(size_type count, const void* = 0) {
- std::size_t a1 = boost::alignment_of<T>::value;
- std::size_t n1 = count * sizeof(Y) + a1 - 1;
- void* p1 = ::operator new(n1 + size);
- char* p2 = static_cast<char*>(p1) + n1;
- while (std::size_t(p2) % a1 != 0) {
- p2--;
- }
- *data = reinterpret_cast<T*>(p2);
- return reinterpret_cast<Y*>(p1);
- }
- void deallocate(pointer memory, size_type) {
- void* p1 = memory;
- ::operator delete(p1);
- }
- void construct(pointer memory, const Y& value) {
- void* p1 = memory;
- ::new(p1) Y(value);
- }
- void destroy(pointer memory) {
- memory->~Y();
- }
- template<typename U>
- bool operator==(const make_array_helper<T[], U>&) const {
- return true;
- }
- template<typename U>
- bool operator!=(const make_array_helper<T[], U>& other) const {
- return !(*this == other);
- }
- private:
- std::size_t size;
- T** data;
- };
- template<typename T, std::size_t N, typename Y>
- class make_array_helper<T[N], Y> {
- template<typename T2, typename Y2>
- friend class make_array_helper;
- public:
- typedef Y value_type;
- typedef Y* pointer;
- typedef const Y* const_pointer;
- typedef Y& reference;
- typedef const Y& const_reference;
- typedef std::size_t size_type;
- typedef ptrdiff_t difference_type;
- template<typename U>
- struct rebind {
- typedef make_array_helper<T[N], U> other;
- };
- make_array_helper(T** data_)
- : data(data_) {
- }
- template<class U>
- make_array_helper(const make_array_helper<T[N], U>& other)
- : data(other.data) {
- }
- pointer address(reference value) const {
- return &value;
- }
- const_pointer address(const_reference value) const {
- return &value;
- }
- size_type max_size() const {
- return static_cast<std::size_t>(-1) / sizeof(Y);
- }
- pointer allocate(size_type count, const void* = 0) {
- std::size_t a1 = boost::alignment_of<T>::value;
- std::size_t n1 = count * sizeof(Y) + a1 - 1;
- void* p1 = ::operator new(n1 + N1);
- char* p2 = static_cast<char*>(p1) + n1;
- while (std::size_t(p2) % a1 != 0) {
- p2--;
- }
- *data = reinterpret_cast<T*>(p2);
- return reinterpret_cast<Y*>(p1);
- }
- void deallocate(pointer memory, size_type) {
- void* p1 = memory;
- ::operator delete(p1);
- }
- void construct(pointer memory, const Y& value) {
- void* p1 = memory;
- ::new(p1) Y(value);
- }
- void destroy(pointer memory) {
- memory->~Y();
- }
- template<typename U>
- bool operator==(const make_array_helper<T[N], U>&) const {
- return true;
- }
- template<typename U>
- bool operator!=(const make_array_helper<T[N], U>& other) const {
- return !(*this == other);
- }
- private:
- enum {
- N1 = N * sizeof(T)
- };
- T** data;
- };
- }
-}
-
-#endif
+++ /dev/null
-#ifndef BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
-
-//
-// detail/shared_array_nmt.hpp - shared_array.hpp without member templates
-//
-// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
-// Copyright (c) 2001, 2002 Peter Dimov
-//
-// 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/smart_ptr/shared_array.htm for documentation.
-//
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/smart_ptr/detail/atomic_count.hpp>
-
-#include <cstddef> // for std::ptrdiff_t
-#include <algorithm> // for std::swap
-#include <functional> // for std::less
-#include <new> // for std::bad_alloc
-
-namespace boost
-{
-
-template<class T> class shared_array
-{
-private:
-
- typedef detail::atomic_count count_type;
-
-public:
-
- typedef T element_type;
-
- explicit shared_array(T * p = 0): px(p)
- {
-#ifndef BOOST_NO_EXCEPTIONS
-
- try // prevent leak if new throws
- {
- pn = new count_type(1);
- }
- catch(...)
- {
- boost::checked_array_delete(p);
- throw;
- }
-
-#else
-
- pn = new count_type(1);
-
- if(pn == 0)
- {
- boost::checked_array_delete(p);
- boost::throw_exception(std::bad_alloc());
- }
-
-#endif
- }
-
- ~shared_array()
- {
- if(--*pn == 0)
- {
- boost::checked_array_delete(px);
- delete pn;
- }
- }
-
- shared_array(shared_array const & r) : px(r.px) // never throws
- {
- pn = r.pn;
- ++*pn;
- }
-
- shared_array & operator=(shared_array const & r)
- {
- shared_array(r).swap(*this);
- return *this;
- }
-
- void reset(T * p = 0)
- {
- BOOST_ASSERT(p == 0 || p != px);
- shared_array(p).swap(*this);
- }
-
- T * get() const // never throws
- {
- return px;
- }
-
- T & operator[](std::ptrdiff_t i) const // never throws
- {
- BOOST_ASSERT(px != 0);
- BOOST_ASSERT(i >= 0);
- return px[i];
- }
-
- long use_count() const // never throws
- {
- return *pn;
- }
-
- bool unique() const // never throws
- {
- return *pn == 1;
- }
-
- void swap(shared_array<T> & other) // never throws
- {
- std::swap(px, other.px);
- std::swap(pn, other.pn);
- }
-
-private:
-
- T * px; // contained pointer
- count_type * pn; // ptr to reference counter
-
-}; // shared_array
-
-template<class T, class U> inline bool operator==(shared_array<T> const & a, shared_array<U> const & b)
-{
- return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(shared_array<T> const & a, shared_array<U> const & b)
-{
- return a.get() != b.get();
-}
-
-template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b)
-{
- return std::less<T*>()(a.get(), b.get());
-}
-
-template<class T> void swap(shared_array<T> & a, shared_array<T> & b)
-{
- a.swap(b);
-}
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED
#endif
{
typedef sp_counted_impl_pda<P, D, A> impl_type;
+
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;
+
+#else
+
typedef typename A::template rebind< impl_type >::other A2;
+#endif
+
A2 a2( a );
#ifndef BOOST_NO_EXCEPTIONS
try
{
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
+ pi_ = pi;
+ std::allocator_traits<A2>::construct( a2, pi, p, d, a );
+
+#else
+
pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
- new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
+ ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
+
+#endif
}
catch(...)
{
throw;
}
+#else
+
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
+ pi_ = pi;
+
#else
pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+#endif
+
if( pi_ != 0 )
{
- new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ std::allocator_traits<A2>::construct( a2, pi, p, d, a );
+
+#else
+
+ ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
+
+#endif
}
else
{
#endif
{
typedef sp_counted_impl_pda< P, D, A > impl_type;
+
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;
+
+#else
+
typedef typename A::template rebind< impl_type >::other A2;
+#endif
+
A2 a2( a );
#ifndef BOOST_NO_EXCEPTIONS
try
{
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
+ pi_ = pi;
+ std::allocator_traits<A2>::construct( a2, pi, p, a );
+
+#else
+
pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
- new( static_cast< void* >( pi_ ) ) impl_type( p, a );
+ ::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
+
+#endif
}
catch(...)
{
throw;
}
+#else
+
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
+ pi_ = pi;
+
#else
pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+#endif
+
if( pi_ != 0 )
{
- new( static_cast< void* >( pi_ ) ) impl_type( p, a );
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ std::allocator_traits<A2>::construct( a2, pi, p, a );
+
+#else
+
+ ::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
+
+#endif
}
else
{
+++ /dev/null
-#ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
-#define BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
-
-//
-// detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates
-//
-// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
-// Copyright (c) 2001, 2002 Peter Dimov
-//
-// 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/smart_ptr/shared_ptr.htm for documentation.
-//
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/smart_ptr/detail/atomic_count.hpp>
-
-#ifndef BOOST_NO_AUTO_PTR
-# include <memory> // for std::auto_ptr
-#endif
-
-#include <algorithm> // for std::swap
-#include <functional> // for std::less
-#include <new> // for std::bad_alloc
-
-namespace boost
-{
-
-template<class T> class shared_ptr
-{
-private:
-
- typedef detail::atomic_count count_type;
-
-public:
-
- typedef T element_type;
- typedef T value_type;
-
- explicit shared_ptr(T * p = 0): px(p)
- {
-#ifndef BOOST_NO_EXCEPTIONS
-
- try // prevent leak if new throws
- {
- pn = new count_type(1);
- }
- catch(...)
- {
- boost::checked_delete(p);
- throw;
- }
-
-#else
-
- pn = new count_type(1);
-
- if(pn == 0)
- {
- boost::checked_delete(p);
- boost::throw_exception(std::bad_alloc());
- }
-
-#endif
- }
-
- ~shared_ptr()
- {
- if(--*pn == 0)
- {
- boost::checked_delete(px);
- delete pn;
- }
- }
-
- shared_ptr(shared_ptr const & r): px(r.px) // never throws
- {
- pn = r.pn;
- ++*pn;
- }
-
- shared_ptr & operator=(shared_ptr const & r)
- {
- shared_ptr(r).swap(*this);
- return *this;
- }
-
-#ifndef BOOST_NO_AUTO_PTR
-
- explicit shared_ptr(std::auto_ptr<T> & r)
- {
- pn = new count_type(1); // may throw
- px = r.release(); // fix: moved here to stop leak if new throws
- }
-
- shared_ptr & operator=(std::auto_ptr<T> & r)
- {
- shared_ptr(r).swap(*this);
- return *this;
- }
-
-#endif
-
- void reset(T * p = 0)
- {
- BOOST_ASSERT(p == 0 || p != px);
- shared_ptr(p).swap(*this);
- }
-
- T & operator*() const // never throws
- {
- BOOST_ASSERT(px != 0);
- return *px;
- }
-
- T * operator->() const // never throws
- {
- BOOST_ASSERT(px != 0);
- return px;
- }
-
- T * get() const // never throws
- {
- return px;
- }
-
- long use_count() const // never throws
- {
- return *pn;
- }
-
- bool unique() const // never throws
- {
- return *pn == 1;
- }
-
- void swap(shared_ptr<T> & other) // never throws
- {
- std::swap(px, other.px);
- std::swap(pn, other.pn);
- }
-
-private:
-
- T * px; // contained pointer
- count_type * pn; // ptr to reference counter
-};
-
-template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
-{
- return a.get() == b.get();
-}
-
-template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
-{
- return a.get() != b.get();
-}
-
-template<class T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
-{
- return std::less<T*>()(a.get(), b.get());
-}
-
-template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b)
-{
- a.swap(b);
-}
-
-// get_pointer() enables boost::mem_fn to recognize shared_ptr
-
-template<class T> inline T * get_pointer(shared_ptr<T> const & p)
-{
- return p.get();
-}
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
// http://www.boost.org/LICENSE_1_0.txt
#include <boost/config.hpp>
+#include <cstddef>
#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( BOOST_NO_SFINAE )
# define BOOST_SP_NO_SP_CONVERTIBLE
//
// detail/sp_counted_base.hpp
//
-// Copyright 2005, 2006 Peter Dimov
+// Copyright 2005-2013 Peter Dimov
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
#include <boost/config.hpp>
#include <boost/smart_ptr/detail/sp_has_sync.hpp>
+#if defined( __clang__ ) && defined( __has_extension )
+# if __has_extension( __c_atomic__ )
+# define BOOST_SP_HAS_CLANG_C11_ATOMICS
+# endif
+#endif
+
#if defined( BOOST_SP_DISABLE_THREADS )
# include <boost/smart_ptr/detail/sp_counted_base_nt.hpp>
+#elif defined( BOOST_SP_USE_STD_ATOMIC )
+# include <boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp>
+
#elif defined( BOOST_SP_USE_SPINLOCK )
# include <boost/smart_ptr/detail/sp_counted_base_spin.hpp>
#elif defined( BOOST_DISABLE_THREADS ) && !defined( BOOST_SP_ENABLE_THREADS ) && !defined( BOOST_DISABLE_WIN32 )
# include <boost/smart_ptr/detail/sp_counted_base_nt.hpp>
+#elif defined( BOOST_SP_HAS_CLANG_C11_ATOMICS )
+# include <boost/smart_ptr/detail/sp_counted_base_clang.hpp>
+
#elif defined( __SNC__ )
# include <boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp>
#endif
+#undef BOOST_SP_HAS_CLANG_C11_ATOMICS
+
#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED
--- /dev/null
+#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// detail/sp_counted_base_clang.hpp - __c11 clang intrinsics
+//
+// Copyright (c) 2007, 2013, 2015 Peter Dimov
+//
+// 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/detail/sp_typeinfo.hpp>
+#include <boost/cstdint.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+typedef _Atomic( boost::int_least32_t ) atomic_int_least32_t;
+
+inline void atomic_increment( atomic_int_least32_t * pw )
+{
+ __c11_atomic_fetch_add( pw, 1, __ATOMIC_RELAXED );
+}
+
+inline boost::int_least32_t atomic_decrement( atomic_int_least32_t * pw )
+{
+ return __c11_atomic_fetch_sub( pw, 1, __ATOMIC_ACQ_REL );
+}
+
+inline boost::int_least32_t atomic_conditional_increment( atomic_int_least32_t * pw )
+{
+ // long r = *pw;
+ // if( r != 0 ) ++*pw;
+ // return r;
+
+ boost::int_least32_t r = __c11_atomic_load( pw, __ATOMIC_RELAXED );
+
+ for( ;; )
+ {
+ if( r == 0 )
+ {
+ return r;
+ }
+
+ if( __c11_atomic_compare_exchange_weak( pw, &r, r + 1, __ATOMIC_RELAXED, __ATOMIC_RELAXED ) )
+ {
+ return r;
+ }
+ }
+}
+
+class sp_counted_base
+{
+private:
+
+ sp_counted_base( sp_counted_base const & );
+ sp_counted_base & operator= ( sp_counted_base const & );
+
+ atomic_int_least32_t use_count_; // #shared
+ atomic_int_least32_t weak_count_; // #weak + (#shared != 0)
+
+public:
+
+ sp_counted_base()
+ {
+ __c11_atomic_init( &use_count_, 1 );
+ __c11_atomic_init( &weak_count_, 1 );
+ }
+
+ virtual ~sp_counted_base() // nothrow
+ {
+ }
+
+ // dispose() is called when use_count_ drops to zero, to release
+ // the resources managed by *this.
+
+ virtual void dispose() = 0; // nothrow
+
+ // destroy() is called when weak_count_ drops to zero.
+
+ virtual void destroy() // nothrow
+ {
+ delete this;
+ }
+
+ virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+ virtual void * get_untyped_deleter() = 0;
+
+ void add_ref_copy()
+ {
+ atomic_increment( &use_count_ );
+ }
+
+ bool add_ref_lock() // true on success
+ {
+ return atomic_conditional_increment( &use_count_ ) != 0;
+ }
+
+ void release() // nothrow
+ {
+ if( atomic_decrement( &use_count_ ) == 1 )
+ {
+ dispose();
+ weak_release();
+ }
+ }
+
+ void weak_add_ref() // nothrow
+ {
+ atomic_increment( &weak_count_ );
+ }
+
+ void weak_release() // nothrow
+ {
+ if( atomic_decrement( &weak_count_ ) == 1 )
+ {
+ destroy();
+ }
+ }
+
+ long use_count() const // nothrow
+ {
+ return __c11_atomic_load( const_cast< atomic_int_least32_t* >( &use_count_ ), __ATOMIC_ACQUIRE );
+ }
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_CLANG_HPP_INCLUDED
//
#include <boost/detail/sp_typeinfo.hpp>
+#include <boost/assert.hpp>
#include <pthread.h>
namespace boost
// HPUX 10.20 / DCE has a nonstandard pthread_mutex_init
#if defined(__hpux) && defined(_DECTHREADS_)
- pthread_mutex_init( &m_, pthread_mutexattr_default );
+ BOOST_VERIFY( pthread_mutex_init( &m_, pthread_mutexattr_default ) == 0 );
#else
- pthread_mutex_init( &m_, 0 );
+ BOOST_VERIFY( pthread_mutex_init( &m_, 0 ) == 0 );
#endif
}
virtual ~sp_counted_base() // nothrow
{
- pthread_mutex_destroy( &m_ );
+ BOOST_VERIFY( pthread_mutex_destroy( &m_ ) == 0 );
}
// dispose() is called when use_count_ drops to zero, to release
void add_ref_copy()
{
- pthread_mutex_lock( &m_ );
+ BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
++use_count_;
- pthread_mutex_unlock( &m_ );
+ BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
}
bool add_ref_lock() // true on success
{
- pthread_mutex_lock( &m_ );
+ BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
bool r = use_count_ == 0? false: ( ++use_count_, true );
- pthread_mutex_unlock( &m_ );
+ BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
return r;
}
void release() // nothrow
{
- pthread_mutex_lock( &m_ );
+ BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
long new_use_count = --use_count_;
- pthread_mutex_unlock( &m_ );
+ BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
if( new_use_count == 0 )
{
void weak_add_ref() // nothrow
{
- pthread_mutex_lock( &m_ );
+ BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
++weak_count_;
- pthread_mutex_unlock( &m_ );
+ BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
}
void weak_release() // nothrow
{
- pthread_mutex_lock( &m_ );
+ BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
long new_weak_count = --weak_count_;
- pthread_mutex_unlock( &m_ );
+ BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
if( new_weak_count == 0 )
{
long use_count() const // nothrow
{
- pthread_mutex_lock( &m_ );
+ BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
long r = use_count_;
- pthread_mutex_unlock( &m_ );
+ BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
return r;
}
--- /dev/null
+#ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_STD_ATOMIC_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_STD_ATOMIC_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// detail/sp_counted_base_std_atomic.hpp - C++11 std::atomic
+//
+// Copyright (c) 2007, 2013 Peter Dimov
+//
+// 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/detail/sp_typeinfo.hpp>
+#include <atomic>
+#include <cstdint>
+
+namespace boost
+{
+
+namespace detail
+{
+
+inline void atomic_increment( std::atomic_int_least32_t * pw )
+{
+ pw->fetch_add( 1, std::memory_order_relaxed );
+}
+
+inline std::int_least32_t atomic_decrement( std::atomic_int_least32_t * pw )
+{
+ return pw->fetch_sub( 1, std::memory_order_acq_rel );
+}
+
+inline std::int_least32_t atomic_conditional_increment( std::atomic_int_least32_t * pw )
+{
+ // long r = *pw;
+ // if( r != 0 ) ++*pw;
+ // return r;
+
+ std::int_least32_t r = pw->load( std::memory_order_relaxed );
+
+ for( ;; )
+ {
+ if( r == 0 )
+ {
+ return r;
+ }
+
+ if( pw->compare_exchange_weak( r, r + 1, std::memory_order_relaxed, std::memory_order_relaxed ) )
+ {
+ return r;
+ }
+ }
+}
+
+class sp_counted_base
+{
+private:
+
+ sp_counted_base( sp_counted_base const & );
+ sp_counted_base & operator= ( sp_counted_base const & );
+
+ std::atomic_int_least32_t use_count_; // #shared
+ std::atomic_int_least32_t weak_count_; // #weak + (#shared != 0)
+
+public:
+
+ sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
+ {
+ }
+
+ virtual ~sp_counted_base() // nothrow
+ {
+ }
+
+ // dispose() is called when use_count_ drops to zero, to release
+ // the resources managed by *this.
+
+ virtual void dispose() = 0; // nothrow
+
+ // destroy() is called when weak_count_ drops to zero.
+
+ virtual void destroy() // nothrow
+ {
+ delete this;
+ }
+
+ virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+ virtual void * get_untyped_deleter() = 0;
+
+ void add_ref_copy()
+ {
+ atomic_increment( &use_count_ );
+ }
+
+ bool add_ref_lock() // true on success
+ {
+ return atomic_conditional_increment( &use_count_ ) != 0;
+ }
+
+ void release() // nothrow
+ {
+ if( atomic_decrement( &use_count_ ) == 1 )
+ {
+ dispose();
+ weak_release();
+ }
+ }
+
+ void weak_add_ref() // nothrow
+ {
+ atomic_increment( &weak_count_ );
+ }
+
+ void weak_release() // nothrow
+ {
+ if( atomic_decrement( &weak_count_ ) == 1 )
+ {
+ destroy();
+ }
+ }
+
+ long use_count() const // nothrow
+ {
+ return use_count_.load( std::memory_order_acquire );
+ }
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_STD_ATOMIC_HPP_INCLUDED
// formulation
//
-#include <boost/detail/interlocked.hpp>
+#include <boost/smart_ptr/detail/sp_interlocked.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/detail/sp_typeinfo.hpp>
void add_ref_copy()
{
- BOOST_INTERLOCKED_INCREMENT( &use_count_ );
+ BOOST_SP_INTERLOCKED_INCREMENT( &use_count_ );
}
bool add_ref_lock() // true on success
// work around a code generation bug
long tmp2 = tmp + 1;
- if( BOOST_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp2, tmp ) == tmp2 - 1 ) return true;
+ if( BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp2, tmp ) == tmp2 - 1 ) return true;
#else
- if( BOOST_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp + 1, tmp ) == tmp ) return true;
+ if( BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE( &use_count_, tmp + 1, tmp ) == tmp ) return true;
#endif
}
void release() // nothrow
{
- if( BOOST_INTERLOCKED_DECREMENT( &use_count_ ) == 0 )
+ if( BOOST_SP_INTERLOCKED_DECREMENT( &use_count_ ) == 0 )
{
dispose();
weak_release();
void weak_add_ref() // nothrow
{
- BOOST_INTERLOCKED_INCREMENT( &weak_count_ );
+ BOOST_SP_INTERLOCKED_INCREMENT( &weak_count_ );
}
void weak_release() // nothrow
{
- if( BOOST_INTERLOCKED_DECREMENT( &weak_count_ ) == 0 )
+ if( BOOST_SP_INTERLOCKED_DECREMENT( &weak_count_ ) == 0 )
{
destroy();
}
boost::checked_delete( px_ );
}
- virtual void * get_deleter( detail::sp_typeinfo const & )
+ virtual void * get_deleter( sp_typeinfo const & )
{
return 0;
}
del( ptr );
}
- virtual void * get_deleter( detail::sp_typeinfo const & ti )
+ virtual void * get_deleter( sp_typeinfo const & ti )
{
return ti == BOOST_SP_TYPEID(D)? &reinterpret_cast<char&>( del ): 0;
}
{
}
- sp_counted_impl_pda( P p, A a ): p_( p ), d_(), a_( a )
+ sp_counted_impl_pda( P p, A a ): p_( p ), d_( a ), a_( a )
{
}
virtual void destroy() // nothrow
{
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ typedef typename std::allocator_traits<A>::template rebind_alloc< this_type > A2;
+
+#else
+
typedef typename A::template rebind< this_type >::other A2;
+#endif
+
A2 a2( a_ );
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ std::allocator_traits<A2>::destroy( a2, this );
+
+#else
+
this->~this_type();
+
+#endif
+
a2.deallocate( this, 1 );
}
- virtual void * get_deleter( detail::sp_typeinfo const & ti )
+ virtual void * get_deleter( sp_typeinfo const & ti )
{
return ti == BOOST_SP_TYPEID( D )? &reinterpret_cast<char&>( d_ ): 0;
}
#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+#if defined( BOOST_GCC ) && __GNUC__ * 100 + __GNUC_MINOR__ <= 404
+
+// GCC 4.4 supports an outdated version of rvalue references and creates a copy of the forwarded object.
+// This results in warnings 'returning reference to temporary'. Therefore we use a special version similar to std::forward.
+template< class T > T&& sp_forward( T && t ) BOOST_NOEXCEPT
+{
+ return t;
+}
+
+#else
+
template< class T > T&& sp_forward( T & t ) BOOST_NOEXCEPT
{
return static_cast< T&& >( t );
#endif
+#endif
+
} // namespace detail
} // namespace boost
/*
- * Copyright (c) 2012 Glen Joseph Fernandes
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes
* glenfe at live dot com
*
* Distributed under the Boost Software License,
namespace boost {
namespace detail {
- template<typename T>
+ template<class T>
struct sp_if_array;
- template<typename T>
+
+ template<class T>
struct sp_if_array<T[]> {
typedef boost::shared_ptr<T[]> type;
};
- template<typename T>
+
+ template<class T>
struct sp_if_size_array;
- template<typename T, std::size_t N>
+
+ template<class T, std::size_t N>
struct sp_if_size_array<T[N]> {
typedef boost::shared_ptr<T[N]> type;
};
--- /dev/null
+#ifndef BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// boost/detail/sp_interlocked.hpp
+//
+// Copyright 2005, 2014 Peter Dimov
+//
+// 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>
+
+// BOOST_SP_HAS_INTRIN_H
+
+// VC9 has intrin.h, but it collides with <utility>
+#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1600
+
+# define BOOST_SP_HAS_INTRIN_H
+
+// Unlike __MINGW64__, __MINGW64_VERSION_MAJOR is defined by MinGW-w64 for both 32 and 64-bit targets.
+#elif defined( __MINGW64_VERSION_MAJOR )
+
+// MinGW-w64 provides intrin.h for both 32 and 64-bit targets.
+# define BOOST_SP_HAS_INTRIN_H
+
+// Intel C++ on Windows on VC10+ stdlib
+#elif defined( BOOST_INTEL_WIN ) && defined( _CPPLIB_VER ) && _CPPLIB_VER >= 520
+
+# define BOOST_SP_HAS_INTRIN_H
+
+#endif
+
+#if defined( BOOST_USE_WINDOWS_H )
+
+# include <windows.h>
+
+# define BOOST_SP_INTERLOCKED_INCREMENT InterlockedIncrement
+# define BOOST_SP_INTERLOCKED_DECREMENT InterlockedDecrement
+# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE InterlockedExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
+
+#elif defined( BOOST_USE_INTRIN_H ) || defined( BOOST_SP_HAS_INTRIN_H )
+
+#include <intrin.h>
+
+# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement
+# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement
+# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
+
+#elif defined( _WIN32_WCE )
+
+#if _WIN32_WCE >= 0x600
+
+extern "C" long __cdecl _InterlockedIncrement( long volatile * );
+extern "C" long __cdecl _InterlockedDecrement( long volatile * );
+extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long );
+extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
+extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );
+
+# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement
+# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement
+# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
+
+#else
+
+// under Windows CE we still have old-style Interlocked* functions
+
+extern "C" long __cdecl InterlockedIncrement( long* );
+extern "C" long __cdecl InterlockedDecrement( long* );
+extern "C" long __cdecl InterlockedCompareExchange( long*, long, long );
+extern "C" long __cdecl InterlockedExchange( long*, long );
+extern "C" long __cdecl InterlockedExchangeAdd( long*, long );
+
+# define BOOST_SP_INTERLOCKED_INCREMENT InterlockedIncrement
+# define BOOST_SP_INTERLOCKED_DECREMENT InterlockedDecrement
+# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE InterlockedExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
+
+#endif
+
+#elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN )
+
+#if defined( __CLRCALL_PURE_OR_CDECL )
+
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedIncrement( long volatile * );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedDecrement( long volatile * );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedCompareExchange( long volatile *, long, long );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchange( long volatile *, long );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchangeAdd( long volatile *, long );
+
+#else
+
+extern "C" long __cdecl _InterlockedIncrement( long volatile * );
+extern "C" long __cdecl _InterlockedDecrement( long volatile * );
+extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long );
+extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
+extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );
+
+#endif
+
+# define BOOST_SP_INTERLOCKED_INCREMENT _InterlockedIncrement
+# define BOOST_SP_INTERLOCKED_DECREMENT _InterlockedDecrement
+# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE _InterlockedCompareExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE _InterlockedExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
+
+#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
+
+namespace boost
+{
+
+namespace detail
+{
+
+extern "C" __declspec(dllimport) long __stdcall InterlockedIncrement( long volatile * );
+extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement( long volatile * );
+extern "C" __declspec(dllimport) long __stdcall InterlockedCompareExchange( long volatile *, long, long );
+extern "C" __declspec(dllimport) long __stdcall InterlockedExchange( long volatile *, long );
+extern "C" __declspec(dllimport) long __stdcall InterlockedExchangeAdd( long volatile *, long );
+
+} // namespace detail
+
+} // namespace boost
+
+# define BOOST_SP_INTERLOCKED_INCREMENT ::boost::detail::InterlockedIncrement
+# define BOOST_SP_INTERLOCKED_DECREMENT ::boost::detail::InterlockedDecrement
+# define BOOST_SP_INTERLOCKED_COMPARE_EXCHANGE ::boost::detail::InterlockedCompareExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE ::boost::detail::InterlockedExchange
+# define BOOST_SP_INTERLOCKED_EXCHANGE_ADD ::boost::detail::InterlockedExchangeAdd
+
+#else
+
+# error "Interlocked intrinsics not available"
+
+#endif
+
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_INTERLOCKED_HPP_INCLUDED
namespace detail
{
-#if defined( __clang__ ) && !defined( _LIBCPP_VERSION ) && !defined( BOOST_NO_CXX11_DECLTYPE )
+#if !defined( BOOST_NO_CXX11_DECLTYPE ) && ( ( defined( __clang__ ) && !defined( _LIBCPP_VERSION ) ) || defined( __INTEL_COMPILER ) )
typedef decltype(nullptr) sp_nullptr_t;
#include <boost/config.hpp>
#include <boost/smart_ptr/detail/sp_has_sync.hpp>
-#if defined( BOOST_SP_USE_PTHREADS )
+#if defined( BOOST_SP_USE_STD_ATOMIC )
+# if !defined( __clang__ )
+# include <boost/smart_ptr/detail/spinlock_std_atomic.hpp>
+# else
+// Clang (at least up to 3.4) can't compile spinlock_pool when
+// using std::atomic, so substitute the __sync implementation instead.
+# include <boost/smart_ptr/detail/spinlock_sync.hpp>
+# endif
+
+#elif defined( BOOST_SP_USE_PTHREADS )
# include <boost/smart_ptr/detail/spinlock_pt.hpp>
#elif defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ )
namespace detail
{
-template< int I > class spinlock_pool
+template< int M > class spinlock_pool
{
private:
};
};
-template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
+template< int M > spinlock spinlock_pool< M >::pool_[ 41 ] =
{
BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,
BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT,
--- /dev/null
+#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// Copyright (c) 2014 Peter Dimov
+//
+// 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/smart_ptr/detail/yield_k.hpp>
+#include <atomic>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class spinlock
+{
+public:
+
+ std::atomic_flag v_;
+
+public:
+
+ bool try_lock()
+ {
+ return !v_.test_and_set( std::memory_order_acquire );
+ }
+
+ void lock()
+ {
+ for( unsigned k = 0; !try_lock(); ++k )
+ {
+ boost::detail::yield( k );
+ }
+ }
+
+ void unlock()
+ {
+ v_ .clear( std::memory_order_release );
+ }
+
+public:
+
+ class scoped_lock
+ {
+ private:
+
+ spinlock & sp_;
+
+ scoped_lock( scoped_lock const & );
+ scoped_lock & operator=( scoped_lock const & );
+
+ public:
+
+ explicit scoped_lock( spinlock & sp ): sp_( sp )
+ {
+ sp.lock();
+ }
+
+ ~scoped_lock()
+ {
+ sp_.unlock();
+ }
+ };
+};
+
+} // namespace detail
+} // namespace boost
+
+#define BOOST_DETAIL_SPINLOCK_INIT { ATOMIC_FLAG_INIT }
+
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED
// http://www.boost.org/LICENSE_1_0.txt)
//
-#include <boost/detail/interlocked.hpp>
+#include <boost/smart_ptr/detail/sp_interlocked.hpp>
#include <boost/smart_ptr/detail/yield_k.hpp>
// BOOST_COMPILER_FENCE
bool try_lock()
{
- long r = BOOST_INTERLOCKED_EXCHANGE( &v_, 1 );
+ long r = BOOST_SP_INTERLOCKED_EXCHANGE( &v_, 1 );
BOOST_COMPILER_FENCE
// yield_k.hpp
//
// Copyright (c) 2008 Peter Dimov
+// Copyright (c) Microsoft Corporation 2014
//
// void yield( unsigned k );
//
//
#include <boost/config.hpp>
+#include <boost/predef.h>
+
+#if BOOST_PLAT_WINDOWS_RUNTIME
+#include <thread>
+#endif
// BOOST_SMT_PAUSE
namespace detail
{
-#if !defined( BOOST_USE_WINDOWS_H )
+#if !defined( BOOST_USE_WINDOWS_H ) && !BOOST_PLAT_WINDOWS_RUNTIME
extern "C" void __stdcall Sleep( unsigned long ms );
#endif
BOOST_SMT_PAUSE
}
#endif
+#if !BOOST_PLAT_WINDOWS_RUNTIME
else if( k < 32 )
{
Sleep( 0 );
{
Sleep( 1 );
}
+#else
+ else
+ {
+ // Sleep isn't supported on the Windows Runtime.
+ std::this_thread::yield();
+ }
+#endif
}
} // namespace detail
#elif defined( BOOST_HAS_PTHREADS )
+#ifndef _AIX
#include <sched.h>
+#else
+ // AIX's sched.h defines ::var which sometimes conflicts with Lambda's var
+ extern "C" int sched_yield(void);
+#endif
+
#include <time.h>
namespace boost
return p;
}
+ weak_ptr<T> weak_from_this() BOOST_NOEXCEPT
+ {
+ return weak_this_;
+ }
+
+ weak_ptr<T const> weak_from_this() const BOOST_NOEXCEPT
+ {
+ return weak_this_;
+ }
+
public: // actually private, but avoids compiler template friendship issues
// Note: invoked automatically by shared_ptr; do not call
this_type( rhs ).swap( *this );
}
+ void reset( T * rhs, bool add_ref )
+ {
+ this_type( rhs, add_ref ).swap( *this );
+ }
+
T * get() const BOOST_NOEXCEPT
{
return px;
}
+ T * detach() BOOST_NOEXCEPT
+ {
+ T * ret = px;
+ px = 0;
+ return ret;
+ }
+
T & operator*() const
{
BOOST_ASSERT( px != 0 );
/*
- * Copyright (c) 2012 Glen Joseph Fernandes
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes
* glenfe at live dot com
*
* Distributed under the Boost Software License,
#ifndef BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
#define BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/detail/array_deleter.hpp>
-#include <boost/smart_ptr/detail/array_traits.hpp>
-#include <boost/smart_ptr/detail/make_array_helper.hpp>
+#include <boost/smart_ptr/detail/array_count_impl.hpp>
#include <boost/smart_ptr/detail/sp_if_array.hpp>
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
namespace boost {
- template<typename T>
+ template<class T>
inline typename boost::detail::sp_if_array<T>::type
make_shared(std::size_t size) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
- T1* p1 = 0;
- T2* p2 = 0;
+ typedef boost::detail::ms_allocator<T> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
std::size_t n1 = size * boost::detail::array_total<T1>::size;
- boost::detail::make_array_helper<T2[]> a1(n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
- p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init(p2);
- return boost::shared_ptr<T>(s1, p1);
- }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
- template<typename T, typename... Args>
- inline typename boost::detail::sp_if_array<T>::type
- make_shared(std::size_t size, Args&&... args) {
- typedef typename boost::detail::array_inner<T>::type T1;
- typedef typename boost::detail::array_base<T1>::type T2;
- T1* p1 = 0;
- T2* p2 = 0;
- std::size_t n1 = size * boost::detail::array_total<T1>::size;
- boost::detail::make_array_helper<T2[]> a1(n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
- p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init(p2, boost::detail::sp_forward<Args>(args)...);
- return boost::shared_ptr<T>(s1, p1);
- }
- template<typename T, typename... Args>
- inline typename boost::detail::sp_if_size_array<T>::type
- make_shared(Args&&... args) {
- typedef typename boost::detail::array_inner<T>::type T1;
- typedef typename boost::detail::array_base<T1>::type T2;
- enum {
- N = boost::detail::array_total<T>::size
- };
T1* p1 = 0;
T2* p2 = 0;
- boost::detail::make_array_helper<T2[N]> a1(&p2);
- boost::detail::array_deleter<T2[N]> d1;
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[N]>* D2;
+ D1 d1;
+ A1 a1(size, &p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+ boost::detail::ms_init(p2, n1);
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init(p2, boost::detail::sp_forward<Args>(args)...);
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
-#endif
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
- template<typename T>
+
+ template<class T>
inline typename boost::detail::sp_if_size_array<T>::type
- make_shared(const T& list) {
+ make_shared() {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
- typedef const T2 T3;
+ typedef boost::detail::ms_allocator<T> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
enum {
N = boost::detail::array_total<T>::size
};
T1* p1 = 0;
T2* p2 = 0;
- T3* p3 = 0;
- boost::detail::make_array_helper<T2[N]> a1(&p2);
- boost::detail::array_deleter<T2[N]> d1;
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[N]>* D2;
- p3 = reinterpret_cast<T3*>(list);
+ D1 d1;
+ A1 a1(&p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+ boost::detail::ms_init(p2, N);
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init_list(p2, p3);
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
- template<typename T>
+
+ template<class T>
inline typename boost::detail::sp_if_array<T>::type
make_shared(std::size_t size,
- const typename boost::detail::array_inner<T>::type& list) {
+ const typename boost::detail::array_inner<T>::type& value) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
typedef const T2 T3;
+ typedef boost::detail::ms_allocator<T> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
enum {
M = boost::detail::array_total<T1>::size
};
+ std::size_t n1 = M * size;
T1* p1 = 0;
T2* p2 = 0;
- T3* p3 = 0;
- std::size_t n1 = M * size;
- boost::detail::make_array_helper<T2[]> a1(n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
- p3 = reinterpret_cast<T3*>(list);
+ T3* p3 = reinterpret_cast<T3*>(&value);
+ D1 d1;
+ A1 a1(size, &p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+ boost::detail::ms_init<T2, M>(p2, n1, p3);
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->template init_list<M>(p2, p3);
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
- template<typename T>
+
+ template<class T>
inline typename boost::detail::sp_if_size_array<T>::type
- make_shared(const typename boost::detail::array_inner<T>::type& list) {
+ make_shared(const typename boost::detail::array_inner<T>::type& value) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
typedef const T2 T3;
+ typedef boost::detail::ms_allocator<T> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
enum {
M = boost::detail::array_total<T1>::size,
N = boost::detail::array_total<T>::size
};
T1* p1 = 0;
T2* p2 = 0;
- T3* p3 = 0;
- boost::detail::make_array_helper<T2[N]> a1(&p2);
- boost::detail::array_deleter<T2[N]> d1;
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[N]>* D2;
- p3 = reinterpret_cast<T3*>(list);
- p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->template init_list<M>(p2, p3);
- return boost::shared_ptr<T>(s1, p1);
- }
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
- template<typename T>
- inline typename boost::detail::sp_if_array<T>::type
- make_shared(std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
- typedef typename boost::detail::array_inner<T>::type T1;
- typedef typename boost::detail::array_base<T1>::type T2;
- typedef const T2 T3;
- T1* p1 = 0;
- T2* p2 = 0;
- T3* p3 = 0;
- std::size_t n1 = list.size() * boost::detail::array_total<T1>::size;
- boost::detail::make_array_helper<T2[]> a1(n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
- p3 = reinterpret_cast<T3*>(list.begin());
- p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init_list(p2, p3);
- return boost::shared_ptr<T>(s1, p1);
- }
-#endif
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
- template<typename T>
- inline typename boost::detail::sp_if_array<T>::type
- make_shared(std::size_t size,
- typename boost::detail::array_base<T>::type&& value) {
- typedef typename boost::detail::array_inner<T>::type T1;
- typedef typename boost::detail::array_base<T1>::type T2;
- T1* p1 = 0;
- T2* p2 = 0;
- std::size_t n1 = size * boost::detail::array_total<T1>::size;
- boost::detail::make_array_helper<T2[]> a1(n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
- p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init(p2, boost::detail::sp_forward<T2>(value));
- return boost::shared_ptr<T>(s1, p1);
- }
- template<typename T>
- inline typename boost::detail::sp_if_size_array<T>::type
- make_shared(typename boost::detail::array_base<T>::type&& value) {
- typedef typename boost::detail::array_inner<T>::type T1;
- typedef typename boost::detail::array_base<T1>::type T2;
- enum {
- N = boost::detail::array_total<T>::size
- };
- T1* p1 = 0;
- T2* p2 = 0;
- boost::detail::make_array_helper<T2[N]> a1(&p2);
- boost::detail::array_deleter<T2[N]> d1;
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[N]>* D2;
+ T3* p3 = reinterpret_cast<T3*>(&value);
+ D1 d1;
+ A1 a1(&p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+ boost::detail::ms_init<T2, M>(p2, N, p3);
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->init(p2, boost::detail::sp_forward<T2>(value));
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
-#endif
-#endif
- template<typename T>
+
+ template<class T>
inline typename boost::detail::sp_if_array<T>::type
make_shared_noinit(std::size_t size) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
+ typedef boost::detail::ms_allocator<T> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
+ std::size_t n1 = size * boost::detail::array_total<T1>::size;
T1* p1 = 0;
T2* p2 = 0;
- std::size_t n1 = size * boost::detail::array_total<T1>::size;
- boost::detail::make_array_helper<T2[]> a1(n1, &p2);
- boost::detail::array_deleter<T2[]> d1(n1);
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[]>* D2;
+ D1 d1;
+ A1 a1(size, &p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+ boost::detail::ms_noinit(p2, n1);
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->noinit(p2);
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
- template<typename T>
+
+ template<class T>
inline typename boost::detail::sp_if_size_array<T>::type
make_shared_noinit() {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
+ typedef boost::detail::ms_allocator<T> A1;
+ typedef boost::detail::ms_in_allocator_tag D1;
enum {
N = boost::detail::array_total<T>::size
};
T1* p1 = 0;
T2* p2 = 0;
- boost::detail::make_array_helper<T2[N]> a1(&p2);
- boost::detail::array_deleter<T2[N]> d1;
- boost::shared_ptr<T> s1(p1, d1, a1);
- typedef boost::detail::array_deleter<T2[N]>* D2;
+ D1 d1;
+ A1 a1(&p2);
+ shared_ptr<T> s1(p1, d1, a1);
+ A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
+ a2->set(0);
+ boost::detail::ms_noinit(p2, N);
+ a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
- D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
- d2->noinit(p2);
- return boost::shared_ptr<T>(s1, p1);
+ return shared_ptr<T>(s1, p1);
}
}
{
}
+ template<class A> explicit sp_ms_deleter( A const & ) BOOST_NOEXCEPT : initialized_( false )
+ {
+ }
+
// optimization: do not copy storage_
sp_ms_deleter( sp_ms_deleter const & ) BOOST_NOEXCEPT : initialized_( false )
{
}
};
+template< class T, class A > class sp_as_deleter
+{
+private:
+
+ typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
+
+ storage_type storage_;
+ A a_;
+ bool initialized_;
+
+private:
+
+ void destroy()
+ {
+ if( initialized_ )
+ {
+ T * p = reinterpret_cast< T* >( storage_.data_ );
+
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ std::allocator_traits<A>::destroy( a_, p );
+
+#else
+
+ p->~T();
+
+#endif
+
+ initialized_ = false;
+ }
+ }
+
+public:
+
+ sp_as_deleter( A const & a ) BOOST_NOEXCEPT : a_( a ), initialized_( false )
+ {
+ }
+
+ // optimization: do not copy storage_
+ sp_as_deleter( sp_as_deleter const & r ) BOOST_NOEXCEPT : a_( r.a_), initialized_( false )
+ {
+ }
+
+ ~sp_as_deleter()
+ {
+ destroy();
+ }
+
+ void operator()( T * )
+ {
+ destroy();
+ }
+
+ static void operator_fn( T* ) // operator() can't be static
+ {
+ }
+
+ void * address() BOOST_NOEXCEPT
+ {
+ return storage_.data_;
+ }
+
+ void set_initialized() BOOST_NOEXCEPT
+ {
+ initialized_ = true;
+ }
+};
+
template< class T > struct sp_if_not_array
{
typedef boost::shared_ptr< T > type;
# define BOOST_SP_MSD( T ) boost::detail::sp_ms_deleter< T >()
#endif
-// Zero-argument versions
-//
-// Used even when variadic templates are available because of the new T() vs new T issue
+// _noinit versions
-template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared()
+template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared_noinit()
{
boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
void * pv = pd->address();
- ::new( pv ) T();
+ ::new( pv ) T;
pd->set_initialized();
T * pt2 = static_cast< T* >( pv );
return boost::shared_ptr< T >( pt, pt2 );
}
-template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared_noinit()
+template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared_noinit( A const & a )
{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
return boost::shared_ptr< T >( pt, pt2 );
}
-template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a )
+#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+// Variadic templates, rvalue reference
+
+template< class T, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Args && ... args )
{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
void * pv = pd->address();
- ::new( pv ) T();
+ ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
pd->set_initialized();
T * pt2 = static_cast< T* >( pv );
return boost::shared_ptr< T >( pt, pt2 );
}
-template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared_noinit( A const & a )
+template< class T, class A, class... Args > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, Args && ... args )
{
- boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
- boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+ typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
+ A2 a2( a );
+
+ typedef boost::detail::sp_as_deleter< T, A2 > D;
+
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
+
+#else
+
+ typedef boost::detail::sp_ms_deleter< T > D;
+ boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a );
+
+#endif
+
+ D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() );
void * pv = pd->address();
- ::new( pv ) T;
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+ std::allocator_traits<A2>::construct( a2, static_cast< T* >( pv ), boost::detail::sp_forward<Args>( args )... );
+
+#else
+
+ ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
+
+#endif
+
pd->set_initialized();
T * pt2 = static_cast< T* >( pv );
return boost::shared_ptr< T >( pt, pt2 );
}
-#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+#else // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-// Variadic templates, rvalue reference
+// Common zero-argument versions
-template< class T, class Arg1, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Arg1 && arg1, Args && ... args )
+template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared()
{
boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
void * pv = pd->address();
- ::new( pv ) T( boost::detail::sp_forward<Arg1>( arg1 ), boost::detail::sp_forward<Args>( args )... );
+ ::new( pv ) T();
pd->set_initialized();
T * pt2 = static_cast< T* >( pv );
return boost::shared_ptr< T >( pt, pt2 );
}
-template< class T, class A, class Arg1, class... Args > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, Arg1 && arg1, Args && ... args )
+template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a )
{
boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
void * pv = pd->address();
- ::new( pv ) T( boost::detail::sp_forward<Arg1>( arg1 ), boost::detail::sp_forward<Args>( args )... );
+ ::new( pv ) T();
pd->set_initialized();
T * pt2 = static_cast< T* >( pv );
return boost::shared_ptr< T >( pt, pt2 );
}
-#elif !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
// For example MSVC 10.0
return boost::shared_ptr< T >( pt, pt2 );
}
-#else
+#else // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
// C++03 version
return boost::shared_ptr< T >( pt, pt2 );
}
-#endif
+#endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+#endif // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
#undef BOOST_SP_MSD
#include <boost/config.hpp> // for broken compiler workarounds
-#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-#include <boost/smart_ptr/detail/shared_array_nmt.hpp>
-#else
-
#include <memory> // TR1 cyclic inclusion fix
#include <boost/assert.hpp>
{
}
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+ shared_array( boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT : px( 0 ), pn()
+ {
+ }
+
+#endif
+
template<class Y>
explicit shared_array( Y * p ): px( p ), pn( p, checked_array_deleter<Y>() )
{
} // namespace boost
-#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
#endif // #ifndef BOOST_SMART_PTR_SHARED_ARRAY_HPP_INCLUDED
#include <boost/config.hpp> // for broken compiler workarounds
-#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-#include <boost/smart_ptr/detail/shared_ptr_nmt.hpp>
-#else
-
// In order to avoid circular dependencies with Boost.TR1
// we make sure that our include of <memory> doesn't try to
// pull in the TR1 headers: that's why we use this header
#if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
#include <boost/smart_ptr/detail/spinlock_pool.hpp>
-#include <boost/memory_order.hpp>
#endif
#include <algorithm> // for std::swap
BOOST_ASSERT( px != 0 );
BOOST_ASSERT( i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 ) );
- return px[ i ];
+ return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
}
element_type * get() const BOOST_NOEXCEPT
{
private:
- shared_ptr<void> deleter_;
+ shared_ptr<void const volatile> deleter_;
public:
return *p;
}
-template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order /*mo*/ )
+template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, /*memory_order mo*/ int )
{
return atomic_load( p );
}
p->swap( r );
}
-template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
+template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int )
{
atomic_store( p, r ); // std::move( r )
}
return r; // return std::move( r )
}
-template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
+template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int )
{
return atomic_exchange( p, r ); // std::move( r )
}
}
}
-template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order /*success*/, memory_order /*failure*/ )
+template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, /*memory_order success*/ int, /*memory_order failure*/ int )
{
return atomic_compare_exchange( p, v, w ); // std::move( w )
}
} // namespace boost
-#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
#endif // #ifndef BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED
-// Copyright (C) 2007 Joseph Gauterin
-//
-// 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)
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * 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)
+ */
#ifndef BOOST_SWAP_HPP
#define BOOST_SWAP_HPP
-#include "boost/utility/swap.hpp"
+// The header file at this path is deprecated;
+// use boost/core/swap.hpp instead.
+
+#include <boost/core/swap.hpp>
#endif
// http://www.boost.org/libs/utility/throw_exception.html
//
-#include <boost/exception/detail/attribute_noreturn.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/config.hpp>
#include <exception>
inline void throw_exception_assert_compatibility( std::exception const & ) { }
-template<class E> BOOST_ATTRIBUTE_NORETURN inline void throw_exception( E const & e )
+template<class E> BOOST_NORETURN inline void throw_exception( E const & e )
{
//All boost exceptions are required to derive from std::exception,
//to ensure compatibility with BOOST_NO_EXCEPTIONS.
exception_detail
{
template <class E>
- BOOST_ATTRIBUTE_NORETURN
+ BOOST_NORETURN
void
throw_exception_( E const & x, char const * current_function, char const * file, int line )
{
#include <boost/assert.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/mpl/if.hpp>
+#include <boost/throw_exception.hpp>
#if !defined(BOOST_NO_CWCTYPE)
#include <cwctype>
#endif
template <typename iterator, typename Token>
void do_escape(iterator& next,iterator end,Token& tok) {
if (++next == end)
- throw escaped_list_error(std::string("cannot end with escape"));
+ BOOST_THROW_EXCEPTION(escaped_list_error(std::string("cannot end with escape")));
if (Traits::eq(*next,'n')) {
tok+='\n';
return;
return;
}
else
- throw escaped_list_error(std::string("unknown escape sequence"));
+ BOOST_THROW_EXCEPTION(escaped_list_error(std::string("unknown escape sequence")));
}
public:
struct assign_or_plus_equal {
template<class Iterator, class Token>
static void assign(Iterator b, Iterator e, Token &t) {
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) &&\
- BOOST_WORKAROUND(__SGI_STL_PORT, < 0x500) &&\
- defined(_STLP_DEBUG) &&\
- (defined(_STLP_USE_DYNAMIC_LIB) || defined(_DLL))
- // Problem with string::assign for msvc-stlport in debug mode: the
- // linker tries to import the templatized version of this memfun,
- // which is obviously not exported.
- // See http://www.stlport.com/dcforum/DCForumID6/1763.html for details.
-
- t = Token();
- while(b != e) t += *b++;
-#else
t.assign(b, e);
-#endif
-
}
template<class Token, class Value>
#ifndef BOOST_TOKENIZER_POLICY_JRB070303_HPP_
#define BOOST_TOKENIZER_POLICY_JRB070303_HPP_
-#include<boost/assert.hpp>
-#include<boost/iterator/iterator_adaptor.hpp>
-#include<boost/iterator/detail/minimum_category.hpp>
-#include<boost/token_functions.hpp>
-#include<utility>
+#include <boost/assert.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/minimum_category.hpp>
+#include <boost/token_functions.hpp>
+#include <utility>
namespace boost
{
: public iterator_facade<
token_iterator<TokenizerFunc, Iterator, Type>
, Type
- , typename detail::minimum_category<
+ , typename iterators::minimum_category<
forward_traversal_tag
, typename iterator_traversal<Iterator>::type
- >::type
+ >::type
, const Type&
>
{
Iterator base()const{return begin_;}
- Iterator end()const{return end_;};
+ Iterator end()const{return end_;}
TokenizerFunc tokenizer_function()const{return f_;}
};
template <
- class TokenizerFunc = char_delimiters_separator<char>,
+ class TokenizerFunc = char_delimiters_separator<char>,
class Iterator = std::string::const_iterator,
class Type = std::string
>
class token_iterator_generator {
- private:
+ private:
public:
typedef token_iterator<TokenizerFunc,Iterator,Type> type;
};
-
-
+
+
// Type has to be first because it needs to be explicitly specified
// because there is no way the function can deduce it.
template<class Type, class Iterator, class TokenizerFunc>
- typename token_iterator_generator<TokenizerFunc,Iterator,Type>::type
+ typename token_iterator_generator<TokenizerFunc,Iterator,Type>::type
make_token_iterator(Iterator begin, Iterator end,const TokenizerFunc& fun){
- typedef typename
+ typedef typename
token_iterator_generator<TokenizerFunc,Iterator,Type>::type ret_type;
return ret_type(fun,begin,end);
}
#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
+#if BOOST_GCC >= 40700
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+#endif
+
namespace boost {
namespace tuples {
inline typename access_traits<
typename element<N, cons<HT, TT> >::type
>::non_const_type
-get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+get(cons<HT, TT>& c) {
typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
apply<cons<HT, TT> > impl;
typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
inline typename access_traits<
typename element<N, cons<HT, TT> >::type
>::const_type
-get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+get(const cons<HT, TT>& c) {
typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
apply<cons<HT, TT> > impl;
- typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
return impl::call(c).head;
}
typename access_traits<
typename element<N, self_type>::type
>::non_const_type
- get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+ get() {
return boost::tuples::get<N>(*this);
}
typename access_traits<
typename element<N, self_type>::type
>::const_type
- get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
+ get() const {
return boost::tuples::get<N>(*this);
}
} // end of namespace boost
+#if BOOST_GCC >= 40700
+#pragma GCC diagnostic pop
+#endif
+
+
#endif // BOOST_TUPLE_BASIC_HPP
+++ /dev/null
-// - tuple_basic_no_partial_spec.hpp -----------------------------------------
-
-// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-// Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu)
-// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
-//
-// 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)
-
-// For more information, see http://www.boost.org or http://lambda.cs.utu.fi
-
-// Revision History
-// 14 02 01 Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG)
-// 10 02 01 Fixed "null_type" constructors.
-// Implemented comparison operators globally.
-// Hide element_type_ref and element_type_const_ref.
-// (DG).
-// 09 02 01 Extended to tuples of length 10. Changed comparison for
-// operator<()
-// to the same used by std::pair<>, added cnull_type() (GP)
-// 03 02 01 Initial Version from original tuple.hpp code by JJ. (DG)
-
-// -----------------------------------------------------------------
-
-#ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
-#define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
-
-#include "boost/type_traits.hpp"
-#include "boost/utility/swap.hpp"
-#include <utility>
-
-#if defined BOOST_MSVC
-#pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored
-#pragma warning(disable:4181) // qualifier applied to reference type ignored
-#pragma warning(disable:4227) // qualifier applied to reference type ignored
-#endif
-
-namespace boost {
-namespace tuples {
-
- // null_type denotes the end of a list built with "cons"
- struct null_type
- {
- null_type() {}
- null_type(const null_type&, const null_type&) {}
- };
-
- // a helper function to provide a const null_type type temporary
- inline const null_type cnull_type() { return null_type(); }
-
-// forward declaration of tuple
- template<
- typename T1 = null_type,
- typename T2 = null_type,
- typename T3 = null_type,
- typename T4 = null_type,
- typename T5 = null_type,
- typename T6 = null_type,
- typename T7 = null_type,
- typename T8 = null_type,
- typename T9 = null_type,
- typename T10 = null_type
- >
- class tuple;
-
-// forward declaration of cons
- template<typename Head, typename Tail = null_type>
- struct cons;
-
- namespace detail {
-
- // Takes a pointer and routes all assignments to whatever it points to
- template<typename T>
- struct assign_to_pointee
- {
- public:
- explicit assign_to_pointee(T* p) : ptr(p) {}
-
- template<typename Other>
- assign_to_pointee& operator=(const Other& other)
- {
- *ptr = other;
- return *this;
- }
-
- private:
- T* ptr;
- };
-
- // Swallows any assignment
- struct swallow_assign
- {
- template<typename T>
- swallow_assign const& operator=(const T&) const
- {
- return *this;
- }
- };
-
- template <typename T> struct add_const_reference : add_reference<typename add_const<T>::type> {};
-
- template <class MyTail>
- struct init_tail
- {
- // Each of vc6 and vc7 seem to require a different formulation
- // of this return type
- template <class H, class T>
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- static typename add_reference<typename add_const<T>::type>::type
-#else
- static typename add_const_reference<T>::type
-#endif
- execute( cons<H,T> const& u, long )
- {
- return u.get_tail();
- }
- };
-
- template <>
- struct init_tail<null_type>
- {
- template <class H>
- static null_type execute( cons<H,null_type> const& u, long )
- {
- return null_type();
- }
-
- template <class U>
- static null_type execute(U const&, ...)
- {
- return null_type();
- }
- private:
- template <class H, class T>
- void execute( cons<H,T> const&, int);
- };
-
- template <class Other>
- Other const&
- init_head( Other const& u, ... )
- {
- return u;
- }
-
- template <class H, class T>
- typename add_reference<typename add_const<H>::type>::type
- init_head( cons<H,T> const& u, int )
- {
- return u.get_head();
- }
-
- inline char**** init_head(null_type const&, int);
-
- } // end of namespace detail
-
- // cons builds a heterogenous list of types
- template<typename Head, typename Tail>
- struct cons
- {
- typedef cons self_type;
- typedef Head head_type;
- typedef Tail tail_type;
-
- private:
- typedef typename boost::add_reference<head_type>::type head_ref;
- typedef typename boost::add_reference<tail_type>::type tail_ref;
- typedef typename detail::add_const_reference<head_type>::type head_cref;
- typedef typename detail::add_const_reference<tail_type>::type tail_cref;
- public:
- head_type head;
- tail_type tail;
-
- head_ref get_head() { return head; }
- tail_ref get_tail() { return tail; }
-
- head_cref get_head() const { return head; }
- tail_cref get_tail() const { return tail; }
-
- cons() : head(), tail() {}
-
-#if defined BOOST_MSVC
- template<typename Tail>
- cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
- const Tail& t) : head(h), tail(t.head, t.tail)
- {
- }
-
- cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
- const null_type& t) : head(h), tail(t)
- {
- }
-
-#else
- template<typename T>
- explicit cons(head_cref h, const T& t) :
- head(h), tail(t.head, t.tail)
- {
- }
-
- explicit cons(head_cref h = head_type(),
- tail_cref t = tail_type()) :
- head(h), tail(t)
- {
- }
-#endif
-
- template <class U>
- cons( const U& u )
- : head(detail::init_head(u, 0))
- , tail(detail::init_tail<Tail>::execute(u, 0L))
- {
- }
-
- template<typename Other>
- cons& operator=(const Other& other)
- {
- head = other.head;
- tail = other.tail;
- return *this;
- }
- };
-
- namespace detail {
-
- // Determines if the parameter is null_type
- template<typename T> struct is_null_type { enum { RET = 0 }; };
- template<> struct is_null_type<null_type> { enum { RET = 1 }; };
-
- /* Build a cons structure from the given Head and Tail. If both are null_type,
- return null_type. */
- template<typename Head, typename Tail>
- struct build_cons
- {
- private:
- enum { tail_is_null_type = is_null_type<Tail>::RET };
- public:
- typedef cons<Head, Tail> RET;
- };
-
- template<>
- struct build_cons<null_type, null_type>
- {
- typedef null_type RET;
- };
-
- // Map the N elements of a tuple into a cons list
- template<
- typename T1,
- typename T2 = null_type,
- typename T3 = null_type,
- typename T4 = null_type,
- typename T5 = null_type,
- typename T6 = null_type,
- typename T7 = null_type,
- typename T8 = null_type,
- typename T9 = null_type,
- typename T10 = null_type
- >
- struct map_tuple_to_cons
- {
- typedef typename detail::build_cons<T10, null_type >::RET cons10;
- typedef typename detail::build_cons<T9, cons10>::RET cons9;
- typedef typename detail::build_cons<T8, cons9>::RET cons8;
- typedef typename detail::build_cons<T7, cons8>::RET cons7;
- typedef typename detail::build_cons<T6, cons7>::RET cons6;
- typedef typename detail::build_cons<T5, cons6>::RET cons5;
- typedef typename detail::build_cons<T4, cons5>::RET cons4;
- typedef typename detail::build_cons<T3, cons4>::RET cons3;
- typedef typename detail::build_cons<T2, cons3>::RET cons2;
- typedef typename detail::build_cons<T1, cons2>::RET cons1;
- };
-
- // Workaround the lack of partial specialization in some compilers
- template<int N>
- struct _element_type
- {
- template<typename Tuple>
- struct inner
- {
- private:
- typedef typename Tuple::tail_type tail_type;
- typedef _element_type<N-1> next_elt_type;
-
- public:
- typedef typename _element_type<N-1>::template inner<tail_type>::RET RET;
- };
- };
-
- template<>
- struct _element_type<0>
- {
- template<typename Tuple>
- struct inner
- {
- typedef typename Tuple::head_type RET;
- };
- };
-
- } // namespace detail
-
-
- // Return the Nth type of the given Tuple
- template<int N, typename Tuple>
- struct element
- {
- private:
- typedef detail::_element_type<N> nth_type;
-
- public:
- typedef typename nth_type::template inner<Tuple>::RET RET;
- typedef RET type;
- };
-
- namespace detail {
-
-#if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
- // special workaround for vc7:
-
- template <bool x>
- struct reference_adder
- {
- template <class T>
- struct rebind
- {
- typedef T& type;
- };
- };
-
- template <>
- struct reference_adder<true>
- {
- template <class T>
- struct rebind
- {
- typedef T type;
- };
- };
-
-
- // Return a reference to the Nth type of the given Tuple
- template<int N, typename Tuple>
- struct element_ref
- {
- private:
- typedef typename element<N, Tuple>::RET elt_type;
- enum { is_ref = is_reference<elt_type>::value };
-
- public:
- typedef reference_adder<is_ref>::rebind<elt_type>::type RET;
- typedef RET type;
- };
-
- // Return a const reference to the Nth type of the given Tuple
- template<int N, typename Tuple>
- struct element_const_ref
- {
- private:
- typedef typename element<N, Tuple>::RET elt_type;
- enum { is_ref = is_reference<elt_type>::value };
-
- public:
- typedef reference_adder<is_ref>::rebind<const elt_type>::type RET;
- typedef RET type;
- };
-
-#else // vc7
-
- // Return a reference to the Nth type of the given Tuple
- template<int N, typename Tuple>
- struct element_ref
- {
- private:
- typedef typename element<N, Tuple>::RET elt_type;
-
- public:
- typedef typename add_reference<elt_type>::type RET;
- typedef RET type;
- };
-
- // Return a const reference to the Nth type of the given Tuple
- template<int N, typename Tuple>
- struct element_const_ref
- {
- private:
- typedef typename element<N, Tuple>::RET elt_type;
-
- public:
- typedef typename add_reference<const elt_type>::type RET;
- typedef RET type;
- };
-#endif // vc7
-
- } // namespace detail
-
- // Get length of this tuple
- template<typename Tuple>
- struct length
- {
- BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
- };
-
- template<> struct length<tuple<> > {
- BOOST_STATIC_CONSTANT(int, value = 0);
- };
-
- template<>
- struct length<null_type>
- {
- BOOST_STATIC_CONSTANT(int, value = 0);
- };
-
- namespace detail {
-
- // Reference the Nth element in a tuple and retrieve it with "get"
- template<int N>
- struct get_class
- {
- template<typename Head, typename Tail>
- static inline
- typename detail::element_ref<N, cons<Head, Tail> >::RET
- get(cons<Head, Tail>& t)
- {
- return get_class<N-1>::get(t.tail);
- }
-
- template<typename Head, typename Tail>
- static inline
- typename detail::element_const_ref<N, cons<Head, Tail> >::RET
- get(const cons<Head, Tail>& t)
- {
- return get_class<N-1>::get(t.tail);
- }
- };
-
- template<>
- struct get_class<0>
- {
- template<typename Head, typename Tail>
- static inline
- typename add_reference<Head>::type
- get(cons<Head, Tail>& t)
- {
- return t.head;
- }
-
- template<typename Head, typename Tail>
- static inline
- typename add_reference<const Head>::type
- get(const cons<Head, Tail>& t)
- {
- return t.head;
- }
- };
-
- } // namespace detail
-
- // tuple class
- template<
- typename T1,
- typename T2,
- typename T3,
- typename T4,
- typename T5,
- typename T6,
- typename T7,
- typename T8,
- typename T9,
- typename T10
- >
- class tuple :
- public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
- {
- private:
- typedef detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mapped_tuple;
- typedef typename mapped_tuple::cons10 cons10;
- typedef typename mapped_tuple::cons9 cons9;
- typedef typename mapped_tuple::cons8 cons8;
- typedef typename mapped_tuple::cons7 cons7;
- typedef typename mapped_tuple::cons6 cons6;
- typedef typename mapped_tuple::cons5 cons5;
- typedef typename mapped_tuple::cons4 cons4;
- typedef typename mapped_tuple::cons3 cons3;
- typedef typename mapped_tuple::cons2 cons2;
- typedef typename mapped_tuple::cons1 cons1;
-
- typedef typename detail::add_const_reference<T1>::type t1_cref;
- typedef typename detail::add_const_reference<T2>::type t2_cref;
- typedef typename detail::add_const_reference<T3>::type t3_cref;
- typedef typename detail::add_const_reference<T4>::type t4_cref;
- typedef typename detail::add_const_reference<T5>::type t5_cref;
- typedef typename detail::add_const_reference<T6>::type t6_cref;
- typedef typename detail::add_const_reference<T7>::type t7_cref;
- typedef typename detail::add_const_reference<T8>::type t8_cref;
- typedef typename detail::add_const_reference<T9>::type t9_cref;
- typedef typename detail::add_const_reference<T10>::type t10_cref;
- public:
- typedef cons1 inherited;
- typedef tuple self_type;
-
- tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
- {}
-
- tuple(
- t1_cref t1,
- t2_cref t2,
- t3_cref t3 = T3(),
- t4_cref t4 = T4(),
- t5_cref t5 = T5(),
- t6_cref t6 = T6(),
- t7_cref t7 = T7(),
- t8_cref t8 = T8(),
- t9_cref t9 = T9(),
- t10_cref t10 = T10()
- ) :
- cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
- {
- }
-
- explicit tuple(t1_cref t1)
- : cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
- {}
-
- template<typename Head, typename Tail>
- tuple(const cons<Head, Tail>& other) :
- cons1(other.head, other.tail)
- {
- }
-
- template<typename First, typename Second>
- self_type& operator=(const std::pair<First, Second>& other)
- {
- this->head = other.first;
- this->tail.head = other.second;
- return *this;
- }
-
- template<typename Head, typename Tail>
- self_type& operator=(const cons<Head, Tail>& other)
- {
- this->head = other.head;
- this->tail = other.tail;
-
- return *this;
- }
- };
-
- namespace detail {
-
- template<int N> struct workaround_holder {};
-
- } // namespace detail
-
- template<int N, typename Head, typename Tail>
- typename detail::element_ref<N, cons<Head, Tail> >::RET
- get(cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
- {
- return detail::get_class<N>::get(t);
- }
-
- template<int N, typename Head, typename Tail>
- typename detail::element_const_ref<N, cons<Head, Tail> >::RET
- get(const cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
- {
- return detail::get_class<N>::get(t);
- }
-
- // Make a tuple
- template<typename T1>
- inline
- tuple<T1>
- make_tuple(const T1& t1)
- {
- return tuple<T1>(t1);
- }
-
- // Make a tuple
- template<typename T1, typename T2>
- inline
- tuple<T1, T2>
- make_tuple(const T1& t1, const T2& t2)
- {
- return tuple<T1, T2>(t1, t2);
- }
-
- // Make a tuple
- template<typename T1, typename T2, typename T3>
- inline
- tuple<T1, T2, T3>
- make_tuple(const T1& t1, const T2& t2, const T3& t3)
- {
- return tuple<T1, T2, T3>(t1, t2, t3);
- }
-
- // Make a tuple
- template<typename T1, typename T2, typename T3, typename T4>
- inline
- tuple<T1, T2, T3, T4>
- make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
- {
- return tuple<T1, T2, T3, T4>(t1, t2, t3, t4);
- }
-
- // Make a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5>
- inline
- tuple<T1, T2, T3, T4, T5>
- make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5)
- {
- return tuple<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5);
- }
-
- // Make a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
- inline
- tuple<T1, T2, T3, T4, T5, T6>
- make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6)
- {
- return tuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
- }
-
- // Make a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
- inline
- tuple<T1, T2, T3, T4, T5, T6, T7>
- make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7)
- {
- return tuple<T1, T2, T3, T4, T5, T6, T7>(t1, t2, t3, t4, t5, t6, t7);
- }
-
- // Make a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
- inline
- tuple<T1, T2, T3, T4, T5, T6, T7, T8>
- make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8)
- {
- return tuple<T1, T2, T3, T4, T5, T6, T7, T8>(t1, t2, t3, t4, t5, t6, t7, t8);
- }
-
- // Make a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
- inline
- tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
- make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9)
- {
- return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(t1, t2, t3, t4, t5, t6, t7, t8, t9);
- }
-
- // Make a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
- inline
- tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
- make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10)
- {
- return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
- }
-
- // Tie variables into a tuple
- template<typename T1>
- inline
- tuple<detail::assign_to_pointee<T1> >
- tie(T1& t1)
- {
- return make_tuple(detail::assign_to_pointee<T1>(&t1));
- }
-
- // Tie variables into a tuple
- template<typename T1, typename T2>
- inline
- tuple<detail::assign_to_pointee<T1>,
- detail::assign_to_pointee<T2> >
- tie(T1& t1, T2& t2)
- {
- return make_tuple(detail::assign_to_pointee<T1>(&t1),
- detail::assign_to_pointee<T2>(&t2));
- }
-
- // Tie variables into a tuple
- template<typename T1, typename T2, typename T3>
- inline
- tuple<detail::assign_to_pointee<T1>,
- detail::assign_to_pointee<T2>,
- detail::assign_to_pointee<T3> >
- tie(T1& t1, T2& t2, T3& t3)
- {
- return make_tuple(detail::assign_to_pointee<T1>(&t1),
- detail::assign_to_pointee<T2>(&t2),
- detail::assign_to_pointee<T3>(&t3));
- }
-
- // Tie variables into a tuple
- template<typename T1, typename T2, typename T3, typename T4>
- inline
- tuple<detail::assign_to_pointee<T1>,
- detail::assign_to_pointee<T2>,
- detail::assign_to_pointee<T3>,
- detail::assign_to_pointee<T4> >
- tie(T1& t1, T2& t2, T3& t3, T4& t4)
- {
- return make_tuple(detail::assign_to_pointee<T1>(&t1),
- detail::assign_to_pointee<T2>(&t2),
- detail::assign_to_pointee<T3>(&t3),
- detail::assign_to_pointee<T4>(&t4));
- }
-
- // Tie variables into a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5>
- inline
- tuple<detail::assign_to_pointee<T1>,
- detail::assign_to_pointee<T2>,
- detail::assign_to_pointee<T3>,
- detail::assign_to_pointee<T4>,
- detail::assign_to_pointee<T5> >
- tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5)
- {
- return make_tuple(detail::assign_to_pointee<T1>(&t1),
- detail::assign_to_pointee<T2>(&t2),
- detail::assign_to_pointee<T3>(&t3),
- detail::assign_to_pointee<T4>(&t4),
- detail::assign_to_pointee<T5>(&t5));
- }
-
- // Tie variables into a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
- inline
- tuple<detail::assign_to_pointee<T1>,
- detail::assign_to_pointee<T2>,
- detail::assign_to_pointee<T3>,
- detail::assign_to_pointee<T4>,
- detail::assign_to_pointee<T5>,
- detail::assign_to_pointee<T6> >
- tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6)
- {
- return make_tuple(detail::assign_to_pointee<T1>(&t1),
- detail::assign_to_pointee<T2>(&t2),
- detail::assign_to_pointee<T3>(&t3),
- detail::assign_to_pointee<T4>(&t4),
- detail::assign_to_pointee<T5>(&t5),
- detail::assign_to_pointee<T6>(&t6));
- }
-
- // Tie variables into a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
- inline
- tuple<detail::assign_to_pointee<T1>,
- detail::assign_to_pointee<T2>,
- detail::assign_to_pointee<T3>,
- detail::assign_to_pointee<T4>,
- detail::assign_to_pointee<T5>,
- detail::assign_to_pointee<T6>,
- detail::assign_to_pointee<T7> >
- tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7)
- {
- return make_tuple(detail::assign_to_pointee<T1>(&t1),
- detail::assign_to_pointee<T2>(&t2),
- detail::assign_to_pointee<T3>(&t3),
- detail::assign_to_pointee<T4>(&t4),
- detail::assign_to_pointee<T5>(&t5),
- detail::assign_to_pointee<T6>(&t6),
- detail::assign_to_pointee<T7>(&t7));
- }
-
- // Tie variables into a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
- inline
- tuple<detail::assign_to_pointee<T1>,
- detail::assign_to_pointee<T2>,
- detail::assign_to_pointee<T3>,
- detail::assign_to_pointee<T4>,
- detail::assign_to_pointee<T5>,
- detail::assign_to_pointee<T6>,
- detail::assign_to_pointee<T7>,
- detail::assign_to_pointee<T8> >
- tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
- {
- return make_tuple(detail::assign_to_pointee<T1>(&t1),
- detail::assign_to_pointee<T2>(&t2),
- detail::assign_to_pointee<T3>(&t3),
- detail::assign_to_pointee<T4>(&t4),
- detail::assign_to_pointee<T5>(&t5),
- detail::assign_to_pointee<T6>(&t6),
- detail::assign_to_pointee<T7>(&t7),
- detail::assign_to_pointee<T8>(&t8));
- }
-
- // Tie variables into a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
- inline
- tuple<detail::assign_to_pointee<T1>,
- detail::assign_to_pointee<T2>,
- detail::assign_to_pointee<T3>,
- detail::assign_to_pointee<T4>,
- detail::assign_to_pointee<T5>,
- detail::assign_to_pointee<T6>,
- detail::assign_to_pointee<T7>,
- detail::assign_to_pointee<T8>,
- detail::assign_to_pointee<T9> >
- tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
- {
- return make_tuple(detail::assign_to_pointee<T1>(&t1),
- detail::assign_to_pointee<T2>(&t2),
- detail::assign_to_pointee<T3>(&t3),
- detail::assign_to_pointee<T4>(&t4),
- detail::assign_to_pointee<T5>(&t5),
- detail::assign_to_pointee<T6>(&t6),
- detail::assign_to_pointee<T7>(&t7),
- detail::assign_to_pointee<T8>(&t8),
- detail::assign_to_pointee<T9>(&t9));
- }
- // Tie variables into a tuple
- template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
- inline
- tuple<detail::assign_to_pointee<T1>,
- detail::assign_to_pointee<T2>,
- detail::assign_to_pointee<T3>,
- detail::assign_to_pointee<T4>,
- detail::assign_to_pointee<T5>,
- detail::assign_to_pointee<T6>,
- detail::assign_to_pointee<T7>,
- detail::assign_to_pointee<T8>,
- detail::assign_to_pointee<T9>,
- detail::assign_to_pointee<T10> >
- tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10)
- {
- return make_tuple(detail::assign_to_pointee<T1>(&t1),
- detail::assign_to_pointee<T2>(&t2),
- detail::assign_to_pointee<T3>(&t3),
- detail::assign_to_pointee<T4>(&t4),
- detail::assign_to_pointee<T5>(&t5),
- detail::assign_to_pointee<T6>(&t6),
- detail::assign_to_pointee<T7>(&t7),
- detail::assign_to_pointee<T8>(&t8),
- detail::assign_to_pointee<T9>(&t9),
- detail::assign_to_pointee<T10>(&t10));
- }
- // "ignore" allows tuple positions to be ignored when using "tie".
-
-detail::swallow_assign const ignore = detail::swallow_assign();
-
-template <class T0, class T1, class T2, class T3, class T4,
- class T5, class T6, class T7, class T8, class T9>
-void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
- tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs);
-inline void swap(null_type&, null_type&) {}
-template<class HH>
-inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
- ::boost::swap(lhs.head, rhs.head);
-}
-template<class HH, class TT>
-inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
- ::boost::swap(lhs.head, rhs.head);
- ::boost::tuples::swap(lhs.tail, rhs.tail);
-}
-template <class T0, class T1, class T2, class T3, class T4,
- class T5, class T6, class T7, class T8, class T9>
-inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
- tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs) {
- typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_type;
- typedef typename tuple_type::inherited base;
- ::boost::tuples::swap(static_cast<base&>(lhs), static_cast<base&>(rhs));
-}
-
-} // namespace tuples
-} // namespace boost
-#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
#include "boost/config.hpp"
#include "boost/static_assert.hpp"
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-// The MSVC version
-#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp"
-
-#else
// other compilers
#include "boost/ref.hpp"
#include "boost/tuple/detail/tuple_basic.hpp"
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
namespace boost {
using tuples::tie;
#if !defined(BOOST_NO_USING_TEMPLATE)
using tuples::get;
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
//
// The "using tuples::get" statement causes the
// Borland compiler to ICE, use forwarding
get(const tuples::cons<HT, TT>& c) {
return tuples::get<N,HT,TT>(c);
}
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//
-// MSVC, using declarations don't mix with templates well,
-// so use forwarding functions instead:
-//
-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_ref<N, tuples::cons<Head, Tail> >::RET
-get(tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
- return tuples::detail::get_class<N>::get(t);
-}
-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_const_ref<N, tuples::cons<Head, Tail> >::RET
-get(const tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
- return tuples::detail::get_class<N>::get(t);
-}
#endif // BOOST_NO_USING_TEMPLATE
} // end namespace boost
--- /dev/null
+//
+// Copyright (c) Antony Polukhin, 2012-2014.
+//
+// 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)
+//
+
+#ifndef BOOST_TYPE_INDEX_HPP
+#define BOOST_TYPE_INDEX_HPP
+
+/// \file boost/type_index.hpp
+/// \brief Includes minimal set of headers required to use the Boost.TypeIndex library.
+///
+/// By inclusion of this file most optimal type index classes will be included and used
+/// as a boost::typeindex::type_index and boost::typeindex::type_info.
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#if defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
+# include BOOST_TYPE_INDEX_USER_TYPEINDEX
+# ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
+# pragma detect_mismatch( "boost__type_index__abi", "user defined type_index class is used: " BOOST_STRINGIZE(BOOST_TYPE_INDEX_USER_TYPEINDEX))
+# endif
+#elif (!defined(BOOST_NO_RTTI) && !defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC)
+# include <boost/type_index/stl_type_index.hpp>
+# if defined(BOOST_NO_RTTI) || defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)
+# include <boost/type_index/detail/stl_register_class.hpp>
+# ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
+# pragma detect_mismatch( "boost__type_index__abi", "RTTI is off - typeid() is used only for templates")
+# endif
+# else
+# ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
+# pragma detect_mismatch( "boost__type_index__abi", "RTTI is used")
+# endif
+# endif
+#else
+# include <boost/type_index/ctti_type_index.hpp>
+# include <boost/type_index/detail/ctti_register_class.hpp>
+# ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
+# pragma detect_mismatch( "boost__type_index__abi", "RTTI is off - using CTTI")
+# endif
+#endif
+
+#ifndef BOOST_TYPE_INDEX_REGISTER_CLASS
+#define BOOST_TYPE_INDEX_REGISTER_CLASS
+#endif
+
+namespace boost { namespace typeindex {
+
+#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
+
+/// \def BOOST_TYPE_INDEX_FUNCTION_SIGNATURE
+/// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is used by boost::typeindex::ctti_type_index class to
+/// deduce the name of a type. If your compiler is not recognized
+/// by the TypeIndex library and you wish to work with boost::typeindex::ctti_type_index, you may
+/// define this macro by yourself.
+///
+/// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE must be defined to a compiler specific macro
+/// that outputs the \b whole function signature \b including \b template \b parameters.
+///
+/// If your compiler is not recognised and BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is not defined,
+/// then a compile-time error will arise at any attempt to use boost::typeindex::ctti_type_index classes.
+///
+/// See BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS and BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING
+/// for an information of how to tune the implementation to make a nice pretty_name() output.
+#define BOOST_TYPE_INDEX_FUNCTION_SIGNATURE BOOST_CURRENT_FUNCTION
+
+/// \def BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING
+/// This is a helper macro for making correct pretty_names() with RTTI off.
+///
+/// BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING macro may be defined to
+/// '(begin_skip, end_skip, runtime_skip, runtime_skip_until)' with parameters for adding a
+/// support for compilers, that by default are not recognized by TypeIndex library.
+///
+/// \b Example:
+///
+/// Imagine the situation when
+/// \code boost::typeindex::ctti_type_index::type_id<int>().pretty_name() \endcode
+/// returns the following string:
+/// \code "static const char *boost::detail::ctti<int>::n() [T = int]" \endcode
+/// and \code boost::typeindex::ctti_type_index::type_id<short>().pretty_name() \endcode returns the following:
+/// \code "static const char *boost::detail::ctti<short>::n() [T = short]" \endcode
+///
+/// As we may see first 39 characters are "static const char *boost::detail::ctti<" and they do not depend on
+/// the type T. After first 39 characters we have a human readable type name which is duplicated at the end
+/// of a string. String always ends on ']', which consumes 1 character.
+///
+/// Now if we define `BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING` to
+/// `(39, 1, false, "")` we'll be getting \code "int>::n() [T = int" \endcode
+/// for `boost::typeindex::ctti_type_index::type_id<int>().pretty_name()` and \code "short>::n() [T = short" \endcode
+/// for `boost::typeindex::ctti_type_index::type_id<short>().pretty_name()`.
+///
+/// Now we need to take additional care of the characters that go before the last mention of our type. We'll
+/// do that by telling the macro that we need to cut off everything that goes before the "T = " including the "T = "
+/// itself:
+///
+/// \code (39, 1, true, "T = ") \endcode
+///
+/// In case of GCC or Clang command line we need to add the following line while compiling all the sources:
+///
+/// \code
+/// -DBOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING='(39, 1, true, "T = ")'
+/// \endcode
+/// \param begin_skip How many characters must be skipped at the beginning of the type holding string.
+/// Must be a compile time constant.
+/// \param end_skip How many characters must be skipped at the end of the type holding string.
+/// Must be a compile time constant.
+/// \param runtime_skip Do we need additional checks at runtime to cut off the more characters.
+/// Must be `true` or `false`.
+/// \param runtime_skip_until Skip all the characters before the following string (including the string itself).
+/// Must be a compile time array of characters.
+///
+/// See [RTTI emulation limitations](boost_typeindex/rtti_emulation_limitations.html) for more info.
+#define BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING (0, 0, false, "")
+
+
+ /// Depending on a compiler flags, optimal implementation of type_index will be used
+ /// as a default boost::typeindex::type_index.
+ ///
+ /// Could be a boost::typeindex::stl_type_index, boost::typeindex::ctti_type_index or
+ /// user defined type_index class.
+ ///
+ /// \b See boost::typeindex::type_index_facade for a full description of type_index functions.
+ typedef platform_specific type_index;
+#elif defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
+ // Nothing to do
+#elif (!defined(BOOST_NO_RTTI) && !defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC)
+ typedef boost::typeindex::stl_type_index type_index;
+#else
+ typedef boost::typeindex::ctti_type_index type_index;
+#endif
+
+/// Depending on a compiler flags, optimal implementation of type_info will be used
+/// as a default boost::typeindex::type_info.
+///
+/// Could be a std::type_info, boost::typeindex::detail::ctti_data or
+/// some user defined class.
+///
+/// type_info \b is \b not copyable or default constructible. It is \b not assignable too!
+typedef type_index::type_info_t type_info;
+
+#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
+
+/// \def BOOST_TYPE_INDEX_USER_TYPEINDEX
+/// BOOST_TYPE_INDEX_USER_TYPEINDEX can be defined to the path to header file
+/// with user provided implementation of type_index.
+///
+/// See [Making a custom type_index](boost_typeindex/making_a_custom_type_index.html) section
+/// of documentation for usage example.
+#define BOOST_TYPE_INDEX_USER_TYPEINDEX <full/absolute/path/to/header/with/type_index.hpp>
+
+
+/// \def BOOST_TYPE_INDEX_REGISTER_CLASS
+/// BOOST_TYPE_INDEX_REGISTER_CLASS is used to help to emulate RTTI.
+/// Put this macro into the public section of polymorphic class to allow runtime type detection.
+///
+/// Depending on the typeid() availability this macro will expand to nothing or to virtual helper function
+/// `virtual const type_info& boost_type_info_type_id_runtime_() const noexcept`.
+///
+/// \b Example:
+/// \code
+/// class A {
+/// public:
+/// BOOST_TYPE_INDEX_REGISTER_CLASS
+/// virtual ~A(){}
+/// };
+///
+/// struct B: public A {
+/// BOOST_TYPE_INDEX_REGISTER_CLASS
+/// };
+///
+/// struct C: public B {
+/// BOOST_TYPE_INDEX_REGISTER_CLASS
+/// };
+///
+/// ...
+///
+/// C c1;
+/// A* pc1 = &c1;
+/// assert(boost::typeindex::type_id<C>() == boost::typeindex::type_id_runtime(*pc1));
+/// \endcode
+#define BOOST_TYPE_INDEX_REGISTER_CLASS nothing-or-some-virtual-functions
+
+/// \def BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
+/// BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY is a helper macro that must be defined if mixing
+/// RTTI on/off modules. See
+/// [Mixing sources with RTTI on and RTTI off](boost_typeindex/mixing_sources_with_rtti_on_and_.html)
+/// section of documentation for more info.
+#define BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
+
+#endif // defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
+
+
+/// Function to get boost::typeindex::type_index for a type T.
+/// Removes const, volatile && and & modifiers from T.
+///
+/// \b Example:
+/// \code
+/// type_index ti = type_id<int&>();
+/// std::cout << ti.pretty_name(); // Outputs 'int'
+/// \endcode
+///
+/// \tparam T Type for which type_index must be created.
+/// \throw Nothing.
+/// \return boost::typeindex::type_index with information about the specified type T.
+template <class T>
+inline type_index type_id() BOOST_NOEXCEPT {
+ return type_index::type_id<T>();
+}
+
+/// Function for constructing boost::typeindex::type_index instance for type T.
+/// Does not remove const, volatile, & and && modifiers from T.
+///
+/// If T has no const, volatile, & and && modifiers, then returns exactly
+/// the same result as in case of calling `type_id<T>()`.
+///
+/// \b Example:
+/// \code
+/// type_index ti = type_id_with_cvr<int&>();
+/// std::cout << ti.pretty_name(); // Outputs 'int&'
+/// \endcode
+///
+/// \tparam T Type for which type_index must be created.
+/// \throw Nothing.
+/// \return boost::typeindex::type_index with information about the specified type T.
+template <class T>
+inline type_index type_id_with_cvr() BOOST_NOEXCEPT {
+ return type_index::type_id_with_cvr<T>();
+}
+
+/// Function that works exactly like C++ typeid(rtti_val) call, but returns boost::type_index.
+///
+/// Retunrs runtime information about specified type.
+///
+/// \b Requirements: RTTI available or Base and Derived classes must be marked with BOOST_TYPE_INDEX_REGISTER_CLASS.
+///
+/// \b Example:
+/// \code
+/// struct Base { virtual ~Base(){} };
+/// struct Derived: public Base {};
+/// ...
+/// Derived d;
+/// Base& b = d;
+/// type_index ti = type_id_runtime(b);
+/// std::cout << ti.pretty_name(); // Outputs 'Derived'
+/// \endcode
+///
+/// \param runtime_val Varaible which runtime type must be returned.
+/// \throw Nothing.
+/// \return boost::typeindex::type_index with information about the specified variable.
+template <class T>
+inline type_index type_id_runtime(const T& runtime_val) BOOST_NOEXCEPT {
+ return type_index::type_id_runtime(runtime_val);
+}
+
+}} // namespace boost::typeindex
+
+
+
+#endif // BOOST_TYPE_INDEX_HPP
+
--- /dev/null
+//
+// Copyright (c) Antony Polukhin, 2013-2014.
+//
+//
+// 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)
+//
+
+#ifndef BOOST_TYPE_INDEX_CTTI_TYPE_INDEX_HPP
+#define BOOST_TYPE_INDEX_CTTI_TYPE_INDEX_HPP
+
+/// \file ctti_type_index.hpp
+/// \brief Contains boost::typeindex::ctti_type_index class.
+///
+/// boost::typeindex::ctti_type_index class can be used as a drop-in replacement
+/// for std::type_index.
+///
+/// It is used in situations when typeid() method is not available or
+/// BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY macro is defined.
+
+#include <boost/type_index/type_index_facade.hpp>
+#include <boost/type_index/detail/compile_time_type_info.hpp>
+
+#include <cstring>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace typeindex {
+
+namespace detail {
+
+// That's the most trickiest part of the TypeIndex library:
+// 1) we do not want to give user ability to manually construct and compare `struct-that-represents-type`
+// 2) we need to distinguish between `struct-that-represents-type` and `const char*`
+// 3) we need a thread-safe way to have references to instances `struct-that-represents-type`
+// 4) we need a compile-time control to make sure that user does not copy or
+// default construct `struct-that-represents-type`
+//
+// Solution would be the following:
+
+/// \class ctti_data
+/// Standard-layout class with private constructors and assignment operators.
+///
+/// You can not work with this class directly. The purpose of this class is to hold type info
+/// \b when \b RTTI \b is \b off and allow ctti_type_index construction from itself.
+///
+/// \b Example:
+/// \code
+/// const detail::ctti_data& foo();
+/// ...
+/// type_index ti = type_index(foo());
+/// std::cout << ti.pretty_name();
+/// \endcode
+class ctti_data {
+#ifndef BOOST_NO_CXX11_DELETED_FUNCTIONS
+public:
+ ctti_data() = delete;
+ ctti_data(const ctti_data&) = delete;
+ ctti_data& operator=(const ctti_data&) = delete;
+#else
+private:
+ ctti_data();
+ ctti_data(const ctti_data&);
+ ctti_data& operator=(const ctti_data&);
+#endif
+};
+
+} // namespace detail
+
+/// Helper method for getting detail::ctti_data of a template parameter T.
+template <class T>
+inline const detail::ctti_data& ctti_construct() BOOST_NOEXCEPT {
+ // Standard C++11, 5.2.10 Reinterpret cast:
+ // An object pointer can be explicitly converted to an object pointer of a different type. When a prvalue
+ // v of type "pointer to T1" is converted to the type "pointer to cv T2", the result is static_cast<cv
+ // T2*>(static_cast<cv void*>(v)) if both T1 and T2 are standard-layout types (3.9) and the alignment
+ // requirements of T2 are no stricter than those of T1, or if either type is void. Converting a prvalue of type
+ // "pointer to T1" to the type "pointer to T2" (where T1 and T2 are object types and where the alignment
+ // requirements of T2 are no stricter than those of T1) and back to its original type yields the original pointer
+ // value.
+ //
+ // Alignments are checked in `type_index_test_ctti_alignment.cpp` test.
+ return *reinterpret_cast<const detail::ctti_data*>(boost::detail::ctti<T>::n());
+}
+
+/// \class ctti_type_index
+/// This class is a wrapper that pretends to work exactly like stl_type_index, but does
+/// not require RTTI support. \b For \b description \b of \b functions \b see type_index_facade.
+///
+/// This class produces slightly longer type names, so consider using stl_type_index
+/// in situations when typeid() is working.
+class ctti_type_index: public type_index_facade<ctti_type_index, detail::ctti_data> {
+ const detail::ctti_data* data_;
+
+ inline std::size_t get_raw_name_length() const BOOST_NOEXCEPT;
+
+public:
+ typedef detail::ctti_data type_info_t;
+
+ inline ctti_type_index() BOOST_NOEXCEPT
+ : data_(&ctti_construct<void>())
+ {}
+
+ inline ctti_type_index(const type_info_t& data) BOOST_NOEXCEPT
+ : data_(&data)
+ {}
+
+ inline const type_info_t& type_info() const BOOST_NOEXCEPT;
+ inline const char* raw_name() const BOOST_NOEXCEPT;
+ inline std::string pretty_name() const;
+ inline std::size_t hash_code() const BOOST_NOEXCEPT;
+
+ template <class T>
+ inline static ctti_type_index type_id() BOOST_NOEXCEPT;
+
+ template <class T>
+ inline static ctti_type_index type_id_with_cvr() BOOST_NOEXCEPT;
+
+ template <class T>
+ inline static ctti_type_index type_id_runtime(const T& variable) BOOST_NOEXCEPT;
+};
+
+
+inline const ctti_type_index::type_info_t& ctti_type_index::type_info() const BOOST_NOEXCEPT {
+ return *data_;
+}
+
+
+template <class T>
+inline ctti_type_index ctti_type_index::type_id() BOOST_NOEXCEPT {
+ typedef BOOST_DEDUCED_TYPENAME boost::remove_reference<T>::type no_ref_t;
+ typedef BOOST_DEDUCED_TYPENAME boost::remove_cv<no_ref_t>::type no_cvr_t;
+ return ctti_construct<no_cvr_t>();
+}
+
+
+
+template <class T>
+inline ctti_type_index ctti_type_index::type_id_with_cvr() BOOST_NOEXCEPT {
+ return ctti_construct<T>();
+}
+
+
+template <class T>
+inline ctti_type_index ctti_type_index::type_id_runtime(const T& variable) BOOST_NOEXCEPT {
+ return variable.boost_type_index_type_id_runtime_();
+}
+
+
+inline const char* ctti_type_index::raw_name() const BOOST_NOEXCEPT {
+ return reinterpret_cast<const char*>(data_);
+}
+
+inline std::size_t ctti_type_index::get_raw_name_length() const BOOST_NOEXCEPT {
+ return std::strlen(raw_name() + detail::ctti_skip_size_at_end);
+}
+
+
+inline std::string ctti_type_index::pretty_name() const {
+ std::size_t len = get_raw_name_length();
+ while (raw_name()[len - 1] == ' ') --len; // MSVC sometimes adds whitespaces
+ return std::string(raw_name(), len);
+}
+
+
+inline std::size_t ctti_type_index::hash_code() const BOOST_NOEXCEPT {
+ return boost::hash_range(raw_name(), raw_name() + get_raw_name_length());
+}
+
+
+}} // namespace boost::typeindex
+
+#endif // BOOST_TYPE_INDEX_CTTI_TYPE_INDEX_HPP
+
--- /dev/null
+//
+// Copyright (c) Antony Polukhin, 2012-2014.
+//
+//
+// 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)
+//
+
+#ifndef BOOST_TYPE_INDEX_DETAIL_COMPILE_TIME_TYPE_INFO_HPP
+#define BOOST_TYPE_INDEX_DETAIL_COMPILE_TIME_TYPE_INFO_HPP
+
+/// \file compile_time_type_info.hpp
+/// \brief Contains helper macros and implementation details of boost::typeindex::ctti_type_index.
+/// Not intended for inclusion from user's code.
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/mpl/bool.hpp>
+#include <algorithm>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+/// @cond
+#define BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(begin_skip, end_skip, runtime_skip, runtime_skip_until) \
+ namespace boost { namespace typeindex { namespace detail { \
+ BOOST_STATIC_CONSTEXPR std::size_t ctti_skip_size_at_begin = begin_skip; \
+ BOOST_STATIC_CONSTEXPR std::size_t ctti_skip_size_at_end = end_skip; \
+ BOOST_STATIC_CONSTEXPR bool ctti_skip_more_at_runtime = runtime_skip; \
+ BOOST_STATIC_CONSTEXPR char ctti_skip_until_runtime[] = runtime_skip_until; \
+ }}} /* namespace boost::typeindex::detail */ \
+ /**/
+/// @endcond
+
+#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
+ /* Nothing to document. All the macro docs are moved to <boost/type_index.hpp> */
+#elif defined(BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING)
+
+# include <boost/preprocessor/facilities/expand.hpp>
+ BOOST_PP_EXPAND( BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING )
+
+#elif defined(_MSC_VER)
+ // sizeof("const char *__cdecl boost::detail::ctti<") - 1, sizeof(">::n(void)") - 1
+ BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(40, 10, false, "");
+#elif defined(__clang__) && defined(__APPLE__)
+ // Someone made __clang_major__ equal to LLVM version rather than compiler version
+ // on APPLE platform.
+ //
+ // Using less efficient solution because there is no good way to detect real version of Clang.
+ // sizeof("static const char *boost::detail::ctti<") - 1, sizeof("]") - 1, true, "???????????>::n() [T = int"
+ BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(39, 1, true, "T = ");
+#elif defined(__clang__) && (__clang_major__ < 3 || (__clang_major__ == 3 && __clang_minor__ == 0))
+ // sizeof("static const char *boost::detail::ctti<") - 1, sizeof(">::n()") - 1
+ // note: checked on 3.0
+ BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(39, 6, false, "");
+#elif defined(__clang__) && __clang_major__ == 3 && __clang_minor__ > 0
+ // sizeof("static const char *boost::detail::ctti<") - 1, sizeof("]") - 1, true, "int>::n() [T = int"
+ // note: checked on 3.1, 3.4
+ BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(39, 1, true, "T = ");
+#elif defined(__GNUC__)
+ // sizeof("static const char* boost::detail::ctti<T>::n() [with T = ") - 1, sizeof("]") - 1
+ BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(57, 1, false, "");
+#else
+ // Deafult code for other platforms... Just skip nothing!
+ BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(0, 0, false, "");
+#endif
+
+#undef BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS
+
+namespace boost { namespace typeindex { namespace detail {
+ template <bool Condition>
+ inline void assert_compile_time_legths() BOOST_NOEXCEPT {
+ BOOST_STATIC_ASSERT_MSG(
+ Condition,
+ "TypeIndex library is misconfigured for your compiler. "
+ "Please define BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING to correct values. See section "
+ "'RTTI emulation limitations' of the documentation for more information."
+ );
+ }
+
+ template <std::size_t ArrayLength>
+ inline const char* skip_begining_runtime(const char* begin, boost::mpl::false_) BOOST_NOEXCEPT {
+ return begin;
+ }
+
+ template <std::size_t ArrayLength>
+ inline const char* skip_begining_runtime(const char* begin, boost::mpl::true_) BOOST_NOEXCEPT {
+ const char* const it = std::search(
+ begin, begin + ArrayLength,
+ ctti_skip_until_runtime, ctti_skip_until_runtime + sizeof(ctti_skip_until_runtime) - 1
+ );
+ return (it == begin + ArrayLength ? begin : it + sizeof(ctti_skip_until_runtime) - 1);
+ }
+
+ template <std::size_t ArrayLength>
+ inline const char* skip_begining(const char* begin) BOOST_NOEXCEPT {
+ assert_compile_time_legths<(ArrayLength > ctti_skip_size_at_begin + ctti_skip_size_at_end)>();
+ return skip_begining_runtime<ArrayLength - ctti_skip_size_at_begin>(
+ begin + ctti_skip_size_at_begin,
+ boost::mpl::bool_<ctti_skip_more_at_runtime>()
+ );
+ }
+}}} // namespace boost::typeindex::detail
+
+namespace boost { namespace detail {
+
+/// Noncopyable type_info that does not require RTTI.
+/// CTTI == Compile Time Type Info.
+/// This name must be as short as possible, to avoid code bloat
+template <class T>
+struct ctti {
+
+ /// Returns raw name. Must be as short, as possible, to avoid code bloat
+ static const char* n() BOOST_NOEXCEPT {
+ #if defined(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE)
+ return boost::typeindex::detail::skip_begining< sizeof(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE >(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE);
+ #elif defined(__FUNCSIG__)
+ return boost::typeindex::detail::skip_begining< sizeof(__FUNCSIG__) >(__FUNCSIG__);
+ #elif defined(__PRETTY_FUNCTION__) \
+ || defined(__GNUC__) \
+ || (defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130)) \
+ || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) \
+ || (defined(__ICC) && (__ICC >= 600)) \
+ || defined(__ghs__) \
+ || defined(__DMC__)
+
+ return boost::typeindex::detail::skip_begining< sizeof(__PRETTY_FUNCTION__) >(__PRETTY_FUNCTION__);
+ #else
+ BOOST_STATIC_ASSERT_MSG(
+ sizeof(T) && false,
+ "TypeIndex library could not detect your compiler. "
+ "Please make the BOOST_TYPE_INDEX_FUNCTION_SIGNATURE macro use "
+ "correct compiler macro for getting the whole function name. "
+ "Define BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING to correct value after that."
+ );
+ #endif
+ }
+};
+
+}} // namespace boost::detail
+
+#endif // BOOST_TYPE_INDEX_DETAIL_COMPILE_TIME_TYPE_INFO_HPP
+
--- /dev/null
+//
+// Copyright (c) Antony Polukhin, 2013-2014.
+//
+//
+// 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)
+//
+
+#ifndef BOOST_TYPE_INDEX_CTTI_REGISTER_CLASS_HPP
+#define BOOST_TYPE_INDEX_CTTI_REGISTER_CLASS_HPP
+
+/// \file ctti_register_class.hpp
+/// \brief Contains BOOST_TYPE_INDEX_REGISTER_CLASS macro implementation that uses boost::typeindex::ctti_type_index.
+/// Not intended for inclusion from user's code.
+
+#include <boost/type_index/ctti_type_index.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace typeindex { namespace detail {
+
+template <class T>
+inline const ctti_data& ctti_construct_typeid_ref(const T*) BOOST_NOEXCEPT {
+ return ctti_construct<T>();
+}
+
+}}} // namespace boost::typeindex::detail
+
+/// @cond
+#define BOOST_TYPE_INDEX_REGISTER_CLASS \
+ virtual const boost::typeindex::detail::ctti_data& boost_type_index_type_id_runtime_() const BOOST_NOEXCEPT { \
+ return boost::typeindex::detail::ctti_construct_typeid_ref(this); \
+ } \
+/**/
+/// @endcond
+
+#endif // BOOST_TYPE_INDEX_CTTI_REGISTER_CLASS_HPP
+
--- /dev/null
+//
+// Copyright (c) Antony Polukhin, 2013-2014.
+//
+//
+// 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)
+//
+
+#ifndef BOOST_TYPE_INDEX_STL_REGISTER_CLASS_HPP
+#define BOOST_TYPE_INDEX_STL_REGISTER_CLASS_HPP
+
+/// \file stl_register_class.hpp
+/// \brief Contains BOOST_TYPE_INDEX_REGISTER_CLASS macro implementation that uses boost::typeindex::stl_type_index.
+/// Not intended for inclusion from user's code.
+
+#include <boost/type_index/stl_type_index.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace typeindex { namespace detail {
+
+template <class T>
+inline const stl_type_index::type_info_t& stl_construct_typeid_ref(const T*) BOOST_NOEXCEPT {
+ return typeid(T);
+}
+
+}}} // namespace boost::typeindex::detail
+
+/// @cond
+#define BOOST_TYPE_INDEX_REGISTER_CLASS \
+ virtual const boost::typeindex::stl_type_index::type_info_t& boost_type_index_type_id_runtime_() const BOOST_NOEXCEPT { \
+ return boost::typeindex::detail::stl_construct_typeid_ref(this); \
+ } \
+/**/
+/// @endcond
+
+#endif // BOOST_TYPE_INDEX_STL_REGISTER_CLASS_HPP
+
--- /dev/null
+//
+// Copyright (c) Antony Polukhin, 2013-2014.
+//
+//
+// 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)
+//
+
+#ifndef BOOST_TYPE_INDEX_STL_TYPE_INDEX_HPP
+#define BOOST_TYPE_INDEX_STL_TYPE_INDEX_HPP
+
+/// \file stl_type_index.hpp
+/// \brief Contains boost::typeindex::stl_type_index class.
+///
+/// boost::typeindex::stl_type_index class can be used as a drop-in replacement
+/// for std::type_index.
+///
+/// It is used in situations when RTTI is enabled or typeid() method is available.
+/// When typeid() is disabled or BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY macro
+/// is defined boost::typeindex::ctti is usually used instead of boost::typeindex::stl_type_index.
+
+#include <boost/type_index/type_index_facade.hpp>
+
+// MSVC is capable of calling typeid(T) even when RTTI is off
+#if defined(BOOST_NO_RTTI) && !defined(BOOST_MSVC)
+#error "File boost/type_index/stl_type_index.ipp is not usable when typeid() is not available."
+#endif
+
+#include <typeinfo>
+#include <cstring> // std::strcmp, std::strlen, std::strstr
+#include <stdexcept>
+#include <boost/static_assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/core/demangle.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/functional/hash_fwd.hpp>
+
+#if (defined(__EDG_VERSION__) && __EDG_VERSION__ < 245) \
+ || (defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 744)
+# include <boost/type_traits/is_signed.hpp>
+# include <boost/type_traits/make_signed.hpp>
+# include <boost/mpl/identity.hpp>
+#endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace typeindex {
+
+/// \class stl_type_index
+/// This class is a wrapper around std::type_info, that workarounds issues and provides
+/// much more rich interface. \b For \b description \b of \b functions \b see type_index_facade.
+///
+/// This class requires typeid() to work. For cases when RTTI is disabled see ctti_type_index.
+class stl_type_index
+ : public type_index_facade<
+ stl_type_index,
+ #ifdef BOOST_NO_STD_TYPEINFO
+ type_info
+ #else
+ std::type_info
+ #endif
+ >
+{
+public:
+#ifdef BOOST_NO_STD_TYPEINFO
+ typedef type_info type_info_t;
+#else
+ typedef std::type_info type_info_t;
+#endif
+
+private:
+ const type_info_t* data_;
+
+public:
+ inline stl_type_index() BOOST_NOEXCEPT
+ : data_(&typeid(void))
+ {}
+
+ inline stl_type_index(const type_info_t& data) BOOST_NOEXCEPT
+ : data_(&data)
+ {}
+
+ inline const type_info_t& type_info() const BOOST_NOEXCEPT;
+
+ inline const char* raw_name() const BOOST_NOEXCEPT;
+ inline const char* name() const BOOST_NOEXCEPT;
+ inline std::string pretty_name() const;
+
+ inline std::size_t hash_code() const BOOST_NOEXCEPT;
+ inline bool equal(const stl_type_index& rhs) const BOOST_NOEXCEPT;
+ inline bool before(const stl_type_index& rhs) const BOOST_NOEXCEPT;
+
+ template <class T>
+ inline static stl_type_index type_id() BOOST_NOEXCEPT;
+
+ template <class T>
+ inline static stl_type_index type_id_with_cvr() BOOST_NOEXCEPT;
+
+ template <class T>
+ inline static stl_type_index type_id_runtime(const T& value) BOOST_NOEXCEPT;
+};
+
+inline const stl_type_index::type_info_t& stl_type_index::type_info() const BOOST_NOEXCEPT {
+ return *data_;
+}
+
+
+inline const char* stl_type_index::raw_name() const BOOST_NOEXCEPT {
+#ifdef _MSC_VER
+ return data_->raw_name();
+#else
+ return data_->name();
+#endif
+}
+
+inline const char* stl_type_index::name() const BOOST_NOEXCEPT {
+ return data_->name();
+}
+
+inline std::string stl_type_index::pretty_name() const {
+ static const char cvr_saver_name[] = "boost::typeindex::detail::cvr_saver<";
+ static BOOST_CONSTEXPR_OR_CONST std::string::size_type cvr_saver_name_len = sizeof(cvr_saver_name) - 1;
+
+ // In case of MSVC demangle() is a no-op, and name() already returns demangled name.
+ // In case of GCC and Clang (on non-Windows systems) name() returns mangled name and demangle() undecorates it.
+ const boost::core::scoped_demangled_name demangled_name(data_->name());
+
+ const char* begin = demangled_name.get();
+ if (!begin) {
+ boost::throw_exception(std::runtime_error("Type name demangling failed"));
+ }
+
+ const std::string::size_type len = std::strlen(begin);
+ const char* end = begin + len;
+
+ if (len > cvr_saver_name_len) {
+ const char* b = std::strstr(begin, cvr_saver_name);
+ if (b) {
+ b += cvr_saver_name_len;
+
+ // Trim leading spaces
+ while (*b == ' ') { // the string is zero terminated, we won't exceed the buffer size
+ ++ b;
+ }
+
+ // Skip the closing angle bracket
+ const char* e = end - 1;
+ while (e > b && *e != '>') {
+ -- e;
+ }
+
+ // Trim trailing spaces
+ while (e > b && *(e - 1) == ' ') {
+ -- e;
+ }
+
+ if (b < e) {
+ // Parsing seems to have succeeded, the type name is not empty
+ begin = b;
+ end = e;
+ }
+ }
+ }
+
+ return std::string(begin, end);
+}
+
+
+inline std::size_t stl_type_index::hash_code() const BOOST_NOEXCEPT {
+#if _MSC_VER > 1600 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__))
+ return data_->hash_code();
+#else
+ return boost::hash_range(raw_name(), raw_name() + std::strlen(raw_name()));
+#endif
+}
+
+
+/// @cond
+
+// for this compiler at least, cross-shared-library type_info
+// comparisons don't work, so we are using typeid(x).name() instead.
+# if (defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5))) \
+ || defined(_AIX) \
+ || (defined(__sgi) && defined(__host_mips)) \
+ || (defined(__hpux) && defined(__HP_aCC)) \
+ || (defined(linux) && defined(__INTEL_COMPILER) && defined(__ICC))
+# define BOOST_CLASSINFO_COMPARE_BY_NAMES
+# endif
+
+/// @endcond
+
+inline bool stl_type_index::equal(const stl_type_index& rhs) const BOOST_NOEXCEPT {
+#ifdef BOOST_CLASSINFO_COMPARE_BY_NAMES
+ return raw_name() == rhs.raw_name() || !std::strcmp(raw_name(), rhs.raw_name());
+#else
+ return *data_ == *rhs.data_;
+#endif
+}
+
+inline bool stl_type_index::before(const stl_type_index& rhs) const BOOST_NOEXCEPT {
+#ifdef BOOST_CLASSINFO_COMPARE_BY_NAMES
+ return raw_name() != rhs.raw_name() && std::strcmp(raw_name(), rhs.raw_name()) < 0;
+#else
+ return !!data_->before(*rhs.data_);
+#endif
+}
+
+#ifdef BOOST_CLASSINFO_COMPARE_BY_NAMES
+#undef BOOST_CLASSINFO_COMPARE_BY_NAMES
+#endif
+
+
+
+template <class T>
+inline stl_type_index stl_type_index::type_id() BOOST_NOEXCEPT {
+ typedef BOOST_DEDUCED_TYPENAME boost::remove_reference<T>::type no_ref_t;
+ typedef BOOST_DEDUCED_TYPENAME boost::remove_cv<no_ref_t>::type no_cvr_prefinal_t;
+
+ # if (defined(__EDG_VERSION__) && __EDG_VERSION__ < 245) \
+ || (defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 744)
+
+ // Old EDG-based compilers seem to mistakenly distinguish 'integral' from 'signed integral'
+ // in typeid() expressions. Full template specialization for 'integral' fixes that issue:
+ typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
+ boost::is_signed<no_cvr_prefinal_t>,
+ boost::make_signed<no_cvr_prefinal_t>,
+ boost::mpl::identity<no_cvr_prefinal_t>
+ >::type no_cvr_prefinal_lazy_t;
+
+ typedef BOOST_DEDUCED_TYPENAME no_cvr_prefinal_t::type no_cvr_t;
+ #else
+ typedef no_cvr_prefinal_t no_cvr_t;
+ #endif
+
+ return typeid(no_cvr_t);
+}
+
+namespace detail {
+ template <class T> class cvr_saver{};
+}
+
+template <class T>
+inline stl_type_index stl_type_index::type_id_with_cvr() BOOST_NOEXCEPT {
+ typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
+ boost::mpl::or_<boost::is_reference<T>, boost::is_const<T>, boost::is_volatile<T> >,
+ detail::cvr_saver<T>,
+ T
+ >::type type;
+
+ return typeid(type);
+}
+
+
+template <class T>
+inline stl_type_index stl_type_index::type_id_runtime(const T& value) BOOST_NOEXCEPT {
+#ifdef BOOST_NO_RTTI
+ return value.boost_type_index_type_id_runtime_();
+#else
+ return typeid(value);
+#endif
+}
+
+}} // namespace boost::typeindex
+
+#endif // BOOST_TYPE_INDEX_STL_TYPE_INDEX_HPP
--- /dev/null
+//
+// Copyright (c) Antony Polukhin, 2013-2014.
+//
+//
+// 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)
+//
+
+#ifndef BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP
+#define BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP
+
+#include <boost/config.hpp>
+#include <boost/functional/hash_fwd.hpp>
+#include <string>
+#include <cstring>
+
+#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_NO_IOSFWD)
+#include <iosfwd> // for std::basic_ostream
+#else
+#include <ostream>
+#endif
+#endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace typeindex {
+
+/// \class type_index_facade
+///
+/// This class takes care about the comparison operators, hash functions and
+/// ostream operators. Use this class as a public base class for defining new
+/// type_info-conforming classes.
+///
+/// \b Example:
+/// \code
+/// class stl_type_index: public type_index_facade<stl_type_index, std::type_info>
+/// {
+/// public:
+/// typedef std::type_info type_info_t;
+/// private:
+/// const type_info_t* data_;
+///
+/// public:
+/// stl_type_index(const type_info_t& data) noexcept
+/// : data_(&data)
+/// {}
+/// // ...
+/// };
+/// \endcode
+///
+/// \tparam Derived Class derived from type_index_facade.
+/// \tparam TypeInfo Class that will be used as a base type_info class.
+/// \note Take a look at the protected methods. They are \b not \b defined in type_index_facade.
+/// Protected member functions raw_name() \b must be defined in Derived class. All the other
+/// methods are mandatory.
+/// \see 'Making a custom type_index' section for more information about
+/// creating your own type_index using type_index_facade.
+template <class Derived, class TypeInfo>
+class type_index_facade {
+private:
+ /// @cond
+ const Derived & derived() const BOOST_NOEXCEPT {
+ return *static_cast<Derived const*>(this);
+ }
+ /// @endcond
+public:
+ typedef TypeInfo type_info_t;
+
+ /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
+ /// \return Name of a type. By default returns Derived::raw_name().
+ inline const char* name() const BOOST_NOEXCEPT {
+ return derived().raw_name();
+ }
+
+ /// \b Override: This function \b may be redefined in Derived class. Overrides may throw.
+ /// \return Human readable type name. By default returns Derived::name().
+ inline std::string pretty_name() const {
+ return derived().name();
+ }
+
+ /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
+ /// \return True if two types are equal. By default compares types by raw_name().
+ inline bool equal(const Derived& rhs) const BOOST_NOEXCEPT {
+ const char* const left = derived().raw_name();
+ const char* const right = rhs.raw_name();
+ return left == right || !std::strcmp(left, right);
+ }
+
+ /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
+ /// \return True if rhs is greater than this. By default compares types by raw_name().
+ inline bool before(const Derived& rhs) const BOOST_NOEXCEPT {
+ const char* const left = derived().raw_name();
+ const char* const right = rhs.raw_name();
+ return left != right && std::strcmp(left, right) < 0;
+ }
+
+ /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
+ /// \return Hash code of a type. By default hashes types by raw_name().
+ /// \note <boost/functional/hash.hpp> has to be included if this function is used.
+ inline std::size_t hash_code() const BOOST_NOEXCEPT {
+ const char* const name = derived().raw_name();
+ return boost::hash_range(name, name + std::strlen(name));
+ }
+
+#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
+protected:
+ /// \b Override: This function \b must be redefined in Derived class. Overrides \b must not throw.
+ /// \return Pointer to unredable/raw type name.
+ inline const char* raw_name() const BOOST_NOEXCEPT;
+
+ /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
+ /// \return Const reference to underlying low level type_info_t.
+ inline const type_info_t& type_info() const BOOST_NOEXCEPT;
+
+ /// This is a factory method that is used to create instances of Derived classes.
+ /// boost::typeindex::type_id() will call this method, if Derived has same type as boost::typeindex::type_index.
+ ///
+ /// \b Override: This function \b may be redefined and made public in Derived class. Overrides \b must not throw.
+ /// Overrides \b must remove const, volatile && and & modifiers from T.
+ /// \tparam T Type for which type_index must be created.
+ /// \return type_index for type T.
+ template <class T>
+ static Derived type_id() BOOST_NOEXCEPT;
+
+ /// This is a factory method that is used to create instances of Derived classes.
+ /// boost::typeindex::type_id_with_cvr() will call this method, if Derived has same type as boost::typeindex::type_index.
+ ///
+ /// \b Override: This function \b may be redefined and made public in Derived class. Overrides \b must not throw.
+ /// Overrides \b must \b not remove const, volatile && and & modifiers from T.
+ /// \tparam T Type for which type_index must be created.
+ /// \return type_index for type T.
+ template <class T>
+ static Derived type_id_with_cvr() BOOST_NOEXCEPT;
+
+ /// This is a factory method that is used to create instances of Derived classes.
+ /// boost::typeindex::type_id_runtime(const T&) will call this method, if Derived has same type as boost::typeindex::type_index.
+ ///
+ /// \b Override: This function \b may be redefined and made public in Derived class.
+ /// \param variable Variable which runtime type will be stored in type_index.
+ /// \return type_index with runtime type of variable.
+ template <class T>
+ static Derived type_id_runtime(const T& variable) BOOST_NOEXCEPT;
+
+#endif
+
+};
+
+/// @cond
+template <class Derived, class TypeInfo>
+inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return static_cast<Derived const&>(lhs).equal(static_cast<Derived const&>(rhs));
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return static_cast<Derived const&>(lhs).before(static_cast<Derived const&>(rhs));;
+}
+
+
+
+template <class Derived, class TypeInfo>
+inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return rhs < lhs;
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return !(lhs > rhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return !(lhs < rhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return !(lhs == rhs);
+}
+
+// ######################### COMPARISONS with Derived ############################ //
+template <class Derived, class TypeInfo>
+inline bool operator == (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return Derived(lhs) == rhs;
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator < (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return Derived(lhs) < rhs;
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator > (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return rhs < Derived(lhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator <= (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return !(Derived(lhs) > rhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator >= (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return !(Derived(lhs) < rhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator != (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) BOOST_NOEXCEPT {
+ return !(Derived(lhs) == rhs);
+}
+
+
+template <class Derived, class TypeInfo>
+inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
+ return lhs == Derived(rhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
+ return lhs < Derived(rhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
+ return Derived(rhs) < lhs;
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
+ return !(lhs > Derived(rhs));
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
+ return !(lhs < Derived(rhs));
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) BOOST_NOEXCEPT {
+ return !(lhs == Derived(rhs));
+}
+
+// ######################### COMPARISONS with Derived END ############################ //
+
+/// @endcond
+
+#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
+
+/// noexcept comparison operators for type_index_facade classes.
+bool operator ==, !=, <, ... (const type_index_facade& lhs, const type_index_facade& rhs) noexcept;
+
+/// noexcept comparison operators for type_index_facade and it's TypeInfo classes.
+bool operator ==, !=, <, ... (const type_index_facade& lhs, const TypeInfo& rhs) noexcept;
+
+/// noexcept comparison operators for type_index_facade's TypeInfo and type_index_facade classes.
+bool operator ==, !=, <, ... (const TypeInfo& lhs, const type_index_facade& rhs) noexcept;
+
+#endif
+
+#ifndef BOOST_NO_IOSTREAM
+#ifdef BOOST_NO_TEMPLATED_IOSTREAMS
+/// @cond
+/// Ostream operator that will output demangled name
+template <class Derived, class TypeInfo>
+inline std::ostream& operator<<(std::ostream& ostr, const type_index_facade<Derived, TypeInfo>& ind) {
+ ostr << static_cast<Derived const&>(ind).pretty_name();
+ return ostr;
+}
+/// @endcond
+#else
+/// Ostream operator that will output demangled name.
+template <class CharT, class TriatT, class Derived, class TypeInfo>
+inline std::basic_ostream<CharT, TriatT>& operator<<(
+ std::basic_ostream<CharT, TriatT>& ostr,
+ const type_index_facade<Derived, TypeInfo>& ind)
+{
+ ostr << static_cast<Derived const&>(ind).pretty_name();
+ return ostr;
+}
+#endif // BOOST_NO_TEMPLATED_IOSTREAMS
+#endif // BOOST_NO_IOSTREAM
+
+/// This free function is used by Boost's unordered containers.
+/// \note <boost/functional/hash.hpp> has to be included if this function is used.
+template <class Derived, class TypeInfo>
+inline std::size_t hash_value(const type_index_facade<Derived, TypeInfo>& lhs) BOOST_NOEXCEPT {
+ return static_cast<Derived const&>(lhs).hash_code();
+}
+
+}} // namespace boost::typeindex
+
+#endif // BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP
+
#include "boost/type_traits/is_const.hpp"
#include "boost/type_traits/is_convertible.hpp"
#include "boost/type_traits/is_copy_constructible.hpp"
+#include "boost/type_traits/is_copy_assignable.hpp"
#include "boost/type_traits/is_empty.hpp"
#include "boost/type_traits/is_enum.hpp"
#include "boost/type_traits/is_float.hpp"
# pragma warning(pop)
#endif
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_const,T&,T&)
-#endif
} // namespace boost
# pragma warning(pop)
#endif
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_cv,T&,T&)
-#endif
} // namespace boost
namespace detail {
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
-template <bool x>
-struct reference_adder
-{
- template <typename T> struct result_
- {
- typedef T& type;
- };
-};
-
-template <>
-struct reference_adder<true>
-{
- template <typename T> struct result_
- {
- typedef T type;
- };
-};
-
-template <typename T>
-struct add_reference_impl
-{
- typedef typename reference_adder<
- ::boost::is_reference<T>::value
- >::template result_<T> result;
-
- typedef typename result::type type;
-};
-
-#else
//
// We can't filter out rvalue_references at the same level as
// references or we get ambiguities from msvc:
typedef typename add_reference_rvalue_layer<T>::type type;
};
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&)
-#endif
-
-#endif
// these full specialisations are always required:
BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void,void)
struct add_rvalue_reference_helper
{ typedef T type; };
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename T>
struct add_rvalue_reference_helper<T, true>
{
# pragma warning(pop)
#endif
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_volatile,T&,T&)
-#endif
} // namespace boost
// references have to be treated specially, assume
// that a reference is just a special pointer:
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <typename T>
struct alignment_of<T&>
: public alignment_of<T*>
{
};
-#endif
#ifdef __BORLANDC__
// long double gives an incorrect value of 10 (!)
// unless we do this...
+++ /dev/null
-// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
-// Use, modification and distribution are subject to 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/type_traits for most recent version including documentation.
-//
-// defines traits classes for arithmetic types:
-// is_void, is_integral, is_float, is_arithmetic, is_fundamental.
-
-#ifndef BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED
-#define BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED
-
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/type_traits/is_float.hpp>
-#include <boost/type_traits/is_fundamental.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/is_void.hpp>
-
-#endif // BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED
+++ /dev/null
-
-// Copyright 2001-2003 Aleksey Gurtovoy.
-// Use, modification and distribution are subject to 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/type_traits for most recent version including documentation.
-
-#ifndef BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
-#define BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
-
-#include <boost/mpl/aux_/lambda_support.hpp>
-#include <boost/config.hpp>
-
-// these are needed regardless of BOOST_TT_NO_BROKEN_COMPILER_SPEC
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-namespace boost { namespace detail {
-template< typename T > struct remove_const_impl { typedef T type; };
-template< typename T > struct remove_volatile_impl { typedef T type; };
-template< typename T > struct remove_pointer_impl { typedef T type; };
-template< typename T > struct remove_reference_impl { typedef T type; };
-typedef int invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces;
-}}
-#endif
-
-// agurt, 27/jun/03: disable the workaround if user defined
-// BOOST_TT_NO_BROKEN_COMPILER_SPEC
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
- || defined(BOOST_TT_NO_BROKEN_COMPILER_SPEC)
-
-# define BOOST_TT_BROKEN_COMPILER_SPEC(T) /**/
-
-#else
-
-// same as BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1 macro, except that it
-// never gets #undef-ined
-# define BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(trait,spec,result) \
-template<> struct trait##_impl<spec> \
-{ \
- typedef result type; \
-}; \
-/**/
-
-# define BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T) \
- BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const,T) \
- BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const volatile,T volatile) \
- BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T volatile,T) \
- BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T const volatile,T const) \
- /**/
-
-# define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T) \
- BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*,T) \
- BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*const,T) \
- BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*volatile,T) \
- BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*const volatile,T) \
- BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_reference,T&,T) \
- /**/
-
-# define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T) \
- BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T) \
- BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const) \
- BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T volatile) \
- BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const volatile) \
- /**/
-
-# define BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T) \
- BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T) \
- BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T) \
- /**/
-
-# define BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T) \
- BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T*) \
- BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const*) \
- BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T volatile*) \
- BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const volatile*) \
- /**/
-
-# define BOOST_TT_BROKEN_COMPILER_SPEC(T) \
- namespace boost { namespace detail { \
- typedef invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces \
- please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces; \
- BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T) \
- BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T) \
- BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T*) \
- BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const*) \
- BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T volatile*) \
- BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const volatile*) \
- }} \
- /**/
-
-# include <boost/type_traits/detail/type_trait_undef.hpp>
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-BOOST_TT_BROKEN_COMPILER_SPEC(bool)
-BOOST_TT_BROKEN_COMPILER_SPEC(char)
-#ifndef BOOST_NO_INTRINSIC_WCHAR_T
-BOOST_TT_BROKEN_COMPILER_SPEC(wchar_t)
-#endif
-BOOST_TT_BROKEN_COMPILER_SPEC(signed char)
-BOOST_TT_BROKEN_COMPILER_SPEC(unsigned char)
-BOOST_TT_BROKEN_COMPILER_SPEC(signed short)
-BOOST_TT_BROKEN_COMPILER_SPEC(unsigned short)
-BOOST_TT_BROKEN_COMPILER_SPEC(signed int)
-BOOST_TT_BROKEN_COMPILER_SPEC(unsigned int)
-BOOST_TT_BROKEN_COMPILER_SPEC(signed long)
-BOOST_TT_BROKEN_COMPILER_SPEC(unsigned long)
-BOOST_TT_BROKEN_COMPILER_SPEC(float)
-BOOST_TT_BROKEN_COMPILER_SPEC(double)
-//BOOST_TT_BROKEN_COMPILER_SPEC(long double)
-
-// for backward compatibility
-#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) \
- BOOST_TT_BROKEN_COMPILER_SPEC(T) \
-/**/
-
-#endif // BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
typedef BOOST_TYPEOF_TPL(declval_b() ? declval_T() : declval_U()) type;
#endif
-#if defined(__GNUC__) && __GNUC__ == 3 && (__GNUC_MINOR__ == 2 || __GNUC_MINOR__ == 3)
+#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ == 3
public:
void public_dummy_function_just_to_silence_warning();
#endif
#endif
# if (BOOST_WORKAROUND(__MWERKS__, < 0x3000) \
- || BOOST_WORKAROUND(BOOST_MSVC, <= 1301) \
- || !defined(__EDG_VERSION__) && BOOST_WORKAROUND(__GNUC__, < 3) \
|| BOOST_WORKAROUND(__IBMCPP__, < 600 ) \
|| BOOST_WORKAROUND(__BORLANDC__, < 0x5A0) \
|| defined(__ghs) \
# define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION 1
#endif
-//
-// Define BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
-// when we can't test for function types with elipsis:
-//
-#if BOOST_WORKAROUND(__GNUC__, < 3)
-# define BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
-#endif
-
//
// define BOOST_TT_TEST_MS_FUNC_SIGS
// when we want to test __stdcall etc function types with is_function etc
# define BOOST_TT_NO_CV_FUNC_TEST
#endif
+//
+// Macros that have been deprecated, defined here for backwards compatibility:
+//
+#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(x)
+#define BOOST_TT_BROKEN_COMPILER_SPEC(x)
+
#endif // BOOST_TT_CONFIG_HPP_INCLUDED
// http://www.boost.org/LICENSE_1_0.txt)
// $Source$
-// $Date: 2011-10-09 15:28:33 -0700 (Sun, 09 Oct 2011) $
-// $Revision: 74865 $
+// $Date$
+// $Revision$
#include <boost/type_traits/detail/template_arity_spec.hpp>
#include <boost/type_traits/integral_constant.hpp>
enum { value = type::value }; \
/**/
# define BOOST_TT_AUX_BOOL_C_BASE(C)
-
-#elif defined(BOOST_MSVC) && BOOST_MSVC < 1300
-
-# define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
- typedef ::boost::integral_constant<bool,C> base_; \
- using base_::value; \
- /**/
-
#endif
#ifndef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
// http://www.boost.org/LICENSE_1_0.txt)
// $Source$
-// $Date: 2011-10-09 15:28:33 -0700 (Sun, 09 Oct 2011) $
-// $Revision: 74865 $
+// $Date$
+// $Revision$
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#ifndef BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED
#define BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED
+#include <cstddef>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
// implementation helper:
-#if !(BOOST_WORKAROUND(__GNUC__,== 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 2))
namespace boost {
namespace detail {
-#else
-#include <boost/type_traits/detail/yes_no_type.hpp>
-namespace boost {
-namespace type_traits {
-namespace gcc8503 {
-#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1700)
+#define BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(X) X
+ template <typename T>
+ struct cv_traits_imp
+ {
+ BOOST_STATIC_CONSTANT(bool, is_const = false);
+ BOOST_STATIC_CONSTANT(bool, is_volatile = false);
+ typedef T unqualified_type;
+ };
+
+ template <typename T>
+ struct cv_traits_imp<T[]>
+ {
+ BOOST_STATIC_CONSTANT(bool, is_const = false);
+ BOOST_STATIC_CONSTANT(bool, is_volatile = false);
+ typedef T unqualified_type[];
+ };
+
+ template <typename T>
+ struct cv_traits_imp<const T[]>
+ {
+ BOOST_STATIC_CONSTANT(bool, is_const = true);
+ BOOST_STATIC_CONSTANT(bool, is_volatile = false);
+ typedef T unqualified_type[];
+ };
+
+ template <typename T>
+ struct cv_traits_imp<volatile T[]>
+ {
+ BOOST_STATIC_CONSTANT(bool, is_const = false);
+ BOOST_STATIC_CONSTANT(bool, is_volatile = true);
+ typedef T unqualified_type[];
+ };
+
+ template <typename T>
+ struct cv_traits_imp<const volatile T[]>
+ {
+ BOOST_STATIC_CONSTANT(bool, is_const = true);
+ BOOST_STATIC_CONSTANT(bool, is_volatile = true);
+ typedef T unqualified_type[];
+ };
+
+ template <typename T, std::size_t N>
+ struct cv_traits_imp<T[N]>
+ {
+ BOOST_STATIC_CONSTANT(bool, is_const = false);
+ BOOST_STATIC_CONSTANT(bool, is_volatile = false);
+ typedef T unqualified_type[N];
+ };
+
+ template <typename T, std::size_t N>
+ struct cv_traits_imp<const T[N]>
+ {
+ BOOST_STATIC_CONSTANT(bool, is_const = true);
+ BOOST_STATIC_CONSTANT(bool, is_volatile = false);
+ typedef T unqualified_type[N];
+ };
+
+ template <typename T, std::size_t N>
+ struct cv_traits_imp<volatile T[N]>
+ {
+ BOOST_STATIC_CONSTANT(bool, is_const = false);
+ BOOST_STATIC_CONSTANT(bool, is_volatile = true);
+ typedef T unqualified_type[N];
+ };
+
+ template <typename T, std::size_t N>
+ struct cv_traits_imp<const volatile T[N]>
+ {
+ BOOST_STATIC_CONSTANT(bool, is_const = true);
+ BOOST_STATIC_CONSTANT(bool, is_volatile = true);
+ typedef T unqualified_type[N];
+ };
+
+#else
+#define BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(X) X *
template <typename T> struct cv_traits_imp {};
template <typename T>
BOOST_STATIC_CONSTANT(bool, is_volatile = false);
typedef T unqualified_type;
};
+#endif
template <typename T>
-struct cv_traits_imp<const T*>
+struct cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(const T)>
{
BOOST_STATIC_CONSTANT(bool, is_const = true);
BOOST_STATIC_CONSTANT(bool, is_volatile = false);
};
template <typename T>
-struct cv_traits_imp<volatile T*>
+struct cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(volatile T)>
{
BOOST_STATIC_CONSTANT(bool, is_const = false);
BOOST_STATIC_CONSTANT(bool, is_volatile = true);
};
template <typename T>
-struct cv_traits_imp<const volatile T*>
+struct cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(const volatile T)>
{
BOOST_STATIC_CONSTANT(bool, is_const = true);
BOOST_STATIC_CONSTANT(bool, is_volatile = true);
typedef T unqualified_type;
};
-#if BOOST_WORKAROUND(__GNUC__,== 3) && BOOST_WORKAROUND(__GNUC_MINOR__, <= 2)
-// We have to exclude function pointers
-// (see http://gcc.gnu.org/bugzilla/show_bug.cgi?8503)
-yes_type mini_funcptr_tester(...);
-no_type mini_funcptr_tester(const volatile void*);
-
-} // namespace gcc8503
-} // namespace type_traits
-
-namespace detail {
-
-// Use the implementation above for non function pointers
-template <typename T, unsigned Select
- = (unsigned)sizeof(::boost::type_traits::gcc8503::mini_funcptr_tester((T)0)) >
-struct cv_traits_imp : public ::boost::type_traits::gcc8503::cv_traits_imp<T> { };
-
-// Functions are never cv-qualified
-template <typename T> struct cv_traits_imp<T*,1>
-{
- BOOST_STATIC_CONSTANT(bool, is_const = false);
- BOOST_STATIC_CONSTANT(bool, is_volatile = false);
- typedef T unqualified_type;
-};
-
-#endif
-
} // namespace detail
} // namespace boost
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#endif // BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED
// warning C4804: '<' : unsafe use of type 'bool' in operation
// warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation
// cannot find another implementation -> declared as system header to suppress these warnings.
-#if defined(__GNUC__) && ((__GNUC__==3 && __GNUC_MINOR__>=1) || (__GNUC__>3))
+#if defined(__GNUC__)
# pragma GCC system_header
#elif defined(BOOST_MSVC)
# pragma warning ( push )
template < typename Lhs, typename Rhs >
struct operator_exists {
- static ::boost::type_traits::yes_type check(has_operator); // this version is preferred when operator exists
- static ::boost::type_traits::no_type check(no_operator); // this version is used otherwise
+ static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists
+ static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise
- BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
+ BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
};
#include <boost/type_traits/detail/bool_trait_def.hpp>
// avoid warnings
-#if defined(__GNUC__) && ((__GNUC__==3 && __GNUC_MINOR__>=1) || (__GNUC__>3))
+#if defined(__GNUC__)
# pragma GCC system_header
#elif defined(BOOST_MSVC)
# pragma warning ( push )
template < typename Lhs >
struct operator_exists {
- static ::boost::type_traits::yes_type check(has_operator); // this version is preferred when operator exists
- static ::boost::type_traits::no_type check(no_operator); // this version is used otherwise
+ static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists
+ static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise
- BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((make<Lhs>() BOOST_TT_TRAIT_OP),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
+ BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((make<Lhs>() BOOST_TT_TRAIT_OP),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
};
// warning C4146: unary minus operator applied to unsigned type, result still unsigned
// warning C4804: '-' : unsafe use of type 'bool' in operation
// cannot find another implementation -> declared as system header to suppress these warnings.
-#if defined(__GNUC__) && ((__GNUC__==3 && __GNUC_MINOR__>=1) || (__GNUC__>3))
+#if defined(__GNUC__)
# pragma GCC system_header
#elif defined(BOOST_MSVC)
# pragma warning ( push )
template < typename Rhs >
struct operator_exists {
- static ::boost::type_traits::yes_type check(has_operator); // this version is preferred when operator exists
- static ::boost::type_traits::no_type check(no_operator); // this version is used otherwise
+ static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists
+ static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise
- BOOST_STATIC_CONSTANT(bool, value = (sizeof(check(((BOOST_TT_TRAIT_OP make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
+ BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((BOOST_TT_TRAIT_OP make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
};
template <class R >
struct is_function_ptr_helper<R (*)()> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R >
struct is_function_ptr_helper<R (*)( ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0>
struct is_function_ptr_helper<R (*)( T0)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0>
struct is_function_ptr_helper<R (*)( T0 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1>
struct is_function_ptr_helper<R (*)( T0 , T1)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1>
struct is_function_ptr_helper<R (*)( T0 , T1 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)> { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#else
#undef BOOST_STATIC_CONSTANT
template <class R >
yes_type is_function_ptr_tester(R (*)());
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R >
yes_type is_function_ptr_tester(R (*)( ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R >
yes_type is_function_ptr_tester(R (__stdcall*)());
-template <class R >
-yes_type is_function_ptr_tester(R (__stdcall*)( ...));
#ifndef _MANAGED
template <class R >
yes_type is_function_ptr_tester(R (__fastcall*)());
-template <class R >
-yes_type is_function_ptr_tester(R (__fastcall*)( ...));
#endif
template <class R >
yes_type is_function_ptr_tester(R (__cdecl*)());
-template <class R >
-yes_type is_function_ptr_tester(R (__cdecl*)( ...));
#endif
template <class R , class T0 >
yes_type is_function_ptr_tester(R (*)( T0));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 >
yes_type is_function_ptr_tester(R (*)( T0 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0));
-template <class R , class T0 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 ...));
#ifndef _MANAGED
template <class R , class T0 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0));
-template <class R , class T0 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 ...));
#endif
template <class R , class T0 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0));
-template <class R , class T0 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 ...));
#endif
template <class R , class T0 , class T1 >
yes_type is_function_ptr_tester(R (*)( T0 , T1));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1));
-template <class R , class T0 , class T1 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1));
-template <class R , class T0 , class T1 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 ...));
#endif
template <class R , class T0 , class T1 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1));
-template <class R , class T0 , class T1 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 ...));
#endif
template <class R , class T0 , class T1 , class T2 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2));
-template <class R , class T0 , class T1 , class T2 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2));
-template <class R , class T0 , class T1 , class T2 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 ...));
#endif
template <class R , class T0 , class T1 , class T2 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2));
-template <class R , class T0 , class T1 , class T2 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3));
-template <class R , class T0 , class T1 , class T2 , class T3 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3));
-template <class R , class T0 , class T1 , class T2 , class T3 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3));
-template <class R , class T0 , class T1 , class T2 , class T3 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_function_ptr_tester(R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_function_ptr_tester(R (__stdcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
#ifndef _MANAGED
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_function_ptr_tester(R (__fastcall*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
#endif
template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
-template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_function_ptr_tester(R (__cdecl*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
#endif
#else
@#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
yes_type is_function_ptr_tester(R (__stdcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
-template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_function_ptr_tester(R (__stdcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
@#ifndef _MANAGED
template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
yes_type is_function_ptr_tester(R (__fastcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
-template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_function_ptr_tester(R (__fastcall*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
@#endif
template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
yes_type is_function_ptr_tester(R (__cdecl*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
-template <class R BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_function_ptr_tester(R (__cdecl*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
@#endif
#undef BOOST_PP_COUNTER
template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T >
template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0>
template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1>
template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2>
template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3>
template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#endif
#if !defined(BOOST_TT_NO_CV_FUNC_TEST)
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
#endif
-#endif
#else
template <class R, class T >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)() const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...));
template <class R, class T >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)());
template <class R, class T >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)() const volatile);
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...));
-
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...) const);
-
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...) volatile);
-
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)());
template <class R, class T >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)() const volatile);
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...));
-
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...) const);
-
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...) volatile);
-
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( ...) const volatile);
#endif
template <class R, class T >
template <class R, class T >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)() const volatile);
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...));
-
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...) const);
-
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...) volatile);
-
-template <class R, class T >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( ...) const volatile);
#endif
template <class R, class T , class T0 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0));
template <class R, class T , class T0 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...));
template <class R, class T , class T0 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0));
template <class R, class T , class T0 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0) const volatile);
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...));
-
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...) const);
-
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...) volatile);
-
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0));
template <class R, class T , class T0 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0) const volatile);
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...));
-
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...) const);
-
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...) volatile);
-
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 ...) const volatile);
#endif
template <class R, class T , class T0 >
template <class R, class T , class T0 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0) const volatile);
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...));
-
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...) const);
-
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...) volatile);
-
-template <class R, class T , class T0 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1));
template <class R, class T , class T0 , class T1 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...));
template <class R, class T , class T0 , class T1 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1));
template <class R, class T , class T0 , class T1 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1) const volatile);
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...));
-
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...) const);
-
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...) volatile);
-
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1));
template <class R, class T , class T0 , class T1 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1) const volatile);
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...));
-
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...) const);
-
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...) volatile);
-
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 >
template <class R, class T , class T0 , class T1 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1) const volatile);
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...));
-
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...) const);
-
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...) volatile);
-
-template <class R, class T , class T0 , class T1 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2));
template <class R, class T , class T0 , class T1 , class T2 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...));
template <class R, class T , class T0 , class T1 , class T2 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2));
template <class R, class T , class T0 , class T1 , class T2 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2));
template <class R, class T , class T0 , class T1 , class T2 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 >
template <class R, class T , class T0 , class T1 , class T2 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3));
template <class R, class T , class T0 , class T1 , class T2 , class T3 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3));
template <class R, class T , class T0 , class T1 , class T2 , class T3 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3));
template <class R, class T , class T0 , class T1 , class T2 , class T3 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
-#endif
+
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...));
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const);
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile);
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile);
+yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
-#ifndef BOOST_TT_NO_ELLIPSIS_IN_FUNC_TESTING
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_mem_fun_pointer_tester(R (T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
-#endif
#ifdef BOOST_TT_TEST_MS_FUNC_SIGS
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
-
#ifndef _MANAGED
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24));
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
#endif
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile);
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...));
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile);
-
-template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24 >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile);
#endif
#else
template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile);
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
-
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const);
-
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile);
-
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__stdcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile);
-
@#ifndef _MANAGED
template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)));
template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile);
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
-
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const);
-
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile);
-
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__fastcall T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile);
@#endif
template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T)) const volatile);
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...));
-
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const);
-
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) volatile);
-
-template <class R, class T BOOST_PP_COMMA_IF(BOOST_PP_COUNTER) BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,class T) >
-yes_type is_mem_fun_pointer_tester(R (__cdecl T::*const volatile*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_COUNTER,T) ...) const volatile);
@#endif
#undef BOOST_PP_COUNTER
// http://www.boost.org/LICENSE_1_0.txt)
// $Source$
-// $Date: 2011-04-25 05:26:48 -0700 (Mon, 25 Apr 2011) $
-// $Revision: 71481 $
+// $Date$
+// $Revision$
#include <boost/type_traits/detail/template_arity_spec.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <cstddef>
-#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300
-# define BOOST_TT_AUX_SIZE_T_BASE(C) public ::boost::integral_constant<std::size_t,C>
-# define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/
-#else
-# define BOOST_TT_AUX_SIZE_T_BASE(C) public ::boost::mpl::size_t<C>
-# define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
- typedef ::boost::mpl::size_t<C> base_; \
- using base_::value; \
- /**/
-#endif
+// Obsolete. Remove.
+#define BOOST_TT_AUX_SIZE_T_BASE(C) public ::boost::integral_constant<std::size_t,C>
+#define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/
#define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) \
template< typename T > struct trait \
- : BOOST_TT_AUX_SIZE_T_BASE(C) \
+ : public ::boost::integral_constant<std::size_t,C> \
{ \
public:\
- BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
}; \
\
#define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) \
template<> struct trait<spec> \
- : BOOST_TT_AUX_SIZE_T_BASE(C) \
+ : public ::boost::integral_constant<std::size_t,C> \
{ \
public:\
- BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
}; \
/**/
#define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) \
template< param > struct trait<spec> \
- : BOOST_TT_AUX_SIZE_T_BASE(C) \
+ : public ::boost::integral_constant<std::size_t,C> \
{ \
}; \
/**/
// http://www.boost.org/LICENSE_1_0.txt)
// $Source$
-// $Date: 2004-09-02 08:41:37 -0700 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Date$
+// $Revision$
#undef BOOST_TT_AUX_SIZE_T_TRAIT_DEF1
#undef BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1
// http://www.boost.org/LICENSE_1_0.txt)
// $Source$
-// $Date: 2011-04-25 05:26:48 -0700 (Mon, 25 Apr 2011) $
-// $Revision: 71481 $
+// $Date$
+// $Revision$
#include <boost/type_traits/detail/template_arity_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
// http://www.boost.org/LICENSE_1_0.txt)
// $Source$
-// $Date: 2004-09-02 08:41:37 -0700 (Thu, 02 Sep 2004) $
-// $Revision: 24874 $
+// $Date$
+// $Revision$
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
+++ /dev/null
-// (C) Copyright David Abrahams 2002.
-// Use, modification and distribution are subject to 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/type_traits for most recent version including documentation.
-
-#ifndef BOOST_TT_DETAIL_WRAP_HPP_INCLUDED
-#define BOOST_TT_DETAIL_WRAP_HPP_INCLUDED
-
-namespace boost {
-namespace type_traits {
-
-template <class T> struct wrap {};
-
-}} // namespace boost::type_traits
-
-#endif // BOOST_TT_DETAIL_WRAP_HPP_INCLUDED
{
BOOST_STATIC_CONSTANT(std::size_t, value = 0);
};
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
template <class T, std::size_t R, std::size_t N>
struct extent_imp<T[R], N>
{
struct extent
: public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
{
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- typedef ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value> base_;
- using base_::value;
-#endif
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,extent,(T))
};
namespace boost {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
namespace detail {
template<typename Function> struct function_traits_helper;
{
};
-#else
-
-namespace detail {
-
-template<unsigned N>
-struct type_of_size
-{
- char elements[N];
-};
-
-template<typename R>
-type_of_size<1> function_arity_helper(R (*f)());
-
-template<typename R, typename T1>
-type_of_size<2> function_arity_helper(R (*f)(T1));
-
-template<typename R, typename T1, typename T2>
-type_of_size<3> function_arity_helper(R (*f)(T1, T2));
-
-template<typename R, typename T1, typename T2, typename T3>
-type_of_size<4> function_arity_helper(R (*f)(T1, T2, T3));
-
-template<typename R, typename T1, typename T2, typename T3, typename T4>
-type_of_size<5> function_arity_helper(R (*f)(T1, T2, T3, T4));
-
-template<typename R, typename T1, typename T2, typename T3, typename T4,
- typename T5>
-type_of_size<6> function_arity_helper(R (*f)(T1, T2, T3, T4, T5));
-
-template<typename R, typename T1, typename T2, typename T3, typename T4,
- typename T5, typename T6>
-type_of_size<7> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6));
-
-template<typename R, typename T1, typename T2, typename T3, typename T4,
- typename T5, typename T6, typename T7>
-type_of_size<8> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7));
-
-template<typename R, typename T1, typename T2, typename T3, typename T4,
- typename T5, typename T6, typename T7, typename T8>
-type_of_size<9> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8));
-
-template<typename R, typename T1, typename T2, typename T3, typename T4,
- typename T5, typename T6, typename T7, typename T8, typename T9>
-type_of_size<10> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8,
- T9));
-
-template<typename R, typename T1, typename T2, typename T3, typename T4,
- typename T5, typename T6, typename T7, typename T8, typename T9,
- typename T10>
-type_of_size<11> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8,
- T9, T10));
-} // end namespace detail
-
-// Won't work with references
-template<typename Function>
-struct function_traits
-{
- BOOST_STATIC_CONSTANT(unsigned, arity = (sizeof(boost::detail::function_arity_helper((Function*)0))-1));
-};
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
}
#endif // BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
#ifndef BOOST_TT_HAS_LOGICAL_NOT_HPP_INCLUDED
#define BOOST_TT_HAS_LOGICAL_NOT_HPP_INCLUDED
+#if defined(__GNUC__) && (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ > 40800)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-value"
+#endif
+
#define BOOST_TT_TRAIT_NAME has_logical_not
#define BOOST_TT_TRAIT_OP !
#define BOOST_TT_FORBIDDEN_IF\
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
+#if defined(__GNUC__) && (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ > 40800)
+#pragma GCC diagnostic pop
+#endif
+
#endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
+#if defined(new)
+# if BOOST_WORKAROUND(BOOST_MSVC, >= 1310)
+# define BOOST_TT_AUX_MACRO_NEW_DEFINED
+# pragma push_macro("new")
+# undef new
+# else
+# error "Sorry but you can't include this header if 'new' is defined as a macro."
+# endif
+#endif
+
namespace boost {
namespace detail {
template <class U, U x>
} // namespace boost
+#if defined(BOOST_TT_AUX_MACRO_NEW_DEFINED)
+# pragma pop_macro("new")
+#endif
+
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED
#ifndef BOOST_TT_HAS_POST_DECREMENT_HPP_INCLUDED
#define BOOST_TT_HAS_POST_DECREMENT_HPP_INCLUDED
+#include <boost/type_traits/is_array.hpp>
+
#define BOOST_TT_TRAIT_NAME has_post_decrement
#define BOOST_TT_TRAIT_OP --
#define BOOST_TT_FORBIDDEN_IF\
::boost::is_pointer< Lhs_noref >::value\
>::value,\
::boost::is_const< Lhs_noref >::value\
- >::value\
+ >::value,\
+ /* Arrays */ \
+ ::boost::is_array<Lhs_noref>::value\
>::value
#ifndef BOOST_TT_HAS_POST_INCREMENT_HPP_INCLUDED
#define BOOST_TT_HAS_POST_INCREMENT_HPP_INCLUDED
+#include <boost/type_traits/is_array.hpp>
+
#define BOOST_TT_TRAIT_NAME has_post_increment
#define BOOST_TT_TRAIT_OP ++
#define BOOST_TT_FORBIDDEN_IF\
::boost::is_pointer< Lhs_noref >::value\
>::value,\
::boost::is_const< Lhs_noref >::value\
- >::value\
+ >::value,\
+ /* Arrays */ \
+ ::boost::is_array<Lhs_noref>::value\
>::value
#ifndef BOOST_TT_HAS_PRE_DECREMENT_HPP_INCLUDED
#define BOOST_TT_HAS_PRE_DECREMENT_HPP_INCLUDED
+#include <boost/type_traits/is_array.hpp>
+
#define BOOST_TT_TRAIT_NAME has_pre_decrement
#define BOOST_TT_TRAIT_OP --
#define BOOST_TT_FORBIDDEN_IF\
::boost::is_pointer< Rhs_noref >::value\
>::value,\
::boost::is_const< Rhs_noref >::value\
- >::value\
+ >::value,\
+ /* Arrays */ \
+ ::boost::is_array<Rhs_noref>::value\
>::value
#ifndef BOOST_TT_HAS_PRE_INCREMENT_HPP_INCLUDED
#define BOOST_TT_HAS_PRE_INCREMENT_HPP_INCLUDED
+#include <boost/type_traits/is_array.hpp>
+
#define BOOST_TT_TRAIT_NAME has_pre_increment
#define BOOST_TT_TRAIT_OP ++
#define BOOST_TT_FORBIDDEN_IF\
::boost::is_pointer< Rhs_noref >::value\
>::value,\
::boost::is_const< Rhs_noref >::value\
- >::value\
+ >::value,\
+ /* Arrays */ \
+ ::boost::is_array<Rhs_noref>::value\
>::value
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/type_traits/detail/ice_not.hpp>
+#ifdef __clang__
+#include <boost/type_traits/is_copy_constructible.hpp>
+#endif
+
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
struct has_trivial_copy_impl
{
#ifdef BOOST_HAS_TRIVIAL_COPY
+# ifdef __clang__
+ BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_TRIVIAL_COPY(T) && boost::is_copy_constructible<T>::value);
+# else
BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_TRIVIAL_COPY(T));
+# endif
#else
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
#endif
};
+#ifdef __clang__
+
+template <typename T, std::size_t N>
+struct has_trivial_copy_impl<T[N]>
+{
+ static const bool value = has_trivial_copy_impl<T>::value;
+};
+
+#endif
+
} // namespace detail
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_copy,T,::boost::detail::has_trivial_copy_impl<T>::value)
template<> struct integral_constant<bool,true> : public mpl::true_
{
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-# pragma warning(push)
-# pragma warning(disable:4097)
- typedef mpl::true_ base_;
- using base_::value;
-# pragma warning(pop)
-#endif
typedef integral_constant<bool,true> type;
};
template<> struct integral_constant<bool,false> : public mpl::false_
{
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-# pragma warning(push)
-# pragma warning(disable:4097)
- typedef mpl::false_ base_;
- using base_::value;
-# pragma warning(pop)
-#endif
typedef integral_constant<bool,false> type;
};
// Same set of integral types as in boost/type_traits/is_integral.hpp.
// Please, keep in sync.
-#if (defined(BOOST_MSVC) && (BOOST_MSVC < 1300)) \
- || (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
+#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
|| (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300))
// TODO: common macro for this #if. Or better yet, PP SEQ of non-standard types.
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int8 )
// BOOST_HAS_NOTHROW_COPY(T) should evaluate to true if T(t) can not throw
// BOOST_HAS_NOTHROW_ASSIGN(T) should evaluate to true if t = u can not throw
// BOOST_HAS_VIRTUAL_DESTRUCTOR(T) should evaluate to true T has a virtual destructor
+// BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T) should evaluate to true if T has a non-throwing move constructor.
+// BOOST_IS_NOTHROW_MOVE_ASSIGN(T) should evaluate to true if T has a non-throwing move assignment operator.
//
// The following can also be defined: when detected our implementation is greatly simplified.
//
// # define BOOST_ALIGNMENT_OF(T) __alignof(T)
# if defined(_MSC_VER) && (_MSC_VER >= 1700)
-# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || ::boost::is_pod<T>::value) && !::boost::is_volatile<T>::value)
-# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || ::boost::is_pod<T>::value) && ! ::boost::is_const<T>::value && !::boost::is_volatile<T>::value)
+# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || __is_pod(T)) && !::boost::is_volatile<T>::value && !::boost::is_reference<T>::value)
+# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || __is_pod(T)) && ! ::boost::is_const<T>::value && !::boost::is_volatile<T>::value && !::boost::is_reference<T>::value)
# endif
-
+#if _MSC_FULL_VER >= 180020827
+# define BOOST_IS_NOTHROW_MOVE_ASSIGN(T) (__is_nothrow_assignable(T&, T&&))
+# define BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T) (__is_nothrow_constructible(T, T&&))
+#endif
# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#endif
# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#endif
-#if defined(BOOST_CLANG) && defined(__has_feature)
+#if defined(BOOST_CLANG) && defined(__has_feature) && !defined(__CUDACC__)
+//
+// Note that these intrinsics are disabled for the CUDA meta-compiler as it appears
+// to not support them, even though the underlying clang compiler does so.
+// This is a rubbish fix as it basically stops type traits from working correctly,
+// but maybe the best we can do for now. See https://svn.boost.org/trac/boost/ticket/10694
+//
# include <cstddef>
# include <boost/type_traits/is_same.hpp>
# include <boost/type_traits/is_reference.hpp>
# define BOOST_IS_CLASS(T) __is_class(T)
# endif
# if __has_feature(is_convertible_to)
-# include <boost/type_traits/is_abstract.hpp>
-# define BOOST_IS_CONVERTIBLE(T,U) (__is_convertible_to(T,U) && !::boost::is_abstract<U>::value)
+# define BOOST_IS_CONVERTIBLE(T,U) __is_convertible_to(T,U)
# endif
# if __has_feature(is_enum)
# define BOOST_IS_ENUM(T) __is_enum(T)
# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) __has_trivial_move_assign(T)
# endif
# define BOOST_ALIGNMENT_OF(T) __alignof(T)
+# if __has_feature(is_final)
+# define BOOST_IS_FINAL(T) __is_final(T)
+# endif
# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#endif
// old implementation instead in that case:
# define BOOST_ALIGNMENT_OF(T) __alignof__(T)
# endif
+# if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))
+# define BOOST_IS_FINAL(T) __is_final(T)
+# endif
+
+# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
+#endif
+
+#if defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130)
+# include <boost/type_traits/is_same.hpp>
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/type_traits/is_volatile.hpp>
+
+# define BOOST_IS_UNION(T) __oracle_is_union(T)
+# define BOOST_IS_POD(T) __oracle_is_pod(T)
+# define BOOST_IS_EMPTY(T) __oracle_is_empty(T)
+# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__oracle_has_trivial_constructor(T) && ! ::boost::is_volatile<T>::value)
+# define BOOST_HAS_TRIVIAL_COPY(T) (__oracle_has_trivial_copy(T) && !is_reference<T>::value && ! ::boost::is_volatile<T>::value)
+# define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__oracle_has_trivial_assign(T) || __oracle_is_trivial(T)) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value)
+# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __oracle_has_trivial_destructor(T)
+# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__oracle_has_nothrow_constructor(T) || __oracle_has_trivial_constructor(T) || __oracle_is_trivial(T))
+# define BOOST_HAS_NOTHROW_COPY(T) ((__oracle_has_nothrow_copy(T) || __oracle_has_trivial_copy(T) || __oracle_is_trivial(T)) && !is_volatile<T>::value && !is_reference<T>::value)
+# define BOOST_HAS_NOTHROW_ASSIGN(T) ((__oracle_has_nothrow_assign(T) || __oracle_has_trivial_assign(T) || __oracle_is_trivial(T)) && !is_volatile<T>::value && !is_const<T>::value)
+# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __oracle_has_virtual_destructor(T)
+
+# define BOOST_IS_ABSTRACT(T) __oracle_is_abstract(T)
+//# define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
+# define BOOST_IS_CLASS(T) __oracle_is_class(T)
+# define BOOST_IS_ENUM(T) __oracle_is_enum(T)
+# define BOOST_IS_POLYMORPHIC(T) __oracle_is_polymorphic(T)
+# define BOOST_ALIGNMENT_OF(T) __alignof__(T)
+# define BOOST_IS_FINAL(T) __oracle_is_final(T)
# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#endif
# define BOOST_IS_ENUM(T) __is_enum(T)
# define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
# define BOOST_ALIGNMENT_OF(T) __alignof__(T)
-
# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#endif
#ifndef BOOST_TT_IS_ABSTRACT_CLASS_HPP
#define BOOST_TT_IS_ABSTRACT_CLASS_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
# pragma once
#endif
// Compile type discovery whether given type is abstract class or not.
//
// Requires DR 337 to be supported by compiler
-// (http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_active.html#337).
+// (http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#337).
//
//
// Believed (Jan 2004) to work on:
#include <boost/type_traits/config.hpp>
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-# include <boost/type_traits/detail/yes_no_type.hpp>
-# include <boost/type_traits/detail/wrap.hpp>
-#endif
#include <cstddef>
#if defined( __CODEGEARC__ )
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,__is_array(T))
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,false)
#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T[N],true)
#endif
#endif
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-namespace detail {
-
-using ::boost::type_traits::yes_type;
-using ::boost::type_traits::no_type;
-using ::boost::type_traits::wrap;
-
-template< typename T > T(* is_array_tester1(wrap<T>) )(wrap<T>);
-char BOOST_TT_DECL is_array_tester1(...);
-
-template< typename T> no_type is_array_tester2(T(*)(wrap<T>));
-yes_type BOOST_TT_DECL is_array_tester2(...);
-
-template< typename T >
-struct is_array_impl
-{
- BOOST_STATIC_CONSTANT(bool, value =
- sizeof(::boost::detail::is_array_tester2(
- ::boost::detail::is_array_tester1(
- ::boost::type_traits::wrap<T>()
- )
- )) == 1
- );
-};
-
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void,false)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void const,false)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void volatile,false)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void const volatile,false)
#endif
-} // namespace detail
-
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,::boost::detail::is_array_impl<T>::value)
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
, (::boost::detail::is_base_and_derived_impl<Base,Derived>::value)
)
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base,Derived&,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived&,false)
-#endif
#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename Base,is_base_and_derived,Base,Base,false)
, Derived
, (::boost::detail::is_base_of_imp<Base, Derived>::value))
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base,Derived&,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived&,false)
-#endif
} // namespace boost
template <typename T>
struct is_class_impl
{
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value,
::boost::type_traits::ice_not< ::boost::is_void<T>::value >::value,
::boost::type_traits::ice_not< ::boost::is_function<T>::value >::value
>::value));
-# else
- BOOST_STATIC_CONSTANT(bool, value =
- (::boost::type_traits::ice_and<
- ::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value,
- ::boost::type_traits::ice_not< ::boost::is_scalar<T>::value >::value,
- ::boost::type_traits::ice_not< ::boost::is_array<T>::value >::value,
- ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value,
- ::boost::type_traits::ice_not< ::boost::is_void<T>::value >::value
- >::value));
-# endif
};
# endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
# include <boost/type_traits/detail/cv_traits_impl.hpp>
# ifdef __GNUC__
# include <boost/type_traits/is_reference.hpp>
# if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
# include <boost/type_traits/remove_bounds.hpp>
# endif
-#else
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/type_traits/is_array.hpp>
-# include <boost/type_traits/detail/yes_no_type.hpp>
-# include <boost/type_traits/detail/false_result.hpp>
-#endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,__is_const(T))
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
namespace detail{
//
#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<typename boost::remove_bounds<T>::type*>::is_const);
#else
- BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<T*>::is_const);
+ BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(T)>::is_const);
#endif
};
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const volatile,false)
#endif
-#if defined(__GNUC__) && (__GNUC__ < 3)
-// special case for gcc where illegally cv-qualified reference types can be
-// generated in some corner cases:
-BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T const,!(::boost::is_reference<T>::value))
-BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T volatile const,!(::boost::is_reference<T>::value))
-#endif
-
-#else
-
-namespace detail {
-
-using ::boost::type_traits::yes_type;
-using ::boost::type_traits::no_type;
-
-yes_type is_const_tester(const volatile void*);
-no_type is_const_tester(volatile void *);
-
-template <bool is_ref, bool array>
-struct is_const_helper
- : public ::boost::type_traits::false_result
-{
-};
-
-template <>
-struct is_const_helper<false,false>
-{
- template <typename T> struct result_
- {
- static T* t;
- BOOST_STATIC_CONSTANT(bool, value = (
- sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_const_tester(t))
- ));
- };
-};
-
-template <>
-struct is_const_helper<false,true>
-{
- template <typename T> struct result_
- {
- static T t;
- BOOST_STATIC_CONSTANT(bool, value = (
- sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_const_tester(&t))
- ));
- };
-};
-
-template <typename T>
-struct is_const_impl
- : public is_const_helper<
- is_reference<T>::value
- , is_array<T>::value
- >::template result_<T>
-{
-};
-
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void,false)
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void const,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void volatile,false)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void const volatile,true)
#endif
-} // namespace detail
-
-//* is a type T declared const - is_const<T>
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::is_const_impl<T>::value)
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#if defined(__MWERKS__)
#include <boost/type_traits/remove_reference.hpp>
#endif
-
+#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+# include <boost/utility/declval.hpp>
+#endif
#endif // BOOST_IS_CONVERTIBLE
// should be always the last #include directive
namespace detail {
-// MS specific version:
+#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
+ // This is a C++11 conforming version, place this first and use it wherever possible:
-// This workaround is necessary to handle when From is void
-// which is normally taken care of by the partial specialization
-// of the is_convertible typename.
-using ::boost::type_traits::yes_type;
-using ::boost::type_traits::no_type;
+# define BOOST_TT_CXX11_IS_CONVERTIBLE
-template< typename From >
-struct does_conversion_exist
-{
- template< typename To > struct result_
- {
- static no_type BOOST_TT_DECL _m_check(...);
- static yes_type BOOST_TT_DECL _m_check(To);
- static typename add_lvalue_reference<From>::type _m_from;
- enum { value = sizeof( _m_check(_m_from) ) == sizeof(yes_type) };
- };
-};
+ template <class A, class B, class C>
+ struct or_helper
+ {
+ static const bool value = (A::value || B::value || C::value);
+ };
-template<>
-struct does_conversion_exist<void>
-{
- template< typename To > struct result_
- {
- enum { value = ::boost::is_void<To>::value };
- };
-};
+ template<typename From, typename To, bool b = or_helper<boost::is_void<From>, boost::is_function<To>, boost::is_array<To> >::value>
+ struct is_convertible_basic_impl
+ {
+ // Nothing converts to function or array, but void converts to void:
+ static const bool value = is_void<To>::value;
+ };
-template <typename From, typename To>
-struct is_convertible_basic_impl
- : public does_conversion_exist<From>::template result_<To>
-{
-};
+ template<typename From, typename To>
+ class is_convertible_basic_impl<From, To, false>
+ {
+ typedef char one;
+ typedef int two;
+
+ template<typename To1>
+ static void test_aux(To1);
+
+ template<typename From1, typename To1>
+ static decltype(test_aux<To1>(boost::declval<From1>()), one()) test(int);
+
+ template<typename, typename>
+ static two test(...);
+
+ public:
+ static const bool value = sizeof(test<From, To>(0)) == 1;
+ };
#elif defined(__BORLANDC__) && (__BORLANDC__ < 0x560)
//
typedef is_convertible_impl_select<
::boost::is_arithmetic<From>::value,
::boost::is_arithmetic<To>::value,
-#ifndef BOOST_NO_IS_ABSTRACT
+#if !defined(BOOST_NO_IS_ABSTRACT) && !defined(BOOST_TT_CXX11_IS_CONVERTIBLE)
+ // We need to filter out abstract types, only if we don't have a strictly conforming C++11 version:
::boost::is_abstract<To>::value
#else
false
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(is_convertible,void,void,true)
#endif // BOOST_NO_CV_VOID_SPECIALIZATIONS
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void,To,false)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void,false)
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const volatile,false)
#endif
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
} // namespace detail
--- /dev/null
+// (C) Copyright Ion Gaztanaga 2014.
+//
+// Use, modification and distribution are subject to 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/type_traits for most recent version including documentation.
+
+#ifndef BOOST_TT_IS_COPY_ASSIGNABLE_HPP_INCLUDED
+#define BOOST_TT_IS_COPY_ASSIGNABLE_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/type_traits/detail/yes_no_type.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/noncopyable.hpp>
+
+#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_CXX11_DECLTYPE) \
+ && !defined(BOOST_INTEL_CXX_VERSION) && \
+ !(defined(BOOST_MSVC) && _MSC_VER == 1800)
+#define BOOST_TT_CXX11_IS_COPY_ASSIGNABLE
+#include <boost/utility/declval.hpp>
+#else
+ //For compilers without decltype
+ #include <boost/type_traits/is_const.hpp>
+ #include <boost/type_traits/is_array.hpp>
+ #include <boost/type_traits/add_reference.hpp>
+ #include <boost/type_traits/remove_reference.hpp>
+#endif
+
+
+// should be the last #include
+#include <boost/type_traits/detail/bool_trait_def.hpp>
+
+namespace boost {
+
+namespace detail{
+
+template <bool DerivedFromNoncopyable, class T>
+struct is_copy_assignable_impl2 {
+
+// Intel compiler has problems with SFINAE for copy constructors and deleted functions:
+//
+// error: function *function_name* cannot be referenced -- it is a deleted function
+// static boost::type_traits::yes_type test(T1&, decltype(T1(boost::declval<T1&>()))* = 0);
+// ^
+//
+// MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See:
+// https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken
+#if defined(BOOST_TT_CXX11_IS_COPY_ASSIGNABLE)
+ typedef boost::type_traits::yes_type yes_type;
+ typedef boost::type_traits::no_type no_type;
+
+ template <class U>
+ static decltype(::boost::declval<U&>() = ::boost::declval<const U&>(), yes_type() ) test(int);
+
+ template <class>
+ static no_type test(...);
+
+ static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
+
+#else
+ static BOOST_DEDUCED_TYPENAME boost::add_reference<T>::type produce();
+
+ template <class T1>
+ static boost::type_traits::no_type test(T1&, typename T1::boost_move_no_copy_constructor_or_assign* = 0);
+
+ static boost::type_traits::yes_type test(...);
+ // If you see errors like this:
+ //
+ // `'T::operator=(const T&)' is private`
+ // `boost/type_traits/is_copy_assignable.hpp:NN:M: error: within this context`
+ //
+ // then you are trying to call that macro for a structure defined like that:
+ //
+ // struct T {
+ // ...
+ // private:
+ // T & operator=(const T &);
+ // ...
+ // };
+ //
+ // To fix that you must modify your structure:
+ //
+ // // C++03 and C++11 version
+ // struct T: private boost::noncopyable {
+ // ...
+ // private:
+ // T & operator=(const T &);
+ // ...
+ // };
+ //
+ // // C++11 version
+ // struct T {
+ // ...
+ // private:
+ // T& operator=(const T &) = delete;
+ // ...
+ // };
+ BOOST_STATIC_CONSTANT(bool, value = (
+ sizeof(test(produce())) == sizeof(boost::type_traits::yes_type)
+ ));
+ #endif
+};
+
+template <class T>
+struct is_copy_assignable_impl2<true, T> {
+ BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct is_copy_assignable_impl {
+
+#if !defined(BOOST_TT_CXX11_IS_COPY_ASSIGNABLE)
+ //For compilers without decltype, at least return false on const types, arrays
+ //types derived from boost::noncopyable and types defined as BOOST_MOVEABLE_BUT_NOT_COPYABLE
+ typedef BOOST_DEDUCED_TYPENAME boost::remove_reference<T>::type unreferenced_t;
+ BOOST_STATIC_CONSTANT(bool, value = (
+ boost::detail::is_copy_assignable_impl2<
+ boost::is_base_and_derived<boost::noncopyable, T>::value
+ || boost::is_const<unreferenced_t>::value || boost::is_array<unreferenced_t>::value
+ ,T
+ >::value
+ ));
+ #else
+ BOOST_STATIC_CONSTANT(bool, value = (
+ boost::detail::is_copy_assignable_impl2<
+ boost::is_base_and_derived<boost::noncopyable, T>::value,T
+ >::value
+ ));
+ #endif
+};
+
+} // namespace detail
+
+BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_copy_assignable,T,::boost::detail::is_copy_assignable_impl<T>::value)
+BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_copy_assignable,void,false)
+#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_copy_assignable,void const,false)
+BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_copy_assignable,void const volatile,false)
+BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_copy_assignable,void volatile,false)
+#endif
+
+} // namespace boost
+
+#include <boost/type_traits/detail/bool_trait_undef.hpp>
+
+#endif // BOOST_TT_IS_COPY_ASSIGNABLE_HPP_INCLUDED
// error: function *function_name* cannot be referenced -- it is a deleted function
// static boost::type_traits::yes_type test(T1&, decltype(T1(boost::declval<T1&>()))* = 0);
// ^
-#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_INTEL_CXX_VERSION)
+//
+// MSVC 12.0 (Visual 2013) has problems when the copy constructor has been deleted. See:
+// https://connect.microsoft.com/VisualStudio/feedback/details/800328/std-is-copy-constructible-is-broken
+#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_INTEL_CXX_VERSION) && !(defined(BOOST_MSVC) && _MSC_VER == 1800)
#ifdef BOOST_NO_CXX11_DECLTYPE
template <class T1>
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/intrinsics.hpp>
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
# include <boost/type_traits/remove_cv.hpp>
# include <boost/type_traits/is_class.hpp>
# include <boost/type_traits/add_reference.hpp>
-#else
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/type_traits/is_pointer.hpp>
-# include <boost/type_traits/is_member_pointer.hpp>
-# include <boost/type_traits/is_array.hpp>
-# include <boost/type_traits/is_void.hpp>
-# include <boost/type_traits/detail/ice_and.hpp>
-# include <boost/type_traits/detail/ice_not.hpp>
-#endif
// should be always the last #include directive
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace detail {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#ifdef BOOST_MSVC
#pragma warning(push)
#endif // __BORLANDC__
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
-
-template <typename T>
-struct empty_helper_t1 : public T
-{
- empty_helper_t1();
- int i[256];
-};
-
-struct empty_helper_t2 { int i[256]; };
-
-template <typename T>
-struct empty_helper_base
-{
- enum { value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2)) };
-};
-
-template <typename T>
-struct empty_helper_nonbase
-{
- enum { value = false };
-};
-
-template <bool base>
-struct empty_helper_chooser
-{
- template <typename T> struct result_
- {
- typedef empty_helper_nonbase<T> type;
- };
-};
-
-template <>
-struct empty_helper_chooser<true>
-{
- template <typename T> struct result_
- {
- typedef empty_helper_base<T> type;
- };
-};
-
-template <typename T>
-struct is_empty_impl
-{
- typedef ::boost::detail::empty_helper_chooser<
- ::boost::type_traits::ice_and<
- ::boost::type_traits::ice_not< ::boost::is_reference<T>::value >::value,
- ::boost::type_traits::ice_not< ::boost::is_convertible<T,double>::value >::value,
- ::boost::type_traits::ice_not< ::boost::is_pointer<T>::value >::value,
- ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value,
- ::boost::type_traits::ice_not< ::boost::is_array<T>::value >::value,
- ::boost::type_traits::ice_not< ::boost::is_void<T>::value >::value,
- ::boost::type_traits::ice_not<
- ::boost::is_convertible<T,void const volatile*>::value
- >::value
- >::value > chooser;
-
- typedef typename chooser::template result_<T> result;
- typedef typename result::type eh_type;
-
- BOOST_STATIC_CONSTANT(bool, value =
- (::boost::type_traits::ice_or<eh_type::value, BOOST_INTERNAL_IS_EMPTY(T)>::value));
-};
-
-#else
-
-template <typename T> struct is_empty_impl
-{
- BOOST_STATIC_CONSTANT(bool, value = BOOST_INTERNAL_IS_EMPTY(T));
-};
-
-#endif // BOOST_MSVC6_MEMBER_TEMPLATES
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
// these help when the compiler has no partial specialization support:
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_empty,void,false)
template <typename T>
struct is_class_or_union
{
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))// we simply can't detect it this way.
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))// we simply can't detect it this way.
BOOST_STATIC_CONSTANT(bool, value = false);
# else
template <class U> static ::boost::type_traits::yes_type is_class_or_union_tester(void(U::*)(void));
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) \
- || BOOST_WORKAROUND(__MWERKS__, <= 0x3000) // no SFINAE
+# if BOOST_WORKAROUND(__MWERKS__, <= 0x3000) // no SFINAE
static ::boost::type_traits::no_type is_class_or_union_tester(...);
BOOST_STATIC_CONSTANT(
bool, value = sizeof(is_class_or_union_tester(0)) == sizeof(::boost::type_traits::yes_type));
#include <boost/type_traits/detail/false_result.hpp>
#include <boost/config.hpp>
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
+#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
# include <boost/type_traits/detail/is_function_ptr_helper.hpp>
#else
# include <boost/type_traits/detail/is_function_ptr_tester.hpp>
namespace detail {
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
+#if !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
template<bool is_ref = true>
struct is_function_chooser
: public ::boost::type_traits::false_result
#endif
};
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template <typename T>
struct is_function_impl<T&> : public false_type
{};
struct is_function_impl<T&&> : public false_type
{};
#endif
-#endif
#endif
// Same set of integral types as in boost/type_traits/integral_promotion.hpp.
// Please, keep in sync. -- Alexander Nasonov
-#if (defined(BOOST_MSVC) && (BOOST_MSVC < 1300)) \
- || (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
+#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
|| (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300))
BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int8,true)
BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int8,true)
#include <boost/type_traits/config.hpp>
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-# include <boost/type_traits/detail/yes_no_type.hpp>
-# include <boost/type_traits/detail/wrap.hpp>
-#endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#if defined( __CODEGEARC__ )
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_lvalue_reference,T,__is_reference(T))
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_lvalue_reference,T,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T&,true)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T& const volatile,true)
#endif
-#if defined(__GNUC__) && (__GNUC__ < 3)
-// these allow us to work around illegally cv-qualified reference
-// types.
-BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T const ,::boost::is_lvalue_reference<T>::value)
-BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T volatile ,::boost::is_lvalue_reference<T>::value)
-BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_lvalue_reference,T const volatile ,::boost::is_lvalue_reference<T>::value)
-// However, the above specializations confuse gcc 2.96 unless we also
-// supply these specializations for array types
-BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,T[N],false)
-BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,const T[N],false)
-BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,volatile T[N],false)
-BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_lvalue_reference,const volatile T[N],false)
#endif
-#else
-
-#ifdef BOOST_MSVC
-# pragma warning(push)
-# pragma warning(disable: 4181 4097)
-#endif
-
-namespace detail {
-
-using ::boost::type_traits::yes_type;
-using ::boost::type_traits::no_type;
-using ::boost::type_traits::wrap;
-
-template <class T> T&(* is_lvalue_reference_helper1(wrap<T>) )(wrap<T>);
-char is_lvalue_reference_helper1(...);
-
-template <class T> no_type is_lvalue_reference_helper2(T&(*)(wrap<T>));
-yes_type is_lvalue_reference_helper2(...);
-
-template <typename T>
-struct is_lvalue_reference_impl
-{
- BOOST_STATIC_CONSTANT(
- bool, value = sizeof(
- ::boost::detail::is_lvalue_reference_helper2(
- ::boost::detail::is_lvalue_reference_helper1(::boost::type_traits::wrap<T>()))) == 1
- );
-};
-
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void,false)
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void const,false)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void volatile,false)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_lvalue_reference,void const volatile,false)
-#endif
-
-} // namespace detail
-
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_lvalue_reference,T,::boost::detail::is_lvalue_reference_impl<T>::value)
-
-#ifdef BOOST_MSVC
-# pragma warning(pop)
-#endif
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#include <boost/type_traits/config.hpp>
#include <boost/detail/workaround.hpp>
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
- && !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
//
// Note: we use the "workaround" version for MSVC because it works for
// __stdcall etc function types, where as the partial specialisation
#if defined( __CODEGEARC__ )
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_function_pointer,T,__is_member_function_pointer( T ))
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
+#elif !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
BOOST_TT_AUX_BOOL_TRAIT_DEF1(
is_member_function_pointer
{
};
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <typename T>
struct is_member_function_pointer_impl<T&> : public false_type{};
-#endif
#else // Borland C++
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_function_pointer,T,::boost::detail::is_member_function_pointer_impl<T>::value)
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#endif
} // namespace boost
#include <boost/type_traits/config.hpp>
#include <boost/detail/workaround.hpp>
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
# include <boost/type_traits/is_member_function_pointer.hpp>
#else
# include <boost/type_traits/is_reference.hpp>
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*,true)
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,::boost::is_member_function_pointer<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*,true)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*const volatile,true)
#endif
-#else // no partial template specialization
-
-namespace detail {
-
-template <typename R, typename T>
-::boost::type_traits::yes_type BOOST_TT_DECL is_member_pointer_tester(R T::*const volatile*);
-::boost::type_traits::no_type BOOST_TT_DECL is_member_pointer_tester(...);
-
-template <bool>
-struct is_member_pointer_select
- : public ::boost::type_traits::false_result
-{
-};
-
-template <>
-struct is_member_pointer_select<false>
-{
- template <typename T> struct result_
- {
- static T* make_t();
- BOOST_STATIC_CONSTANT(
- bool, value =
- (::boost::type_traits::ice_or<
- (1 == sizeof(::boost::type_traits::is_mem_fun_pointer_tester(make_t()))),
- (1 == sizeof(is_member_pointer_tester(make_t())))
- >::value) );
- };
-};
-
-template <typename T>
-struct is_member_pointer_impl
- : public is_member_pointer_select<
- ::boost::type_traits::ice_or<
- ::boost::is_reference<T>::value
- , ::boost::is_array<T>::value
- >::value
- >::template result_<T>
-{
-};
-
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void,false)
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void const,false)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void volatile,false)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void const volatile,false)
#endif
-} // namespace detail
-
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,::boost::detail::is_member_pointer_impl<T>::value)
-
-#endif // __BORLANDC__
-
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
namespace detail{
-#ifndef BOOST_NO_CXX11_NOEXCEPT
+#ifdef BOOST_IS_NOTHROW_MOVE_ASSIGN
+
+template <class T>
+struct is_nothrow_move_assignable_imp{ BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_NOTHROW_MOVE_ASSIGN(T)); };
+template <class T>
+struct is_nothrow_move_assignable_imp<T const>{ BOOST_STATIC_CONSTANT(bool, value = false); };
+template <class T>
+struct is_nothrow_move_assignable_imp<T volatile>{ BOOST_STATIC_CONSTANT(bool, value = false); };
+template <class T>
+struct is_nothrow_move_assignable_imp<T const volatile>{ BOOST_STATIC_CONSTANT(bool, value = false); };
+template <class T>
+struct is_nothrow_move_assignable_imp<T&>{ BOOST_STATIC_CONSTANT(bool, value = false); };
+template <class T>
+struct is_nothrow_move_assignable_imp<T&&>{ BOOST_STATIC_CONSTANT(bool, value = false); };
+
+
+#elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR)
template <class T, class Enable = void>
struct false_or_cpp11_noexcept_move_assignable: public ::boost::false_type {};
template <class T>
struct is_nothrow_move_assignable_imp{
- BOOST_STATIC_CONSTANT(bool, value = (
- ::boost::type_traits::ice_and<
- ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value,
- ::boost::type_traits::ice_not< ::boost::is_reference<T>::value >::value,
- ::boost::detail::false_or_cpp11_noexcept_move_assignable<T>::value
- >::value));
+ BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::false_or_cpp11_noexcept_move_assignable<T>::value);
};
+template <class T>
+struct is_nothrow_move_assignable_imp<T const> : public ::boost::false_type {};
+template <class T>
+struct is_nothrow_move_assignable_imp<T volatile> : public ::boost::false_type{};
+template <class T>
+struct is_nothrow_move_assignable_imp<T const volatile> : public ::boost::false_type{};
+template <class T>
+struct is_nothrow_move_assignable_imp<T&> : public ::boost::false_type{};
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <class T>
+struct is_nothrow_move_assignable_imp<T&&> : public ::boost::false_type{};
+#endif
+
#else
template <class T>
#define BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED
#include <boost/config.hpp>
+#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/has_trivial_move_constructor.hpp>
#include <boost/type_traits/has_nothrow_copy.hpp>
#include <boost/type_traits/is_array.hpp>
namespace detail{
-#ifndef BOOST_NO_CXX11_NOEXCEPT
+#ifdef BOOST_IS_NOTHROW_MOVE_CONSTRUCT
+
+template <class T>
+struct is_nothrow_move_constructible_imp{
+ BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_NOTHROW_MOVE_CONSTRUCT(T));
+};
+
+template <class T>
+struct is_nothrow_move_constructible_imp<volatile T> : public ::boost::false_type {};
+template <class T>
+struct is_nothrow_move_constructible_imp<const volatile T> : public ::boost::false_type{};
+template <class T>
+struct is_nothrow_move_constructible_imp<T&> : public ::boost::false_type{};
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <class T>
+struct is_nothrow_move_constructible_imp<T&&> : public ::boost::false_type{};
+#endif
+
+#elif !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_SFINAE_EXPR)
template <class T, class Enable = void>
struct false_or_cpp11_noexcept_move_constructible: public ::boost::false_type {};
template <class T>
struct is_nothrow_move_constructible_imp{
- BOOST_STATIC_CONSTANT(bool, value =
- (::boost::type_traits::ice_and<
- ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value,
- ::boost::type_traits::ice_not< ::boost::is_reference<T>::value >::value,
- ::boost::detail::false_or_cpp11_noexcept_move_constructible<T>::value
- >::value));
+ BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::false_or_cpp11_noexcept_move_constructible<T>::value);
};
+template <class T>
+struct is_nothrow_move_constructible_imp<volatile T> : public ::boost::false_type {};
+template <class T>
+struct is_nothrow_move_constructible_imp<const volatile T> : public ::boost::false_type{};
+template <class T>
+struct is_nothrow_move_constructible_imp<T&> : public ::boost::false_type{};
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <class T>
+struct is_nothrow_move_constructible_imp<T&&> : public ::boost::false_type{};
+#endif
+
#else
template <class T>
template <typename T>
struct is_object_impl
{
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value,
::boost::type_traits::ice_not< ::boost::is_void<T>::value>::value,
::boost::type_traits::ice_not< ::boost::is_function<T>::value>::value
>::value));
-#else
- BOOST_STATIC_CONSTANT(bool, value =
- (::boost::type_traits::ice_and<
- ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value,
- ::boost::type_traits::ice_not< ::boost::is_void<T>::value>::value
- >::value));
-#endif
};
} // namespace detail
namespace detail {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <typename T> struct is_pod_impl
{
};
#endif
-#else
-
-template <bool is_array = false>
-struct is_pod_helper
-{
- template <typename T> struct result_
- {
- BOOST_STATIC_CONSTANT(
- bool, value =
- (::boost::type_traits::ice_or<
- ::boost::is_scalar<T>::value,
- ::boost::is_void<T>::value,
- BOOST_INTERNAL_IS_POD(T)
- >::value));
- };
-};
-
-template <bool b>
-struct bool_to_yes_no_type
-{
- typedef ::boost::type_traits::no_type type;
-};
-
-template <>
-struct bool_to_yes_no_type<true>
-{
- typedef ::boost::type_traits::yes_type type;
-};
-
-template <typename ArrayType>
-struct is_pod_array_helper
-{
- enum { is_pod = ::boost::is_POD<ArrayType>::value }; // MSVC workaround
- typedef typename bool_to_yes_no_type<is_pod>::type type;
- type instance() const;
-};
-
-template <typename T>
-is_pod_array_helper<T> is_POD_array(T*);
-
-template <>
-struct is_pod_helper<true>
-{
- template <typename T> struct result_
- {
- static T& help();
- BOOST_STATIC_CONSTANT(bool, value =
- sizeof(is_POD_array(help()).instance()) == sizeof(::boost::type_traits::yes_type)
- );
- };
-};
-
-
-template <typename T> struct is_pod_impl
-{
- BOOST_STATIC_CONSTANT(
- bool, value = (
- ::boost::detail::is_pod_helper<
- ::boost::is_array<T>::value
- >::template result_<T>::value
- )
- );
-};
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
// the following help compilers without partial specialization support:
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void,true)
#include <boost/type_traits/detail/ice_and.hpp>
#include <boost/type_traits/detail/ice_not.hpp>
#include <boost/type_traits/config.hpp>
-#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#include <boost/type_traits/remove_cv.hpp>
-#endif
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/type_traits/is_array.hpp>
-# include <boost/type_traits/detail/is_function_ptr_tester.hpp>
-# include <boost/type_traits/detail/false_result.hpp>
-# include <boost/type_traits/detail/ice_or.hpp>
-#endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#if defined( __CODEGEARC__ )
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pointer,T,__is_pointer(T))
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
namespace detail {
template< typename T >
struct is_pointer_impl
{
-#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
- BOOST_STATIC_CONSTANT(bool, value =
- (::boost::type_traits::ice_and<
- ::boost::detail::is_pointer_helper<T>::value
- , ::boost::type_traits::ice_not<
- ::boost::is_member_pointer<T>::value
- >::value
- >::value)
- );
-#else
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value
>::value
>::value)
);
-#endif
};
} // namespace detail
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& const volatile,false)
#endif
-#else // no partial template specialization
-
-namespace detail {
-
-struct pointer_helper
-{
- pointer_helper(const volatile void*);
-};
-
-yes_type BOOST_TT_DECL is_pointer_tester(pointer_helper);
-no_type BOOST_TT_DECL is_pointer_tester(...);
-
-template <bool>
-struct is_pointer_select
- : public ::boost::type_traits::false_result
-{
-};
-
-template <>
-struct is_pointer_select<false>
-{
- template <typename T> struct result_
- {
- static T& make_t();
- BOOST_STATIC_CONSTANT(bool, value =
- (::boost::type_traits::ice_or<
- (1 == sizeof(is_pointer_tester(make_t()))),
- (1 == sizeof(type_traits::is_function_ptr_tester(make_t())))
- >::value));
- };
-};
-
-template <typename T>
-struct is_pointer_impl
- : public is_pointer_select<
- ::boost::type_traits::ice_or<
- ::boost::is_reference<T>::value
- , ::boost::is_array<T>::value
- >::value
- >::template result_<T>
-{
-};
-
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void,false)
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void const,false)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void volatile,false)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void const volatile,false)
#endif
-} // namespace detail
-
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pointer,T,::boost::detail::is_pointer_impl<T>::value)
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#include <boost/type_traits/detail/bool_trait_def.hpp>
#include <boost/detail/workaround.hpp>
+#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1700)
+#pragma warning(push)
+#pragma warning(disable:4250)
+#endif
+
namespace boost{
#ifndef BOOST_IS_POLYMORPHIC
#include <boost/type_traits/detail/bool_trait_undef.hpp>
+#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1700)
+#pragma warning(pop)
+#endif
+
#endif
#define BOOST_TT_IS_SAME_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/type_traits/detail/ice_and.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_same,T,U,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename T,is_same,T,T,true)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename T,is_same,T&,T&,true)
#endif
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-namespace detail {
-
-#ifdef BOOST_MSVC
-// the following VC6 specific implementation is *NOT* legal
-// C++, but has the advantage that it works for incomplete
-// types.
-
-template< typename T1 >
-struct is_same_part_1
-{
- template<typename T2> struct part_2 { enum { value = false }; };
- template<> struct part_2<T1> { enum { value = true }; };
-};
-
-template< typename T1, typename T2 >
-struct is_same_impl
-{
- enum { value = boost::detail::is_same_part_1<T1>::template part_2<T2>::value };
-};
-
-#else // generic "no-partial-specialization" version
-
-template <typename T>
-::boost::type_traits::yes_type
-BOOST_TT_DECL is_same_tester(T*, T*);
-
-::boost::type_traits::no_type
-BOOST_TT_DECL is_same_tester(...);
-
-template <typename T, typename U>
-struct is_same_impl
-{
- static T t;
- static U u;
-
- BOOST_STATIC_CONSTANT(bool, value =
- (::boost::type_traits::ice_and<
- (sizeof(type_traits::yes_type) == sizeof(boost::detail::is_same_tester(&t,&u))),
- (::boost::is_reference<T>::value == ::boost::is_reference<U>::value),
- (sizeof(T) == sizeof(U))
- >::value));
-};
-
-#endif // BOOST_MSVC
-
-} // namespace detail
-
-BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_same,T,U,(::boost::detail::is_same_impl<T,U>::value))
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
} // namespace boost
> selector;
typedef typename selector::template rebind<T> binder;
typedef typename binder::type type;
-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
- BOOST_STATIC_CONSTANT(bool, value = is_signed_imp<T>::type::value);
-#else
BOOST_STATIC_CONSTANT(bool, value = type::value);
-#endif
};
#else
, (::boost::detail::is_virtual_base_of_impl2<Base,Derived>::value)
)
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_virtual_base_of,Base&,Derived,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_virtual_base_of,Base,Derived&,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_virtual_base_of,Base&,Derived&,false)
-#endif
} // namespace boost
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
# include <boost/type_traits/detail/cv_traits_impl.hpp>
# if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
# include <boost/type_traits/remove_bounds.hpp>
# endif
-#else
-# include <boost/type_traits/is_reference.hpp>
-# include <boost/type_traits/is_array.hpp>
-# include <boost/type_traits/detail/yes_no_type.hpp>
-# include <boost/type_traits/detail/false_result.hpp>
-#endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<typename boost::remove_bounds<T>::type*>::is_volatile);
#else
- BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<T*>::is_volatile);
+ BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(T)>::is_volatile);
#endif
};
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
#if defined( __CODEGEARC__ )
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,__is_volatile(T))
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
//* is a type T declared volatile - is_volatile<T>
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::is_volatile_rval_filter<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& const volatile,false)
#endif
-#else
-
-namespace detail {
-
-using ::boost::type_traits::yes_type;
-using ::boost::type_traits::no_type;
-
-yes_type is_volatile_tester(void const volatile*);
-no_type is_volatile_tester(void const*);
-
-template <bool is_ref, bool array>
-struct is_volatile_helper
- : public ::boost::type_traits::false_result
-{
-};
-
-template <>
-struct is_volatile_helper<false,false>
-{
- template <typename T> struct result_
- {
- static T* t;
- BOOST_STATIC_CONSTANT(bool, value = (
- sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_volatile_tester(t))
- ));
- };
-};
-
-template <>
-struct is_volatile_helper<false,true>
-{
- template <typename T> struct result_
- {
- static T t;
- BOOST_STATIC_CONSTANT(bool, value = (
- sizeof(boost::detail::yes_type) == sizeof(boost::detail::is_volatile_tester(&t))
- ));
- };
-};
-
-template <typename T>
-struct is_volatile_impl
- : public is_volatile_helper<
- is_reference<T>::value
- , is_array<T>::value
- >::template result_<T>
-{
-};
-
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void,false)
-#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void const,false)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void volatile,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void const volatile,true)
#endif
-} // namespace detail
-
-//* is a type T declared volatile - is_volatile<T>
-BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::is_volatile_impl<T>::value)
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
{
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value));
-#if !BOOST_WORKAROUND(BOOST_MSVC, <=1300)
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_not< ::boost::is_same<
typename remove_cv<T>::type, bool>::value>::value));
-#endif
typedef typename remove_cv<T>::type t_no_cv;
typedef typename mpl::if_c<
{
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value));
-#if !BOOST_WORKAROUND(BOOST_MSVC, <=1300)
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_not< ::boost::is_same<
typename remove_cv<T>::type, bool>::value>::value));
-#endif
typedef typename remove_cv<T>::type t_no_cv;
typedef typename mpl::if_c<
+++ /dev/null
-// Copyright (C) 2004 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_ALL_EXTENT_HOLT_2004_0827
-#define BOOST_TYPE_TRAITS_MSVC_REMOVE_ALL_EXTENT_HOLT_2004_0827
-
-#include <boost/type_traits/msvc/typeof.hpp>
-#include <boost/type_traits/is_array.hpp>
-
-namespace boost {
- template<typename T>
- struct remove_all_extents;
-
- namespace detail {
- template<bool IsArray>
- struct remove_all_extents_impl_typeof {
- template<typename T,typename ID>
- struct inner {
- typedef T type;
- };
- };
- template<>
- struct remove_all_extents_impl_typeof<true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(U[]);
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type reduced_type;
- typedef typename remove_all_extents<reduced_type>::type type;
- };
- };
- } //namespace detail
-
- template<typename T>
- struct remove_all_extents {
- typedef typename boost::detail::remove_all_extents_impl_typeof<
- boost::is_array<T>::value
- >::template inner<T,remove_all_extents<T> >::type type;
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_all_extents,T)
- };
-} //namespace boost
-
-#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827
-
+++ /dev/null
-// Copyright (C) 2004 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827
-#define BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827
-
-#include <boost/type_traits/msvc/typeof.hpp>
-#include <boost/type_traits/is_array.hpp>
-
-namespace boost {
- namespace detail {
- template<bool IsArray>
- struct remove_bounds_impl_typeof {
- template<typename T,typename ID>
- struct inner {
- typedef T type;
- };
- };
- template<>
- struct remove_bounds_impl_typeof<true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(U[]);
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- };
- } //namespace detail
-
- template<typename T>
- struct remove_bounds {
- typedef typename boost::detail::remove_bounds_impl_typeof<
- boost::is_array<T>::value
- >::template inner<T,remove_bounds<T> >::type type;
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_bounds,T)
- };
-} //namespace boost
-
-#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827
-
+++ /dev/null
-// Copyright (C) 2004 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_CONST_HOLT_2004_0828
-#define BOOST_TYPE_TRAITS_MSVC_REMOVE_CONST_HOLT_2004_0828
-
-#include <boost/type_traits/msvc/typeof.hpp>
-#include <boost/type_traits/is_volatile.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_array.hpp>
-
-namespace boost {
- namespace detail {
- template<bool IsPointer,bool IsArray,bool IsConst,bool IsVolatile>
- struct remove_const_impl_typeof {
- template<typename T,typename ID>
- struct inner {
- typedef T type;
- };
- template<typename T>
- struct transform_type {
- typedef T type;
- };
- };
- template<> //Const
- struct remove_const_impl_typeof<false,false,true,false> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(U const&(*)());
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T& type;
- };
- };
- template<> //CV
- struct remove_const_impl_typeof<false,false,true,true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U volatile,ID> test(U const volatile&(*)());
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T& type;
- };
- };
- template<> //Const Pointer
- struct remove_const_impl_typeof<true,false,true,false> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(void(*)(U const[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type[];
- };
- };
- template<> //CV Pointer
- struct remove_const_impl_typeof<true,false,true,true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U volatile,ID> test(void(*)(U const volatile[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type[];
- };
- };
- template<> //Const Array
- struct remove_const_impl_typeof<false,true,true,false> {
- template<typename T,typename ID>
- struct inner {
- BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
-
- template<typename U>
- static msvc_register_type<U[value],ID> test(void(*)(U const[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type;
- };
- };
-
- template<> //CV Array
- struct remove_const_impl_typeof<false,true,true,true> {
- template<typename T,typename ID>
- struct inner {
- BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
-
- template<typename U>
- static msvc_register_type<U volatile[value],ID> test(void(*)(U const volatile[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type;
- };
- };
-
- } //namespace detail
-
- template<typename T>
- struct remove_const {
- typedef boost::detail::remove_const_impl_typeof<
- boost::is_pointer<T>::value,
- boost::is_array<T>::value,
- boost::is_const<T>::value,
- boost::is_volatile<T>::value
- > remove_const_type;
- typedef typename
- remove_const_type::template inner<
- typename remove_const_type::template transform_type<T>::type,
- remove_const<T>
- >::type
- type;
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_const,T)
- };
-}//namespace boost
-
-#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_CONST_HOLT_2004_0828
+++ /dev/null
-// Copyright (C) 2004 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_CV_HOLT_2004_0901
-#define BOOST_TYPE_TRAITS_MSVC_REMOVE_CV_HOLT_2004_0901
-
-#include <boost/type_traits/msvc/typeof.hpp>
-#include <boost/type_traits/is_volatile.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_array.hpp>
-
-namespace boost {
- namespace detail {
- template<bool IsPointer,bool IsArray,bool IsConst,bool IsVolatile>
- struct remove_cv_impl_typeof {
- template<typename T,typename ID>
- struct inner {
- typedef T type;
- };
- template<typename T>
- struct transform_type {
- typedef T type;
- };
- };
- template<> //Volatile
- struct remove_cv_impl_typeof<false,false,false,true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(U volatile&(*)());
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T& type;
- };
- };
- template<> //Const
- struct remove_cv_impl_typeof<false,false,true,false> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(U const&(*)());
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T& type;
- };
- };
- template<> //CV
- struct remove_cv_impl_typeof<false,false,true,true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(U const volatile&(*)());
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T& type;
- };
- };
- template<> //Volatile Pointer
- struct remove_cv_impl_typeof<true,false,false,true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(void(*)(U volatile[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type[];
- };
- };
- template<> //Const Pointer
- struct remove_cv_impl_typeof<true,false,true,false> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(void(*)(U const[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type[];
- };
- };
- template<> //CV Pointer
- struct remove_cv_impl_typeof<true,false,true,true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(void(*)(U const volatile[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type[];
- };
- };
- template<> //Volatile Array
- struct remove_cv_impl_typeof<false,true,false,true> {
- template<typename T,typename ID>
- struct inner {
- BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
-
- template<typename U>
- static msvc_register_type<U[value],ID> test(void(*)(U volatile[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type;
- };
- };
- template<> //Const Array
- struct remove_cv_impl_typeof<false,true,true,false> {
- template<typename T,typename ID>
- struct inner {
- BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
-
- template<typename U>
- static msvc_register_type<U[value],ID> test(void(*)(U const[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type;
- };
- };
-
- template<> //CV Array
- struct remove_cv_impl_typeof<false,true,true,true> {
- template<typename T,typename ID>
- struct inner {
- BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
-
- template<typename U>
- static msvc_register_type<U[value],ID> test(void(*)(U const volatile[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type;
- };
- };
-
- } //namespace detail
-
- template<typename T>
- struct remove_cv {
- typedef boost::detail::remove_cv_impl_typeof<
- boost::is_pointer<T>::value,
- boost::is_array<T>::value,
- boost::is_const<T>::value,
- boost::is_volatile<T>::value
- > remove_cv_type;
- typedef typename
- remove_cv_type::template inner<
- typename remove_cv_type::template transform_type<T>::type,
- remove_cv<T>
- >::type
- type;
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_cv,T)
- };
-}//namespace boost
-
-#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_CV_HOLT_2004_0901
+++ /dev/null
-// Copyright (C) 2004 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_EXTENT_HOLT_2004_0827
-#define BOOST_TYPE_TRAITS_MSVC_REMOVE_EXTENT_HOLT_2004_0827
-
-#include <boost/type_traits/msvc/typeof.hpp>
-#include <boost/type_traits/is_array.hpp>
-
-namespace boost {
- namespace detail {
- template<bool IsArray>
- struct remove_extent_impl_typeof {
- template<typename T,typename ID>
- struct inner {
- typedef T type;
- };
- };
- template<>
- struct remove_extent_impl_typeof<true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(U[]);
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- };
- } //namespace detail
-
- template<typename T>
- struct remove_extent {
- typedef typename boost::detail::remove_extent_impl_typeof<
- boost::is_array<T>::value
- >::template inner<T,remove_extent<T> >::type type;
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_extent,T)
- };
-} //namespace boost
-
-#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827
-
+++ /dev/null
-// Copyright (C) 2004 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_POINTER_HOLT_2004_0827
-#define BOOST_TYPE_TRAITS_MSVC_REMOVE_POINTER_HOLT_2004_0827
-
-#include <boost/type_traits/msvc/typeof.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-
-namespace boost {
- namespace detail {
- template<int IsPointer>
- struct remove_pointer_impl_typeof {
- template<typename T,typename ID>
- struct inner {
- typedef T type;
- };
- };
- template<>
- struct remove_pointer_impl_typeof<true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(U*);
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- };
- } //namespace detail
-
- template<typename T>
- struct remove_pointer {
- typedef typename boost::detail::remove_pointer_impl_typeof<
- boost::is_pointer<T>::value
- >::template inner<T,remove_pointer<T> >::type type;
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_pointer,T)
- };
-} //namespace boost
-
-#endif //BOOST_TYPE_TRAITS_REMOVE_POINTER_HOLT_2004_0827
+++ /dev/null
-// Copyright (C) 2004 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_REFERENCE_HOLT_2004_0827
-#define BOOST_TYPE_TRAITS_MSVC_REMOVE_REFERENCE_HOLT_2004_0827
-
-#include <boost/type_traits/msvc/typeof.hpp>
-#include <boost/type_traits/is_reference.hpp>
-
-namespace boost {
- namespace detail {
- template<bool IsReference>
- struct remove_reference_impl_typeof {
- template<typename T,typename ID>
- struct inner {
- typedef T type;
- };
- };
- template<>
- struct remove_reference_impl_typeof<true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(U&(*)());
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- };
- } //namespace detail
-
- template<typename T>
- struct remove_reference {
- typedef typename boost::detail::remove_reference_impl_typeof<
- boost::is_reference<T>::value
- >::template inner<T,remove_reference<T> >::type type;
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_reference,T)
- };
-} //namespace boost
-
-#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_REFERENCE_HOLT_2004_0827
+++ /dev/null
-// Copyright (C) 2004 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_VOLATILE_HOLT_2004_0828
-#define BOOST_TYPE_TRAITS_MSVC_REMOVE_VOLATILE_HOLT_2004_0828
-
-#include <boost/type_traits/msvc/typeof.hpp>
-#include <boost/type_traits/is_volatile.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_array.hpp>
-
-namespace boost {
- namespace detail {
- template<bool IsPointer,bool IsArray,bool IsConst,bool IsVolatile>
- struct remove_volatile_impl_typeof {
- template<typename T,typename ID>
- struct inner {
- typedef T type;
- };
- template<typename T>
- struct transform_type {
- typedef T type;
- };
- };
- template<> //Volatile
- struct remove_volatile_impl_typeof<false,false,false,true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(U volatile&(*)());
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T& type;
- };
- };
- template<> //CV
- struct remove_volatile_impl_typeof<false,false,true,true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U const,ID> test(U const volatile&(*)());
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T& type;
- };
- };
- template<> //Volatile Pointer
- struct remove_volatile_impl_typeof<true,false,false,true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U,ID> test(void(*)(U volatile[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type[];
- };
- };
- template<> //CV Pointer
- struct remove_volatile_impl_typeof<true,false,true,true> {
- template<typename T,typename ID>
- struct inner {
- template<typename U>
- static msvc_register_type<U const,ID> test(void(*)(U const volatile[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type[];
- };
- };
- template<> //Volatile Array
- struct remove_volatile_impl_typeof<false,true,false,true> {
- template<typename T,typename ID>
- struct inner {
- BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
-
- template<typename U>
- static msvc_register_type<U[value],ID> test(void(*)(U volatile[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type;
- };
- };
-
- template<> //CV Array
- struct remove_volatile_impl_typeof<false,true,true,true> {
- template<typename T,typename ID>
- struct inner {
- BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
-
- template<typename U>
- static msvc_register_type<U const[value],ID> test(void(*)(U const volatile[]));
- static msvc_register_type<T,ID> test(...);
- BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
- typedef typename msvc_extract_type<ID>::id2type::type type;
- };
- template<typename T>
- struct transform_type {
- typedef T type;
- };
- };
-
- } //namespace detail
-
- template<typename T>
- struct remove_volatile {
- typedef boost::detail::remove_volatile_impl_typeof<
- boost::is_pointer<T>::value,
- boost::is_array<T>::value,
- boost::is_const<T>::value,
- boost::is_volatile<T>::value
- > remove_volatile_type;
- typedef typename
- remove_volatile_type::template inner<
- typename remove_volatile_type::template transform_type<T>::type,
- remove_volatile<T>
- >::type
- type;
- BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_volatile,T)
- };
-}//namespace boost
-
-#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_VOLATILE_HOLT_2004_0828
+++ /dev/null
-// Copyright (C) 2004 Peder Holt
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPETRAITS_MSVC_TYPEOF_HPP
-#define BOOST_TYPETRAITS_MSVC_TYPEOF_HPP
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-namespace boost { namespace detail {
-# if BOOST_WORKAROUND(BOOST_MSVC,==1300)
- template<typename ID>
- struct msvc_extract_type
- {
- template<bool>
- struct id2type_impl;
-
- typedef id2type_impl<true> id2type;
- };
-
- template<typename T, typename ID>
- struct msvc_register_type : public msvc_extract_type<ID>
- {
- template<>
- struct id2type_impl<true> //VC7.0 specific bugfeature
- {
- typedef T type;
- };
- };
-# else
- template<typename ID>
- struct msvc_extract_type
- {
- struct id2type;
- };
-
- template<typename T, typename ID>
- struct msvc_register_type : public msvc_extract_type<ID>
- {
- typedef msvc_extract_type<ID> base_type;
- struct base_type::id2type // This uses nice VC6.5 and VC7.1 bugfeature
- {
- typedef T type;
- };
- };
-# endif
-}}
-
-#endif //BOOST_TYPETRAITS_MSVC_TYPEOF_IMPL_HPP
{
BOOST_STATIC_CONSTANT(std::size_t, value = N);
};
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
template <class T, std::size_t R, std::size_t N>
struct rank_imp<T[R], N>
{
#include <cstddef>
#include <boost/detail/workaround.hpp>
-#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-#include <boost/type_traits/msvc/remove_all_extents.hpp>
-#endif
-
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
-#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-
namespace boost {
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_all_extents,T,T)
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_all_extents,T[N],typename boost::remove_all_extents<T>::type type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_all_extents,T const[N],typename boost::remove_all_extents<T const>::type type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_all_extents,T volatile[N],typename boost::remove_all_extents<T volatile>::type type)
} // namespace boost
-#endif
-
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED
#include <cstddef>
#include <boost/detail/workaround.hpp>
-#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-#include <boost/type_traits/msvc/remove_bounds.hpp>
-#endif
-
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
-#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-
namespace boost {
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_bounds,T,T)
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T[N],T type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T const[N],T const type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T volatile[N],T volatile type)
} // namespace boost
-#endif
-
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED
#define BOOST_TT_REMOVE_CONST_HPP_INCLUDED
#include <boost/type_traits/is_volatile.hpp>
-#include <boost/type_traits/broken_compiler_spec.hpp>
#include <boost/type_traits/detail/cv_traits_impl.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <cstddef>
-#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-#include <boost/type_traits/msvc/remove_const.hpp>
-#endif
-
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
namespace detail {
struct remove_const_impl
{
typedef typename remove_const_helper<
- typename cv_traits_imp<T*>::unqualified_type
+ typename cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(T)>::unqualified_type
, ::boost::is_volatile<T>::value
>::type type;
};
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_const,T const volatile[N],T volatile type[N])
#endif
-#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-
-BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_const,T,typename boost::detail::remove_const_impl<T>::type)
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
} // namespace boost
#ifndef BOOST_TT_REMOVE_CV_HPP_INCLUDED
#define BOOST_TT_REMOVE_CV_HPP_INCLUDED
-#include <boost/type_traits/broken_compiler_spec.hpp>
#include <boost/type_traits/detail/cv_traits_impl.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <cstddef>
-#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-#include <boost/type_traits/msvc/remove_cv.hpp>
-#endif
-
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
namespace detail{
template <class T>
struct rvalue_ref_filter_rem_cv
{
- typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type;
+ typedef typename boost::detail::cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(T)>::unqualified_type type;
};
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T const volatile[N],T type[N])
#endif
-#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-
-namespace detail {
-template <typename T>
-struct remove_cv_impl
-{
- typedef typename remove_volatile_impl<
- typename remove_const_impl<T>::type
- >::type type;
-};
-}
-
-BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_cv,T,typename boost::detail::remove_cv_impl<T>::type)
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
} // namespace boost
#include <boost/detail/workaround.hpp>
#include <cstddef>
-#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-#include <boost/type_traits/msvc/remove_extent.hpp>
-#endif
-
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
-#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-
namespace boost {
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_extent,T,T)
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_extent,T[N],T type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_extent,T const[N],T const type)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_extent,T volatile[N],T volatile type)
} // namespace boost
-#endif
-
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/type_traits/broken_compiler_spec.hpp>
-#endif
-#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-#include <boost/type_traits/msvc/remove_pointer.hpp>
-#elif defined(BOOST_MSVC)
+#if defined(BOOST_MSVC)
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/is_pointer.hpp>
#endif
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,typename boost::detail::remove_pointer_imp2<T>::type)
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,T)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T*,T)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* volatile,T)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* const volatile,T)
-#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-
-BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,typename boost::detail::remove_pointer_impl<T>::type)
-
#endif
} // namespace boost
#ifndef BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED
#define BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED
-#include <boost/type_traits/broken_compiler_spec.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
-#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-#include <boost/type_traits/msvc/remove_reference.hpp>
-#endif
-
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
namespace detail{
//
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& const volatile,T)
#endif
-#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-
-BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,typename boost::detail::remove_reference_impl<T>::type)
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
} // namespace boost
#define BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED
#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/broken_compiler_spec.hpp>
#include <boost/type_traits/detail/cv_traits_impl.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <cstddef>
-#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-#include <boost/type_traits/msvc/remove_volatile.hpp>
-#endif
-
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
namespace detail {
struct remove_volatile_impl
{
typedef typename remove_volatile_helper<
- typename cv_traits_imp<T*>::unqualified_type
+ typename cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(T)>::unqualified_type
, ::boost::is_const<T>::value
>::type type;
};
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_volatile,T const volatile[N],T const type[N])
#endif
-#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
-
-BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_volatile,T,typename boost::detail::remove_volatile_impl<T>::type)
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
} // namespace boost
// This template gets instantiated a lot, so use partial
// specialization when available to reduce the compiler burden.
//
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <bool found = true>
-struct lower_alignment_helper_impl
-{
- template <std::size_t, class>
- struct apply
- {
- typedef char type;
- enum { value = true };
- };
-};
-
-template <>
-struct lower_alignment_helper_impl<false>
-{
- template <std::size_t target, class TestType>
- struct apply
- : public mpl::if_c<(alignment_of<TestType>::value == target), TestType, char>
- {
- enum { value = (alignment_of<TestType>::value == target) };
- };
-};
-
-template <bool found, std::size_t target, class TestType>
-struct lower_alignment_helper
- : public lower_alignment_helper_impl<found>::template apply<target,TestType>
-{
-};
-#else
template <bool found, std::size_t target, class TestType>
struct lower_alignment_helper
{
enum { value = (alignment_of<TestType>::value == target) };
typedef typename mpl::if_c<value, TestType, char>::type type;
};
-#endif
#define BOOST_TT_CHOOSE_MIN_ALIGNMENT(R,P,I,T) \
typename lower_alignment_helper< \
);
};
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::max_align,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<1> ,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<2> ,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<4> ,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<8> ,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<10> ,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<16> ,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<32> ,true)
-#endif
} // namespace detail
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template<std::size_t Align>
struct is_pod< ::boost::detail::lower_alignment<Align> >
{
BOOST_STATIC_CONSTANT(std::size_t, value = true);
};
-#endif
// This alignment method originally due to Brian Parker, implemented by David
// Abrahams, and then ported here by Doug Gregor.
{
};
-#if defined(__GNUC__)
-namespace align {
+#if defined(__GNUC__) || (defined (__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130))
+namespace tt_align_ns {
struct __attribute__((__aligned__(2))) a2 {};
struct __attribute__((__aligned__(4))) a4 {};
struct __attribute__((__aligned__(8))) a8 {};
}
template<> class type_with_alignment<1> { public: typedef char type; };
-template<> class type_with_alignment<2> { public: typedef align::a2 type; };
-template<> class type_with_alignment<4> { public: typedef align::a4 type; };
-template<> class type_with_alignment<8> { public: typedef align::a8 type; };
-template<> class type_with_alignment<16> { public: typedef align::a16 type; };
-template<> class type_with_alignment<32> { public: typedef align::a32 type; };
-template<> class type_with_alignment<64> { public: typedef align::a64 type; };
-template<> class type_with_alignment<128> { public: typedef align::a128 type; };
+template<> class type_with_alignment<2> { public: typedef tt_align_ns::a2 type; };
+template<> class type_with_alignment<4> { public: typedef tt_align_ns::a4 type; };
+template<> class type_with_alignment<8> { public: typedef tt_align_ns::a8 type; };
+template<> class type_with_alignment<16> { public: typedef tt_align_ns::a16 type; };
+template<> class type_with_alignment<32> { public: typedef tt_align_ns::a32 type; };
+template<> class type_with_alignment<64> { public: typedef tt_align_ns::a64 type; };
+template<> class type_with_alignment<128> { public: typedef tt_align_ns::a128 type; };
namespace detail {
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a2,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a4,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a8,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a16,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a32,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a64,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a128,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a2,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a4,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a8,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a16,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a32,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a64,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a128,true)
}
#endif
-#if (defined(BOOST_MSVC) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && _MSC_VER >= 1300
+#if defined(BOOST_MSVC) || (defined(BOOST_INTEL) && defined(_MSC_VER))
//
// MSVC supports types which have alignments greater than the normal
// maximum: these are used for example in the types __m64 and __m128
// Boost.Optional). However, this only happens when we have no choice
// in the matter because no other "ordinary" type is available.
//
-namespace align {
+namespace tt_align_ns {
struct __declspec(align(8)) a8 {
char m[8];
typedef a8 type;
{
typedef mpl::if_c<
::boost::alignment_of<boost::detail::max_align>::value < 8,
- align::a8,
+ tt_align_ns::a8,
boost::detail::type_with_alignment_imp<8> >::type t1;
public:
typedef t1::type type;
{
typedef mpl::if_c<
::boost::alignment_of<boost::detail::max_align>::value < 16,
- align::a16,
+ tt_align_ns::a16,
boost::detail::type_with_alignment_imp<16> >::type t1;
public:
typedef t1::type type;
{
typedef mpl::if_c<
::boost::alignment_of<boost::detail::max_align>::value < 32,
- align::a32,
+ tt_align_ns::a32,
boost::detail::type_with_alignment_imp<32> >::type t1;
public:
typedef t1::type type;
template<> class type_with_alignment<64> {
typedef mpl::if_c<
::boost::alignment_of<boost::detail::max_align>::value < 64,
- align::a64,
+ tt_align_ns::a64,
boost::detail::type_with_alignment_imp<64> >::type t1;
public:
typedef t1::type type;
template<> class type_with_alignment<128> {
typedef mpl::if_c<
::boost::alignment_of<boost::detail::max_align>::value < 128,
- align::a128,
+ tt_align_ns::a128,
boost::detail::type_with_alignment_imp<128> >::type t1;
public:
typedef t1::type type;
};
namespace detail {
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a8,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a16,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a32,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a64,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a128,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a8,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a16,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a32,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a64,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a128,true)
}
#endif
// 2) Because of Borlands #pragma option we can create types with alignments that are
// greater that the largest aligned builtin type.
-namespace align{
+namespace tt_align_ns{
#pragma option push -a16
struct a2{ short s; };
struct a4{ int s; };
namespace detail {
-typedef ::boost::align::a16 max_align;
+typedef ::boost::tt_align_ns::a16 max_align;
//#if ! BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a2,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a4,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a8,true)
-BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a16,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a2,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a4,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a8,true)
+BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::tt_align_ns::a16,true)
//#endif
}
// We should never get to here, but if we do use the maximally
// aligned type:
// BOOST_STATIC_ASSERT(0);
- typedef align::a16 type;
+ typedef tt_align_ns::a16 type;
};
template <> struct type_with_alignment<1>{ typedef char type; };
-template <> struct type_with_alignment<2>{ typedef align::a2 type; };
-template <> struct type_with_alignment<4>{ typedef align::a4 type; };
-template <> struct type_with_alignment<8>{ typedef align::a8 type; };
-template <> struct type_with_alignment<16>{ typedef align::a16 type; };
+template <> struct type_with_alignment<2>{ typedef tt_align_ns::a2 type; };
+template <> struct type_with_alignment<4>{ typedef tt_align_ns::a4 type; };
+template <> struct type_with_alignment<8>{ typedef tt_align_ns::a8 type; };
+template <> struct type_with_alignment<16>{ typedef tt_align_ns::a16 type; };
#endif
-// Copyright (C) 2002 Brad King (brad.king@kitware.com)
-// Douglas Gregor (gregod@cs.rpi.edu)
-//
-// Copyright (C) 2002, 2008 Peter Dimov
-//
-// 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)
-
-// For more information, see http://www.boost.org
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * 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)
+ */
#ifndef BOOST_UTILITY_ADDRESSOF_HPP
-# define BOOST_UTILITY_ADDRESSOF_HPP
-
-# include <boost/config.hpp>
-# include <boost/detail/workaround.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-template<class T> struct addr_impl_ref
-{
- T & v_;
-
- inline addr_impl_ref( T & v ): v_( v ) {}
- inline operator T& () const { return v_; }
-
-private:
- addr_impl_ref & operator=(const addr_impl_ref &);
-};
-
-template<class T> struct addressof_impl
-{
- static inline T * f( T & v, long )
- {
- return reinterpret_cast<T*>(
- &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
- }
-
- static inline T * f( T * v, int )
- {
- return v;
- }
-};
-
-} // namespace detail
-
-template<class T> T * addressof( T & v )
-{
-#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || defined( __SUNPRO_CC )
-
- return boost::detail::addressof_impl<T>::f( v, 0 );
+#define BOOST_UTILITY_ADDRESSOF_HPP
-#else
+// The header file at this path is deprecated;
+// use boost/core/addressof.hpp instead.
- return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
+#include <boost/core/addressof.hpp>
#endif
-}
-
-#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
-
-namespace detail
-{
-
-template<class T> struct addressof_addp
-{
- typedef T * type;
-};
-
-} // namespace detail
-
-template< class T, std::size_t N >
-typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
-{
- return &t;
-}
-
-#endif
-
-// Borland doesn't like casting an array reference to a char reference
-// but these overloads work around the problem.
-#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-template<typename T,std::size_t N>
-T (*addressof(T (&t)[N]))[N]
-{
- return reinterpret_cast<T(*)[N]>(&t);
-}
-
-template<typename T,std::size_t N>
-const T (*addressof(const T (&t)[N]))[N]
-{
- return reinterpret_cast<const T(*)[N]>(&t);
-}
-#endif
-
-} // namespace boost
-
-#endif // BOOST_UTILITY_ADDRESSOF_HPP
}; // boost::base_from_member
+template < typename MemberType, int UniqueID >
+class base_from_member<MemberType&, UniqueID>
+{
+protected:
+ MemberType& member;
+
+ explicit BOOST_CONSTEXPR base_from_member( MemberType& x )
+ BOOST_NOEXCEPT
+ : member( x )
+ {}
+
+}; // boost::base_from_member
+
} // namespace boost
-// Boost enable_if library
-
-// Copyright 2003 (c) The Trustees of Indiana University.
-
-// Use, modification, and distribution is subject to 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)
-
-// Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
-// Jeremiah Willcock (jewillco at osl.iu.edu)
-// Andrew Lumsdaine (lums at osl.iu.edu)
-
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * 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)
+ */
#ifndef BOOST_UTILITY_ENABLE_IF_HPP
#define BOOST_UTILITY_ENABLE_IF_HPP
-#include "boost/config.hpp"
-
-// Even the definition of enable_if causes problems on some compilers,
-// so it's macroed out for all compilers that do not support SFINAE
-
-#ifndef BOOST_NO_SFINAE
-
-namespace boost
-{
-
- template <bool B, class T = void>
- struct enable_if_c {
- typedef T type;
- };
-
- template <class T>
- struct enable_if_c<false, T> {};
-
- template <class Cond, class T = void>
- struct enable_if : public enable_if_c<Cond::value, T> {};
-
- template <bool B, class T>
- struct lazy_enable_if_c {
- typedef typename T::type type;
- };
-
- template <class T>
- struct lazy_enable_if_c<false, T> {};
-
- template <class Cond, class T>
- struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
-
-
- template <bool B, class T = void>
- struct disable_if_c {
- typedef T type;
- };
-
- template <class T>
- struct disable_if_c<true, T> {};
-
- template <class Cond, class T = void>
- struct disable_if : public disable_if_c<Cond::value, T> {};
-
- template <bool B, class T>
- struct lazy_disable_if_c {
- typedef typename T::type type;
- };
-
- template <class T>
- struct lazy_disable_if_c<true, T> {};
-
- template <class Cond, class T>
- struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
-
-} // namespace boost
-
-#else
-
-namespace boost {
-
- namespace detail { typedef void enable_if_default_T; }
-
- template <typename T>
- struct enable_if_does_not_work_on_this_compiler;
-
- template <bool B, class T = detail::enable_if_default_T>
- struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
- { };
-
- template <bool B, class T = detail::enable_if_default_T>
- struct disable_if_c : enable_if_does_not_work_on_this_compiler<T>
- { };
-
- template <bool B, class T = detail::enable_if_default_T>
- struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler<T>
- { };
-
- template <bool B, class T = detail::enable_if_default_T>
- struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler<T>
- { };
-
- template <class Cond, class T = detail::enable_if_default_T>
- struct enable_if : enable_if_does_not_work_on_this_compiler<T>
- { };
-
- template <class Cond, class T = detail::enable_if_default_T>
- struct disable_if : enable_if_does_not_work_on_this_compiler<T>
- { };
-
- template <class Cond, class T = detail::enable_if_default_T>
- struct lazy_enable_if : enable_if_does_not_work_on_this_compiler<T>
- { };
-
- template <class Cond, class T = detail::enable_if_default_T>
- struct lazy_disable_if : enable_if_does_not_work_on_this_compiler<T>
- { };
-
-} // namespace boost
+// The header file at this path is deprecated;
+// use boost/core/enable_if.hpp instead.
-#endif // BOOST_NO_SFINAE
+#include <boost/core/enable_if.hpp>
#endif
{}
template<class T>
- void* apply(void* address
- BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const
+ void* apply(void* address) const
{
return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
}
template<class T>
- void* apply(void* address, std::size_t n
- BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T)) const
+ void* apply(void* address, std::size_t n) const
{
for(char* next = address = this->BOOST_NESTED_TEMPLATE apply<T>(address);
!! --n;)
-// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
-//
-// 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)
-// For more information, see http://www.boost.org
-
+/*
+ * Copyright (c) 2014 Glen Fernandes
+ *
+ * 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)
+ */
#ifndef BOOST_UTILITY_SWAP_HPP
#define BOOST_UTILITY_SWAP_HPP
-// Note: the implementation of this utility contains various workarounds:
-// - swap_impl is put outside the boost namespace, to avoid infinite
-// recursion (causing stack overflow) when swapping objects of a primitive
-// type.
-// - swap_impl has a using-directive, rather than a using-declaration,
-// because some compilers (including MSVC 7.1, Borland 5.9.3, and
-// Intel 8.1) don't do argument-dependent lookup when it has a
-// using-declaration instead.
-// - boost::swap has two template arguments, instead of one, to
-// avoid ambiguity when swapping objects of a Boost type that does
-// not have its own boost::swap overload.
-
-#include <algorithm> //for std::swap
-#include <cstddef> //for std::size_t
-
-namespace boost_swap_impl
-{
- template<class T>
- void swap_impl(T& left, T& right)
- {
- using namespace std;//use std::swap if argument dependent lookup fails
- swap(left,right);
- }
-
- template<class T, std::size_t N>
- void swap_impl(T (& left)[N], T (& right)[N])
- {
- for (std::size_t i = 0; i < N; ++i)
- {
- ::boost_swap_impl::swap_impl(left[i], right[i]);
- }
- }
-}
+// The header file at this path is deprecated;
+// use boost/core/swap.hpp instead.
-namespace boost
-{
- template<class T1, class T2>
- void swap(T1& left, T2& right)
- {
- ::boost_swap_impl::swap_impl(left, right);
- }
-}
+#include <boost/core/swap.hpp>
#endif
#define BOOST_VERSION_HPP
//
-// Caution, this is the only boost header that is guarenteed
-// to change with every boost release, including this header
-// will cause a recompile every time a new boost version is
-// released.
+// Caution: this is the only Boost header that is guaranteed
+// to change with every Boost release. Including this header
+// will cause a recompile every time a new Boost version is
+// used.
//
// BOOST_VERSION % 100 is the patch level
// BOOST_VERSION / 100 % 1000 is the minor version
// BOOST_VERSION / 100000 is the major version
-#define BOOST_VERSION 105500
+#define BOOST_VERSION 105800
//
// BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION
// number, y is the minor version number, and z is the patch level if not 0.
// This is used by <config/auto_link.hpp> to select which library version to link to.
-#define BOOST_LIB_VERSION "1_55"
+#define BOOST_LIB_VERSION "1_58"
#endif
#ifndef BOOST_VISIT_EACH_HPP
#define BOOST_VISIT_EACH_HPP
-#include <boost/config.hpp>
-
namespace boost {
template<typename Visitor, typename T>
inline void visit_each(Visitor& visitor, const T& t, long)
std::string src(p1, p2);
while(s < (r = std::strxfrm(&*result.begin(), src.c_str(), s)))
{
+#if defined(_CPPLIB_VER)
+ //
+ // A bug in VC11 and 12 causes the program to hang if we pass a null-string
+ // to std::strxfrm, but only for certain locales :-(
+ // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).
+ //
+ if(r == INT_MAX)
+ {
+ result.erase();
+ result.insert(result.begin(), static_cast<char>(0));
+ return result;
+ }
+#endif
result.append(r - s + 3, ' ');
s = result.size();
}
read_size = std::fread(*node + sizeof(int), _size % buf_size, 1, hfile);
else
read_size = std::fread(*node + sizeof(int), buf_size, 1, hfile);
-#ifndef BOOST_NO_EXCEPTIONS
if((read_size == 0) || (std::ferror(hfile)))
{
+#ifndef BOOST_NO_EXCEPTIONS
+ unlock(node);
throw std::runtime_error("Unable to read file.");
- }
#else
- BOOST_REGEX_NOEH_ASSERT((0 == std::ferror(hfile)) && (read_size != 0));
+ BOOST_REGEX_NOEH_ASSERT((0 == std::ferror(hfile)) && (read_size != 0));
#endif
+ }
}
else
{
#endif
expression->re_magic = magic_value;
static_cast<c_regex_type*>(expression->guts)->set_expression(ptr, p2, flags);
- expression->re_nsub = static_cast<c_regex_type*>(expression->guts)->mark_count() - 1;
+ expression->re_nsub = static_cast<c_regex_type*>(expression->guts)->mark_count();
result = static_cast<c_regex_type*>(expression->guts)->error_code();
#ifndef BOOST_NO_EXCEPTIONS
}
#define BOOST_REGEX_SOURCE
#include <boost/config.hpp>
+#include <boost/assert.hpp>
#ifdef BOOST_HAS_THREADS
{
if(0 == m_have_lock)
{
- pthread_mutex_lock(&(m_mutex.m_mutex));
- m_have_lock = true;
+ // Client code will throw if this fails:
+ m_have_lock = (pthread_mutex_lock(&(m_mutex.m_mutex)) == 0);
}
}
{
if(m_have_lock)
{
- pthread_mutex_unlock(&(m_mutex.m_mutex));
+ // If this fails there's nothing we can do except assert,
+ // exceptions are out of the question as this code is called
+ // from the lock's destructor:
+ BOOST_VERIFY(pthread_mutex_unlock(&(m_mutex.m_mutex)) == 0);
m_have_lock = false;
}
}
{
boost::call_once(static_mutex::m_once,&static_mutex::init);
if(0 == m_plock)
- m_plock = new boost::recursive_mutex::scoped_lock(*static_mutex::m_pmutex, boost::defer_lock);
+ m_plock = new boost::unique_lock<boost::recursive_mutex>(*static_mutex::m_pmutex, boost::defer_lock);
m_plock->lock();
m_have_lock = true;
}
std::wstring result(s, L' ');
while(s < (r = std::wcsxfrm(&*result.begin(), src.c_str(), s)))
{
+#if defined(_CPPLIB_VER)
+ //
+ // A bug in VC11 and 12 causes the program to hang if we pass a null-string
+ // to std::strxfrm, but only for certain locales :-(
+ // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).
+ //
+ if(r == INT_MAX)
+ {
+ result.erase();
+ result.insert(result.begin(), static_cast<wchar_t>(0));
+ return result;
+ }
+#endif
result.append(r - s + 3, L' ');
s = result.size();
}
#endif
expression->re_magic = wmagic_value;
static_cast<wc_regex_type*>(expression->guts)->set_expression(ptr, p2, flags);
- expression->re_nsub = static_cast<wc_regex_type*>(expression->guts)->mark_count() - 1;
+ expression->re_nsub = static_cast<wc_regex_type*>(expression->guts)->mark_count();
result = static_cast<wc_regex_type*>(expression->guts)->error_code();
#ifndef BOOST_NO_EXCEPTIONS
}
typedef slot_container_type::const_iterator const_group_iterator;
-#if BOOST_WORKAROUND(_MSC_VER, <= 1700)
+#if BOOST_WORKAROUND(_MSC_VER, <= 1900)
void named_slot_map_iterator::decrement() { assert(false); }
void named_slot_map_iterator::advance(difference_type) { assert(false); }
#endif