mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-14 11:32:34 +00:00
*** empty log message ***
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2976 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
parent
cb86317967
commit
b8a9d9030d
208
include/boost/type_traits/alignment_traits.hpp
Normal file
208
include/boost/type_traits/alignment_traits.hpp
Normal file
@ -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
|
||||
266
include/boost/type_traits/arithmetic_traits.hpp
Normal file
266
include/boost/type_traits/arithmetic_traits.hpp
Normal file
@ -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
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
85
include/boost/type_traits/array_traits.hpp
Normal file
85
include/boost/type_traits/array_traits.hpp
Normal file
@ -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
|
||||
990
include/boost/type_traits/composite_traits.hpp
Normal file
990
include/boost/type_traits/composite_traits.hpp
Normal file
@ -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
|
||||
{
|
||||
static T& make_t();
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_or<
|
||||
(1 == sizeof(is_pointer_helper(make_t()))),
|
||||
(1 == sizeof(is_function_tester(make_t())))
|
||||
>::value));
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct is_pointer : ::boost::detail::is_pointer_select<
|
||||
::boost::detail::neither_array_nor_reference<T>::value
|
||||
>::template apply<T>
|
||||
{};
|
||||
|
||||
template <>
|
||||
struct is_pointer <void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct is_pointer <const void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <>
|
||||
struct is_pointer <volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <>
|
||||
struct is_pointer <const volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_union
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T> struct is_union
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_UNION(cvt));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_enum
|
||||
*
|
||||
**********************************************/
|
||||
namespace detail
|
||||
{
|
||||
struct int_convertible
|
||||
{
|
||||
int_convertible(int);
|
||||
};
|
||||
|
||||
// Don't evaluate convertibility to int_convertible unless the type
|
||||
// is non-arithmetic. This suppresses warnings with GCC.
|
||||
template <bool is_class_arithmetic_or_reference = true>
|
||||
struct is_enum_helper
|
||||
{
|
||||
template <class T>
|
||||
struct type
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct is_enum_helper<false>
|
||||
{
|
||||
template <class T>
|
||||
struct type
|
||||
: ::boost::is_convertible<T,::boost::detail::int_convertible>
|
||||
{
|
||||
};
|
||||
};
|
||||
} // namespace detail
|
||||
#if !(defined(__BORLANDC__) && (__BORLANDC__ <= 0x551))
|
||||
template <typename T> struct is_enum
|
||||
{
|
||||
private:
|
||||
typedef ::boost::add_reference<T> ar_t;
|
||||
typedef typename ar_t::type r_type;
|
||||
|
||||
# if (defined(__MWERKS__) && __MWERKS__ >= 0x3000) || BOOST_MSVC > 1301 || defined(BOOST_NO_COMPILER_CONFIG)
|
||||
BOOST_STATIC_CONSTANT(bool, selector =
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::is_arithmetic<T>::value
|
||||
, ::boost::is_reference<T>::value
|
||||
// We MUST do this on conforming compilers in order to
|
||||
// correctly deduce that noncopyable types are not enums (dwa
|
||||
// 2002/04/15)...
|
||||
, ::boost::is_class<T>::value
|
||||
>::value));
|
||||
# else
|
||||
BOOST_STATIC_CONSTANT(bool, selector =
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::is_arithmetic<T>::value
|
||||
, ::boost::is_reference<T>::value
|
||||
// However, not doing this on non-conforming compilers prevents
|
||||
// a dependency recursion.
|
||||
>::value));
|
||||
# endif
|
||||
#ifdef __BORLANDC__
|
||||
typedef ::boost::detail::is_enum_helper< ::boost::is_enum<T>::selector> se_t;
|
||||
#else
|
||||
typedef ::boost::detail::is_enum_helper<selector> se_t;
|
||||
#endif
|
||||
typedef typename se_t::template type<r_type> helper;
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, value = helper::value);
|
||||
};
|
||||
|
||||
// Specializations suppress some nasty warnings with GCC
|
||||
template<>
|
||||
struct is_enum<float>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
|
||||
template<>
|
||||
struct is_enum<double>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
|
||||
template<>
|
||||
struct is_enum<long double>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
|
||||
#else // __BORLANDC__
|
||||
//
|
||||
// buggy is_convertible prevents working
|
||||
// implementation of is_enum:
|
||||
template <typename T> struct is_enum
|
||||
{
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_ENUM(T));
|
||||
};
|
||||
#endif
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_member_pointer
|
||||
*
|
||||
**********************************************/
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__)
|
||||
template <typename T> struct is_member_pointer
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = ::boost::is_member_function_pointer<T>::value); };
|
||||
template <typename T, typename U> struct is_member_pointer<U T::*>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_member_function_pointer
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct is_member_function_pointer{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
|
||||
template <class R, class T>
|
||||
struct is_member_function_pointer<R (T::*)(void)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0>
|
||||
struct is_member_function_pointer<R (T::*)(A0)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
|
||||
// Metrowerks thinks this creates ambiguities
|
||||
# if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
|
||||
template <class R, class T>
|
||||
struct is_member_function_pointer<R (T::*)(void)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0>
|
||||
struct is_member_function_pointer<R (T::*)(A0)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)const>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
|
||||
template <class R, class T>
|
||||
struct is_member_function_pointer<R (T::*)(void)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0>
|
||||
struct is_member_function_pointer<R (T::*)(A0)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
|
||||
template <class R, class T>
|
||||
struct is_member_function_pointer<R (T::*)(void)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0>
|
||||
struct is_member_function_pointer<R (T::*)(A0)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T, 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>
|
||||
struct is_member_function_pointer<R (T::*)(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)const volatile>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
|
||||
# endif // __MWERKS__ < 0x3000
|
||||
#else
|
||||
|
||||
namespace detail{
|
||||
template <class R, class T>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(void));
|
||||
template <class R, class T, class A0>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0));
|
||||
template <class R, class T, class A0, class A1>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1));
|
||||
template <class R, class T, class A0, class A1, class A2>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2));
|
||||
template <class R, class T, class A0, class A1, class A2, class A3>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3));
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4));
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5));
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6));
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7));
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19));
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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 T, 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_member_function_pointer_helper(R (T::*)(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 T, 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_member_function_pointer_helper(R (T::*)(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 T, 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_member_function_pointer_helper(R (T::*)(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 T, 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_member_function_pointer_helper(R (T::*)(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 T, 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_member_function_pointer_helper(R (T::*)(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 T, 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_member_function_pointer_helper(R (T::*)(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 T, 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_member_function_pointer_helper(R (T::*)(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 T, 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_member_function_pointer_helper(R (T::*)(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 T, 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_member_function_pointer_helper(R (T::*)(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));
|
||||
|
||||
template <class R, class T>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(void) const);
|
||||
template <class R, class T, class A0>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0) const);
|
||||
template <class R, class T, class A0, class A1>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1) const);
|
||||
template <class R, class T, class A0, class A1, class A2>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2) const);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3) const);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4) const);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5) const);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6) const);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7) const);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const);
|
||||
|
||||
template <class R, class T>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(void) volatile);
|
||||
template <class R, class T, class A0>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0) volatile);
|
||||
template <class R, class T, class A0, class A1>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1) volatile);
|
||||
template <class R, class T, class A0, class A1, class A2>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2) volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3) volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4) volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5) volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6) volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7) volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) volatile);
|
||||
|
||||
template <class R, class T>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(void) const volatile);
|
||||
template <class R, class T, class A0>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0) const volatile);
|
||||
template <class R, class T, class A0, class A1>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1) const volatile);
|
||||
template <class R, class T, class A0, class A1, class A2>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2) const volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3) const volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4) const volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5) const volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6) const volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7) const volatile);
|
||||
template <class R, class T, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
::boost::type_traits::yes_type is_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const volatile);
|
||||
template <class R, class T, 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_member_function_pointer_helper(R (T::*)(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) const volatile);
|
||||
::boost::type_traits::no_type BOOST_TT_DECL is_member_function_pointer_helper(...);
|
||||
|
||||
template <class R, class T>
|
||||
::boost::type_traits::yes_type BOOST_TT_DECL is_member_pointer_helper(R T::*);
|
||||
::boost::type_traits::no_type BOOST_TT_DECL is_member_pointer_helper(...);
|
||||
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <bool maybe = false>
|
||||
struct is_member_function_pointer_select
|
||||
: ::boost::type_traits::false_unary_metafunction
|
||||
{
|
||||
};
|
||||
|
||||
template <>
|
||||
struct is_member_function_pointer_select<true>
|
||||
{
|
||||
template <class T>
|
||||
struct apply
|
||||
{
|
||||
static T& make_t();
|
||||
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value = (1 == sizeof(detail::is_member_function_pointer_helper(make_t()))) );
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct is_member_function_pointer : ::boost::detail::is_member_function_pointer_select<
|
||||
::boost::detail::neither_array_nor_reference<T>::value
|
||||
>::template apply<T>
|
||||
{};
|
||||
|
||||
template <>
|
||||
struct is_member_function_pointer<void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct is_member_function_pointer<const void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <>
|
||||
struct is_member_function_pointer<volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <>
|
||||
struct is_member_function_pointer<const volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#endif
|
||||
#ifdef __BORLANDC__
|
||||
template <typename T> struct is_member_pointer
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
template <typename T, typename U> struct is_member_pointer<U T::*>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#else
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <bool maybe = false>
|
||||
struct is_member_pointer_select
|
||||
: ::boost::type_traits::false_unary_metafunction
|
||||
{
|
||||
};
|
||||
|
||||
template <>
|
||||
struct is_member_pointer_select<true>
|
||||
{
|
||||
template <class T>
|
||||
struct apply
|
||||
{
|
||||
static T& make_t();
|
||||
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value =
|
||||
(::boost::type_traits::ice_or<
|
||||
(1 == sizeof(detail::is_member_function_pointer_helper(make_t()))),
|
||||
(1 == sizeof(detail::is_member_pointer_helper(make_t())))
|
||||
>::value) );
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct is_member_pointer : ::boost::detail::is_member_pointer_select<
|
||||
::boost::detail::neither_array_nor_reference<T>::value
|
||||
>::template apply<T>
|
||||
{};
|
||||
|
||||
template <>
|
||||
struct is_member_pointer<void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct is_member_pointer<const void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <>
|
||||
struct is_member_pointer<volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <>
|
||||
struct is_member_pointer<const volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#endif
|
||||
#endif // __BORLANDC__
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_COMPOSITE_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
328
include/boost/type_traits/conversion_traits.hpp
Normal file
328
include/boost/type_traits/conversion_traits.hpp
Normal file
@ -0,0 +1,328 @@
|
||||
|
||||
// Copyright (C) 2000 John Maddock (john_maddock@compuserve.com)
|
||||
// Copyright (C) 2000 Jeremy Siek (jsiek@lsc.nd.edu)
|
||||
// Copyright (C) 1999, 2000 Jaakko J„rvi (jaakko.jarvi@cs.utu.fi)
|
||||
//
|
||||
// Permission to copy and use this software is granted,
|
||||
// provided this copyright notice appears in all copies.
|
||||
// Permission to modify the code and to distribute modified code is granted,
|
||||
// provided this copyright notice appears in all copies, and a notice
|
||||
// that the code was modified is included with the copyright notice.
|
||||
//
|
||||
// This software is provided "as is" without express or implied warranty,
|
||||
// and with no claim as to its suitability for any purpose.
|
||||
//
|
||||
|
||||
#ifndef BOOST_CONVERSION_TYPE_TRAITS_HPP
|
||||
#define BOOST_CONVERSION_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_ARITHMETIC_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits/arithmetic_traits.hpp>
|
||||
#endif
|
||||
//
|
||||
// is one type convertable to another?
|
||||
//
|
||||
// there are multiple versions of the is_convertible
|
||||
// template, almost every compiler seems to require its
|
||||
// own version.
|
||||
//
|
||||
// Thanks to Andrei Alexandrescu for the original version of the
|
||||
// conversion detection technique!
|
||||
//
|
||||
|
||||
namespace boost{
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
|
||||
//
|
||||
// MS specific version:
|
||||
//
|
||||
namespace detail{
|
||||
|
||||
// This workaround is necessary to handle when From is void
|
||||
// which is normally taken care of by the partial specialization
|
||||
// of the is_convertible class.
|
||||
using ::boost::type_traits::yes_type;
|
||||
using ::boost::type_traits::no_type;
|
||||
|
||||
struct from_not_void_conversion {
|
||||
template <class From, class To>
|
||||
struct n_bind {
|
||||
static no_type BOOST_TT_DECL _m_check(...);
|
||||
static yes_type BOOST_TT_DECL _m_check(To);
|
||||
public:
|
||||
void foo(); // avoid warning about all members being private
|
||||
static From _m_from;
|
||||
enum { exists = sizeof( _m_check(_m_from) ) == sizeof(yes_type) };
|
||||
};
|
||||
};
|
||||
struct from_is_void_conversion {
|
||||
template <class From, class To>
|
||||
struct n_bind {
|
||||
enum { exists = ::boost::is_void<To>::value };
|
||||
};
|
||||
};
|
||||
|
||||
template <class From>
|
||||
struct conversion_helper {
|
||||
typedef from_not_void_conversion type;
|
||||
};
|
||||
template <>
|
||||
struct conversion_helper<void> {
|
||||
typedef from_is_void_conversion type;
|
||||
};
|
||||
} // namespace detail
|
||||
|
||||
template <class From, class To>
|
||||
struct is_convertible
|
||||
{
|
||||
typedef typename detail::conversion_helper<From>::type Selector;
|
||||
typedef typename Selector::template n_bind<From,To> Conversion;
|
||||
public:
|
||||
enum { value = Conversion::exists };
|
||||
};
|
||||
|
||||
#elif defined(__BORLANDC__)
|
||||
//
|
||||
// special version for Borland compilers
|
||||
// this version breaks when used for some
|
||||
// UDT conversions:
|
||||
//
|
||||
template <class From, class To>
|
||||
struct is_convertible
|
||||
{
|
||||
private:
|
||||
#pragma option push -w-8074
|
||||
// This workaround for Borland breaks the EDG C++ frontend,
|
||||
// so we only use it for Borland.
|
||||
template <class T>
|
||||
struct checker
|
||||
{
|
||||
static type_traits::no_type BOOST_TT_DECL _m_check(...);
|
||||
static type_traits::yes_type BOOST_TT_DECL _m_check(T);
|
||||
};
|
||||
static From _m_from;
|
||||
public:
|
||||
static const bool value = sizeof( checker<To>::_m_check(_m_from) ) == sizeof(type_traits::yes_type);
|
||||
|
||||
void foo(); // avoid warning about all members being private
|
||||
#pragma option pop
|
||||
};
|
||||
|
||||
#elif defined(__GNUC__)
|
||||
//
|
||||
// special version for gcc compiler
|
||||
//
|
||||
namespace detail{
|
||||
struct any_conversion
|
||||
{
|
||||
template <class T>
|
||||
any_conversion(const T&);
|
||||
template <class T>
|
||||
any_conversion(T&);
|
||||
};
|
||||
template <class T>
|
||||
struct checker
|
||||
{
|
||||
static boost::type_traits::no_type _m_check(any_conversion ...);
|
||||
static boost::type_traits::yes_type _m_check(T, int);
|
||||
};
|
||||
} // namespace detail
|
||||
template <class From, class To>
|
||||
struct is_convertible
|
||||
{
|
||||
private:
|
||||
static From _m_from;
|
||||
public:
|
||||
static const bool value = sizeof( detail::checker<To>::_m_check(_m_from, 0) ) == sizeof(type_traits::yes_type);
|
||||
|
||||
void foo(); // avoid warning about all members being private
|
||||
};
|
||||
|
||||
// Declare specializations of is_convertible for all of the floating
|
||||
// types to all of the integral types. This suppresses some nasty
|
||||
// warnings
|
||||
|
||||
# define BOOST_IS_CONVERTIBLE(T1,T2) template<>struct is_convertible<T1,T2>{static const bool value=true;};
|
||||
# define BOOST_IS_CONVERTIBLE2(T1,T2) \
|
||||
BOOST_IS_CONVERTIBLE(T1,signed T2) \
|
||||
BOOST_IS_CONVERTIBLE(T1,unsigned T2)
|
||||
|
||||
# define BOOST_FLOAT_IS_CONVERTIBLE(F) \
|
||||
BOOST_IS_CONVERTIBLE(F,char) \
|
||||
BOOST_IS_CONVERTIBLE2(F,char) \
|
||||
BOOST_IS_CONVERTIBLE2(F,short) \
|
||||
BOOST_IS_CONVERTIBLE2(F,int) \
|
||||
BOOST_IS_CONVERTIBLE2(F,long) \
|
||||
BOOST_IS_CONVERTIBLE2(F,long long)
|
||||
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(float)
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(double)
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(long double)
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(float const)
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(double const)
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(long double const)
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(float volatile)
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(double volatile)
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(long double volatile)
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(float const volatile)
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(double const volatile)
|
||||
BOOST_FLOAT_IS_CONVERTIBLE(long double const volatile)
|
||||
# undef BOOST_FLOAT_IS_CONVERTIBLE
|
||||
# undef BOOST_IS_CONVERTIBLE2
|
||||
# undef BOOST_IS_CONVERTIBLE
|
||||
#else
|
||||
|
||||
template <class From, class To>
|
||||
struct is_convertible
|
||||
{
|
||||
private:
|
||||
static type_traits::no_type BOOST_TT_DECL _m_check(...);
|
||||
static type_traits::yes_type BOOST_TT_DECL _m_check(To);
|
||||
static From _m_from;
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, value = sizeof( _m_check(_m_from) ) == sizeof(type_traits::yes_type));
|
||||
void foo(); // avoid warning about all members being private
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||
// A definition is required even for integral static constants
|
||||
template <class From, class To>
|
||||
const bool is_convertible<From, To>::value;
|
||||
#endif
|
||||
|
||||
|
||||
#endif // is_convertible
|
||||
|
||||
//
|
||||
// Now add the full and partial specialisations
|
||||
// for void types, these are common to all the
|
||||
// implementation above:
|
||||
//
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <class From>
|
||||
struct is_convertible<From, void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <class From>
|
||||
struct is_convertible<From, const void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <class From>
|
||||
struct is_convertible<From, volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <class From>
|
||||
struct is_convertible<From, const volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#endif // BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
|
||||
template <class To>
|
||||
struct is_convertible<void, To>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <class To>
|
||||
struct is_convertible<const void, To>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <class To>
|
||||
struct is_convertible<volatile void, To>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <class To>
|
||||
struct is_convertible<const volatile void, To>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#endif
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
template <>
|
||||
struct is_convertible<void, void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct is_convertible<void, const void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<void, volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<void, const volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<const void, const void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<const void, volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<const void, const volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<volatile void, const void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<volatile void, volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<volatile void, const volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<const volatile void, const void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<const volatile void, volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<const volatile void, const volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // include guard
|
||||
|
||||
|
||||
399
include/boost/type_traits/cv_traits.hpp
Normal file
399
include/boost/type_traits/cv_traits.hpp
Normal file
@ -0,0 +1,399 @@
|
||||
// (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 cv-qualified types:
|
||||
// is_const, is_volatile, remove_const, remove_volatile, remove_cv.
|
||||
//
|
||||
// Revision History:
|
||||
// 24th March 2001:
|
||||
// Fixed is_const/is_volatile so that they work with reference types
|
||||
|
||||
#ifndef BOOST_CV_TYPE_TRAITS_HPP
|
||||
#define BOOST_CV_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_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_TT_UTILITY_HPP
|
||||
# include <boost/type_traits/utility.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
namespace detail{
|
||||
//
|
||||
// implementation helper:
|
||||
//
|
||||
template <class T>
|
||||
struct cv_traits_imp{};
|
||||
|
||||
template <class T>
|
||||
struct cv_traits_imp<T*>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, is_const = false);
|
||||
BOOST_STATIC_CONSTANT(bool, is_volatile = false);
|
||||
typedef T unqualified_type;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct cv_traits_imp<const T*>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, is_const = true);
|
||||
BOOST_STATIC_CONSTANT(bool, is_volatile = false);
|
||||
typedef T unqualified_type;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct cv_traits_imp<volatile T*>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, is_const = false);
|
||||
BOOST_STATIC_CONSTANT(bool, is_volatile = true);
|
||||
typedef T unqualified_type;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct cv_traits_imp<const volatile T*>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, is_const = true);
|
||||
BOOST_STATIC_CONSTANT(bool, is_volatile = true);
|
||||
typedef T unqualified_type;
|
||||
};
|
||||
|
||||
template <class T, bool is_vol>
|
||||
struct remove_const_helper
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
template <class T>
|
||||
struct remove_const_helper<T, true>
|
||||
{
|
||||
typedef volatile T type;
|
||||
};
|
||||
|
||||
template <class T, bool is_vol>
|
||||
struct remove_volatile_helper
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
template <class T>
|
||||
struct remove_volatile_helper<T, true>
|
||||
{
|
||||
typedef const T type;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// * convert a type T to a non-volatile type - remove_volatile<T>
|
||||
template <typename T>
|
||||
struct remove_volatile
|
||||
{
|
||||
typedef typename detail::cv_traits_imp<T*>::unqualified_type uq_type;
|
||||
typedef typename detail::remove_volatile_helper<uq_type, ::boost::is_const<T>::value>::type type;
|
||||
};
|
||||
template <typename T> struct remove_volatile<T&>{ typedef T& type; };
|
||||
template <typename T, std::size_t N> struct remove_volatile<volatile T[N]>{ typedef T type[N]; };
|
||||
template <typename T, std::size_t N> struct remove_volatile<const volatile T[N]>{ typedef const T type[N]; };
|
||||
|
||||
// * convert a type T to non-const type - remove_const<T>
|
||||
template <typename T>
|
||||
struct remove_const
|
||||
{
|
||||
typedef typename detail::cv_traits_imp<T*>::unqualified_type uq_type;
|
||||
typedef typename detail::remove_const_helper<uq_type, ::boost::is_volatile<T>::value>::type type;
|
||||
};
|
||||
template <typename T> struct remove_const<T&>{ typedef T& type; };
|
||||
template <typename T, std::size_t N> struct remove_const<const T[N]>{ typedef T type[N]; };
|
||||
template <typename T, std::size_t N> struct remove_const<const volatile T[N]>{ typedef volatile T type[N]; };
|
||||
|
||||
// convert a type T to a non-cv-qualified type - remove_cv<T>
|
||||
template <typename T>
|
||||
struct remove_cv
|
||||
{
|
||||
typedef typename detail::cv_traits_imp<T*>::unqualified_type type;
|
||||
};
|
||||
template <typename T> struct remove_cv<T&>{ typedef T& type; };
|
||||
template <typename T, std::size_t N> struct remove_cv<const T[N]>{ typedef T type[N]; };
|
||||
template <typename T, std::size_t N> struct remove_cv<volatile T[N]>{ typedef T type[N]; };
|
||||
template <typename T, std::size_t N> struct remove_cv<const volatile T[N]>{ typedef T type[N]; };
|
||||
|
||||
//* is a type T declared const - is_const<T>
|
||||
template <typename T>
|
||||
struct is_const
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = detail::cv_traits_imp<T*>::is_const);
|
||||
};
|
||||
template <typename T> struct is_const<T&>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
#if defined(__BORLANDC__)
|
||||
// these are illegal specialisations; cv-qualifies applied to
|
||||
// references have no effect according to [8.3.2p1],
|
||||
// C++ Builder requires them though as it treats cv-qualified
|
||||
// references as distinct types...
|
||||
template <typename T> struct is_const<T&const>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
template <typename T> struct is_const<T&volatile>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
template <typename T> struct is_const<T&const volatile>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
#endif
|
||||
|
||||
//* is a type T declared volatile - is_volatile<T>
|
||||
template <typename T>
|
||||
struct is_volatile
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = detail::cv_traits_imp<T*>::is_volatile);
|
||||
};
|
||||
template <typename T> struct is_volatile<T&>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
#if defined(__BORLANDC__)
|
||||
// these are illegal specialisations; cv-qualifies applied to
|
||||
// references have no effect according to [8.3.2p1],
|
||||
// C++ Builder requires them though as it treats cv-qualified
|
||||
// references as distinct types...
|
||||
template <typename T> struct is_volatile<T&const>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
template <typename T> struct is_volatile<T&volatile>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
template <typename T> struct is_volatile<T&const volatile>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
#endif
|
||||
|
||||
#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
// The following three don't work:
|
||||
template <typename T> struct remove_volatile{ typedef T type; };
|
||||
template <typename T> struct remove_const{ typedef T type; };
|
||||
template <typename T> struct remove_cv{ typedef T type; };
|
||||
|
||||
namespace detail{
|
||||
using ::boost::type_traits::yes_type;
|
||||
using ::boost::type_traits::no_type;
|
||||
yes_type is_const_helper(const volatile void*);
|
||||
no_type is_const_helper(volatile void *);
|
||||
yes_type is_volatile_helper(const volatile void*);
|
||||
no_type is_volatile_helper(const void *);
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <bool is_ref = true, bool array>
|
||||
struct is_const_impl
|
||||
: ::boost::type_traits::false_unary_metafunction
|
||||
{};
|
||||
|
||||
template <>
|
||||
struct is_const_impl<false,false>
|
||||
{
|
||||
template <class T>
|
||||
struct apply
|
||||
{
|
||||
private:
|
||||
static T* t;
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, value = (sizeof(detail::yes_type) == sizeof(detail::is_const_helper(t))));
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct is_const_impl<false,true>
|
||||
{
|
||||
template <class T>
|
||||
struct apply
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, value = (sizeof(detail::yes_type) == sizeof(detail::is_const_helper(&t))));
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct is_const
|
||||
: ::boost::detail::is_const_impl<
|
||||
is_reference<T>::value
|
||||
, is_array<T>::value
|
||||
>::template apply<T>
|
||||
{
|
||||
};
|
||||
|
||||
template <>
|
||||
struct is_const<void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct is_const<const void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_const<volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <>
|
||||
struct is_const<const volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
#endif
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <bool is_ref = true, bool array>
|
||||
struct is_volatile_impl
|
||||
: ::boost::type_traits::false_unary_metafunction
|
||||
{};
|
||||
|
||||
template <>
|
||||
struct is_volatile_impl<false,false>
|
||||
{
|
||||
template <class T>
|
||||
struct apply
|
||||
{
|
||||
private:
|
||||
static T* t;
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, value = (sizeof(detail::yes_type) == sizeof(detail::is_volatile_helper(t))));
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct is_volatile_impl<false,true>
|
||||
{
|
||||
template <class T>
|
||||
struct apply
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, value = (sizeof(detail::yes_type) == sizeof(detail::is_volatile_helper(&t))));
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct is_volatile
|
||||
: ::boost::detail::is_volatile_impl<
|
||||
is_reference<T>::value
|
||||
, is_array<T>::value
|
||||
>::template apply<T>
|
||||
{
|
||||
};
|
||||
|
||||
|
||||
template <>
|
||||
struct is_volatile<void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct is_volatile<const void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <>
|
||||
struct is_volatile<volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct is_volatile<const volatile void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
// * convert a type T to const type - add_const<T>
|
||||
// this is not required since the result is always
|
||||
// the same as "T const", but it does suppress warnings
|
||||
// from some compilers:
|
||||
template <typename T>
|
||||
struct add_const
|
||||
{
|
||||
#if defined(BOOST_MSVC)
|
||||
// This bogus warning will appear when add_const is applied to a
|
||||
// const volatile reference because we can't detect const volatile
|
||||
// references with MSVC6.
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
|
||||
#endif
|
||||
typedef T const type;
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
};
|
||||
// * convert a type T to volatile type - add_volatile<T>
|
||||
// this is not required since the result is always
|
||||
// the same as "T volatile", but it does suppress warnings
|
||||
// from some compilers:
|
||||
template <typename T>
|
||||
struct add_volatile
|
||||
{
|
||||
#if defined(BOOST_MSVC)
|
||||
// This bogus warning will appear when add_volatile is applied to a
|
||||
// const volatile reference because we can't detect const volatile
|
||||
// references with MSVC6.
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
|
||||
#endif
|
||||
typedef T volatile type;
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
};
|
||||
// * convert a type T to a const volatile type - add_cv<T>
|
||||
// this is not required since the result is always
|
||||
// the same as "T const volatile", but it does suppress warnings
|
||||
// from some compilers:
|
||||
template <typename T>
|
||||
struct add_cv
|
||||
{
|
||||
#if defined(BOOST_MSVC)
|
||||
// This bogus warning will appear when add_volatile is applied to a
|
||||
// const volatile reference because we can't detect const volatile
|
||||
// references with MSVC6.
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
|
||||
#endif
|
||||
typedef T const volatile type;
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
};
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <class T>
|
||||
struct add_const<T&>{ typedef T& type; };
|
||||
template <class T>
|
||||
struct add_volatile<T&>{ typedef T& type; };
|
||||
template <class T>
|
||||
struct add_cv<T&>{ typedef T& type; };
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
|
||||
#endif // BOOST_CV_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
153
include/boost/type_traits/function_traits.hpp
Normal file
153
include/boost/type_traits/function_traits.hpp
Normal file
@ -0,0 +1,153 @@
|
||||
|
||||
// Copyright (C) 2000 John Maddock (john_maddock@compuserve.com)
|
||||
//
|
||||
// Permission to copy and use this software is granted,
|
||||
// provided this copyright notice appears in all copies.
|
||||
// Permission to modify the code and to distribute modified code is granted,
|
||||
// provided this copyright notice appears in all copies, and a notice
|
||||
// that the code was modified is included with the copyright notice.
|
||||
//
|
||||
// This software is provided "as is" without express or implied warranty,
|
||||
// and with no claim as to its suitability for any purpose.
|
||||
|
||||
#ifndef BOOST_FUNCTION_TYPE_TRAITS_HPP
|
||||
#define BOOST_FUNCTION_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_COMPOSITE_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits/composite_traits.hpp>
|
||||
#endif
|
||||
//
|
||||
// is a type a function?
|
||||
// Please note that this implementation is unnecessarily complex:
|
||||
// we could just use !is_convertible<T*, const volatile void*>::value,
|
||||
// except that some compilers erroneously allow conversions from
|
||||
// function pointers to void*.
|
||||
//
|
||||
namespace boost{
|
||||
namespace detail{
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
template <class R>
|
||||
struct is_function_helper_base{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
template <class R>
|
||||
struct is_function_helper_base<R (*)(void)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class A0>
|
||||
struct is_function_helper_base<R (*)(A0)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class A0, class A1>
|
||||
struct is_function_helper_base<R (*)(A0, A1)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class A0, class A1, class A2>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class A0, class A1, class A2, class A3>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class A0, class A1, class A2, class A3, class A4>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<R (*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<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)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<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)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<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)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<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)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<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)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
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>
|
||||
struct is_function_helper_base<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)>{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
|
||||
template <class T>
|
||||
struct is_function_helper : is_function_helper_base<T*>{};
|
||||
|
||||
#else
|
||||
|
||||
template <class T>
|
||||
struct is_function_helper
|
||||
{
|
||||
static T* t;
|
||||
BOOST_STATIC_CONSTANT(bool, value = sizeof(is_function_tester(t)) == sizeof(::boost::type_traits::yes_type));
|
||||
//BOOST_STATIC_CONSTANT(bool, value = (!::boost::is_convertible<T*, const volatile void*>::value));
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
template <class T>
|
||||
struct is_function_ref_helper
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
template <class T, bool is_ref>
|
||||
struct is_function_chooser
|
||||
{
|
||||
typedef is_function_helper<T> type;
|
||||
};
|
||||
template <class T>
|
||||
struct is_function_chooser<T, true>
|
||||
{
|
||||
typedef is_function_ref_helper<T> type;
|
||||
};
|
||||
#endif
|
||||
} // namespace detail
|
||||
|
||||
template <class T>
|
||||
struct is_function
|
||||
{
|
||||
private:
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
typedef typename detail::is_function_chooser<T, ::boost::is_reference<T>::value>::type m_type;
|
||||
#else
|
||||
// without partial specialistaion we can't use is_reference on
|
||||
// function types, that leaves this template broken in the case that
|
||||
// T is a reference:
|
||||
typedef detail::is_function_helper<T> m_type;
|
||||
#endif
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, value = m_type::value);
|
||||
};
|
||||
|
||||
} // boost
|
||||
|
||||
#endif // BOOST_FUNCTION_TYPE_TRAITS_HPP
|
||||
201
include/boost/type_traits/fwd.hpp
Normal file
201
include/boost/type_traits/fwd.hpp
Normal file
@ -0,0 +1,201 @@
|
||||
// (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.
|
||||
//
|
||||
// forward declarations of type_traits classes
|
||||
//
|
||||
#ifndef BOOST_FWD_TYPE_TRAITS_HPP
|
||||
#define BOOST_FWD_TYPE_TRAITS_HPP
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstddef>
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
#include <boost/config.hpp>
|
||||
#endif
|
||||
|
||||
//
|
||||
// Helper macros for builtin compiler support.
|
||||
// If your compiler has builtin support for any of the following
|
||||
// traits concepts, then redefine the appropriate macros to pick
|
||||
// up on the compiler support:
|
||||
//
|
||||
// (these should largely ignore cv-qualifiers)
|
||||
// BOOST_IS_CLASS(T) should evaluate to true if T is a class or struct type
|
||||
// BOOST_IS_ENUM(T) should evaluate to true if T is an enumerator type
|
||||
// BOOST_IS_UNION(T) should evaluate to true if T is a union type
|
||||
// BOOST_IS_POD(T) should evaluate to true if T is a POD type
|
||||
// BOOST_IS_EMPTY(T) should evaluate to true if T is an empty struct or union
|
||||
// BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect
|
||||
// BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy
|
||||
// BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy
|
||||
// BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect
|
||||
|
||||
#ifdef BOOST_HAS_SGI_TYPE_TRAITS
|
||||
# define BOOST_IS_POD(T) ::boost::is_same< typename ::__type_traits<T>::is_POD_type, ::__true_type>::value
|
||||
# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_default_constructor, ::__true_type>::value
|
||||
# define BOOST_HAS_TRIVIAL_COPY(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_copy_constructor, ::__true_type>::value
|
||||
# define BOOST_HAS_TRIVIAL_ASSIGN(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_assignment_operator, ::__true_type>::value
|
||||
# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) ::boost::is_same< typename ::__type_traits<T>::has_trivial_destructor, ::__true_type>::value
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_IS_CLASS
|
||||
# define BOOST_IS_CLASS(T) false
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_IS_ENUM
|
||||
# define BOOST_IS_ENUM(T) false
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_IS_UNION
|
||||
# define BOOST_IS_UNION(T) false
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_IS_POD
|
||||
# define BOOST_IS_POD(T) false
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_IS_EMPTY
|
||||
# define BOOST_IS_EMPTY(T) false
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_HAS_TRIVIAL_CONSTRUCTOR
|
||||
# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_HAS_TRIVIAL_COPY
|
||||
# define BOOST_HAS_TRIVIAL_COPY(T) false
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_HAS_TRIVIAL_ASSIGN
|
||||
# define BOOST_HAS_TRIVIAL_ASSIGN(T) false
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_HAS_TRIVIAL_DESTRUCTOR
|
||||
# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false
|
||||
#endif
|
||||
|
||||
//
|
||||
// whenever we have a conversion function with elipses
|
||||
// it needs to be declared __cdecl to suppress compiler
|
||||
// warnings from MS and Borland compilers:
|
||||
#if defined(BOOST_MSVC) || defined(__BORLANDC__)
|
||||
#define BOOST_TT_DECL __cdecl
|
||||
#else
|
||||
#define BOOST_TT_DECL
|
||||
#endif
|
||||
|
||||
|
||||
namespace boost{
|
||||
//
|
||||
// forward declare all type traits templates here
|
||||
//
|
||||
// conversion_traits.hpp:
|
||||
template <class From, class To>
|
||||
struct is_convertible;
|
||||
// alignment_traits.hpp:
|
||||
template <class T>
|
||||
struct alignment_of;
|
||||
// arithmetic_traits.hpp:
|
||||
template <class T>
|
||||
struct is_void;
|
||||
template <class T>
|
||||
struct is_integral;
|
||||
template <class T>
|
||||
struct is_float;
|
||||
template <class T>
|
||||
struct is_arithmetic;
|
||||
template <class T>
|
||||
struct is_fundamental;
|
||||
|
||||
// cv_traits.hpp:
|
||||
template <class T>
|
||||
struct is_const;
|
||||
template <class T>
|
||||
struct is_volatile;
|
||||
template <class T>
|
||||
struct remove_const;
|
||||
template <class T>
|
||||
struct remove_volatile;
|
||||
template <class T>
|
||||
struct remove_cv;
|
||||
template <class T>
|
||||
struct add_const;
|
||||
template <class T>
|
||||
struct add_volatile;
|
||||
template <class T>
|
||||
struct add_cv;
|
||||
|
||||
// composite_traits.hpp:
|
||||
template <class T>
|
||||
struct is_array;
|
||||
template <class T>
|
||||
struct is_pointer;
|
||||
template <class T>
|
||||
struct is_reference;
|
||||
template <class T>
|
||||
struct is_member_pointer;
|
||||
template <class T>
|
||||
struct is_member_function_pointer;
|
||||
template <class T>
|
||||
struct is_enum;
|
||||
template <class T>
|
||||
struct is_union;
|
||||
|
||||
// object_traits.hpp:
|
||||
template <class T>
|
||||
struct is_object;
|
||||
template <class T>
|
||||
struct is_scalar;
|
||||
template <class T>
|
||||
struct is_class;
|
||||
template <class T>
|
||||
struct is_compound;
|
||||
template <class T>
|
||||
struct is_POD;
|
||||
template <class T>
|
||||
struct has_trivial_constructor;
|
||||
template <class T>
|
||||
struct has_trivial_copy;
|
||||
template <class T>
|
||||
struct has_trivial_assign;
|
||||
template <class T>
|
||||
struct has_trivial_destructor;
|
||||
template <class T>
|
||||
struct has_nothrow_constructor;
|
||||
template <class T>
|
||||
struct has_nothrow_copy;
|
||||
template <class T>
|
||||
struct has_nothrow_assign;
|
||||
template <class T>
|
||||
struct is_empty;
|
||||
template <class Base, class Derived>
|
||||
struct is_base_and_derived;
|
||||
|
||||
// transform_traits.hpp:
|
||||
template <class T>
|
||||
struct remove_reference;
|
||||
template <class T>
|
||||
struct add_reference;
|
||||
template <class T>
|
||||
struct remove_bounds;
|
||||
template <class T>
|
||||
struct remove_pointer;
|
||||
template <class T>
|
||||
struct add_pointer;
|
||||
|
||||
// same_traits.hpp:
|
||||
template <class T, class U>
|
||||
struct is_same;
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_FWD_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
87
include/boost/type_traits/ice.hpp
Normal file
87
include/boost/type_traits/ice.hpp
Normal file
@ -0,0 +1,87 @@
|
||||
|
||||
// (C) Copyright John Maddock and Steve Cleary 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.
|
||||
//
|
||||
// macros and helpers for working with integral-constant-expressions.
|
||||
|
||||
#ifndef BOOST_ICE_TYPE_TRAITS_HPP
|
||||
#define BOOST_ICE_TYPE_TRAITS_HPP
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
#include <boost/config.hpp>
|
||||
#endif
|
||||
|
||||
|
||||
namespace boost{
|
||||
namespace type_traits{
|
||||
|
||||
typedef char yes_type;
|
||||
typedef double no_type;
|
||||
|
||||
template <bool b>
|
||||
struct ice_not
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <>
|
||||
struct ice_not<true>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
|
||||
template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
|
||||
struct ice_or;
|
||||
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
|
||||
struct ice_or
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <>
|
||||
struct ice_or<false, false, false, false, false, false, false>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
|
||||
template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
|
||||
struct ice_and;
|
||||
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
|
||||
struct ice_and
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <>
|
||||
struct ice_and<true, true, true, true, true, true, true>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
|
||||
template <int b1, int b2>
|
||||
struct ice_eq
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = (b1 == b2));
|
||||
};
|
||||
|
||||
template <int b1, int b2>
|
||||
struct ice_ne
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = (b1 != b2));
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||
template <int b1, int b2>
|
||||
const bool ice_eq<b1,b2>::value;
|
||||
template <int b1, int b2>
|
||||
const bool ice_ne<b1,b2>::value;
|
||||
#endif
|
||||
|
||||
} // namespace type_traits
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ICE_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
49
include/boost/type_traits/is_class.hpp
Normal file
49
include/boost/type_traits/is_class.hpp
Normal file
@ -0,0 +1,49 @@
|
||||
// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
|
||||
// Hinnant & John Maddock 2000-2002. 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_TYPE_TRAITS_IS_CLASS_HPP
|
||||
# define BOOST_TYPE_TRAITS_IS_CLASS_HPP
|
||||
|
||||
# if (defined(__MWERKS__) && __MWERKS__ >= 0x3000) || defined(BOOST_MSVC) && _MSC_FULL_VER > 13012108 || defined(BOOST_NO_COMPILER_CONFIG)
|
||||
# ifndef BOOST_ICE_TYPE_TRAITS_HPP
|
||||
# include <boost/type_traits/ice.hpp>
|
||||
# endif
|
||||
|
||||
# define BOOST_TYPE_TRAITS_IS_CLASS_DEFINED
|
||||
namespace boost {
|
||||
|
||||
template <typename T>
|
||||
struct is_class
|
||||
{
|
||||
// This is actually the conforming implementation which works with
|
||||
// abstract classes. However, enough compilers have trouble with
|
||||
// it that most will use the one in
|
||||
// boost/type_traits/object_traits.hpp. This implementation
|
||||
// actually works with VC7.0, but other interactions seem to fail
|
||||
// when we use it.
|
||||
|
||||
// is_class<> metafunction due to Paul Mensonides
|
||||
// (leavings@attbi.com). For more details:
|
||||
// http://groups.google.com/groups?hl=en&selm=000001c1cc83%24e154d5e0%247772e50c%40c161550a&rnum=1
|
||||
private:
|
||||
template <class U> static ::boost::type_traits::yes_type is_class_helper(void(U::*)(void));
|
||||
template <class U> static ::boost::type_traits::no_type is_class_helper(...);
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value = sizeof(
|
||||
is_class_helper<T>(0)
|
||||
) == sizeof(::boost::type_traits::yes_type));
|
||||
};
|
||||
}
|
||||
|
||||
# else // nonconforming compilers will use a different impelementation, in object_traits.hpp
|
||||
|
||||
# endif // nonconforming implementations
|
||||
|
||||
#endif // BOOST_TYPE_TRAITS_IS_CLASS_HPP
|
||||
562
include/boost/type_traits/object_traits.hpp
Normal file
562
include/boost/type_traits/object_traits.hpp
Normal file
@ -0,0 +1,562 @@
|
||||
// (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 object traits classes:
|
||||
// is_object, is_scalar, is_class, is_compound, is_POD,
|
||||
// has_trivial_constructor, has_trivial_copy, has_trivial_assign,
|
||||
// has_trivial_destructor, is_empty.
|
||||
//
|
||||
|
||||
#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
|
||||
#define BOOST_OBJECT_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_COMPOSITE_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits/composite_traits.hpp>
|
||||
#endif
|
||||
#ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits/arithmetic_traits.hpp>
|
||||
#endif
|
||||
#ifndef BOOST_FUNCTION_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits/function_traits.hpp>
|
||||
#endif
|
||||
#ifndef BOOST_TYPE_TRAITS_IS_CLASS_HPP
|
||||
# include <boost/type_traits/is_class.hpp>
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_HAS_SGI_TYPE_TRAITS
|
||||
# include <type_traits.h>
|
||||
# include <boost/type_traits/same_traits.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_object
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct is_object
|
||||
{
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_and<
|
||||
::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_void<T>::value>::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_function<T>::value>::value
|
||||
>::value));
|
||||
#else
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_and<
|
||||
::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_void<T>::value>::value
|
||||
>::value));
|
||||
#endif
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_scalar
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct is_scalar
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::is_arithmetic<T>::value,
|
||||
::boost::is_enum<T>::value,
|
||||
::boost::is_pointer<T>::value,
|
||||
::boost::is_member_pointer<T>::value
|
||||
>::value));
|
||||
};
|
||||
|
||||
# ifndef BOOST_TYPE_TRAITS_IS_CLASS_DEFINED
|
||||
// conforming compilers use the implementation in <boost/type_traits/is_class.hpp>
|
||||
/**********************************************
|
||||
*
|
||||
* is_class
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct is_class
|
||||
{
|
||||
# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_and<
|
||||
::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_scalar<T>::value >::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_array<T>::value >::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_void<T>::value >::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_function<T>::value >::value
|
||||
>::value));
|
||||
# else
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_and<
|
||||
::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_scalar<T>::value >::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_array<T>::value >::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_void<T>::value >::value
|
||||
>::value));
|
||||
# endif
|
||||
};
|
||||
# endif // nonconforming implementations
|
||||
/**********************************************
|
||||
*
|
||||
* is_compound
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T> struct is_compound
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::is_array<T>::value,
|
||||
::boost::is_pointer<T>::value,
|
||||
::boost::is_reference<T>::value,
|
||||
::boost::is_class<T>::value,
|
||||
::boost::is_union<T>::value,
|
||||
::boost::is_enum<T>::value,
|
||||
::boost::is_member_pointer<T>::value
|
||||
>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_POD
|
||||
*
|
||||
**********************************************/
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <typename T> struct is_POD
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value =
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::is_scalar<T>::value,
|
||||
::boost::is_void<T>::value,
|
||||
BOOST_IS_POD(T)
|
||||
>::value));
|
||||
};
|
||||
|
||||
template <typename T, std::size_t sz>
|
||||
struct is_POD<T[sz]>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = ::boost::is_POD<T>::value);
|
||||
};
|
||||
#else
|
||||
namespace detail
|
||||
{
|
||||
template <bool is_array = false> struct is_POD_helper;
|
||||
}
|
||||
|
||||
template <typename T> struct is_POD
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value = (
|
||||
::boost::detail::is_POD_helper<
|
||||
::boost::is_array<T>::value
|
||||
>::template apply<T>::value
|
||||
)
|
||||
);
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <bool is_array>
|
||||
struct is_POD_helper
|
||||
{
|
||||
template <typename T> struct apply
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value =
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::is_scalar<T>::value,
|
||||
::boost::is_void<T>::value,
|
||||
BOOST_IS_POD(T)
|
||||
>::value));
|
||||
};
|
||||
};
|
||||
|
||||
template <bool b>
|
||||
struct bool_to_type
|
||||
{
|
||||
typedef ::boost::type_traits::no_type type;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct bool_to_type<true>
|
||||
{
|
||||
typedef ::boost::type_traits::yes_type type;
|
||||
};
|
||||
|
||||
template <class ArrayType>
|
||||
struct is_POD_array_helper
|
||||
{
|
||||
typedef
|
||||
#if !defined(__BORLANDC__) || __BORLANDC__ > 0x551
|
||||
typename
|
||||
#endif
|
||||
::boost::detail::bool_to_type<(::boost::is_POD<ArrayType>::value)>::type type;
|
||||
|
||||
type instance() const;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
is_POD_array_helper<T> is_POD_array(T*);
|
||||
|
||||
template <>
|
||||
struct is_POD_helper<true>
|
||||
{
|
||||
template <typename T> struct apply
|
||||
{
|
||||
static T& help();
|
||||
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value =
|
||||
sizeof(is_POD_array(help()).instance()) == sizeof(::boost::type_traits::yes_type));
|
||||
};
|
||||
};
|
||||
}
|
||||
#endif
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* has_trivial_constructor
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct has_trivial_constructor
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::is_POD<T>::value,
|
||||
BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)
|
||||
>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* has_trivial_copy
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct has_trivial_copy
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_and<
|
||||
::boost::type_traits::ice_or<
|
||||
::boost::is_POD<T>::value,
|
||||
BOOST_HAS_TRIVIAL_COPY(T)
|
||||
>::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value
|
||||
>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* has_trivial_assign
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct has_trivial_assign
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_and<
|
||||
::boost::type_traits::ice_or<
|
||||
::boost::is_POD<T>::value,
|
||||
BOOST_HAS_TRIVIAL_ASSIGN(T)
|
||||
>::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_const<T>::value >::value,
|
||||
::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value
|
||||
>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* has_trivial_destructor
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct has_trivial_destructor
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::is_POD<T>::value,
|
||||
BOOST_HAS_TRIVIAL_DESTRUCTOR(T)
|
||||
>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* has_nothrow_constructor
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct has_nothrow_constructor
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::has_trivial_constructor<T>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* has_nothrow_copy
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct has_nothrow_copy
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::has_trivial_copy<T>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* has_nothrow_assign
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct has_nothrow_assign
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::has_trivial_assign<T>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_empty
|
||||
*
|
||||
**********************************************/
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
namespace detail
|
||||
{
|
||||
template <typename T>
|
||||
struct empty_helper_t1 : public T
|
||||
{
|
||||
//#ifdef __MWERKS__
|
||||
empty_helper_t1(); // hh compiler bug workaround
|
||||
//#endif
|
||||
int i[256];
|
||||
};
|
||||
struct empty_helper_t2 { int i[256]; };
|
||||
}
|
||||
|
||||
# ifndef __BORLANDC__
|
||||
namespace detail
|
||||
{
|
||||
template <typename T, bool is_a_class = false>
|
||||
struct empty_helper{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
|
||||
template <typename T>
|
||||
struct empty_helper<T, true>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2)));
|
||||
};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct is_empty
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value = (
|
||||
::boost::type_traits::ice_or<
|
||||
::boost::detail::empty_helper<T,::boost::is_class<T>::value>::value
|
||||
, BOOST_IS_EMPTY(cvt)
|
||||
>::value
|
||||
));
|
||||
};
|
||||
|
||||
# else // __BORLANDC__
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <typename T, bool is_a_class, bool convertible_to_int>
|
||||
struct empty_helper{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
|
||||
template <typename T>
|
||||
struct empty_helper<T, true, false>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2)));
|
||||
};
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct is_empty
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
typedef typename add_reference<T>::type r_type;
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value = (
|
||||
::boost::type_traits::ice_or<
|
||||
::boost::detail::empty_helper<
|
||||
T
|
||||
, ::boost::is_class<T>::value
|
||||
, ::boost::is_convertible< r_type,int>::value
|
||||
>::value
|
||||
, BOOST_IS_EMPTY(cvt)
|
||||
>::value));
|
||||
};
|
||||
# endif // __BORLANDC__
|
||||
|
||||
#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <typename T>
|
||||
struct empty_helper_t1 : public T
|
||||
{
|
||||
empty_helper_t1();
|
||||
int i[256];
|
||||
};
|
||||
struct empty_helper_t2 { int i[256]; };
|
||||
|
||||
template <typename T>
|
||||
struct empty_helper_base
|
||||
{
|
||||
enum{ value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2)) };
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct empty_helper_nonbase
|
||||
{
|
||||
enum{ value = false };
|
||||
};
|
||||
|
||||
template <bool base>
|
||||
struct empty_helper_chooser
|
||||
{
|
||||
template <class T>
|
||||
struct rebind
|
||||
{
|
||||
typedef empty_helper_nonbase<T> type;
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct empty_helper_chooser<true>
|
||||
{
|
||||
template <class T>
|
||||
struct rebind
|
||||
{
|
||||
typedef empty_helper_base<T> type;
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <typename T>
|
||||
struct is_empty
|
||||
{
|
||||
private:
|
||||
typedef ::boost::detail::empty_helper_chooser<
|
||||
::boost::type_traits::ice_and<
|
||||
::boost::type_traits::ice_not<
|
||||
::boost::is_reference<T>::value>::value,
|
||||
::boost::type_traits::ice_not<
|
||||
::boost::is_convertible<T,double>::value>::value,
|
||||
::boost::type_traits::ice_not<
|
||||
::boost::is_pointer<T>::value>::value,
|
||||
::boost::type_traits::ice_not<
|
||||
::boost::is_member_pointer<T>::value>::value,
|
||||
::boost::type_traits::ice_not<
|
||||
::boost::is_array<T>::value>::value,
|
||||
::boost::type_traits::ice_not<
|
||||
::boost::is_void<T>::value>::value,
|
||||
::boost::type_traits::ice_not<
|
||||
::boost::is_convertible<T, const volatile void*>::value>::value
|
||||
>::value> chooser;
|
||||
typedef typename chooser::template rebind<T> bound_type;
|
||||
typedef typename bound_type::type eh_type;
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_or<eh_type::value, BOOST_IS_EMPTY(T)>::value));
|
||||
};
|
||||
|
||||
#else
|
||||
template <typename T> struct is_empty
|
||||
{ enum{ value = BOOST_IS_EMPTY(T) }; };
|
||||
#endif // BOOST_MSVC6_MEMBER_TEMPLATES
|
||||
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_stateless
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct is_stateless
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_and<
|
||||
::boost::has_trivial_constructor<T>::value,
|
||||
::boost::has_trivial_copy<T>::value,
|
||||
::boost::has_trivial_destructor<T>::value,
|
||||
::boost::is_class<T>::value,
|
||||
::boost::is_empty<T>::value
|
||||
>::value));
|
||||
};
|
||||
|
||||
template <class Base, class Derived>
|
||||
struct is_base_and_derived
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_and<
|
||||
::boost::is_convertible<Derived*,Base*>::value,
|
||||
::boost::is_class<Derived>::value,
|
||||
::boost::is_class<Base>::value
|
||||
>::value)
|
||||
);
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <class Base, class Derived>
|
||||
struct is_base_and_derived<Base&, Derived>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <class Base, class Derived>
|
||||
struct is_base_and_derived<Base, Derived&>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
template <class Base, class Derived>
|
||||
struct is_base_and_derived<Base&, Derived&>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_OBJECT_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
90
include/boost/type_traits/reference_traits.hpp
Normal file
90
include/boost/type_traits/reference_traits.hpp
Normal file
@ -0,0 +1,90 @@
|
||||
// (C) Copyright David Abrahams Steve Cleary, Beman Dawes, Howard
|
||||
// Hinnant & John Maddock 2000-2002. 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_REFERENCE_TRAITS_HPP
|
||||
# define BOOST_TT_REFERENCE_TRAITS_HPP
|
||||
|
||||
# ifndef BOOST_TT_UTILITY_HPP
|
||||
# include <boost/type_traits/utility.hpp>
|
||||
# endif // BOOST_TT_UTILITY_HPP
|
||||
|
||||
namespace boost {
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_reference
|
||||
*
|
||||
**********************************************/
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <typename T> struct is_reference
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
template <typename T> struct is_reference<T&>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if defined(__BORLANDC__)
|
||||
// these are illegal specialisations; cv-qualifies applied to
|
||||
// references have no effect according to [8.3.2p1],
|
||||
// C++ Builder requires them though as it treats cv-qualified
|
||||
// references as distinct types...
|
||||
template <typename T> struct is_reference<T&const>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <typename T> struct is_reference<T&volatile>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <typename T> struct is_reference<T&const volatile>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
#else
|
||||
# ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 4181)
|
||||
#endif // BOOST_MSVC
|
||||
|
||||
namespace detail
|
||||
{
|
||||
using ::boost::type_traits::yes_type;
|
||||
using ::boost::type_traits::no_type;
|
||||
using ::boost::type_traits::wrap;
|
||||
|
||||
template <class T> T&(* is_reference_helper1(wrap<T>) )(wrap<T>);
|
||||
char is_reference_helper1(...);
|
||||
|
||||
template <class T> no_type is_reference_helper2(T&(*)(wrap<T>));
|
||||
yes_type is_reference_helper2(...);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct is_reference
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, value = sizeof(
|
||||
::boost::detail::is_reference_helper2(
|
||||
::boost::detail::is_reference_helper1(::boost::type_traits::wrap<T>()))) == 1
|
||||
);
|
||||
};
|
||||
|
||||
template <> struct is_reference<void>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <> struct is_reference<const void>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
template <> struct is_reference<volatile void>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
template <> struct is_reference<const volatile void>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
#endif
|
||||
|
||||
# ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
# endif // BOOST_MSVC
|
||||
#endif
|
||||
|
||||
} // namespace boost::type_traits
|
||||
|
||||
#endif // BOOST_TT_REFERENCE_TRAITS_HPP
|
||||
108
include/boost/type_traits/same_traits.hpp
Normal file
108
include/boost/type_traits/same_traits.hpp
Normal file
@ -0,0 +1,108 @@
|
||||
// (C) Copyright Steve Cleary, Beman Dawes, Aleksey Gurtovoy, 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 is_same:
|
||||
|
||||
// Revision History
|
||||
// 19 Feb 2001 Fixed for MSVC (David Abrahams)
|
||||
|
||||
#ifndef BOOST_SAME_TRAITS_HPP
|
||||
#define BOOST_SAME_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
|
||||
#if !defined(BOOST_COMPOSITE_TYPE_TRAITS_HPP) && defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC)
|
||||
#include <boost/type_traits/composite_traits.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_same
|
||||
*
|
||||
**********************************************/
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
template <typename T, typename U>
|
||||
struct is_same
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = false); };
|
||||
|
||||
template <typename T>
|
||||
struct is_same<T, T>
|
||||
{ BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
|
||||
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||
// A definition is required even for integral static constants
|
||||
template <typename T, typename U>
|
||||
const bool is_same<T, U>::value;
|
||||
|
||||
template <typename T>
|
||||
const bool is_same<T, T>::value;
|
||||
#endif
|
||||
|
||||
#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
//
|
||||
// the following VC6 specific implementation is *NOT* legal
|
||||
// C++, but has the advantage that it works for incomplete
|
||||
// types.
|
||||
//
|
||||
namespace detail{
|
||||
|
||||
template<class T1>
|
||||
struct is_same_part_1 {
|
||||
template<class T2> struct part_2 { enum { value = false }; };
|
||||
template<> struct part_2<T1> { enum { value = true }; };
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<class T1, class T2>
|
||||
struct is_same {
|
||||
enum { value = detail::is_same_part_1<T1>::template part_2<T2>::value };
|
||||
};
|
||||
|
||||
#else // BOOST_MSVC
|
||||
|
||||
namespace detail{
|
||||
template <class T>
|
||||
::boost::type_traits::yes_type BOOST_TT_DECL is_same_helper(T*, T*);
|
||||
::boost::type_traits::no_type BOOST_TT_DECL is_same_helper(...);
|
||||
}
|
||||
|
||||
template <typename T, typename U>
|
||||
struct is_same
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
static U u;
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
(::boost::type_traits::ice_and<
|
||||
(sizeof(type_traits::yes_type) == sizeof(detail::is_same_helper(&t,&u))),
|
||||
(::boost::is_reference<T>::value == ::boost::is_reference<U>::value),
|
||||
(sizeof(T) == sizeof(U))
|
||||
>::value));
|
||||
};
|
||||
|
||||
#endif // BOOST_MSVC
|
||||
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_SAME_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
199
include/boost/type_traits/transform_traits.hpp
Normal file
199
include/boost/type_traits/transform_traits.hpp
Normal file
@ -0,0 +1,199 @@
|
||||
// (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 transforming one type to another:
|
||||
// remove_reference, add_reference, remove_bounds, remove_pointer.
|
||||
//
|
||||
// Revision History:
|
||||
// 21st March 2001
|
||||
// Added void specialisations to add_reference.
|
||||
|
||||
#ifndef BOOST_TRANSFORM_TRAITS_HPP
|
||||
#define BOOST_TRANSFORM_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
|
||||
#if !defined(BOOST_COMPOSITE_TYPE_TRAITS_HPP) && defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
#include <boost/type_traits/composite_traits.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* remove_reference
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct remove_reference
|
||||
{ typedef T type; };
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <typename T>
|
||||
struct remove_reference<T&>
|
||||
{ typedef T type; };
|
||||
#endif
|
||||
#if defined(__BORLANDC__) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
// these are illegal specialisations; cv-qualifies applied to
|
||||
// references have no effect according to [8.3.2p1],
|
||||
// C++ Builder requires them though as it treats cv-qualified
|
||||
// references as distinct types...
|
||||
template <typename T>
|
||||
struct remove_reference<T&const>
|
||||
{ typedef T type; };
|
||||
template <typename T>
|
||||
struct remove_reference<T&volatile>
|
||||
{ typedef T type; };
|
||||
template <typename T>
|
||||
struct remove_reference<T&const volatile>
|
||||
{ typedef T type; };
|
||||
#endif
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* add_reference
|
||||
*
|
||||
**********************************************/
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <typename T>
|
||||
struct add_reference
|
||||
{ typedef T& type; };
|
||||
template <typename T>
|
||||
struct add_reference<T&>
|
||||
{ typedef T& type; };
|
||||
#elif defined(BOOST_MSVC6_MEMBER_TEMPLATES)
|
||||
namespace detail{
|
||||
|
||||
template <bool x>
|
||||
struct reference_adder
|
||||
{
|
||||
template <class T>
|
||||
struct rebind
|
||||
{
|
||||
typedef T& type;
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct reference_adder<true>
|
||||
{
|
||||
template <class T>
|
||||
struct rebind
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <typename T>
|
||||
struct add_reference
|
||||
{
|
||||
private:
|
||||
typedef typename detail::reference_adder< ::boost::is_reference<T>::value>::template rebind<T> binder;
|
||||
public:
|
||||
typedef typename binder::type type;
|
||||
};
|
||||
|
||||
#else
|
||||
template <typename T>
|
||||
struct add_reference
|
||||
{ typedef T& type; };
|
||||
#endif
|
||||
|
||||
//
|
||||
// these full specialisations are always required:
|
||||
template <> struct add_reference<void>{ typedef void type; };
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <> struct add_reference<const volatile void>{ typedef const volatile void type; };
|
||||
template <> struct add_reference<const void>{ typedef const void type; };
|
||||
template <> struct add_reference<volatile void>{ typedef volatile void type; };
|
||||
#endif
|
||||
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* remove_bounds
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct remove_bounds
|
||||
{ typedef T type; };
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <typename T, std::size_t N>
|
||||
struct remove_bounds<T[N]>
|
||||
{ typedef T type; };
|
||||
template <typename T, std::size_t N>
|
||||
struct remove_bounds<const T[N]>
|
||||
{ typedef const T type; };
|
||||
template <typename T, std::size_t N>
|
||||
struct remove_bounds<volatile T[N]>
|
||||
{ typedef volatile T type; };
|
||||
template <typename T, std::size_t N>
|
||||
struct remove_bounds<const volatile T[N]>
|
||||
{ typedef const volatile T type; };
|
||||
#endif
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* remove_pointer
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct remove_pointer
|
||||
{ typedef T type; };
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <typename T>
|
||||
struct remove_pointer<T*>
|
||||
{ typedef T type; };
|
||||
template <typename T>
|
||||
struct remove_pointer<T*const>
|
||||
{ typedef T type; };
|
||||
template <typename T>
|
||||
struct remove_pointer<T*volatile>
|
||||
{ typedef T type; };
|
||||
template <typename T>
|
||||
struct remove_pointer<T*const volatile>
|
||||
{ typedef T type; };
|
||||
#endif
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* add_pointer
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct add_pointer
|
||||
{
|
||||
private:
|
||||
typedef typename remove_reference<T>::type no_ref_type;
|
||||
public:
|
||||
typedef no_ref_type* type;
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
//
|
||||
// if there is no partial specialisation support
|
||||
// include a bunch of full specialisations as a workaround:
|
||||
//
|
||||
#include <boost/type_traits/transform_traits_spec.hpp>
|
||||
#else
|
||||
#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(x)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_TRANSFORM_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
78
include/boost/type_traits/transform_traits_spec.hpp
Normal file
78
include/boost/type_traits/transform_traits_spec.hpp
Normal file
@ -0,0 +1,78 @@
|
||||
|
||||
// Copyright (c) 2001 Aleksey Gurtovoy.
|
||||
// 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.
|
||||
|
||||
#ifndef BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP
|
||||
#define BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP
|
||||
|
||||
#ifndef TRANSFORM_TRAITS_HPP
|
||||
#include <boost/type_traits/transform_traits.hpp>
|
||||
#endif
|
||||
|
||||
#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_CONST_VOLATILE_RANK1(T) \
|
||||
template<> struct remove_const<T const> { typedef T type; }; \
|
||||
template<> struct remove_const<T const volatile> { typedef T volatile type; }; \
|
||||
template<> struct remove_volatile<T volatile> { typedef T type; }; \
|
||||
template<> struct remove_volatile<T const volatile> { typedef T const type; }; \
|
||||
template<> struct remove_cv<T const> { typedef T type; }; \
|
||||
template<> struct remove_cv<T volatile> { typedef T type; }; \
|
||||
template<> struct remove_cv<T const volatile> { typedef T type; }; \
|
||||
/**/
|
||||
|
||||
#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T) \
|
||||
template<> struct remove_pointer<T*> { typedef T type; }; \
|
||||
template<> struct remove_reference<T&> { typedef T type; }; \
|
||||
/**/
|
||||
|
||||
#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_2(T) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T const) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T volatile) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_1(T const volatile) \
|
||||
/**/
|
||||
|
||||
#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_PTR_REF_RANK_2(T) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_CONST_VOLATILE_RANK1(T) \
|
||||
/**/
|
||||
|
||||
#define BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T*) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T const*) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T volatile*) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T const volatile*) \
|
||||
/**/
|
||||
|
||||
#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) \
|
||||
namespace boost { \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_1(T) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T*) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T const*) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T volatile*) \
|
||||
BOOST_TYPE_TRAITS_SPECIALIZATION_REMOVE_ALL_RANK_2(T const volatile*) \
|
||||
} \
|
||||
/**/
|
||||
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(bool)
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(char)
|
||||
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(wchar_t)
|
||||
#endif
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed char)
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned char)
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed short)
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned short)
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed int)
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned int)
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(signed long)
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(unsigned long)
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(float)
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(double)
|
||||
BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(long double)
|
||||
|
||||
#endif // BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP
|
||||
|
||||
434
include/boost/type_traits/type_traits_test.hpp
Normal file
434
include/boost/type_traits/type_traits_test.hpp
Normal file
@ -0,0 +1,434 @@
|
||||
// (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.
|
||||
|
||||
// common test code for type-traits tests
|
||||
// WARNING: contains code as well as declarations!
|
||||
|
||||
|
||||
#ifndef BOOST_TYPE_TRAITS_TEST_HPP
|
||||
#define BOOST_TYPE_TRAITS_TEST_HPP
|
||||
#include <iostream>
|
||||
#include <typeinfo>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/type_traits/alignment_traits.hpp>
|
||||
//
|
||||
// define tests here
|
||||
unsigned failures = 0;
|
||||
unsigned test_count = 0;
|
||||
//
|
||||
// This must get defined within the test file.
|
||||
// All compilers have bugs, set this to the number of
|
||||
// regressions *expected* from a given compiler,
|
||||
// if there are no workarounds for the bugs, *and*
|
||||
// the regressions have been investigated.
|
||||
//
|
||||
extern unsigned int expected_failures;
|
||||
//
|
||||
// proc check_result()
|
||||
// Checks that there were no regressions:
|
||||
//
|
||||
int check_result(int argc, char** argv)
|
||||
{
|
||||
std::cout << test_count << " tests completed, "
|
||||
<< failures << " failures found, "
|
||||
<< expected_failures << " failures expected from this compiler." << std::endl;
|
||||
if((argc == 2)
|
||||
&& (argv[1][0] == '-')
|
||||
&& (argv[1][1] == 'a')
|
||||
&& (argv[1][2] == 0))
|
||||
{
|
||||
std::cout << "Press any key to continue...";
|
||||
std::cin.get();
|
||||
}
|
||||
return (failures == expected_failures)
|
||||
? 0
|
||||
: (failures != 0) ? static_cast<int>(failures) : -1;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// this one is to verify that a constant is indeed a
|
||||
// constant-integral-expression:
|
||||
//
|
||||
// HP aCC cannot deal with missing names for template value parameters
|
||||
template <bool b>
|
||||
struct checker
|
||||
{
|
||||
static void check(bool, bool, const char*, bool){ ++test_count; }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct checker<false>
|
||||
{
|
||||
static void check(bool o, bool n, const char* name, bool soft)
|
||||
{
|
||||
++test_count;
|
||||
++failures;
|
||||
// if this is a soft test, then failure is expected,
|
||||
// or may depend upon factors outside our control
|
||||
// (like compiler options)...
|
||||
if(soft)++expected_failures;
|
||||
std::cout << "checking value of " << name << "...failed" << std::endl;
|
||||
std::cout << "\tfound: " << n << " expected " << o << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct typify{};
|
||||
|
||||
template <class T, class U>
|
||||
struct type_checker
|
||||
{
|
||||
static void check(const char* TT, const char*, const char* expression)
|
||||
{
|
||||
++test_count;
|
||||
if(typeid(typify<T>) != typeid(typify<U>))
|
||||
{
|
||||
++failures;
|
||||
std::cout << "checking type of " << expression << "...failed" << std::endl;
|
||||
std::cout << " evaluating: type_checker<" << TT << "," << expression << ">" << std::endl;
|
||||
std::cout << " expected: type_checker<" << TT << "," << TT << ">" << std::endl;
|
||||
std::cout << " but got: " << typeid(type_checker<T,U>).name() << std::endl;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <class T>
|
||||
struct type_checker<T,T>
|
||||
{
|
||||
static void check(const char*, const char*, const char*)
|
||||
{
|
||||
++test_count;
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
#define value_test(v, x) checker<(v == x)>::check(v, x, #x, false);
|
||||
#define soft_value_test(v, x) checker<(v == x)>::check(v, x, #x, true);
|
||||
|
||||
#define value_fail(v, x) \
|
||||
++test_count; \
|
||||
++failures; \
|
||||
++expected_failures;\
|
||||
std::cout << "checking value of " << #x << "...failed" << std::endl; \
|
||||
std::cout << " " #x " does not compile on this compiler" << std::endl;
|
||||
|
||||
|
||||
#define type_test(v, x) type_checker<v,x>::check(#v, #x, #x);
|
||||
#define type_test3(v, x, z) type_checker<v,x,z>::check(#v, #x "," #z, #x "," #z);
|
||||
#ifndef SHORT_TRANSFORM_TEST
|
||||
#define transform_check(name, from_suffix, to_suffix)\
|
||||
type_test(bool to_suffix, name<bool from_suffix>::type);\
|
||||
type_test(char to_suffix, name<char from_suffix>::type);\
|
||||
type_test(wchar_t to_suffix, name<wchar_t from_suffix>::type);\
|
||||
type_test(signed char to_suffix, name<signed char from_suffix>::type);\
|
||||
type_test(unsigned char to_suffix, name<unsigned char from_suffix>::type);\
|
||||
type_test(short to_suffix, name<short from_suffix>::type);\
|
||||
type_test(unsigned short to_suffix, name<unsigned short from_suffix>::type);\
|
||||
type_test(int to_suffix, name<int from_suffix>::type);\
|
||||
type_test(unsigned int to_suffix, name<unsigned int from_suffix>::type);\
|
||||
type_test(long to_suffix, name<long from_suffix>::type);\
|
||||
type_test(unsigned long to_suffix, name<unsigned long from_suffix>::type);\
|
||||
type_test(float to_suffix, name<float from_suffix>::type);\
|
||||
type_test(long double to_suffix, name<long double from_suffix>::type);\
|
||||
type_test(double to_suffix, name<double from_suffix>::type);\
|
||||
type_test(UDT to_suffix, name<UDT from_suffix>::type);\
|
||||
type_test(enum1 to_suffix, name<enum1 from_suffix>::type);
|
||||
#else
|
||||
#define transform_check(name, from_suffix, to_suffix)\
|
||||
type_test(int to_suffix, name<int from_suffix>::type);\
|
||||
type_test(UDT to_suffix, name<UDT from_suffix>::type);\
|
||||
type_test(enum1 to_suffix, name<enum1 from_suffix>::type);
|
||||
#endif
|
||||
|
||||
#define boost_dummy_macro_param
|
||||
|
||||
template <class T>
|
||||
struct test_align
|
||||
{
|
||||
struct padded
|
||||
{
|
||||
char c;
|
||||
T t;
|
||||
};
|
||||
static void do_it()
|
||||
{
|
||||
padded p;
|
||||
unsigned a = reinterpret_cast<char*>(&(p.t)) - reinterpret_cast<char*>(&p);
|
||||
++test_count;
|
||||
// only fail if we do not have a multiple of the actual value:
|
||||
if((a > ::boost::alignment_of<T>::value) || (a % ::boost::alignment_of<T>::value))
|
||||
{
|
||||
++failures;
|
||||
std::cout << "checking value of " << typeid(boost::alignment_of<T>).name() << "...failed" << std::endl;
|
||||
std::cout << "\tfound: " << boost::alignment_of<T>::value << " expected " << a << std::endl;
|
||||
}
|
||||
// suppress warnings about unused variables:
|
||||
(void)p;
|
||||
(void)a;
|
||||
}
|
||||
};
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <class T>
|
||||
struct test_align<T&>
|
||||
{
|
||||
static void do_it()
|
||||
{
|
||||
//
|
||||
// we can't do the usual test because we can't take the address
|
||||
// of a reference, so check that the result is the same as for a
|
||||
// pointer type instead:
|
||||
unsigned a = boost::alignment_of<T*>::value;
|
||||
++test_count;
|
||||
if(a != boost::alignment_of<T&>::value)
|
||||
{
|
||||
++failures;
|
||||
std::cout << "checking value of " << typeid(boost::alignment_of<T&>).name() << "...failed" << std::endl;
|
||||
std::cout << "\tfound: " << boost::alignment_of<T&>::value << " expected " << a << std::endl;
|
||||
}
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
#define align_test(T) test_align<T>::do_it()
|
||||
|
||||
template<class T>
|
||||
struct test_type_with_align
|
||||
{
|
||||
typedef typename boost::type_with_alignment<
|
||||
(boost::alignment_of<T>::value)>::type
|
||||
align_t;
|
||||
|
||||
static void do_it()
|
||||
{
|
||||
int align = boost::alignment_of<T>::value;
|
||||
int new_align = boost::alignment_of<align_t>::value;
|
||||
++test_count;
|
||||
if (new_align % align != 0) {
|
||||
++failures;
|
||||
std::cerr << "checking for an object with same alignment as "
|
||||
<< typeid(T).name() << "...failed" << std::endl;
|
||||
std::cerr << "\tfound: " << typeid(align_t).name() << std::endl;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#define type_with_align_test(T) test_type_with_align<T>::do_it()
|
||||
|
||||
//
|
||||
// the following code allows us to test that a particular
|
||||
// template functions correctly when instanciated inside another template
|
||||
// (some bugs only show up in that situation). For each template
|
||||
// we declare one NESTED_DECL(classname) that sets up the template class
|
||||
// and multiple NESTED_TEST(classname, template-arg) declarations, to carry
|
||||
// the actual tests:
|
||||
template <bool b>
|
||||
struct nested_test
|
||||
{
|
||||
typedef nested_test type;
|
||||
bool run_time_value;
|
||||
const char* what;
|
||||
nested_test(bool b2, const char* w) : run_time_value(b2), what(w) { check(); }
|
||||
void check()
|
||||
{
|
||||
++test_count;
|
||||
if(b != run_time_value)
|
||||
{
|
||||
++failures;
|
||||
std::cerr << "Mismatch between runtime and compile time values in " << what << std::endl;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#ifndef __SUNPRO_CC
|
||||
#define NESTED_DECL(what)\
|
||||
template <class T> \
|
||||
struct BOOST_TT_JOIN(nested_tester_,what){\
|
||||
nested_test< (::boost::type_traits::ice_ne<0, ::boost::what<T>::value>::value)> tester;\
|
||||
BOOST_TT_JOIN(nested_tester_,what)(const char* s) : tester(::boost::what<T>::value, s){}\
|
||||
};
|
||||
#define NESTED_TEST(what, with)\
|
||||
{BOOST_TT_JOIN(nested_tester_,what)<with> check(#what "<" #with ">"); (void)check;}
|
||||
#else
|
||||
#define NESTED_DECL(what)
|
||||
#define NESTED_TEST(what, with)
|
||||
#endif
|
||||
|
||||
#define BOOST_TT_JOIN( X, Y ) BOOST_DO_TT_JOIN( X, Y )
|
||||
#define BOOST_DO_TT_JOIN( X, Y ) X##Y
|
||||
|
||||
|
||||
|
||||
//
|
||||
// define some types to test with:
|
||||
//
|
||||
enum enum_UDT{ one, two, three };
|
||||
struct UDT
|
||||
{
|
||||
UDT(){};
|
||||
~UDT(){};
|
||||
UDT(const UDT&);
|
||||
UDT& operator=(const UDT&);
|
||||
int i;
|
||||
|
||||
void f1();
|
||||
int f2();
|
||||
int f3(int);
|
||||
int f4(int, float);
|
||||
};
|
||||
|
||||
typedef void(*f1)();
|
||||
typedef int(*f2)(int);
|
||||
typedef int(*f3)(int, bool);
|
||||
typedef void (UDT::*mf1)();
|
||||
typedef int (UDT::*mf2)();
|
||||
typedef int (UDT::*mf3)(int);
|
||||
typedef int (UDT::*mf4)(int, float);
|
||||
typedef int (UDT::*mp);
|
||||
typedef int (UDT::*cmf)(int) const;
|
||||
|
||||
// cv-qualifiers applied to reference types should have no effect
|
||||
// declare these here for later use with is_reference and remove_reference:
|
||||
# ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 4181)
|
||||
# elif defined(__ICL)
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 21)
|
||||
# endif
|
||||
//
|
||||
// This is intentional:
|
||||
// r_type and cr_type should be the same type
|
||||
// but some compilers wrongly apply cv-qualifiers
|
||||
// to reference types (this may generate a warning
|
||||
// on some compilers):
|
||||
//
|
||||
typedef int& r_type;
|
||||
typedef const r_type cr_type;
|
||||
# ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
# elif defined(__ICL)
|
||||
# pragma warning(pop)
|
||||
# pragma warning(disable: 985) // identifier truncated in debug information
|
||||
# endif
|
||||
|
||||
struct POD_UDT { int x; };
|
||||
struct empty_UDT
|
||||
{
|
||||
~empty_UDT(){};
|
||||
empty_UDT& operator=(const empty_UDT&){ return *this; }
|
||||
bool operator==(const empty_UDT&)const
|
||||
{ return true; }
|
||||
};
|
||||
struct empty_POD_UDT
|
||||
{
|
||||
empty_POD_UDT& operator=(const empty_POD_UDT&){ return *this; }
|
||||
bool operator==(const empty_POD_UDT&)const
|
||||
{ return true; }
|
||||
};
|
||||
union union_UDT
|
||||
{
|
||||
int x;
|
||||
double y;
|
||||
~union_UDT();
|
||||
};
|
||||
union POD_union_UDT
|
||||
{
|
||||
int x;
|
||||
double y;
|
||||
};
|
||||
union empty_union_UDT
|
||||
{
|
||||
~empty_union_UDT();
|
||||
};
|
||||
union empty_POD_union_UDT{};
|
||||
|
||||
class Base { };
|
||||
|
||||
class Derived : public Base { };
|
||||
|
||||
class NonDerived { };
|
||||
|
||||
enum enum1
|
||||
{
|
||||
one_,two_
|
||||
};
|
||||
|
||||
enum enum2
|
||||
{
|
||||
three_,four_
|
||||
};
|
||||
|
||||
struct VB
|
||||
{
|
||||
virtual ~VB(){};
|
||||
};
|
||||
|
||||
struct VD : VB
|
||||
{
|
||||
~VD(){};
|
||||
};
|
||||
//
|
||||
// struct non_pointer:
|
||||
// used to verify that is_pointer does not return
|
||||
// true for class types that implement operator void*()
|
||||
//
|
||||
struct non_pointer
|
||||
{
|
||||
operator void*(){return this;}
|
||||
};
|
||||
struct non_int_pointer
|
||||
{
|
||||
int i;
|
||||
operator int*(){return &i;}
|
||||
};
|
||||
struct int_constructible
|
||||
{
|
||||
int_constructible(int);
|
||||
};
|
||||
struct int_convertible
|
||||
{
|
||||
operator int();
|
||||
};
|
||||
//
|
||||
// struct non_empty:
|
||||
// used to verify that is_empty does not emit
|
||||
// spurious warnings or errors.
|
||||
//
|
||||
struct non_empty : private boost::noncopyable
|
||||
{
|
||||
int i;
|
||||
};
|
||||
//
|
||||
// abstract base classes:
|
||||
struct test_abc1
|
||||
{
|
||||
virtual void foo() = 0;
|
||||
virtual void foo2() = 0;
|
||||
};
|
||||
|
||||
struct test_abc2
|
||||
{
|
||||
virtual void foo() = 0;
|
||||
virtual void foo2() = 0;
|
||||
};
|
||||
|
||||
struct incomplete_type;
|
||||
|
||||
|
||||
#endif // BOOST_TYPE_TRAITS_TEST_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
24
include/boost/type_traits/utility.hpp
Normal file
24
include/boost/type_traits/utility.hpp
Normal file
@ -0,0 +1,24 @@
|
||||
// Copyright David Abrahams 2002. 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.
|
||||
#ifndef BOOST_TT_UTILITY_HPP
|
||||
# define BOOST_TT_UTILITY_HPP
|
||||
|
||||
namespace boost { namespace type_traits
|
||||
{
|
||||
// Utility metafunction class which always returns false
|
||||
struct false_unary_metafunction
|
||||
{
|
||||
template <class T>
|
||||
struct apply
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
};
|
||||
|
||||
template <class T> struct wrap {};
|
||||
}} // namespace boost::type_traits
|
||||
|
||||
#endif // BOOST_TT_UTILITY_HPP
|
||||
Loading…
Reference in New Issue
Block a user