-// (see libs/utility/compressed_pair.htm)

-#if defined(_MSC_VER) && (_MSC_VER >= 1020) && \

-#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)

-

- template <class charT> struct string_char_traits;

-#else

-#endif

-// Copyright 2005 Caleb Epstein

-// Copyright 2006 John Maddock

-// Copyright 2010 Rene Rivera

-/*

- * Copyright (c) 1997

- * Silicon Graphics Computer Systems, Inc.

- *

- * Permission to use, copy, modify, distribute and sell this software

- * and its documentation for any purpose is hereby granted without fee,

- * provided that the above copyright notice appear in all copies and

- * that both that copyright notice and this permission notice appear

- * in supporting documentation. Silicon Graphics makes no

- * representations about the suitability of this software for any

- * purpose. It is provided "as is" without express or implied warranty.

- */

-

-/*

- * Copyright notice reproduced from <boost/detail/limits.hpp>, from

- * which this code was originally taken.

- *

- * Modified by Caleb Epstein to use <endian.h> with GNU libc and to

- * defined the BOOST_ENDIAN macro.

- */

-

-// GNU libc offers the helpful header <endian.h> which defines

-// __BYTE_ORDER

-

-#if defined (__GLIBC__)

-# include <endian.h>

-# if (__BYTE_ORDER == __LITTLE_ENDIAN)

-# define BOOST_LITTLE_ENDIAN

-# elif (__BYTE_ORDER == __BIG_ENDIAN)

-# define BOOST_BIG_ENDIAN

-# elif (__BYTE_ORDER == __PDP_ENDIAN)

-# define BOOST_PDP_ENDIAN

-# else

-# error Unknown machine endianness detected.

-# endif

-# define BOOST_BYTE_ORDER __BYTE_ORDER

-#elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) || \

- defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) || \

- defined(_STLP_BIG_ENDIAN) && !defined(_STLP_LITTLE_ENDIAN)

-# define BOOST_BIG_ENDIAN

-# define BOOST_BYTE_ORDER 4321

-#elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) || \

- defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) || \

- defined(_STLP_LITTLE_ENDIAN) && !defined(_STLP_BIG_ENDIAN)

-# define BOOST_LITTLE_ENDIAN

-# define BOOST_BYTE_ORDER 1234

-#elif defined(__sparc) || defined(__sparc__) \

- || defined(_POWER) || defined(__powerpc__) \

- || defined(__ppc__) || defined(__hpux) || defined(__hppa) \

- || defined(_MIPSEB) || defined(_POWER) \

- || defined(__s390__)

-# define BOOST_BIG_ENDIAN

-# define BOOST_BYTE_ORDER 4321

-#elif defined(__i386__) || defined(__alpha__) \

- || defined(__ia64) || defined(__ia64__) \

- || defined(_M_IX86) || defined(_M_IA64) \

- || defined(_M_ALPHA) || defined(__amd64) \

- || defined(__amd64__) || defined(_M_AMD64) \

- || defined(__x86_64) || defined(__x86_64__) \

- || defined(_M_X64) || defined(__bfin__) \

- || defined(ANDROID)

-# define BOOST_LITTLE_ENDIAN

-# define BOOST_BYTE_ORDER 1234

-#else

-# error The file boost/detail/endian.hpp needs to be set up for your CPU type.

-#endif

-

-/* If we're using clang + glibc, we have to get hacky.

-

-

-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

-# include <boost/detail/is_function_ref_tester.hpp>

-# endif

-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

-# 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

-// MS compatible compilers support #pragma once

-

-#if defined(_MSC_VER) && (_MSC_VER >= 1020)

-# pragma once

-#endif

-

-#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1600

-# pragma intrinsic( _InterlockedIncrement )

-# pragma intrinsic( _InterlockedDecrement )

-# pragma intrinsic( _InterlockedCompareExchange )

-# pragma intrinsic( _InterlockedExchange )

-# pragma intrinsic( _InterlockedExchangeAdd )

-

-# pragma intrinsic( _InterlockedCompareExchangePointer )

-# pragma intrinsic( _InterlockedExchangePointer )

-

-#if defined(__MINGW64__)

-#define BOOST_INTERLOCKED_IMPORT

-#else

-#endif

-

-

-// (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/type_traits/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

-# if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \

- || BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

-// 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)

-

-# 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)

-# 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;

-};

-template <class Iterator>

-struct msvc_stdlib_const_traits

- : std::iterator_traits<Iterator>

- 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>

-};

-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

-# undef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF

-# undef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION

-// Copyright 2001 John Maddock

-// 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)

-

-/*

- * Copyright (c) 1997

- * Silicon Graphics Computer Systems, Inc.

- *

- * Permission to use, copy, modify, distribute and sell this software

- * and its documentation for any purpose is hereby granted without fee,

- * provided that the above copyright notice appear in all copies and

- * that both that copyright notice and this permission notice appear

- * in supporting documentation. Silicon Graphics makes no

- * representations about the suitability of this software for any

- * purpose. It is provided "as is" without express or implied warranty.

- */

-

-/* NOTE: This is not portable code. Parts of numeric_limits<> are

- * inherently machine-dependent, and this file is written for the MIPS

- * architecture and the SGI MIPSpro C++ compiler. Parts of it (in

- * particular, some of the characteristics of floating-point types)

- * are almost certainly incorrect for any other platform.

- */

-

-/* The above comment is almost certainly out of date. This file works

- * on systems other than SGI MIPSpro C++ now.

- */

-

-/*

- * Revision history:

- * 21 Sep 2001:

- * Only include <cwchar> if BOOST_NO_CWCHAR is defined. (Darin Adler)

- * 10 Aug 2001:

- * Added MIPS (big endian) to the big endian family. (Jens Maurer)

- * 13 Apr 2001:

- * Added powerpc to the big endian family. (Jeremy Siek)

- * 5 Apr 2001:

- * Added sparc (big endian) processor support (John Maddock).

- * Initial sub:

- * Modified by Jens Maurer for gcc 2.95 on x86.

- */

-

-#ifndef BOOST_SGI_CPP_LIMITS

-#define BOOST_SGI_CPP_LIMITS

-

-#include <climits>

-#include <cfloat>

-#include <boost/config.hpp>

-#include <boost/detail/endian.hpp>

-

-#ifndef BOOST_NO_CWCHAR

-#include <cwchar> // for WCHAR_MIN and WCHAR_MAX

-#endif

-

-namespace std {

-

-enum float_round_style {

- round_indeterminate = -1,

- round_toward_zero = 0,

- round_to_nearest = 1,

- round_toward_infinity = 2,

- round_toward_neg_infinity = 3

-};

-

-enum float_denorm_style {

- denorm_indeterminate = -1,

- denorm_absent = 0,

- denorm_present = 1

-};

-

-// The C++ standard (section 18.2.1) requires that some of the members of

-// numeric_limits be static const data members that are given constant-

-// initializers within the class declaration. On compilers where the

-// BOOST_NO_INCLASS_MEMBER_INITIALIZATION macro is defined, it is impossible to write

-// a standard-conforming numeric_limits class.

-//

-// There are two possible workarounds: either initialize the data

-// members outside the class, or change them from data members to

-// enums. Neither workaround is satisfactory: the former makes it

-// impossible to use the data members in constant-expressions, and the

-// latter means they have the wrong type and that it is impossible to

-// take their addresses. We choose the former workaround.

-

-#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-# define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \

- enum { __mem_name = __mem_value }

-#else /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */

-# define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \

- static const __mem_type __mem_name = __mem_value

-#endif /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */

-

-// Base class for all specializations of numeric_limits.

-template <class __number>

-class _Numeric_limits_base {

-public:

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, false);

-

- static __number min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __number(); }

- static __number max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __number(); }

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits, 0);

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, 0);

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, false);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, false);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact, false);

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 0);

-

- static __number epsilon() throw() { return __number(); }

- static __number round_error() throw() { return __number(); }

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent, 0);

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, 0);

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent, 0);

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, 0);

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, false);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, false);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, false);

- BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style,

- has_denorm,

- denorm_absent);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false);

-

- static __number infinity() throw() { return __number(); }

- static __number quiet_NaN() throw() { return __number(); }

- static __number signaling_NaN() throw() { return __number(); }

- static __number denorm_min() throw() { return __number(); }

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, false);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, false);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, false);

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps, false);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false);

- BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style,

- round_style,

- round_toward_zero);

-};

-

-// Base class for integers.

-

-template <class _Int,

- _Int __imin,

- _Int __imax,

- int __idigits = -1>

-class _Integer_limits : public _Numeric_limits_base<_Int>

-{

-public:

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);

-

- static _Int min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __imin; }

- static _Int max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __imax; }

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(int,

- digits,

- (__idigits < 0) ? (int)(sizeof(_Int) * CHAR_BIT)

- - (__imin == 0 ? 0 : 1)

- : __idigits);

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000);

- // log 2 = 0.301029995664...

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, __imin != 0);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, true);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact, true);

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 2);

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, true);

-};

-

-#if defined(BOOST_BIG_ENDIAN)

-

- template<class Number, unsigned int Word>

- struct float_helper{

- static Number get_word() throw() {

- // sizeof(long double) == 16

- const unsigned int _S_word[4] = { Word, 0, 0, 0 };

- return *reinterpret_cast<const Number*>(&_S_word);

- }

-};

-

-#else

-

- template<class Number, unsigned int Word>

- struct float_helper{

- static Number get_word() throw() {

- // sizeof(long double) == 12, but only 10 bytes significant

- const unsigned int _S_word[4] = { 0, 0, 0, Word };

- return *reinterpret_cast<const Number*>(

- reinterpret_cast<const char *>(&_S_word)+16-

- (sizeof(Number) == 12 ? 10 : sizeof(Number)));

- }

-};

-

-#endif

-

-// Base class for floating-point numbers.

-template <class __number,

- int __Digits, int __Digits10,

- int __MinExp, int __MaxExp,

- int __MinExp10, int __MaxExp10,

- unsigned int __InfinityWord,

- unsigned int __QNaNWord, unsigned int __SNaNWord,

- bool __IsIEC559,

- float_round_style __RoundStyle>

-class _Floating_limits : public _Numeric_limits_base<__number>

-{

-public:

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits, __Digits);

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, __Digits10);

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, true);

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 2);

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent, __MinExp);

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent, __MaxExp);

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, __MinExp10);

- BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, __MaxExp10);

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, true);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, true);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, true);

- BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style,

- has_denorm,

- denorm_indeterminate);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false);

-

-

- static __number infinity() throw() {

- return float_helper<__number, __InfinityWord>::get_word();

- }

- static __number quiet_NaN() throw() {

- return float_helper<__number,__QNaNWord>::get_word();

- }

- static __number signaling_NaN() throw() {

- return float_helper<__number,__SNaNWord>::get_word();

- }

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, __IsIEC559);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true);

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps, false /* was: true */ );

- BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false);

-

- BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style, round_style, __RoundStyle);

-};

-

-// Class numeric_limits

-

-// The unspecialized class.

-

-template<class T>

-class numeric_limits : public _Numeric_limits_base<T> {};

-

-// Specializations for all built-in integral types.

-

-template<>

-class numeric_limits<bool>

- : public _Integer_limits<bool, false, true, 0>

-{};

-

-template<>

-class numeric_limits<char>

- : public _Integer_limits<char, CHAR_MIN, CHAR_MAX>

-{};

-

-template<>

-class numeric_limits<signed char>

- : public _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX>

-{};

-

-template<>

-class numeric_limits<unsigned char>

- : public _Integer_limits<unsigned char, 0, UCHAR_MAX>

-{};

-

-#ifndef BOOST_NO_INTRINSIC_WCHAR_T

-template<>

-class numeric_limits<wchar_t>

-#if !defined(WCHAR_MAX) || !defined(WCHAR_MIN)

-#if defined(_WIN32) || defined(__CYGWIN__)

- : public _Integer_limits<wchar_t, 0, USHRT_MAX>

-#elif defined(__hppa)

-// wchar_t has "unsigned int" as the underlying type

- : public _Integer_limits<wchar_t, 0, UINT_MAX>

-#else

-// assume that wchar_t has "int" as the underlying type

- : public _Integer_limits<wchar_t, INT_MIN, INT_MAX>

-#endif

-#else

-// we have WCHAR_MIN and WCHAR_MAX defined, so use it

- : public _Integer_limits<wchar_t, WCHAR_MIN, WCHAR_MAX>

-#endif

-{};

-#endif

-

-template<>

-class numeric_limits<short>

- : public _Integer_limits<short, SHRT_MIN, SHRT_MAX>

-{};

-

-template<>

-class numeric_limits<unsigned short>

- : public _Integer_limits<unsigned short, 0, USHRT_MAX>

-{};

-

-template<>

-class numeric_limits<int>

- : public _Integer_limits<int, INT_MIN, INT_MAX>

-{};

-

-template<>

-class numeric_limits<unsigned int>

- : public _Integer_limits<unsigned int, 0, UINT_MAX>

-{};

-

-template<>

-class numeric_limits<long>

- : public _Integer_limits<long, LONG_MIN, LONG_MAX>

-{};

-

-template<>

-class numeric_limits<unsigned long>

- : public _Integer_limits<unsigned long, 0, ULONG_MAX>

-{};

-

-#ifdef __GNUC__

-

-// Some compilers have long long, but don't define the

-// LONGLONG_MIN and LONGLONG_MAX macros in limits.h. This

-// assumes that long long is 64 bits.

-#if !defined(LONGLONG_MAX) && !defined(ULONGLONG_MAX)

-

-# define ULONGLONG_MAX 0xffffffffffffffffLLU

-# define LONGLONG_MAX 0x7fffffffffffffffLL

-

-#endif

-

-#if !defined(LONGLONG_MIN)

-# define LONGLONG_MIN (-LONGLONG_MAX - 1)

-#endif

-

-

-#if !defined(ULONGLONG_MIN)

-# define ULONGLONG_MIN 0

-#endif

-

-#endif /* __GNUC__ */

-

-// Specializations for all built-in floating-point type.

-

-template<> class numeric_limits<float>

- : public _Floating_limits<float,

- FLT_MANT_DIG, // Binary digits of precision

- FLT_DIG, // Decimal digits of precision

- FLT_MIN_EXP, // Minimum exponent

- FLT_MAX_EXP, // Maximum exponent

- FLT_MIN_10_EXP, // Minimum base 10 exponent

- FLT_MAX_10_EXP, // Maximum base 10 exponent

-#if defined(BOOST_BIG_ENDIAN)

- 0x7f80 << (sizeof(int)*CHAR_BIT-16), // Last word of +infinity

- 0x7f81 << (sizeof(int)*CHAR_BIT-16), // Last word of quiet NaN

- 0x7fc1 << (sizeof(int)*CHAR_BIT-16), // Last word of signaling NaN

-#else

- 0x7f800000u, // Last word of +infinity

- 0x7f810000u, // Last word of quiet NaN

- 0x7fc10000u, // Last word of signaling NaN

-#endif

- true, // conforms to iec559

- round_to_nearest>

-{

-public:

- static float min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return FLT_MIN; }

- static float denorm_min() throw() { return FLT_MIN; }

- static float max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return FLT_MAX; }

- static float epsilon() throw() { return FLT_EPSILON; }

- static float round_error() throw() { return 0.5f; } // Units: ulps.

-};

-

-template<> class numeric_limits<double>

- : public _Floating_limits<double,

- DBL_MANT_DIG, // Binary digits of precision

- DBL_DIG, // Decimal digits of precision

- DBL_MIN_EXP, // Minimum exponent

- DBL_MAX_EXP, // Maximum exponent

- DBL_MIN_10_EXP, // Minimum base 10 exponent

- DBL_MAX_10_EXP, // Maximum base 10 exponent

-#if defined(BOOST_BIG_ENDIAN)

- 0x7ff0 << (sizeof(int)*CHAR_BIT-16), // Last word of +infinity

- 0x7ff1 << (sizeof(int)*CHAR_BIT-16), // Last word of quiet NaN

- 0x7ff9 << (sizeof(int)*CHAR_BIT-16), // Last word of signaling NaN

-#else

- 0x7ff00000u, // Last word of +infinity

- 0x7ff10000u, // Last word of quiet NaN

- 0x7ff90000u, // Last word of signaling NaN

-#endif

- true, // conforms to iec559

- round_to_nearest>

-{

-public:

- static double min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return DBL_MIN; }

- static double denorm_min() throw() { return DBL_MIN; }

- static double max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return DBL_MAX; }

- static double epsilon() throw() { return DBL_EPSILON; }

- static double round_error() throw() { return 0.5; } // Units: ulps.

-};

-

-template<> class numeric_limits<long double>

- : public _Floating_limits<long double,

- LDBL_MANT_DIG, // Binary digits of precision

- LDBL_DIG, // Decimal digits of precision

- LDBL_MIN_EXP, // Minimum exponent

- LDBL_MAX_EXP, // Maximum exponent

- LDBL_MIN_10_EXP,// Minimum base 10 exponent

- LDBL_MAX_10_EXP,// Maximum base 10 exponent

-#if defined(BOOST_BIG_ENDIAN)

- 0x7ff0 << (sizeof(int)*CHAR_BIT-16), // Last word of +infinity

- 0x7ff1 << (sizeof(int)*CHAR_BIT-16), // Last word of quiet NaN

- 0x7ff9 << (sizeof(int)*CHAR_BIT-16), // Last word of signaling NaN

-#else

- 0x7fff8000u, // Last word of +infinity

- 0x7fffc000u, // Last word of quiet NaN

- 0x7fff9000u, // Last word of signaling NaN

-#endif

- false, // Doesn't conform to iec559

- round_to_nearest>

-{

-public:

- static long double min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return LDBL_MIN; }

- static long double denorm_min() throw() { return LDBL_MIN; }

- static long double max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return LDBL_MAX; }

- static long double epsilon() throw() { return LDBL_EPSILON; }

- static long double round_error() throw() { return 4; } // Units: ulps.

-};

-

-} // namespace std

-

-#endif /* BOOST_SGI_CPP_LIMITS */

-

-// Local Variables:

-// mode:C++

-// End:

-

-

-

-#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_

-#define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_

-#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:

-void foo() {

- { try {

- ...

- } catch (const std::bad_alloc&) {

- ...

- throw;

- } catch (const std::exception& e) {

- ...

- }

- }

-}

-With exception support disabled it will expand into:

-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

-// (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

-// (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.

-// see libs/utility/compressed_pair.hpp

-//

-/* Release notes:

- 20 Jan 2001:

- Fixed obvious bugs (David Abrahams)

- 07 Oct 2000:

- Added better single argument constructor support.

- 03 Oct 2000:

- Added VC6 support (JM).

- 23rd July 2000:

- Additional comments added. (JM)

- Jan 2000:

- Original version: this version crippled for use with crippled compilers

- - John Maddock Jan 2000.

-*/

-

-

-#ifndef BOOST_OB_COMPRESSED_PAIR_HPP

-#define BOOST_OB_COMPRESSED_PAIR_HPP

-

-#include <algorithm>

-#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP

-#include <boost/type_traits/object_traits.hpp>

-#endif

-#ifndef BOOST_SAME_TRAITS_HPP

-#include <boost/type_traits/same_traits.hpp>

-#endif

-#ifndef BOOST_CALL_TRAITS_HPP

-#include <boost/call_traits.hpp>

-#endif

-

-namespace boost

-{

-#ifdef BOOST_MSVC6_MEMBER_TEMPLATES

-//

-// use member templates to emulate

-// partial specialisation. Note that due to

-// problems with overload resolution with VC6

-// each of the compressed_pair versions that follow

-// have one template single-argument constructor

-// in place of two specific constructors:

-//

-

-template <class T1, class T2>

-class compressed_pair;

-

-namespace detail{

-

-template <class A, class T1, class T2>

-struct best_conversion_traits

-{

- typedef char one;

- typedef char (&two)[2];

- static A a;

- static one test(T1);

- static two test(T2);

-

- enum { value = sizeof(test(a)) };

-};

-

-template <int>

-struct init_one;

-

-template <>

-struct init_one<1>

-{

- template <class A, class T1, class T2>

- static void init(const A& a, T1* p1, T2*)

- {

- *p1 = a;

- }

-};

-

-template <>

-struct init_one<2>

-{

- template <class A, class T1, class T2>

- static void init(const A& a, T1*, T2* p2)

- {

- *p2 = a;

- }

-};

-

-

-// T1 != T2, both non-empty

-template <class T1, class T2>

-class compressed_pair_0

-{

-private:

- T1 _first;

- T2 _second;

-public:

- typedef T1 first_type;

- typedef T2 second_type;

- typedef typename call_traits<first_type>::param_type first_param_type;

- typedef typename call_traits<second_type>::param_type second_param_type;

- typedef typename call_traits<first_type>::reference first_reference;

- typedef typename call_traits<second_type>::reference second_reference;

- typedef typename call_traits<first_type>::const_reference first_const_reference;

- typedef typename call_traits<second_type>::const_reference second_const_reference;

-

- compressed_pair_0() : _first(), _second() {}

- compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {}

- template <class A>

- explicit compressed_pair_0(const A& val)

- {

- init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second);

- }

- compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x)

- : _first(x.first()), _second(x.second()) {}

-

-#if 0

- compressed_pair_0& operator=(const compressed_pair_0& x) {

- cout << "assigning compressed pair 0" << endl;

- _first = x._first;

- _second = x._second;

- cout << "finished assigning compressed pair 0" << endl;

- return *this;

- }

-#endif

-

- first_reference first() { return _first; }

- first_const_reference first() const { return _first; }

-

- second_reference second() { return _second; }

- second_const_reference second() const { return _second; }

-

- void swap(compressed_pair_0& y)

- {

- using std::swap;

- swap(_first, y._first);

- swap(_second, y._second);

- }

-};

-

-// T1 != T2, T2 empty

-template <class T1, class T2>

-class compressed_pair_1 : T2

-{

-private:

- T1 _first;

-public:

- typedef T1 first_type;

- typedef T2 second_type;

- typedef typename call_traits<first_type>::param_type first_param_type;

- typedef typename call_traits<second_type>::param_type second_param_type;

- typedef typename call_traits<first_type>::reference first_reference;

- typedef typename call_traits<second_type>::reference second_reference;

- typedef typename call_traits<first_type>::const_reference first_const_reference;

- typedef typename call_traits<second_type>::const_reference second_const_reference;

-

- compressed_pair_1() : T2(), _first() {}

- compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {}

-

- template <class A>

- explicit compressed_pair_1(const A& val)

- {

- init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this));

- }

-

- compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)

- : T2(x.second()), _first(x.first()) {}

-

-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300

- // Total weirdness. If the assignment to _first is moved after

- // the call to the inherited operator=, then this breaks graph/test/graph.cpp

- // by way of iterator_adaptor.

- compressed_pair_1& operator=(const compressed_pair_1& x) {

- _first = x._first;

- T2::operator=(x);

- return *this;

- }

-#endif

-

- first_reference first() { return _first; }

- first_const_reference first() const { return _first; }

-

- second_reference second() { return *this; }

- second_const_reference second() const { return *this; }

-

- void swap(compressed_pair_1& y)

- {

- // no need to swap empty base class:

- using std::swap;

- swap(_first, y._first);

- }

-};

-

-// T1 != T2, T1 empty

-template <class T1, class T2>

-class compressed_pair_2 : T1

-{

-private:

- T2 _second;

-public:

- typedef T1 first_type;

- typedef T2 second_type;

- typedef typename call_traits<first_type>::param_type first_param_type;

- typedef typename call_traits<second_type>::param_type second_param_type;

- typedef typename call_traits<first_type>::reference first_reference;

- typedef typename call_traits<second_type>::reference second_reference;

- typedef typename call_traits<first_type>::const_reference first_const_reference;

- typedef typename call_traits<second_type>::const_reference second_const_reference;

-

- compressed_pair_2() : T1(), _second() {}

- compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {}

- template <class A>

- explicit compressed_pair_2(const A& val)

- {

- init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second);

- }

- compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x)

- : T1(x.first()), _second(x.second()) {}

-

-#if 0

- compressed_pair_2& operator=(const compressed_pair_2& x) {

- cout << "assigning compressed pair 2" << endl;

- T1::operator=(x);

- _second = x._second;

- cout << "finished assigning compressed pair 2" << endl;

- return *this;

- }

-#endif

- first_reference first() { return *this; }

- first_const_reference first() const { return *this; }

-

- second_reference second() { return _second; }

- second_const_reference second() const { return _second; }

-

- void swap(compressed_pair_2& y)

- {

- // no need to swap empty base class:

- using std::swap;

- swap(_second, y._second);

- }

-};

-

-// T1 != T2, both empty

-template <class T1, class T2>

-class compressed_pair_3 : T1, T2

-{

-public:

- typedef T1 first_type;

- typedef T2 second_type;

- typedef typename call_traits<first_type>::param_type first_param_type;

- typedef typename call_traits<second_type>::param_type second_param_type;

- typedef typename call_traits<first_type>::reference first_reference;

- typedef typename call_traits<second_type>::reference second_reference;

- typedef typename call_traits<first_type>::const_reference first_const_reference;

- typedef typename call_traits<second_type>::const_reference second_const_reference;

-

- compressed_pair_3() : T1(), T2() {}

- compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {}

- template <class A>

- explicit compressed_pair_3(const A& val)

- {

- init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), static_cast<T2*>(this));

- }

- compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x)

- : T1(x.first()), T2(x.second()) {}

-

- first_reference first() { return *this; }

- first_const_reference first() const { return *this; }

-

- second_reference second() { return *this; }

- second_const_reference second() const { return *this; }

-

- void swap(compressed_pair_3& y)

- {

- // no need to swap empty base classes:

- }

-};

-

-// T1 == T2, and empty

-template <class T1, class T2>

-class compressed_pair_4 : T1

-{

-public:

- typedef T1 first_type;

- typedef T2 second_type;

- typedef typename call_traits<first_type>::param_type first_param_type;

- typedef typename call_traits<second_type>::param_type second_param_type;

- typedef typename call_traits<first_type>::reference first_reference;

- typedef typename call_traits<second_type>::reference second_reference;

- typedef typename call_traits<first_type>::const_reference first_const_reference;

- typedef typename call_traits<second_type>::const_reference second_const_reference;

-

- compressed_pair_4() : T1() {}

- compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {}

- // only one single argument constructor since T1 == T2

- explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {}

- compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x)

- : T1(x.first()), m_second(x.second()) {}

-

- first_reference first() { return *this; }

- first_const_reference first() const { return *this; }

-

- second_reference second() { return m_second; }

- second_const_reference second() const { return m_second; }

-

- void swap(compressed_pair_4& y)

- {

- // no need to swap empty base classes:

- }

-private:

- T2 m_second;

-};

-

-// T1 == T2, not empty

-template <class T1, class T2>

-class compressed_pair_5

-{

-private:

- T1 _first;

- T2 _second;

-public:

- typedef T1 first_type;

- typedef T2 second_type;

- typedef typename call_traits<first_type>::param_type first_param_type;

- typedef typename call_traits<second_type>::param_type second_param_type;

- typedef typename call_traits<first_type>::reference first_reference;

- typedef typename call_traits<second_type>::reference second_reference;

- typedef typename call_traits<first_type>::const_reference first_const_reference;

- typedef typename call_traits<second_type>::const_reference second_const_reference;

-

- compressed_pair_5() : _first(), _second() {}

- compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {}

- // only one single argument constructor since T1 == T2

- explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {}

- compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c)

- : _first(c.first()), _second(c.second()) {}

-

- first_reference first() { return _first; }

- first_const_reference first() const { return _first; }

-

- second_reference second() { return _second; }

- second_const_reference second() const { return _second; }

-

- void swap(compressed_pair_5& y)

- {

- using std::swap;

- swap(_first, y._first);

- swap(_second, y._second);

- }

-};

-

-template <bool e1, bool e2, bool same>

-struct compressed_pair_chooser

-{

- template <class T1, class T2>

- struct rebind

- {

- typedef compressed_pair_0<T1, T2> type;

- };

-};

-

-template <>

-struct compressed_pair_chooser<false, true, false>

-{

- template <class T1, class T2>

- struct rebind

- {

- typedef compressed_pair_1<T1, T2> type;

- };

-};

-

-template <>

-struct compressed_pair_chooser<true, false, false>

-{

- template <class T1, class T2>

- struct rebind

- {

- typedef compressed_pair_2<T1, T2> type;

- };

-};

-

-template <>

-struct compressed_pair_chooser<true, true, false>

-{

- template <class T1, class T2>

- struct rebind

- {

- typedef compressed_pair_3<T1, T2> type;

- };

-};

-

-template <>

-struct compressed_pair_chooser<true, true, true>

-{

- template <class T1, class T2>

- struct rebind

- {

- typedef compressed_pair_4<T1, T2> type;

- };

-};

-

-template <>

-struct compressed_pair_chooser<false, false, true>

-{

- template <class T1, class T2>

- struct rebind

- {

- typedef compressed_pair_5<T1, T2> type;

- };

-};

-

-template <class T1, class T2>

-struct compressed_pair_traits

-{

-private:

- typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser;

- typedef typename chooser::template rebind<T1, T2> bound_type;

-public:

- typedef typename bound_type::type type;

-};

-

-} // namespace detail

-

-template <class T1, class T2>

-class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type

-{

-private:

- typedef typename detail::compressed_pair_traits<T1, T2>::type base_type;

-public:

- typedef T1 first_type;

- typedef T2 second_type;

- typedef typename call_traits<first_type>::param_type first_param_type;

- typedef typename call_traits<second_type>::param_type second_param_type;

- typedef typename call_traits<first_type>::reference first_reference;

- typedef typename call_traits<second_type>::reference second_reference;

- typedef typename call_traits<first_type>::const_reference first_const_reference;

- typedef typename call_traits<second_type>::const_reference second_const_reference;

-

- compressed_pair() : base_type() {}

- compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {}

- template <class A>

- explicit compressed_pair(const A& x) : base_type(x){}

-

- first_reference first() { return base_type::first(); }

- first_const_reference first() const { return base_type::first(); }

-

- second_reference second() { return base_type::second(); }

- second_const_reference second() const { return base_type::second(); }

-};

-

-template <class T1, class T2>

-inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)

-{

- x.swap(y);

-}

-

-#else

-// no partial specialisation, no member templates:

-

-template <class T1, class T2>

-class compressed_pair

-{

-private:

- T1 _first;

- T2 _second;

-public:

- typedef T1 first_type;

- typedef T2 second_type;

- typedef typename call_traits<first_type>::param_type first_param_type;

- typedef typename call_traits<second_type>::param_type second_param_type;

- typedef typename call_traits<first_type>::reference first_reference;

- typedef typename call_traits<second_type>::reference second_reference;

- typedef typename call_traits<first_type>::const_reference first_const_reference;

- typedef typename call_traits<second_type>::const_reference second_const_reference;

-

- compressed_pair() : _first(), _second() {}

- compressed_pair(first_param_type x, second_param_type y) : _first(x), _second(y) {}

- explicit compressed_pair(first_param_type x) : _first(x), _second() {}

- // can't define this in case T1 == T2:

- // explicit compressed_pair(second_param_type y) : _first(), _second(y) {}

-

- first_reference first() { return _first; }

- first_const_reference first() const { return _first; }

-

- second_reference second() { return _second; }

- second_const_reference second() const { return _second; }

-

- void swap(compressed_pair& y)

- {

- using std::swap;

- swap(_first, y._first);

- swap(_second, y._second);

- }

-};

-

-template <class T1, class T2>

-inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)

-{

- x.swap(y);

-}

-

-#endif

-

-} // boost

-

-#endif // BOOST_OB_COMPRESSED_PAIR_HPP

-

-

-

-#ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED

-#define BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED

-

-// MS compatible compilers support #pragma once

-

-#if defined(_MSC_VER) && (_MSC_VER >= 1020)

-# pragma once

-#endif

-

-//

-// detail/quick_allocator.hpp

-//

-// Copyright (c) 2003 David Abrahams

-// Copyright (c) 2003 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/quick_allocator.hpp>

-

-#endif // #ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED

-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

-#else

-# include "boost/mpl/if.hpp"

-# include "boost/type_traits/is_reference.hpp"

-#endif

-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

-#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

-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

-#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

-// scoped_enum_emulation.hpp ---------------------------------------------------------//

-

-// Copyright Beman Dawes, 2009

-// Copyright (C) 2011-2012 Vicente J. Botet Escriba

-// Copyright (C) 2012 Anthony Williams

-

-// Distributed under the Boost Software License, Version 1.0.

-// See http://www.boost.org/LICENSE_1_0.txt

-

-[section:scoped_enums Scoped Enums]

-

-Generates C++0x scoped enums if the feature is present, otherwise emulates C++0x

-scoped enums with C++03 namespaces and enums. The Boost.Config BOOST_NO_SCOPED_ENUMS

-macro is used to detect feature support.

-

-See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf for a

-description of the scoped enum feature. Note that the committee changed the name

-from strongly typed enum to scoped enum.

-

-Some of the enumerations defined in the standard library are scoped enums.

-

- enum class future_errc

- {

- broken_promise,

- future_already_retrieved,

- promise_already_satisfied,

- no_state

- };

-

-On compilers that don't support them, the library provides two emulations:

-

-[heading Strict]

-

-* Able to specify the underlying type.

-* explicit conversion to/from underlying type.

-* The wrapper is not a C++03 enum type.

-

-The user can declare declare these types as

-

- BOOST_SCOPED_ENUM_DECLARE_BEGIN(future_errc)

- {

- broken_promise,

- future_already_retrieved,

- promise_already_satisfied,

- no_state

- }

- BOOST_SCOPED_ENUM_DECLARE_END(future_errc)

-

-These macros allows to use 'future_errc' in almost all the cases as an scoped enum.

-

- future_errc err = future_errc::no_state;

-

-There are however some limitations:

-

-* The type is not a C++ enum, so 'is_enum<future_errc>' will be false_type.

-* The emulated scoped enum can not be used in switch nor in template arguments. For these cases the user needs to use some macros.

-

-Instead of

-

- switch (ev)

- {

- case future_errc::broken_promise:

- // ...

-

-use

-

- switch (boost::native_value(ev))

- {

- case future_errc::broken_promise:

-

-And instead of

-

- #ifdef BOOST_NO_SCOPED_ENUMS

- template <>

- struct BOOST_SYMBOL_VISIBLE is_error_code_enum<future_errc> : public true_type { };

- #endif

-

-use

-

- #ifdef BOOST_NO_SCOPED_ENUMS

- template <>

- struct BOOST_SYMBOL_VISIBLE is_error_code_enum<future_errc::enum_type > : public true_type { };

- #endif

-

-

-Sample usage:

-

- BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(algae, char) { green, red, cyan }; BOOST_SCOPED_ENUM_DECLARE_END(algae)

- ...

- algae sample( algae::red );

- void foo( algae color );

- ...

- sample = algae::green;

- foo( algae::cyan );

-

- Light

- Caution: only the syntax is emulated; the semantics are not emulated and

- the syntax emulation doesn't include being able to specify the underlying

- representation type.

-

- The literal scoped emulation is via struct rather than namespace to allow use within classes.

- Thanks to Andrey Semashev for pointing that out.

- However the type is an real C++03 enum and so convertible implicitly to an int.

-

- Sample usage:

-

- BOOST_SCOPED_ENUM_START(algae) { green, red, cyan }; BOOST_SCOPED_ENUM_END

- ...

- BOOST_SCOPED_ENUM(algae) sample( algae::red );

- void foo( BOOST_SCOPED_ENUM(algae) color );

- ...

- sample = algae::green;

- foo( algae::cyan );

-

- Helpful comments and suggestions were also made by Kjell Elster, Phil Endecott,

- Joel Falcou, Mathias Gaunard, Felipe Magno de Almeida, Matt Calabrese, Vicente

- Botet, and Daniel James.

-

-[endsect]

-*/

-

-

-#ifndef BOOST_SCOPED_ENUM_EMULATION_HPP

-#define BOOST_SCOPED_ENUM_EMULATION_HPP

-

-#include <boost/config.hpp>

-#include <boost/detail/workaround.hpp>

-

-namespace boost

-{

-

-#ifdef BOOST_NO_SCOPED_ENUMS

- /**

- * Meta-function to get the underlying type of a scoped enum.

- *

- * Requires EnumType must be an enum type or the emulation of a scoped enum

- */

- template <typename EnumType>

- struct underlying_type

- {

- /**

- * The member typedef type names the underlying type of EnumType. It is EnumType::underlying_type when the EnumType is an emulated scoped enum,

- * std::underlying_type<EnumType>::type when the standard library std::underlying_type is provided.

- *

- * The user will need to specialize it when the compiler supports scoped enums but don't provides std::underlying_type.

- */

- typedef typename EnumType::underlying_type type;

- };

-

- /**

- * Meta-function to get the native enum type associated to an enum class or its emulation.

- */

- template <typename EnumType>

- struct native_type

- {

- /**

- * The member typedef type names the native enum type associated to the scoped enum,

- * which is it self if the compiler supports scoped enums or EnumType::enum_type if it is an emulated scoped enum.

- */

- typedef typename EnumType::enum_type type;

- };

-

- /**

- * Casts a scoped enum to its underlying type.

- *

- * This function is useful when working with scoped enum classes, which doens't implicitly convert to the underlying type.

- * @param v A scoped enum.

- * @returns The underlying type.

- * @throws No-throws.

- */

- template <typename UnderlyingType, typename EnumType>

- UnderlyingType underlying_cast(EnumType v)

- {

- return v.get_underlying_value_();

- }

-

- /**

- * Casts a scoped enum to its native enum type.

- *

- * This function is useful to make programs portable when the scoped enum emulation can not be use where native enums can.

- *

- * EnumType the scoped enum type

- *

- * @param v A scoped enum.

- * @returns The native enum value.

- * @throws No-throws.

- */

- template <typename EnumType>

- inline

- typename EnumType::enum_type native_value(EnumType e)

- {

- return e.native_value_();

- }

-

-#else // BOOST_NO_SCOPED_ENUMS

-

- template <typename EnumType>

- struct underlying_type

- {

- //typedef typename std::underlying_type<EnumType>::type type;

- };

-

- template <typename EnumType>

- struct native_type

- {

- typedef EnumType type;

- };

-

- template <typename UnderlyingType, typename EnumType>

- UnderlyingType underlying_cast(EnumType v)

- {

- return static_cast<UnderlyingType>(v);

- }

-

- template <typename EnumType>

- inline

- EnumType native_value(EnumType e)

- {

- return e;

- }

-

-#endif

-}

-

-

-#ifdef BOOST_NO_SCOPED_ENUMS

-

-#ifndef BOOST_NO_EXPLICIT_CONVERSION_OPERATORS

-

-#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \

- explicit operator underlying_type() const { return get_underlying_value_(); }

-

-#else

-

-#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR

-

-#endif

-

-/**

- * Start a declaration of a scoped enum.

- * @param EnumType The new scoped enum.

- * @param UnderlyingType The underlying type.

-#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType, UnderlyingType) \

- struct EnumType { \

- typedef UnderlyingType underlying_type; \

- EnumType() BOOST_NOEXCEPT {} \

- explicit EnumType(underlying_type v) : v_(v) {} \

- underlying_type get_underlying_value_() const { return v_; } \

- BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \

- private: \

- underlying_type v_; \

- typedef EnumType self_type; \

- public: \

- enum enum_type

-#define BOOST_SCOPED_ENUM_DECLARE_END2() \

- enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \

- operator enum_type() const BOOST_NOEXCEPT { return get_native_value_(); } \

- friend bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \

- friend bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \

- friend bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \

- friend bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \

- friend bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \

- friend bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \

- friend bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \

- friend bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \

- friend bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \

- friend bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \

- friend bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \

- friend bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \

- friend bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \

- friend bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \

- friend bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \

- friend bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \

- friend bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \

- friend bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \

- };

-#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) \

- ; \

- EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {} \

- BOOST_SCOPED_ENUM_DECLARE_END2()

-/**

- * Starts a declaration of a scoped enum with the default int underlying type.

- *

- * @param EnumType The new scoped enum.

- */

-#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) \

- BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,int)

-/**

- * Name of the native enum type.

- *

- * @param NT The new scoped enum.

- */

-#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType::enum_type

-/**

- * Forward declares an scoped enum.

- *

- * @param NT The scoped enum.

- */

-#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) struct EnumType

-

-#else // BOOST_NO_SCOPED_ENUMS

-

-#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,UnderlyingType) enum class EnumType:UnderlyingType

-#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) enum class EnumType

-#define BOOST_SCOPED_ENUM_DECLARE_END2()

-#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) ;

-

-#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType

-#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) enum class EnumType

-

-#endif // BOOST_NO_SCOPED_ENUMS

-

-#define BOOST_SCOPED_ENUM_START(name) BOOST_SCOPED_ENUM_DECLARE_BEGIN(name)

-#define BOOST_SCOPED_ENUM_END BOOST_SCOPED_ENUM_DECLARE_END2()

-#define BOOST_SCOPED_ENUM(name) BOOST_SCOPED_ENUM_NATIVE(name)

-

-//#ifdef BOOST_NO_SCOPED_ENUMS

-//

-//# define BOOST_SCOPED_ENUM_START(name) struct name { enum enum_type

-//# define BOOST_SCOPED_ENUM_END };

-//# define BOOST_SCOPED_ENUM(name) name::enum_type

-//

-//#else

-//

-//# define BOOST_SCOPED_ENUM_START(name) enum class name

-//# define BOOST_SCOPED_ENUM_END

-//# define BOOST_SCOPED_ENUM(name) name

-//

-//#endif

-#endif // BOOST_SCOPED_ENUM_EMULATION_HPP

-// 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;

- }

-};

-#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>

-#if defined( BOOST_NO_STD_TYPEINFO )

-

-typedef ::type_info sp_typeinfo;

-

-#else

-

-typedef std::type_info sp_typeinfo;

-

-#endif

-#define BOOST_SP_TYPEID(T) typeid(T)

-

-#endif

- std::mbstate_t & state, const wchar_t * from,

- const wchar_t * from_end, const wchar_t* & from_next,

- char * to, char * to_end, char * & to_next

- static unsigned int get_cont_octet_count(unsigned char lead_octet) {

- static unsigned int get_octet_count(unsigned char lead_octet);

- virtual bool do_always_noconv() const throw() { return false; }

- ) const

- {

- virtual int do_encoding() const throw() {

-#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))

- ) const throw();

-#else

- ) const;

-#endif

- virtual int do_max_length() const throw () {

- BOOST_CODECVT_DO_LENGTH_CONST std::mbstate_t &,

-#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))

-) const throw()

-#else

-#ifndef BOOST_DETAIL_WIN_GETLASTERROR_HPP

-#define BOOST_DETAIL_WIN_GETLASTERROR_HPP

-#include <boost/detail/win/basic_types.hpp>

-namespace win32 {

-#endif // BOOST_DETAIL_WIN_TIME_HPP

-#ifndef BOOST_DETAIL_WIN_BASIC_TYPES_HPP

-#define BOOST_DETAIL_WIN_BASIC_TYPES_HPP

-#include <boost/config.hpp>

-# include <WinError.h>

-namespace win32 {

-// @FIXME Which condition must be tested

-//~ #if !defined(_M_IX86)

-//~ #if defined(BOOST_NO_INT64_T)

- //~ typedef double LONGLONG_;

-//~ #else

- //~ typedef __int64 LONGLONG_;

-//~ #endif

-//~ #else

- //~ typedef double LONGLONG_;

-//~ #endif

-

-#endif // BOOST_DETAIL_WIN_TIME_HPP

-#ifndef BOOST_DETAIL_WIN_TIME_HPP

-#define BOOST_DETAIL_WIN_TIME_HPP

-#include <boost/detail/win/basic_types.hpp>

-namespace win32 {

- #ifndef UNDER_CE // Windows CE does not define GetSystemTimeAsFileTime

- #ifndef UNDER_CE // Windows CE does not define GetSystemTimeAsFileTime

- FileTimeToLocalFileTime(const FILETIME_* lpFileTime,

- SystemTimeToFileTime(const SYSTEMTIME_* lpSystemTime,

- __declspec(dllimport) unsigned long __stdcall

-#endif // BOOST_DETAIL_WIN_TIME_HPP

-#ifndef BOOST_DETAIL_WIN_TIMERS_HPP

-#define BOOST_DETAIL_WIN_TIMERS_HPP

-#include <boost/detail/win/basic_types.hpp>

-namespace win32

-#endif // BOOST_DETAIL_WIN_TIMERS_HPP