diff options
| -rw-r--r-- | include/boost/type_traits/alignment_traits.hpp | 208 | ||||
| -rw-r--r-- | include/boost/type_traits/arithmetic_traits.hpp | 266 | ||||
| -rw-r--r-- | include/boost/type_traits/array_traits.hpp | 85 | ||||
| -rw-r--r-- | include/boost/type_traits/composite_traits.hpp | 990 | ||||
| -rw-r--r-- | include/boost/type_traits/conversion_traits.hpp | 328 | ||||
| -rw-r--r-- | include/boost/type_traits/cv_traits.hpp | 399 | ||||
| -rw-r--r-- | include/boost/type_traits/function_traits.hpp | 153 | ||||
| -rw-r--r-- | include/boost/type_traits/fwd.hpp | 201 | ||||
| -rw-r--r-- | include/boost/type_traits/ice.hpp | 87 | ||||
| -rw-r--r-- | include/boost/type_traits/is_class.hpp | 49 | ||||
| -rw-r--r-- | include/boost/type_traits/object_traits.hpp | 562 | ||||
| -rw-r--r-- | include/boost/type_traits/reference_traits.hpp | 90 | ||||
| -rw-r--r-- | include/boost/type_traits/same_traits.hpp | 108 | ||||
| -rw-r--r-- | include/boost/type_traits/transform_traits.hpp | 199 | ||||
| -rw-r--r-- | include/boost/type_traits/transform_traits_spec.hpp | 78 | ||||
| -rw-r--r-- | include/boost/type_traits/type_traits_test.hpp | 434 | ||||
| -rw-r--r-- | include/boost/type_traits/utility.hpp | 24 |
17 files changed, 4261 insertions, 0 deletions
diff --git a/include/boost/type_traits/alignment_traits.hpp b/include/boost/type_traits/alignment_traits.hpp new file mode 100644 index 0000000000..b509f67361 --- /dev/null +++ b/include/boost/type_traits/alignment_traits.hpp @@ -0,0 +1,208 @@ + +// (C) Copyright John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. + +// +// defines alignment_of: + +#ifndef ALIGNMENT_TYPE_TRAITS_HPP +#define ALIGNMENT_TYPE_TRAITS_HPP + +#include <cstdlib> +#include <cstddef> +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#include <boost/type_traits/ice.hpp> +#endif +#include <boost/preprocessor/list/for_each_i.hpp> +#include <boost/preprocessor/tuple/to_list.hpp> +#include <boost/preprocessor/cat.hpp> +#include <boost/type_traits/transform_traits.hpp> +#include <boost/static_assert.hpp> + +#ifdef BOOST_MSVC +# pragma warning(push) +# pragma warning(disable: 4121) // alignment is sensitive to packing +#endif + +namespace boost{ +template <class T> struct alignment_of; + +// +// get the alignment of some arbitrary type: +namespace detail{ + +template <class T> +struct alignment_of_hack +{ + char c; + T t; + alignment_of_hack(); +}; + + +template <unsigned A, unsigned S> +struct alignment_logic +{ + BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S); +}; + +} // namespace detail + +template <class T> +struct alignment_of +{ + BOOST_STATIC_CONSTANT(std::size_t, value = + (::boost::detail::alignment_logic< + sizeof(detail::alignment_of_hack<T>) - sizeof(T), + sizeof(T) + >::value)); +}; + +// +// references have to be treated specially, assume +// that a reference is just a special pointer: +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template <class T> +struct alignment_of<T&> +{ +public: + BOOST_STATIC_CONSTANT(std::size_t, value = ::boost::alignment_of<T*>::value); +}; +#endif +// +// void has to be treated specially: +template <> +struct alignment_of<void> +{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); }; +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> +struct alignment_of<const void> +{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); }; +template <> +struct alignment_of<volatile void> +{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); }; +template <> +struct alignment_of<const volatile void> +{ BOOST_STATIC_CONSTANT(std::size_t, value = 0); }; +#endif + +namespace detail { +class alignment_dummy; +typedef void (*function_ptr)(); +typedef int (alignment_dummy::*member_ptr); +typedef int (alignment_dummy::*member_function_ptr)(); + +/* + * The ct_if implementation is temporary code. It will be replaced with MPL + * in the future... + */ +struct select_then +{ + template<typename Then, typename Else> + struct result + { + typedef Then type; + }; +}; + +struct select_else +{ + template<typename Then, typename Else> + struct result + { + typedef Else type; + }; +}; + +template<bool Condition> +struct ct_if_selector +{ + typedef select_then type; +}; + +template<> +struct ct_if_selector<false> +{ + typedef select_else type; +}; + +template<bool Condition, typename Then, typename Else> +struct ct_if +{ + typedef typename ct_if_selector<Condition>::type select; + typedef typename select::template result<Then,Else>::type type; +}; + +#define BOOST_TT_ALIGNMENT_TYPES BOOST_PP_TUPLE_TO_LIST( \ + 11, ( \ + char, short, int, long, float, double, long double \ + , void*, function_ptr, member_ptr, member_function_ptr)) + +#define BOOST_TT_CHOOSE_LOWER_ALIGNMENT(R,P,I,T) \ + typename ct_if< \ + alignment_of<T>::value <= target, T, char>::type BOOST_PP_CAT(t,I); + +#define BOOST_TT_CHOOSE_T(R,P,I,T) T BOOST_PP_CAT(t,I); + +template <std::size_t target> +union lower_alignment +{ + BOOST_PP_LIST_FOR_EACH_I( + BOOST_TT_CHOOSE_LOWER_ALIGNMENT + , ignored, BOOST_TT_ALIGNMENT_TYPES) +}; + +union max_align +{ + BOOST_PP_LIST_FOR_EACH_I( + BOOST_TT_CHOOSE_T + , ignored, BOOST_TT_ALIGNMENT_TYPES) +}; + +#undef BOOST_TT_ALIGNMENT_TYPES +#undef BOOST_TT_CHOOSE_LOWER_ALIGNMENT +#undef BOOST_TT_CHOOSE_T + +template<int TAlign, int Align> +struct is_aligned +{ + BOOST_STATIC_CONSTANT(bool, + value = (TAlign >= Align) & (TAlign % Align == 0)); +}; + +} + +// This alignment method originally due to Brian Parker, implemented by David +// Abrahams, and then ported here by Doug Gregor. +template <int Align> +class type_with_alignment +{ + typedef detail::lower_alignment<Align> t1; + + typedef type_with_alignment<Align> this_type; + + typedef typename detail::ct_if< + (detail::is_aligned<(alignment_of<t1>::value), Align>::value) + , t1 + , detail::max_align + >::type align_t; + + BOOST_STATIC_CONSTANT(std::size_t, found = alignment_of<align_t>::value); + + BOOST_STATIC_ASSERT(found >= Align); + BOOST_STATIC_ASSERT(found % Align == 0); + +public: + typedef align_t type; +}; + +} // namespace boost + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#endif // ALIGNMENT_TYPE_TRAITS_HPP diff --git a/include/boost/type_traits/arithmetic_traits.hpp b/include/boost/type_traits/arithmetic_traits.hpp new file mode 100644 index 0000000000..1d111c4b98 --- /dev/null +++ b/include/boost/type_traits/arithmetic_traits.hpp @@ -0,0 +1,266 @@ +// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. +// Permission to copy, use, modify, sell and +// distribute this software is granted provided this copyright notice appears +// in all copies. This software is provided "as is" without express or implied +// warranty, and with no claim as to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. +// +// defines traits classes for arithmetic types: +// is_void, is_integral, is_float, is_arithmetic, is_fundamental. +// + +// Revision History: +// Feb 19 2001 Added #include <climits> (David Abrahams) + +#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP +#define BOOST_ARITHMETIC_TYPE_TRAITS_HPP + +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +#include <boost/type_traits/ice.hpp> +#endif +#ifndef BOOST_FWD_TYPE_TRAITS_HPP +#include <boost/type_traits/fwd.hpp> +#endif + +#include <limits.h> // for ULLONG_MAX/ULONG_LONG_MAX + +namespace boost{ + +//* is a type T void - is_void<T> +template <typename T> struct is_void{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template <> struct is_void<void>{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +//* is a type T an [cv-qualified-] integral type described in the standard (3.9.1p3) +// as an extention we include long long, as this is likely to be added to the +// standard at a later date +template <typename T> struct is_integral +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template <> struct is_integral<unsigned char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<unsigned short> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<unsigned int> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<unsigned long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<signed char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<signed short> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<signed int> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<signed long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template <> struct is_integral<wchar_t> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +template <> struct is_integral<bool> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +# if defined(BOOST_HAS_LONG_LONG) +template <> struct is_integral<unsigned long long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<long long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#elif defined(BOOST_HAS_MS_INT64) +template <> struct is_integral<unsigned __int64> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<__int64> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif + +//* is a type T a floating-point type described in the standard (3.9.1p8) +template <typename T> struct is_float +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template <> struct is_float<float> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float<double> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float<long double> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +// +// declare cv-qualified specialisations of these templates only +// if BOOST_NO_CV_SPECIALIZATIONS is not defined: +#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> struct is_void<const void> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_void<volatile void> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_void<const volatile void> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +#ifndef BOOST_NO_CV_SPECIALIZATIONS +// const-variations: +template <> struct is_integral<const unsigned char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const unsigned short> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const unsigned int> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const unsigned long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const signed char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const signed short> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const signed int> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const signed long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template <> struct is_integral<const wchar_t> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +template <> struct is_integral<const bool> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +# if defined(BOOST_HAS_LONG_LONG) +template <> struct is_integral<const unsigned long long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const long long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#elif defined(BOOST_HAS_MS_INT64) +template <> struct is_integral<const unsigned __int64> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const __int64> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif //__int64 + +template <> struct is_float<const float> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float<const double> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float<const long double> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +// volatile-variations: +template <> struct is_integral<volatile unsigned char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<volatile unsigned short> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<volatile unsigned int> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<volatile unsigned long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<volatile signed char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<volatile signed short> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<volatile signed int> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<volatile signed long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<volatile char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template <> struct is_integral<volatile wchar_t> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +template <> struct is_integral<volatile bool> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +# if defined(BOOST_HAS_LONG_LONG) +template <> struct is_integral<volatile unsigned long long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<volatile long long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#elif defined(BOOST_HAS_MS_INT64) +template <> struct is_integral<volatile unsigned __int64> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<volatile __int64> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif //__int64 + +template <> struct is_float<volatile float> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float<volatile double> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float<volatile long double> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +// const-volatile-variations: +template <> struct is_integral<const volatile unsigned char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const volatile unsigned short> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const volatile unsigned int> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const volatile unsigned long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const volatile signed char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const volatile signed short> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const volatile signed int> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const volatile signed long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const volatile char> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#ifndef BOOST_NO_INTRINSIC_WCHAR_T +template <> struct is_integral<const volatile wchar_t> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif +template <> struct is_integral<const volatile bool> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +# if defined(BOOST_HAS_LONG_LONG) +template <> struct is_integral<const volatile unsigned long long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const volatile long long> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#elif defined(BOOST_HAS_MS_INT64) +template <> struct is_integral<const volatile unsigned __int64> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_integral<const volatile __int64> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#endif //__int64 + +template <> struct is_float<const volatile float> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float<const volatile double> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <> struct is_float<const volatile long double> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; + +#endif // BOOST_NO_CV_SPECIALIZATIONS + +//* is a type T an arithmetic type described in the standard (3.9.1p8) +template <typename T> +struct is_arithmetic +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_integral<T>::value, + ::boost::is_float<T>::value + >::value)); +}; + +//* is a type T a fundamental type described in the standard (3.9.1) +template <typename T> +struct is_fundamental +{ + BOOST_STATIC_CONSTANT(bool, value = + (::boost::type_traits::ice_or< + ::boost::is_arithmetic<T>::value, + ::boost::is_void<T>::value + >::value)); +}; + +} // namespace boost + +#endif + + + + + + + diff --git a/include/boost/type_traits/array_traits.hpp b/include/boost/type_traits/array_traits.hpp new file mode 100644 index 0000000000..04f8488522 --- /dev/null +++ b/include/boost/type_traits/array_traits.hpp @@ -0,0 +1,85 @@ +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. +// +#ifndef BOOST_TT_ARRAY_TRAITS_HPP +# define BOOST_TT_ARRAY_TRAITS_HPP +# include <boost/type_traits/utility.hpp> + +namespace boost { + +/********************************************** + * + * is_array + * + **********************************************/ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template <typename T> struct is_array +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template <typename T, std::size_t N> struct is_array<T[N]> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <typename T, std::size_t N> struct is_array<const T[N]> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <typename T, std::size_t N> struct is_array<volatile T[N]> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <typename T, std::size_t N> struct is_array<const volatile T[N]> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +#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 <class T> T(* is_array_helper1(wrap<T>) )(wrap<T>); + char is_array_helper1(...); + + template <class T> no_type is_array_helper2(T(*)(wrap<T>)); + yes_type is_array_helper2(...); +} + +template <typename T> +struct is_array +{ +public: + BOOST_STATIC_CONSTANT( + bool, value = sizeof( + ::boost::detail::is_array_helper2( + ::boost::detail::is_array_helper1( + ::boost::type_traits::wrap<T>()))) == 1 + ); +}; + +template <> +struct is_array<void> +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; + +# ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS +template <> +struct is_array<const void> +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +template <> +struct is_array<volatile void> +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +template <> +struct is_array<const volatile void> +{ + BOOST_STATIC_CONSTANT(bool, value = false); +}; +# endif +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +} // namespace boost + +#endif // BOOST_TT_ARRAY_TRAITS_HPP diff --git a/include/boost/type_traits/composite_traits.hpp b/include/boost/type_traits/composite_traits.hpp new file mode 100644 index 0000000000..4a4980ec2b --- /dev/null +++ b/include/boost/type_traits/composite_traits.hpp @@ -0,0 +1,990 @@ +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// +// See http://www.boost.org for most recent version including documentation. +// +// defines traits classes for composite types: +// is_array, is_pointer, is_reference, is_member_pointer, is_enum, is_union. +// +// Fixed is_pointer, is_reference, is_const, is_volatile, is_same, +// is_member_pointer based on the Simulated Partial Specialization work +// of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or +// http://groups.yahoo.com/group/boost/message/5441 +// Some workarounds in here use ideas suggested from "Generic<Programming>: +// Mappings between Types and Values" +// by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). +// Fixes for is_array are based on a newgroup posting by Jonathan Lundquist. + +// +// Revision History: +// 21st March 2001: +// Fixed is_enum so that it works with incomplete types. + +#ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP +#define BOOST_COMPOSITE_TYPE_TRAITS_HPP + +#ifndef BOOST_ICE_TYPE_TRAITS_HPP +# include <boost/type_traits/ice.hpp> +#endif +#ifndef BOOST_FWD_TYPE_TRAITS_HPP +# include <boost/type_traits/fwd.hpp> +#endif +#ifndef BOOST_CONVERSION_TYPE_TRAITS_HPP +# include <boost/type_traits/conversion_traits.hpp> +#endif +#ifndef BOOST_CV_TYPE_TRAITS_HPP +# include <boost/type_traits/cv_traits.hpp> +#endif +#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP +# include <boost/type_traits/arithmetic_traits.hpp> +#endif +#ifndef BOOST_TRANSFORM_TRAITS_HPP +# include <boost/type_traits/transform_traits.hpp> +#endif +#ifndef BOOST_TT_REFERENCE_TRAITS_HPP +# include <boost/type_traits/reference_traits.hpp> +#endif +#ifndef BOOST_TT_ARRAY_TRAITS_HPP +# include <boost/type_traits/array_traits.hpp> +#endif +#ifndef BOOST_TYPE_TRAITS_IS_CLASS_HPP +# include <boost/type_traits/is_class.hpp> +#endif + +namespace boost{ + +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +namespace detail{ + + struct pointer_helper + { + pointer_helper(const volatile void*); + }; + yes_type BOOST_TT_DECL is_pointer_helper(pointer_helper); + no_type BOOST_TT_DECL is_pointer_helper(...); + +::boost::type_traits::no_type BOOST_TT_DECL is_function_tester(...); +template <class R> +::boost::type_traits::yes_type is_function_tester(R (*)(void)); +template <class R, class A0> +::boost::type_traits::yes_type is_function_tester(R (*)(A0)); +template <class R, class A0, class A1> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1)); +template <class R, class A0, class A1, class A2> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2)); +template <class R, class A0, class A1, class A2, class A3> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3)); +template <class R, class A0, class A1, class A2, class A3, class A4> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28)); +template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11, class A12, class A13, class A14, class A15, class A16, class A17, class A18, class A19, class A20, class A21, class A22, class A23, class A24, class A25, class A26, class A27, class A28, class A29> +::boost::type_traits::yes_type is_function_tester(R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29)); +} // namespace detail +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + +namespace detail +{ + // Utility metafunction which returns true if its argument is not an + // array and not a reference. + template <class T> + struct neither_array_nor_reference : ::boost::type_traits::ice_not< + ::boost::type_traits::ice_or< + ::boost::is_reference<T>::value + , ::boost::is_array<T>::value + >::value> + {}; +} + +/********************************************** + * + * is_pointer + * + **********************************************/ +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +namespace detail{ +template <typename T> struct is_pointer_helper +{ BOOST_STATIC_CONSTANT(bool, value = false); }; +template <typename T> struct is_pointer_helper<T*> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <typename T> struct is_pointer_helper<T*const> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <typename T> struct is_pointer_helper<T*volatile> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +template <typename T> struct is_pointer_helper<T*const volatile> +{ BOOST_STATIC_CONSTANT(bool, value = true); }; +} // namespace detail +template <typename T> struct is_pointer +{ 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 + +namespace detail +{ + // is_pointer implementation + template <bool maybe = false> + struct is_pointer_select : ::boost::type_traits::false_unary_metafunction + { + }; + + template <> + struct is_pointer_select<true> + { + template <class T> + struct apply + { + |