forked from boostorg/type_traits
Compare commits
15 Commits
boost-1.40
...
boost-1.30
| Author | SHA1 | Date | |
|---|---|---|---|
| d8d79336a8 | |||
| 0115d43ef9 | |||
| 8a661e5434 | |||
| b7c17d021e | |||
| af38687238 | |||
| 3f73f722db | |||
| a49dc8fc42 | |||
| 16b088bbbd | |||
| d7831e06a2 | |||
| 2e3c6afd1f | |||
| a84570579a | |||
| c109448265 | |||
| 56a8554ad6 | |||
| 0fa3a5020b | |||
| ee8ef4cbd6 |
@ -1,44 +0,0 @@
|
||||
|
||||
// (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.
|
||||
|
||||
#include <boost/type_traits/alignment_traits.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hrdstop
|
||||
#endif
|
||||
#include "boost/type_traits/type_traits_test.hpp"
|
||||
|
||||
NESTED_DECL(alignment_of)
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
NESTED_TEST(alignment_of, int)
|
||||
NESTED_TEST(alignment_of, int_constructible)
|
||||
|
||||
align_test(int);
|
||||
align_test(char);
|
||||
align_test(double);
|
||||
align_test(int[4]);
|
||||
align_test(int(*)(int));
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
align_test(char&);
|
||||
align_test(char (&)(int));
|
||||
align_test(char(&)[4]);
|
||||
#endif
|
||||
align_test(int*);
|
||||
//align_test(const int);
|
||||
align_test(VB);
|
||||
align_test(VD);
|
||||
value_test(0, ::boost::alignment_of<void>::value);
|
||||
|
||||
return check_result(argc, argv);
|
||||
}
|
||||
|
||||
//
|
||||
// define the number of failures expected for given compilers:
|
||||
unsigned int expected_failures = 0;
|
||||
|
||||
@ -1,197 +0,0 @@
|
||||
|
||||
// (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.
|
||||
|
||||
#include <boost/type_traits/arithmetic_traits.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hrdstop
|
||||
#endif
|
||||
#include "boost/type_traits/type_traits_test.hpp"
|
||||
|
||||
NESTED_DECL(is_void)
|
||||
NESTED_DECL(is_integral)
|
||||
NESTED_DECL(is_float)
|
||||
NESTED_DECL(is_arithmetic)
|
||||
NESTED_DECL(is_fundamental)
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
NESTED_TEST(is_void, void)
|
||||
NESTED_TEST(is_void, int)
|
||||
NESTED_TEST(is_integral, int)
|
||||
NESTED_TEST(is_integral, float)
|
||||
NESTED_TEST(is_float, void)
|
||||
NESTED_TEST(is_float, double)
|
||||
NESTED_TEST(is_arithmetic, void)
|
||||
NESTED_TEST(is_arithmetic, int)
|
||||
NESTED_TEST(is_fundamental, UDT)
|
||||
NESTED_TEST(is_fundamental, int)
|
||||
|
||||
value_test(true, boost::is_void<void>::value)
|
||||
value_test(true, boost::is_void<const void>::value)
|
||||
value_test(true, boost::is_void<volatile void>::value)
|
||||
value_test(true, boost::is_void<const volatile void>::value)
|
||||
value_test(false, boost::is_void<int>::value)
|
||||
|
||||
value_test(false, boost::is_integral<UDT>::value)
|
||||
value_test(false, boost::is_integral<void>::value)
|
||||
value_test(true, boost::is_integral<bool>::value)
|
||||
value_test(true, boost::is_integral<char>::value)
|
||||
value_test(true, boost::is_integral<signed char>::value)
|
||||
value_test(true, boost::is_integral<unsigned char>::value)
|
||||
value_test(true, boost::is_integral<wchar_t>::value)
|
||||
value_test(true, boost::is_integral<short>::value)
|
||||
value_test(true, boost::is_integral<unsigned short>::value)
|
||||
value_test(true, boost::is_integral<int>::value)
|
||||
value_test(true, boost::is_integral<unsigned int>::value)
|
||||
value_test(true, boost::is_integral<long>::value)
|
||||
value_test(true, boost::is_integral<unsigned long>::value)
|
||||
value_test(false, boost::is_integral<float>::value)
|
||||
value_test(false, boost::is_integral<double>::value)
|
||||
value_test(false, boost::is_integral<long double>::value)
|
||||
#ifdef ULLONG_MAX
|
||||
value_test(true, boost::is_integral<long long>::value)
|
||||
value_test(true, boost::is_integral<unsigned long long>::value)
|
||||
#endif
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||||
value_test(true, boost::is_integral<__int64>::value)
|
||||
value_test(true, boost::is_integral<unsigned __int64>::value)
|
||||
#endif
|
||||
//const qualified ints:
|
||||
value_test(true, boost::is_integral<const bool>::value)
|
||||
value_test(true, boost::is_integral<const char>::value)
|
||||
value_test(true, boost::is_integral<const signed char>::value)
|
||||
value_test(true, boost::is_integral<const unsigned char>::value)
|
||||
value_test(true, boost::is_integral<const wchar_t>::value)
|
||||
value_test(true, boost::is_integral<const short>::value)
|
||||
value_test(true, boost::is_integral<const unsigned short>::value)
|
||||
value_test(true, boost::is_integral<const int>::value)
|
||||
value_test(true, boost::is_integral<const unsigned int>::value)
|
||||
value_test(true, boost::is_integral<const long>::value)
|
||||
value_test(true, boost::is_integral<const unsigned long>::value)
|
||||
#ifdef ULLONG_MAX
|
||||
value_test(true, boost::is_integral<const long long>::value)
|
||||
value_test(true, boost::is_integral<const unsigned long long>::value)
|
||||
#endif
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||||
value_test(true, boost::is_integral<const __int64>::value)
|
||||
value_test(true, boost::is_integral<const unsigned __int64>::value)
|
||||
#endif
|
||||
// volatile qualified ints:
|
||||
value_test(true, boost::is_integral<volatile bool>::value)
|
||||
value_test(true, boost::is_integral<volatile char>::value)
|
||||
value_test(true, boost::is_integral<volatile signed char>::value)
|
||||
value_test(true, boost::is_integral<volatile unsigned char>::value)
|
||||
value_test(true, boost::is_integral<volatile wchar_t>::value)
|
||||
value_test(true, boost::is_integral<volatile short>::value)
|
||||
value_test(true, boost::is_integral<volatile unsigned short>::value)
|
||||
value_test(true, boost::is_integral<volatile int>::value)
|
||||
value_test(true, boost::is_integral<volatile unsigned int>::value)
|
||||
value_test(true, boost::is_integral<volatile long>::value)
|
||||
value_test(true, boost::is_integral<volatile unsigned long>::value)
|
||||
#ifdef ULLONG_MAX
|
||||
value_test(true, boost::is_integral<volatile long long>::value)
|
||||
value_test(true, boost::is_integral<volatile unsigned long long>::value)
|
||||
#endif
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||||
value_test(true, boost::is_integral<volatile __int64>::value)
|
||||
value_test(true, boost::is_integral<volatile unsigned __int64>::value)
|
||||
#endif
|
||||
//const qualified ints:
|
||||
value_test(true, boost::is_integral<const volatile bool>::value)
|
||||
value_test(true, boost::is_integral<const volatile char>::value)
|
||||
value_test(true, boost::is_integral<const volatile signed char>::value)
|
||||
value_test(true, boost::is_integral<const volatile unsigned char>::value)
|
||||
value_test(true, boost::is_integral<const volatile wchar_t>::value)
|
||||
value_test(true, boost::is_integral<const volatile short>::value)
|
||||
value_test(true, boost::is_integral<const volatile unsigned short>::value)
|
||||
value_test(true, boost::is_integral<const volatile int>::value)
|
||||
value_test(true, boost::is_integral<const volatile unsigned int>::value)
|
||||
value_test(true, boost::is_integral<const volatile long>::value)
|
||||
value_test(true, boost::is_integral<const volatile unsigned long>::value)
|
||||
#ifdef ULLONG_MAX
|
||||
value_test(true, boost::is_integral<const volatile long long>::value)
|
||||
value_test(true, boost::is_integral<const volatile unsigned long long>::value)
|
||||
#endif
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||||
value_test(true, boost::is_integral<const volatile __int64>::value)
|
||||
value_test(true, boost::is_integral<const volatile unsigned __int64>::value)
|
||||
#endif
|
||||
value_test(true, boost::is_float<const volatile float>::value)
|
||||
value_test(true, boost::is_float<const volatile double>::value)
|
||||
value_test(true, boost::is_float<const volatile long double>::value)
|
||||
value_test(true, boost::is_float<volatile float>::value)
|
||||
value_test(true, boost::is_float<volatile double>::value)
|
||||
value_test(true, boost::is_float<volatile long double>::value)
|
||||
value_test(true, boost::is_float<const float>::value)
|
||||
value_test(true, boost::is_float<const double>::value)
|
||||
value_test(true, boost::is_float<const long double>::value)
|
||||
value_test(true, boost::is_float<float>::value)
|
||||
value_test(true, boost::is_float<double>::value)
|
||||
value_test(true, boost::is_float<long double>::value)
|
||||
value_test(false, boost::is_float<int>::value)
|
||||
value_test(false, boost::is_float<void>::value)
|
||||
value_test(false, boost::is_float<UDT>::value)
|
||||
|
||||
|
||||
value_test(false, boost::is_arithmetic<UDT>::value)
|
||||
value_test(false, boost::is_arithmetic<void>::value)
|
||||
value_test(true, boost::is_arithmetic<bool>::value)
|
||||
value_test(true, boost::is_arithmetic<char>::value)
|
||||
value_test(true, boost::is_arithmetic<signed char>::value)
|
||||
value_test(true, boost::is_arithmetic<unsigned char>::value)
|
||||
value_test(true, boost::is_arithmetic<wchar_t>::value)
|
||||
value_test(true, boost::is_arithmetic<short>::value)
|
||||
value_test(true, boost::is_arithmetic<unsigned short>::value)
|
||||
value_test(true, boost::is_arithmetic<int>::value)
|
||||
value_test(true, boost::is_arithmetic<unsigned int>::value)
|
||||
value_test(true, boost::is_arithmetic<long>::value)
|
||||
value_test(true, boost::is_arithmetic<unsigned long>::value)
|
||||
value_test(true, boost::is_arithmetic<float>::value)
|
||||
value_test(true, boost::is_arithmetic<double>::value)
|
||||
value_test(true, boost::is_arithmetic<long double>::value)
|
||||
#ifdef ULLONG_MAX
|
||||
value_test(true, boost::is_arithmetic<long long>::value)
|
||||
value_test(true, boost::is_arithmetic<unsigned long long>::value)
|
||||
#endif
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||||
value_test(true, boost::is_arithmetic<__int64>::value)
|
||||
value_test(true, boost::is_arithmetic<unsigned __int64>::value)
|
||||
#endif
|
||||
|
||||
value_test(false, boost::is_fundamental<UDT>::value)
|
||||
value_test(true, boost::is_fundamental<void>::value)
|
||||
value_test(true, boost::is_fundamental<bool>::value)
|
||||
value_test(true, boost::is_fundamental<char>::value)
|
||||
value_test(true, boost::is_fundamental<signed char>::value)
|
||||
value_test(true, boost::is_fundamental<unsigned char>::value)
|
||||
value_test(true, boost::is_fundamental<wchar_t>::value)
|
||||
value_test(true, boost::is_fundamental<short>::value)
|
||||
value_test(true, boost::is_fundamental<unsigned short>::value)
|
||||
value_test(true, boost::is_fundamental<int>::value)
|
||||
value_test(true, boost::is_fundamental<unsigned int>::value)
|
||||
value_test(true, boost::is_fundamental<long>::value)
|
||||
value_test(true, boost::is_fundamental<unsigned long>::value)
|
||||
value_test(true, boost::is_fundamental<float>::value)
|
||||
value_test(true, boost::is_fundamental<double>::value)
|
||||
value_test(true, boost::is_fundamental<long double>::value)
|
||||
#ifdef ULLONG_MAX
|
||||
value_test(true, boost::is_fundamental<long long>::value)
|
||||
value_test(true, boost::is_fundamental<unsigned long long>::value)
|
||||
#endif
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||||
value_test(true, boost::is_fundamental<__int64>::value)
|
||||
value_test(true, boost::is_fundamental<unsigned __int64>::value)
|
||||
#endif
|
||||
|
||||
return check_result(argc, argv);
|
||||
}
|
||||
|
||||
//
|
||||
// define the number of failures expected for given compilers:
|
||||
unsigned int expected_failures = 0;
|
||||
|
||||
@ -1,116 +0,0 @@
|
||||
|
||||
// (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.
|
||||
|
||||
#include <boost/type_traits/composite_traits.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hrdstop
|
||||
#endif
|
||||
#include "boost/type_traits/type_traits_test.hpp"
|
||||
|
||||
NESTED_DECL(is_array)
|
||||
NESTED_DECL(is_pointer)
|
||||
NESTED_DECL(is_reference)
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
NESTED_TEST(is_array, int)
|
||||
NESTED_TEST(is_array, int[2])
|
||||
NESTED_TEST(is_array, int[3][4])
|
||||
NESTED_TEST(is_array, int const [5])
|
||||
NESTED_TEST(is_array, int(&)[2])
|
||||
NESTED_TEST(is_array, int (*)(double))
|
||||
NESTED_TEST(is_pointer, int)
|
||||
NESTED_TEST(is_pointer, int*)
|
||||
NESTED_TEST(is_reference, int)
|
||||
NESTED_TEST(is_reference, int&)
|
||||
|
||||
value_test(false, boost::is_array<int>::value)
|
||||
value_test(false, boost::is_array<int*>::value)
|
||||
value_test(false, boost::is_array<const int*>::value)
|
||||
value_test(false, boost::is_array<const volatile int*>::value)
|
||||
value_test(false, boost::is_array<int*const>::value)
|
||||
value_test(false, boost::is_array<const int*volatile>::value)
|
||||
value_test(false, boost::is_array<const volatile int*const>::value)
|
||||
value_test(true, boost::is_array<int[2]>::value)
|
||||
value_test(true, boost::is_array<const int[2]>::value)
|
||||
value_test(true, boost::is_array<const volatile int[2]>::value)
|
||||
value_test(true, boost::is_array<int[2][3]>::value)
|
||||
value_test(true, boost::is_array<UDT[2]>::value)
|
||||
value_test(false, boost::is_array<int(&)[2]>::value)
|
||||
value_test(false, boost::is_array<f1>::value)
|
||||
value_test(false, boost::is_array<void>::value)
|
||||
|
||||
value_test(false, boost::is_pointer<int>::value)
|
||||
value_test(false, boost::is_pointer<int&>::value)
|
||||
value_test(true, boost::is_pointer<int*>::value)
|
||||
value_test(true, boost::is_pointer<const int*>::value)
|
||||
value_test(true, boost::is_pointer<volatile int*>::value)
|
||||
value_test(true, boost::is_pointer<non_pointer*>::value)
|
||||
// these were false in previous versions (JM 20 Dec 2000):
|
||||
value_test(true, boost::is_pointer<int*const>::value)
|
||||
value_test(true, boost::is_pointer<int*volatile>::value)
|
||||
value_test(true, boost::is_pointer<int*const volatile>::value)
|
||||
// JM 02 Oct 2000:
|
||||
value_test(false, boost::is_pointer<non_pointer>::value)
|
||||
value_test(false, boost::is_pointer<int*&>::value)
|
||||
value_test(false, boost::is_pointer<int(&)[2]>::value)
|
||||
value_test(false, boost::is_pointer<int[2]>::value)
|
||||
value_test(false, boost::is_pointer<char[sizeof(void*)]>::value)
|
||||
value_test(false, boost::is_pointer<void>::value)
|
||||
|
||||
value_test(true, boost::is_pointer<f1>::value)
|
||||
value_test(true, boost::is_pointer<f2>::value)
|
||||
value_test(true, boost::is_pointer<f3>::value)
|
||||
// Steve: was 'true', should be 'false', via 3.9.2p3
|
||||
value_test(false, boost::is_pointer<mf1>::value)
|
||||
value_test(false, boost::is_pointer<mf2>::value)
|
||||
value_test(false, boost::is_pointer<mf3>::value)
|
||||
value_test(false, boost::is_pointer<mf4>::value)
|
||||
|
||||
value_test(false, boost::is_reference<bool>::value)
|
||||
value_test(true, boost::is_reference<int&>::value)
|
||||
value_test(true, boost::is_reference<const int&>::value)
|
||||
value_test(true, boost::is_reference<volatile int &>::value)
|
||||
value_test(true, boost::is_reference<const volatile int &>::value)
|
||||
value_test(true, boost::is_reference<r_type>::value)
|
||||
value_test(true, boost::is_reference<cr_type>::value)
|
||||
value_test(true, boost::is_reference<const UDT&>::value)
|
||||
value_test(false, boost::is_reference<void>::value)
|
||||
|
||||
value_test(false, boost::is_member_pointer<f1>::value)
|
||||
value_test(false, boost::is_member_pointer<f2>::value)
|
||||
value_test(false, boost::is_member_pointer<f3>::value)
|
||||
value_test(false, boost::is_member_pointer<void*>::value)
|
||||
value_test(true, boost::is_member_pointer<mf1>::value)
|
||||
value_test(true, boost::is_member_pointer<mf2>::value)
|
||||
value_test(true, boost::is_member_pointer<mf3>::value)
|
||||
value_test(true, boost::is_member_pointer<mf4>::value)
|
||||
value_test(false, boost::is_member_pointer<void>::value)
|
||||
|
||||
value_test(false, boost::is_enum<int>::value)
|
||||
value_test(true, boost::is_enum<enum_UDT>::value)
|
||||
value_test(false, boost::is_enum<int_convertible>::value)
|
||||
value_test(false, boost::is_enum<int&>::value)
|
||||
value_test(false, boost::is_enum<void>::value)
|
||||
|
||||
return check_result(argc, argv);
|
||||
}
|
||||
|
||||
//
|
||||
// define the number of failures expected for given compilers:
|
||||
#ifdef __BORLANDC__
|
||||
unsigned int expected_failures = 2;
|
||||
#elif defined(__GNUC__)
|
||||
unsigned int expected_failures = 1; // can't handle cv-qualified references
|
||||
#elif defined(BOOST_MSVC)
|
||||
unsigned int expected_failures = 1;
|
||||
#else
|
||||
unsigned int expected_failures = 0;
|
||||
#endif
|
||||
|
||||
|
||||
@ -1,240 +0,0 @@
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1999
|
||||
* Dr John Maddock
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Dr John Maddock makes no representations
|
||||
* about the suitability of this software for any purpose.
|
||||
* It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* This file provides some example of type_traits usage -
|
||||
* by "optimising" various algorithms:
|
||||
*
|
||||
* opt::copy - optimised for trivial copy (cf std::copy)
|
||||
*
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <typeinfo>
|
||||
#include <algorithm>
|
||||
#include <iterator>
|
||||
#include <memory>
|
||||
|
||||
#include <boost/timer.hpp>
|
||||
#include <boost/type_traits.hpp>
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::cin;
|
||||
|
||||
namespace opt{
|
||||
|
||||
//
|
||||
// opt::copy
|
||||
// same semantics as std::copy
|
||||
// calls memcpy where appropiate.
|
||||
//
|
||||
|
||||
namespace detail{
|
||||
|
||||
template<typename I1, typename I2>
|
||||
I2 copy_imp(I1 first, I1 last, I2 out)
|
||||
{
|
||||
while(first != last)
|
||||
{
|
||||
*out = *first;
|
||||
++out;
|
||||
++first;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
template <bool b>
|
||||
struct copier
|
||||
{
|
||||
template<typename I1, typename I2>
|
||||
static I2 do_copy(I1 first, I1 last, I2 out)
|
||||
{ return copy_imp(first, last, out); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct copier<true>
|
||||
{
|
||||
template<typename I1, typename I2>
|
||||
static I2* do_copy(I1* first, I1* last, I2* out)
|
||||
{
|
||||
memcpy(out, first, (last-first)*sizeof(I2));
|
||||
return out+(last-first);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_STD_ITERATOR_TRAITS
|
||||
|
||||
template<typename I1, typename I2>
|
||||
inline I2 copy(I1 first, I1 last, I2 out)
|
||||
{
|
||||
typedef typename boost::remove_cv<typename std::iterator_traits<I1>::value_type>::type v1_t;
|
||||
typedef typename boost::remove_cv<typename std::iterator_traits<I2>::value_type>::type v2_t;
|
||||
return detail::copier<
|
||||
::boost::type_traits::ice_and<
|
||||
::boost::is_same<v1_t, v2_t>::value,
|
||||
::boost::is_pointer<I1>::value,
|
||||
::boost::is_pointer<I2>::value,
|
||||
::boost::has_trivial_assign<v1_t>::value
|
||||
>::value>::do_copy(first, last, out);
|
||||
}
|
||||
|
||||
#else // BOOST_NO_STD_ITERATOR_TRAITS
|
||||
|
||||
//
|
||||
// If there is no standard iterator_traits then we have to
|
||||
// use overloading rather than iterator_traits to detect
|
||||
// when we have T*'s to copy. Note that we cannot overload
|
||||
// copy directly as that will cause some standard conforming
|
||||
// code to fail to build:
|
||||
|
||||
namespace detail{
|
||||
|
||||
template<typename I1, typename I2>
|
||||
inline I2 copy_(const I1& first, const I1& last, const I2& out)
|
||||
{
|
||||
return detail::copier<false>::do_copy(first, last, out);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline T* copy_(const T* first, const T* last, T* out)
|
||||
{
|
||||
return detail::copier<
|
||||
::boost::has_trivial_assign<T>::value
|
||||
>::do_copy(first, last, out);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template<typename I1, typename I2>
|
||||
inline I2 copy(I1 first, I1 last, I2 out)
|
||||
{
|
||||
return detail::copy_(first, last, out);
|
||||
}
|
||||
|
||||
#endif // BOOST_NO_STD_ITERATOR_TRAITS
|
||||
|
||||
}; // namespace opt
|
||||
|
||||
//
|
||||
// define some global data:
|
||||
//
|
||||
const int array_size = 1000;
|
||||
int i_array_[array_size] = {0,};
|
||||
const int ci_array_[array_size] = {0,};
|
||||
char c_array_[array_size] = {0,};
|
||||
const char cc_array_[array_size] = { 0,};
|
||||
//
|
||||
// since arrays aren't iterators we define a set of pointer
|
||||
// aliases into the arrays (otherwise the compiler is entitled
|
||||
// to deduce the type passed to the template functions as
|
||||
// T (&)[N] rather than T*).
|
||||
int* i_array = i_array_;
|
||||
const int* ci_array = ci_array_;
|
||||
char* c_array = c_array_;
|
||||
const char* cc_array = cc_array_;
|
||||
|
||||
const int iter_count = 1000000;
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::timer t;
|
||||
double result;
|
||||
int i;
|
||||
cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl;
|
||||
cout << "testing copy...\n"
|
||||
"[Some standard library versions may already perform this optimisation.]" << endl;
|
||||
|
||||
// cache load:
|
||||
opt::copy(ci_array, ci_array + array_size, i_array);
|
||||
|
||||
// time optimised version:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
opt::copy(ci_array, ci_array + array_size, i_array);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "opt::copy<const int*, int*>: " << result << endl;
|
||||
|
||||
// cache load:
|
||||
std::copy(ci_array, ci_array + array_size, i_array);
|
||||
|
||||
// time standard version:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
std::copy(ci_array, ci_array + array_size, i_array);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "std::copy<const int*, int*>: " << result << endl;
|
||||
|
||||
// cache load:
|
||||
opt::detail::copier<false>::do_copy(ci_array, ci_array + array_size, i_array);
|
||||
|
||||
// time unoptimised version:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
opt::detail::copier<false>::do_copy(ci_array, ci_array + array_size, i_array);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "standard \"unoptimised\" copy: " << result << endl << endl;
|
||||
|
||||
// cache load:
|
||||
opt::copy(cc_array, cc_array + array_size, c_array);
|
||||
|
||||
// time optimised version:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
opt::copy(cc_array, cc_array + array_size, c_array);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "opt::copy<const char*, char*>: " << result << endl;
|
||||
|
||||
// cache load:
|
||||
std::copy(cc_array, cc_array + array_size, c_array);
|
||||
|
||||
// time standard version:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
std::copy(cc_array, cc_array + array_size, c_array);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "std::copy<const char*, char*>: " << result << endl;
|
||||
|
||||
// cache load:
|
||||
opt::detail::copier<false>::do_copy(cc_array, cc_array + array_size, c_array);
|
||||
|
||||
// time unoptimised version:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
opt::detail::copier<false>::do_copy(cc_array, cc_array + array_size, c_array);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "standard \"unoptimised\" copy: " << result << endl << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,113 +0,0 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>
|
||||
Compiler Status: linux
|
||||
</title>
|
||||
</head>
|
||||
<body bgcolor="#ffffff" text="#000000">
|
||||
<h1><img border border="0" src="../c++boost.gif" width="277" height="86"></h1>
|
||||
<h1>Compiler Status: linux</h1>
|
||||
|
||||
<p><b>Run Date:</b> 07 Jan 2001 22:21 GMT</p>
|
||||
<p><b>System Configuration:</b> Linux 2.2.13</p>
|
||||
<p>
|
||||
<table border="1" cellspacing="0" cellpadding="5">
|
||||
<tr>
|
||||
<td>Program</td>
|
||||
<td>Test<br>Type</td>
|
||||
<td>GNU<br>GCC<br>2.95.2</td>
|
||||
<td>GNU<br>GCC<br>2.95.2<br>STLport<br>4.0</td>
|
||||
<td>Comeau C++<br>4.2.44 beta3<br>STLport<br>4.0</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/alignment_test.cpp">libs/type_traits/alignment_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td><font color="#FF0000">Fail</font></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/arithmetic_traits_test.cpp">libs/type_traits/arithmetic_traits_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/composite_traits_test.cpp">libs/type_traits/composite_traits_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/cv_traits_test.cpp">libs/type_traits/cv_traits_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/is_convertible_test.cpp">libs/type_traits/is_convertible_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/is_same_test.cpp">libs/type_traits/is_same_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/object_type_traits_test.cpp">libs/type_traits/object_type_traits_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td><font color="#FF0000">Fail</font></td>
|
||||
<td><font color="#FF0000">Fail</font></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/transform_traits_test.cpp">libs/type_traits/transform_traits_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/trivial_destructor_example.cpp">libs/type_traits/trivial_destructor_example.cpp</a></td>
|
||||
<td>compile</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/copy_example.cpp">libs/type_traits/copy_example.cpp</a></td>
|
||||
<td>compile</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/fill_example.cpp">libs/type_traits/fill_example.cpp</a></td>
|
||||
<td>compile</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/iter_swap_example.cpp">libs/type_traits/iter_swap_example.cpp</a></td>
|
||||
<td>compile</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
</table></p>
|
||||
<p>
|
||||
Notes: A hand-crafted <limits> Standard header has been
|
||||
applied to all configurations.
|
||||
The tests were run on a GNU libc 2.2 system which has improved
|
||||
wide character support compared to previous versions.</p>
|
||||
</body>
|
||||
</html>
|
||||
@ -1,162 +0,0 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>
|
||||
Compiler Status: win32
|
||||
</title>
|
||||
</head>
|
||||
<body bgcolor="#ffffff" text="#000000">
|
||||
<h1><img border border="0" src="../c++boost.gif" width="277" height="86"></h1>
|
||||
<h1>Compiler Status: win32</h1>
|
||||
|
||||
<p><b>Run Date:</b> 03 Feb 2001 11:25 GMT</p>
|
||||
<p><b>System Configuration:</b> Microsoft Windows 32bit</p>
|
||||
<p>
|
||||
<table border="1" cellspacing="0" cellpadding="5">
|
||||
<tr>
|
||||
<td>Program</td>
|
||||
<td>Test<br>Type</td>
|
||||
<td>cygwin<br>GCC 2.95.2</td>
|
||||
<td>cygwin<br>GCC 2.95.2<br>+ SGI STL 3.3</td>
|
||||
<td>cygwin<br>GCC 2.95.2<br>+ STLPort 4</td>
|
||||
<td>Borland<br>5.5.1</td>
|
||||
<td>Borland<br>5.4</td>
|
||||
<td>Microsoft<br>VC++<br>6.0 SP4</td>
|
||||
<td>Microsoft<br>VC++<br>6.0 SP4<br>STLport<br>4.0</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/alignment_test.cpp">libs/type_traits/alignment_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/arithmetic_traits_test.cpp">libs/type_traits/arithmetic_traits_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/composite_traits_test.cpp">libs/type_traits/composite_traits_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/cv_traits_test.cpp">libs/type_traits/cv_traits_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/is_convertible_test.cpp">libs/type_traits/is_convertible_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td><font color="#FF0000">Fail</font></td>
|
||||
<td><font color="#FF0000">Fail</font></td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/is_same_test.cpp">libs/type_traits/is_same_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/object_type_traits_test.cpp">libs/type_traits/object_type_traits_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/transform_traits_test.cpp">libs/type_traits/transform_traits_test.cpp</a></td>
|
||||
<td>run</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td><font color="#FF0000">Fail</font></td>
|
||||
<td><font color="#FF0000">Fail</font></td>
|
||||
<td><font color="#FF0000">Fail</font></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/trivial_destructor_example.cpp">libs/type_traits/trivial_destructor_example.cpp</a></td>
|
||||
<td>compile</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/copy_example.cpp">libs/type_traits/copy_example.cpp</a></td>
|
||||
<td>compile</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/fill_example.cpp">libs/type_traits/fill_example.cpp</a></td>
|
||||
<td>compile</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td><a href="../libs/type_traits/iter_swap_example.cpp">libs/type_traits/iter_swap_example.cpp</a></td>
|
||||
<td>compile</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td>Pass</td>
|
||||
<td><font color="#FF0000">Fail</font></td>
|
||||
<td><font color="#FF0000">Fail</font></td>
|
||||
</tr>
|
||||
</table></p>
|
||||
<p>
|
||||
</p>
|
||||
</body>
|
||||
</html>
|
||||
@ -1,50 +0,0 @@
|
||||
|
||||
// (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.
|
||||
|
||||
#include <boost/type_traits/cv_traits.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hrdstop
|
||||
#endif
|
||||
#include "boost/type_traits/type_traits_test.hpp"
|
||||
|
||||
NESTED_DECL(is_const)
|
||||
NESTED_DECL(is_volatile)
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
NESTED_TEST(is_const, int)
|
||||
NESTED_TEST(is_const, const int)
|
||||
NESTED_TEST(is_const, volatile int)
|
||||
NESTED_TEST(is_volatile, int)
|
||||
NESTED_TEST(is_volatile, const int)
|
||||
NESTED_TEST(is_volatile, volatile int)
|
||||
|
||||
value_test(false, boost::is_const<void>::value)
|
||||
value_test(true, boost::is_const<const void>::value)
|
||||
value_test(false, boost::is_const<int>::value)
|
||||
value_test(true, boost::is_const<const int>::value)
|
||||
value_test(true, boost::is_const<const UDT>::value)
|
||||
value_test(true, boost::is_const<const volatile UDT>::value)
|
||||
value_test(false, boost::is_volatile<void>::value)
|
||||
value_test(true, boost::is_volatile<volatile void>::value)
|
||||
value_test(false, boost::is_volatile<int>::value)
|
||||
value_test(true, boost::is_volatile<volatile int>::value)
|
||||
value_test(true, boost::is_volatile<volatile UDT>::value)
|
||||
value_test(true, boost::is_volatile<volatile UDT>::value)
|
||||
|
||||
return check_result(argc, argv);
|
||||
}
|
||||
|
||||
//
|
||||
// define the number of failures expected for given compilers:
|
||||
#ifdef BOOST_MSVC
|
||||
unsigned int expected_failures = 2;
|
||||
#else
|
||||
unsigned int expected_failures = 0;
|
||||
#endif
|
||||
|
||||
@ -1,191 +0,0 @@
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1999
|
||||
* Dr John Maddock
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Dr John Maddock makes no representations
|
||||
* about the suitability of this software for any purpose.
|
||||
* It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* This file provides some example of type_traits usage -
|
||||
* by "optimising" various algorithms:
|
||||
*
|
||||
* opt::fill - optimised for trivial copy/small types (cf std::fill)
|
||||
*
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <typeinfo>
|
||||
#include <algorithm>
|
||||
#include <iterator>
|
||||
#include <memory>
|
||||
|
||||
#include <boost/timer.hpp>
|
||||
#include <boost/type_traits.hpp>
|
||||
#include <boost/call_traits.hpp>
|
||||
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE) || (defined(std) && defined(__SGI_STL_PORT))
|
||||
namespace std{ using :: memset; }
|
||||
#endif
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::cin;
|
||||
|
||||
namespace opt{
|
||||
//
|
||||
// fill
|
||||
// same as std::fill, uses memset where appropriate, along with call_traits
|
||||
// to "optimise" parameter passing.
|
||||
//
|
||||
namespace detail{
|
||||
|
||||
template <typename I, typename T>
|
||||
void do_fill_(I first, I last, typename boost::call_traits<T>::param_type val)
|
||||
{
|
||||
while(first != last)
|
||||
{
|
||||
*first = val;
|
||||
++first;
|
||||
}
|
||||
}
|
||||
|
||||
template <bool opt>
|
||||
struct filler
|
||||
{
|
||||
template <typename I, typename T>
|
||||
struct rebind
|
||||
{
|
||||
static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val)
|
||||
{ do_fill_<I,T>(first, last, val); }
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct filler<true>
|
||||
{
|
||||
template <typename I, typename T>
|
||||
struct rebind
|
||||
{
|
||||
static void do_fill(I first, I last, T val)
|
||||
{
|
||||
std::memset(first, val, last-first);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template <class I, class T>
|
||||
inline void fill(I first, I last, const T& val)
|
||||
{
|
||||
typedef detail::filler<
|
||||
::boost::type_traits::ice_and<
|
||||
::boost::is_pointer<I>::value,
|
||||
::boost::is_arithmetic<T>::value,
|
||||
(sizeof(T) == 1)
|
||||
>::value> filler_t;
|
||||
typedef typename filler_t:: template rebind<I,T> binder;
|
||||
binder::do_fill(first, last, val);
|
||||
}
|
||||
|
||||
}; // namespace opt
|
||||
|
||||
//
|
||||
// define some global data:
|
||||
//
|
||||
const int array_size = 1000;
|
||||
int i_array_[array_size] = {0,};
|
||||
const int ci_array_[array_size] = {0,};
|
||||
char c_array_[array_size] = {0,};
|
||||
const char cc_array_[array_size] = { 0,};
|
||||
//
|
||||
// since arrays aren't iterators we define a set of pointer
|
||||
// aliases into the arrays (otherwise the compiler is entitled
|
||||
// to deduce the type passed to the template functions as
|
||||
// T (&)[N] rather than T*).
|
||||
int* i_array = i_array_;
|
||||
const int* ci_array = ci_array_;
|
||||
char* c_array = c_array_;
|
||||
const char* cc_array = cc_array_;
|
||||
|
||||
const int iter_count = 1000000;
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::timer t;
|
||||
double result;
|
||||
int i;
|
||||
//
|
||||
// test destroy_array,
|
||||
// compare destruction time of an array of ints
|
||||
// with unoptimised form.
|
||||
//
|
||||
cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl;
|
||||
|
||||
cout << "testing fill(char)...\n"
|
||||
"[Some standard library versions may already perform this optimisation.]" << endl;
|
||||
|
||||
// cache load:
|
||||
opt::fill(c_array, c_array + array_size, (char)3);
|
||||
|
||||
// time optimised version:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
opt::fill(c_array, c_array + array_size, (char)3);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "opt::fill<char*, char>: " << result << endl;
|
||||
|
||||
// cache load:
|
||||
std::fill(c_array, c_array + array_size, (char)3);
|
||||
|
||||
// time standard version:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
std::fill(c_array, c_array + array_size, (char)3);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "std::fill<char*, char>: " << result << endl << endl;
|
||||
|
||||
cout << "testing fill(int)...\n"
|
||||
"[Tests the effect of call_traits pass-by-value optimisation -\nthe value of this optimisation may depend upon hardware characteristics.]" << endl;
|
||||
|
||||
// cache load:
|
||||
opt::fill(i_array, i_array + array_size, 3);
|
||||
|
||||
// timer optimised version:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
opt::fill(i_array, i_array + array_size, 3);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "opt::fill<int*, int>: " << result << endl;
|
||||
|
||||
// cache load:
|
||||
std::fill(i_array, i_array + array_size, 3);
|
||||
|
||||
// time standard version:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
std::fill(i_array, i_array + array_size, 3);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "std::fill<int*, int>: " << result << endl << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,23 +0,0 @@
|
||||
// (C) Copyright Boost.org 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.
|
||||
// See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp
|
||||
// for full copyright notices.
|
||||
|
||||
#ifndef BOOST_CALL_TRAITS_HPP
|
||||
#define BOOST_CALL_TRAITS_HPP
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
#include <boost/config.hpp>
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
#include <boost/detail/ob_call_traits.hpp>
|
||||
#else
|
||||
#include <boost/detail/call_traits.hpp>
|
||||
#endif
|
||||
|
||||
#endif // BOOST_CALL_TRAITS_HPP
|
||||
@ -1,427 +0,0 @@
|
||||
// Boost config.hpp configuration header file ------------------------------//
|
||||
|
||||
// (C) Copyright Boost.org 1999. 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.
|
||||
|
||||
// Boost config.hpp policy and rationale documentation has been moved to
|
||||
// http://www.boost.org/libs/config
|
||||
|
||||
// Revision History (excluding minor changes for specific compilers)
|
||||
// 31 Dec 00 BOOST_NO_CV_SPECIALIZATIONS
|
||||
// BOOST_NO_CV_VOID_SPECIALIZATIONS (John Maddock)
|
||||
// 17 Nov 00 BOOST_NO_AUTO_PTR (John Maddock)
|
||||
// 4 Oct 00 BOOST_NO_STD_MIN_MAX (Jeremy Siek)
|
||||
// 29 Sep 00 BOOST_NO_INTEGRAL_INT64_T (Jens Maurer)
|
||||
// 25 Sep 00 BOOST_NO_STD_ALLOCATOR (Jeremy Siek)
|
||||
// 18 SEP 00 BOOST_NO_SLIST, BOOST_NO_HASH,
|
||||
// BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
|
||||
// BOOST_NO_LIMITS (Jeremy Siek)
|
||||
// 1 Sep 00 BOOST_NO_PRIVATE_IN_AGGREGATE added. (Mark Rodgers)
|
||||
// 23 Jul 00 Fixed spelling of BOOST_NO_INCLASS_MEMBER_INITIALIZATION in
|
||||
// comment (Dave Abrahams).
|
||||
// 10 Jul 00 BOOST_NO_POINTER_TO_MEMBER_CONST added (Mark Rodgers)
|
||||
// 26 Jun 00 BOOST_NO_STD_ITERATOR, BOOST_MSVC_STD_ITERATOR,
|
||||
// BOOST_NO_STD_ITERATOR_TRAITS, BOOST_NO_USING_TEMPLATE,
|
||||
// added (Jeremy Siek)
|
||||
// 20 Jun 00 BOOST_MSVC added (Aleksey Gurtovoy)
|
||||
// 14 Jun 00 BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS (Jens M.)
|
||||
// 22 Mar 00 BOOST_MSVC6_MEMBER_TEMPLATES added (Dave Abrahams)
|
||||
// 18 Feb 00 BOOST_NO_INCLASS_MEMBER_INITIALIZATION added (Jens Maurer)
|
||||
// 26 Jan 00 Borland compiler support added (John Maddock)
|
||||
// 26 Jan 00 Sun compiler support added (J<>rg Schaible)
|
||||
// 30 Dec 99 BOOST_NMEMBER_TEMPLATES compatibility moved here from
|
||||
// smart_ptr.hpp. (Dave Abrahams)
|
||||
// 15 Nov 99 BOOST_NO_OPERATORS_IN_NAMESPACE,
|
||||
// BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION added (Beman Dawes)
|
||||
// 11 Oct 99 BOOST_NO_STDC_NAMESPACE refined; <cstddef> supplied
|
||||
// 29 Sep 99 BOOST_NO_STDC_NAMESPACE added (Ed Brey)
|
||||
// 24 Sep 99 BOOST_DECL added (Ed Brey)
|
||||
// 10 Aug 99 Endedness flags added, GNU CC support added
|
||||
// 22 Jul 99 Initial version
|
||||
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
#define BOOST_CONFIG_HPP
|
||||
|
||||
// Conformance Flag Macros -------------------------------------------------//
|
||||
//
|
||||
// Conformance flag macros should identify the absence of C++ Standard
|
||||
// conformance rather than its presence. This ensures that standard conforming
|
||||
// compilers do not require a lot of configuration flag macros. It places the
|
||||
// burden where it should be, on non-conforming compilers. In the future,
|
||||
// hopefully, less rather than more conformance flags will have to be defined.
|
||||
|
||||
// BOOST_NO_CV_SPECIALIZATIONS: if template specialisations for cv-qualified types
|
||||
// conflict with a specialistaion for unqualififed type.
|
||||
|
||||
// BOOST_NO_CV_VOID_SPECIALIZATIONS: if template specialisations for cv-void types
|
||||
// conflict with a specialistaion for void.
|
||||
|
||||
// BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS: Template value
|
||||
// parameters cannot have a dependent type, for example
|
||||
// "template<class T, typename T::type value> class X { ... };"
|
||||
|
||||
// BOOST_NO_INCLASS_MEMBER_INITIALIZATION: Compiler violates std::9.4.2/4.
|
||||
|
||||
// BOOST_NO_INT64_T: <boost/cstdint.hpp> does not support 64-bit integer
|
||||
// types. (Set by <boost/cstdint.hpp> rather than <boost/config.hpp>).
|
||||
|
||||
// BOOST_NO_INTEGRAL_INT64_T: int64_t as defined by <boost/cstdint.hpp> is
|
||||
// not an integral type.
|
||||
|
||||
// BOOST_NO_MEMBER_TEMPLATES: Member template functions not fully supported.
|
||||
// Also see BOOST_MSVC6_MEMBER_TEMPLATES in the Compiler Control section below.
|
||||
|
||||
// BOOST_NO_MEMBER_TEMPLATE_FRIENDS: Member template friend syntax
|
||||
// ("template<class P> friend class frd;") described in the C++ Standard,
|
||||
// 14.5.3, not supported.
|
||||
|
||||
// BOOST_NO_OPERATORS_IN_NAMESPACE: Compiler requires inherited operator
|
||||
// friend functions to be defined at namespace scope, then using'ed to boost.
|
||||
// Probably GCC specific. See boost/operators.hpp for example.
|
||||
|
||||
// BOOST_NO_POINTER_TO_MEMBER_CONST: The compiler does not correctly handle
|
||||
// pointers to const member functions, preventing use of these in overloaded
|
||||
// function templates. See boost/functional.hpp for example.
|
||||
|
||||
// BOOST_NO_PRIVATE_IN_AGGREGATE: The compiler misreads 8.5.1, treating classes
|
||||
// as non-aggregate if they contain private or protected member functions.
|
||||
|
||||
// BOOST_NO_STD_ITERATOR: The C++ implementation fails to provide the
|
||||
// std::iterator class.
|
||||
|
||||
// BOOST_NO_STD_ITERATOR_TRAITS: The compiler does not provide a standard
|
||||
// compliant implementation of std::iterator_traits. Note that
|
||||
// the compiler may still have a non-standard implementation.
|
||||
|
||||
// BOOST_NO_STDC_NAMESPACE: The contents of C++ standard headers for C library
|
||||
// functions (the <c...> headers) have not been placed in namespace std.
|
||||
// Because the use of std::size_t is so common, a specific workaround for
|
||||
// <cstddef> (and thus std::size_t) is provided in this header (see below).
|
||||
// For other <c...> headers, a workaround must be provided in the boost header:
|
||||
//
|
||||
// #include <cstdlib> // for abs
|
||||
// #ifdef BOOST_NO_STDC_NAMESPACE
|
||||
// namespace std { using ::abs; }
|
||||
// #endif
|
||||
|
||||
// BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION. Class template partial
|
||||
// specialization (14.5.4 [temp.class.spec]) not supported.
|
||||
|
||||
// BOOST_NO_USING_TEMPLATE: The compiler will not accept a using declaration
|
||||
// that imports a template from the global namespace into a named namespace.
|
||||
// Probably Borland specific.
|
||||
|
||||
// BOOST_NO_AUTO_PTR: If the compiler / library supplies non-standard or broken
|
||||
// std::auto_ptr.
|
||||
|
||||
// Compiler Control or Information Macros ----------------------------------//
|
||||
//
|
||||
// Compilers often supply features outside of the C++ Standard which need to be
|
||||
// controlled or detected. As usual, reasonable default behavior should occur
|
||||
// if any of these macros are not defined.
|
||||
|
||||
// BOOST_DECL: Certain compilers for Microsoft operating systems require
|
||||
// non-standard class and function decoration if dynamic load library linking
|
||||
// is desired. BOOST_DECL supplies that decoration, defaulting to a nul string
|
||||
// so that it is harmless when not required. Boost does not encourage the use
|
||||
// of BOOST_DECL - it is non-standard and to be avoided if practical to do so.
|
||||
|
||||
// BOOST_DECL_EXPORTS: User defined, BOOST_DECL_EXPORTS causes BOOST_DECL to
|
||||
// be defined as __declspec(dllexport) rather than __declspec(dllimport).
|
||||
|
||||
// BOOST_MSVC6_MEMBER_TEMPLATES: Microsoft Visual C++ 6.0 has enough member
|
||||
// template idiosyncrasies (being polite) that BOOST_NO_MEMBER_TEMPLATES is
|
||||
// defined for this compiler. BOOST_MSVC6_MEMBER_TEMPLATES is defined to allow
|
||||
// compiler specific workarounds.
|
||||
|
||||
// BOOST_MSVC: defined as _MSC_VER for the Microsoft compiler only. In general,
|
||||
// boost headers should test for a specific conformance flag macro (for
|
||||
// example, BOOST_NO_MEMBER_TEMPLATE_FRIENDS) rather than a specific compiler.
|
||||
// VC++ is a special case, however, since many libraries try to support it yet
|
||||
// it has so many conformance issues that sometimes it is just easier to test
|
||||
// for it directly. On the other hand, the obvious way to do this doesn't work,
|
||||
// as many non-Microsoft compilers define _MSC_VER. Thus BOOST_MSVC.
|
||||
|
||||
// BOOST_MSVC_STD_ITERATOR: Microsoft's broken version of std::iterator
|
||||
// is being used.
|
||||
|
||||
// BOOST_SYSTEM_HAS_STDINT_H: There are no 1998 C++ Standard headers <stdint.h>
|
||||
// or <cstdint>, although the 1999 C Standard does include <stdint.h>.
|
||||
// If <stdint.h> is present, <boost/stdint.h> can make good use of it,
|
||||
// so a flag is supplied (signalling presence; thus the default is not
|
||||
// present, conforming to the current C++ standard).
|
||||
|
||||
// BOOST_NO_SLIST: The C++ implementation does not provide the slist class.
|
||||
|
||||
// BOOST_NO_HASH: The C++ implementation does not provide the hash_set
|
||||
// or hash_map classes.
|
||||
|
||||
// BOOST_STD_EXTENSION_NAMESPACE: The name of the namespace in which the slist,
|
||||
// hash_set and/or hash_map templates are defined in this implementation (if any).
|
||||
|
||||
// BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS: The standard library does not provide
|
||||
// templated iterator constructors for its containers.
|
||||
|
||||
// BOOST_NO_LIMITS: The C++ implementation does not provide the <limits> header.
|
||||
|
||||
// BOOST_NO_INTRINSIC_WCHAR_T: The C++ implementation does not provide wchar_t,
|
||||
// or it is really a synonym for another integral type. Use this symbol to
|
||||
// decide whether it is appropriate to explicitly specialize a template on
|
||||
// wchar_t if there is already a specialization for other integer types.
|
||||
|
||||
// BOOST_NO_STD_ALLOCATOR: The C++ standard library does not provide
|
||||
// a standards conforming std::allocator.
|
||||
|
||||
// BOOST_NO_STD_MIN_MAX: The C++ standard library does not provide
|
||||
// the min() and max() template functions that should be in <algorithm>.
|
||||
|
||||
// Compilers are listed in alphabetic order (except VC++ last - see below)---//
|
||||
|
||||
// GNU CC (also known as GCC and G++) --------------------------------------//
|
||||
|
||||
# if defined __GNUC__
|
||||
# if __GNUC__ == 2 && __GNUC_MINOR__ == 91
|
||||
// egcs 1.1 won't parse smart_ptr.hpp without this:
|
||||
# define BOOST_NO_AUTO_PTR
|
||||
# endif
|
||||
# if __GNUC__ == 2 && __GNUC_MINOR__ <= 95
|
||||
# include <iterator> // not sure this is the right way to do this -JGS
|
||||
# if !defined(_CXXRT_STD) && !defined(__SGI_STL) // need to ask Dietmar about this -JGS
|
||||
# define BOOST_NO_STD_ITERATOR
|
||||
# define BOOST_NO_LIMITS
|
||||
# endif
|
||||
# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
# define BOOST_NO_OPERATORS_IN_NAMESPACE
|
||||
# endif
|
||||
# if __GNUC__ == 2 && __GNUC_MINOR__ <= 8
|
||||
# define BOOST_NO_MEMBER_TEMPLATES
|
||||
# endif
|
||||
|
||||
// Kai C++ ------------------------------------------------------------------//
|
||||
|
||||
#elif defined __KCC
|
||||
# define BOOST_NO_SLIST
|
||||
# define BOOST_NO_HASH
|
||||
|
||||
// Greenhills C++ -----------------------------------------------------------//
|
||||
|
||||
#elif defined __ghs
|
||||
# define BOOST_NO_SLIST
|
||||
# define BOOST_NO_HASH
|
||||
|
||||
// Borland ------------------------------------------------------------------//
|
||||
|
||||
#elif defined __BORLANDC__
|
||||
# define BOOST_NO_SLIST
|
||||
# define BOOST_NO_HASH
|
||||
# if __BORLANDC__ <= 0x0551
|
||||
# define BOOST_NO_INTEGRAL_INT64_T
|
||||
# define BOOST_NO_PRIVATE_IN_AGGREGATE
|
||||
# endif
|
||||
# if __BORLANDC__ <= 0x0550
|
||||
// Borland C++ Builder 4 and 5:
|
||||
# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
# define BOOST_NO_USING_TEMPLATE
|
||||
# if __BORLANDC__ == 0x0550
|
||||
// Borland C++ Builder 5, command-line compiler 5.5:
|
||||
# define BOOST_NO_OPERATORS_IN_NAMESPACE
|
||||
# endif
|
||||
# endif
|
||||
# if defined BOOST_DECL_EXPORTS
|
||||
# define BOOST_DECL __declspec(dllexport)
|
||||
# else
|
||||
# define BOOST_DECL __declspec(dllimport)
|
||||
# endif
|
||||
# define BOOST_NO_CV_SPECIALIZATIONS
|
||||
# define BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
|
||||
// Intel -------------------------------------------------------------------//
|
||||
|
||||
# elif defined __ICL
|
||||
# include <iterator> // not sure this is the right way to do this -JGS
|
||||
# if __SGI_STL_PORT >= 0x400 || __SGI_STL_PORT >= 0x321 && defined(__STL_USE_NAMESPACES)
|
||||
// a perfectly good implementation of std::iterator is supplied
|
||||
# elif defined(__SGI_STL_ITERATOR)
|
||||
# define BOOST_NO_STD_ITERATOR // No std::iterator in this case
|
||||
# else // assume using dinkumware's STL that comes with VC++ 6.0
|
||||
# define BOOST_MSVC_STD_ITERATOR
|
||||
# define BOOST_NO_STD_ITERATOR_TRAITS
|
||||
# define BOOST_NO_STDC_NAMESPACE
|
||||
# define BOOST_NO_SLIST
|
||||
# define BOOST_NO_HASH
|
||||
# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
|
||||
# define BOOST_NO_STD_ALLOCATOR
|
||||
# define BOOST_NO_STD_MIN_MAX
|
||||
# endif
|
||||
|
||||
|
||||
// Metrowerks CodeWarrior --------------------------------------------------//
|
||||
|
||||
# elif defined __MWERKS__
|
||||
# if __MWERKS__ <= 0x4000
|
||||
# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
# endif
|
||||
# if __MWERKS__ <= 0x2301
|
||||
# define BOOST_NO_POINTER_TO_MEMBER_CONST
|
||||
# endif
|
||||
# if __MWERKS__ >= 0x2300
|
||||
# define BOOST_SYSTEM_HAS_STDINT_H
|
||||
# endif
|
||||
# if defined BOOST_DECL_EXPORTS
|
||||
# define BOOST_DECL __declspec(dllexport)
|
||||
# else
|
||||
# define BOOST_DECL __declspec(dllimport)
|
||||
# endif
|
||||
|
||||
# define BOOST_STD_EXTENSION_NAMESPACE Metrowerks
|
||||
|
||||
// Sun Workshop Compiler C++ ------------------------------------------------//
|
||||
|
||||
# elif defined __SUNPRO_CC
|
||||
# if __SUNPRO_CC <= 0x500
|
||||
# define BOOST_NO_MEMBER_TEMPLATES
|
||||
# define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
# endif
|
||||
|
||||
// Microsoft Visual C++ (excluding Intel/EDG front end) --------------------//
|
||||
//
|
||||
// Must remain the last #elif since some other vendors (Metrowerks, for
|
||||
// example) also #define _MSC_VER
|
||||
|
||||
# elif defined _MSC_VER
|
||||
# define BOOST_MSVC _MSC_VER
|
||||
|
||||
// turn off the warnings before we #include anything
|
||||
# pragma warning( disable : 4786 ) // ident trunc to '255' chars in debug info
|
||||
# pragma warning( disable : 4503 ) // warning: decorated name length exceeded
|
||||
|
||||
# if _MSC_VER <= 1200 // 1200 == VC++ 6.0
|
||||
# define BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||
# define BOOST_NO_PRIVATE_IN_AGGREGATE
|
||||
|
||||
# define BOOST_NO_INTEGRAL_INT64_T
|
||||
# define BOOST_NO_INTRINSIC_WCHAR_T
|
||||
|
||||
// VC++ 6.0 has member templates but they have numerous problems including
|
||||
// cases of silent failure, so for safety we define:
|
||||
# define BOOST_NO_MEMBER_TEMPLATES
|
||||
// For VC++ experts wishing to attempt workarounds, we define:
|
||||
# define BOOST_MSVC6_MEMBER_TEMPLATES
|
||||
|
||||
# define BOOST_NO_MEMBER_TEMPLATE_FRIENDS
|
||||
# define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
# define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
|
||||
|
||||
# include <iterator> // not sure this is the right way to do this -JGS
|
||||
# if __SGI_STL_PORT >= 0x400 || __SGI_STL_PORT >= 0x321 && defined(__STL_USE_NAMESPACES)
|
||||
// a perfectly good implementation of std::iterator is supplied
|
||||
# elif defined(__SGI_STL_ITERATOR)
|
||||
# define BOOST_NO_STD_ITERATOR // No std::iterator in this case
|
||||
# else
|
||||
# define BOOST_MSVC_STD_ITERATOR 1
|
||||
# define BOOST_NO_SLIST
|
||||
# define BOOST_NO_HASH
|
||||
# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
|
||||
# define BOOST_NO_STD_ALLOCATOR
|
||||
# ifndef _CPPLIB_VER
|
||||
// Updated Dinkum library defines this, and provides
|
||||
// its own min and max definitions.
|
||||
# define BOOST_NO_STD_MIN_MAX
|
||||
# undef min
|
||||
# undef max
|
||||
# endif
|
||||
# ifndef NOMINMAX
|
||||
// avoid spurious NOMINMAX redefinition warning
|
||||
# define NOMINMAX
|
||||
# endif
|
||||
# endif
|
||||
# define BOOST_NO_STD_ITERATOR_TRAITS
|
||||
# define BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
|
||||
|
||||
// Make sure at least one standard library header is included so that library
|
||||
// implementation detection will work, even if no standard headers have been
|
||||
// included in front of a boost header. (Ed Brey 5 Jun 00)
|
||||
# include <cstddef>
|
||||
|
||||
// Determine if the standard library implementation is already pulling names
|
||||
// into std. STLport defines the following if so. (Ed Brey 5 Jun 00)
|
||||
# ifndef __STL_IMPORT_VENDOR_CSTD
|
||||
# define BOOST_NO_STDC_NAMESPACE
|
||||
# endif
|
||||
|
||||
# endif
|
||||
|
||||
# if defined BOOST_DECL_EXPORTS
|
||||
# define BOOST_DECL __declspec(dllexport)
|
||||
# else
|
||||
# define BOOST_DECL __declspec(dllimport)
|
||||
# endif
|
||||
|
||||
# endif // Microsoft (excluding Intel/EDG frontend)
|
||||
|
||||
# ifndef BOOST_DECL
|
||||
# define BOOST_DECL // default for compilers not needing this decoration.
|
||||
# endif
|
||||
|
||||
// end of compiler specific portion ----------------------------------------//
|
||||
|
||||
#ifndef BOOST_STD_EXTENSION_NAMESPACE
|
||||
# define BOOST_STD_EXTENSION_NAMESPACE std
|
||||
#endif
|
||||
|
||||
// Check for old name "BOOST_NMEMBER_TEMPLATES" for compatibility -----------//
|
||||
// Don't use BOOST_NMEMBER_TEMPLATES. It is deprecated and will be removed soon.
|
||||
#if defined( BOOST_NMEMBER_TEMPLATES ) && !defined( BOOST_NO_MEMBER_TEMPLATES )
|
||||
#define BOOST_NO_MEMBER_TEMPLATES
|
||||
#endif
|
||||
|
||||
// BOOST_NO_STDC_NAMESPACE workaround --------------------------------------//
|
||||
//
|
||||
// Because std::size_t usage is so common, even in boost headers which do not
|
||||
// otherwise use the C library, the <cstddef> workaround is included here so
|
||||
// that ugly workaround code need not appear in many other boost headers.
|
||||
// NOTE WELL: This is a workaround for non-conforming compilers; <cstddef>
|
||||
// must still be #included in the usual places so that <cstddef> inclusion
|
||||
// works as expected with standard conforming compilers. The resulting
|
||||
// double inclusion of <cstddef> is harmless.
|
||||
|
||||
# ifdef BOOST_NO_STDC_NAMESPACE
|
||||
# include <cstddef>
|
||||
namespace std { using ::ptrdiff_t; using ::size_t; }
|
||||
// using ::wchar_t; removed since wchar_t is a C++ built-in type (Ed Brey)
|
||||
# endif
|
||||
|
||||
#ifdef BOOST_NO_STD_MIN_MAX
|
||||
namespace std {
|
||||
template <class _Tp>
|
||||
inline const _Tp& min(const _Tp& __a, const _Tp& __b) {
|
||||
return __b < __a ? __b : __a;
|
||||
}
|
||||
template <class _Tp>
|
||||
inline const _Tp& max(const _Tp& __a, const _Tp& __b) {
|
||||
return __a < __b ? __b : __a;
|
||||
}
|
||||
#ifdef BOOST_MSVC
|
||||
inline long min(long __a, long __b) {
|
||||
return __b < __a ? __b : __a;
|
||||
}
|
||||
inline long max(long __a, long __b) {
|
||||
return __a < __b ? __b : __a;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // BOOST_CONFIG_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,138 +0,0 @@
|
||||
// (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.
|
||||
|
||||
// call_traits: defines typedefs for function usage
|
||||
// (see libs/utility/call_traits.htm)
|
||||
|
||||
/* Release notes:
|
||||
23rd July 2000:
|
||||
Fixed array specialization. (JM)
|
||||
Added Borland specific fixes for reference types
|
||||
(issue raised by Steve Cleary).
|
||||
*/
|
||||
|
||||
#ifndef BOOST_DETAIL_CALL_TRAITS_HPP
|
||||
#define BOOST_DETAIL_CALL_TRAITS_HPP
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
#include <boost/config.hpp>
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <typename T, bool isp, bool b1, bool b2>
|
||||
struct ct_imp
|
||||
{
|
||||
typedef const T& param_type;
|
||||
};
|
||||
|
||||
template <typename T, bool isp>
|
||||
struct ct_imp<T, isp, true, true>
|
||||
{
|
||||
typedef T const param_type;
|
||||
};
|
||||
|
||||
template <typename T, bool b1, bool b2>
|
||||
struct ct_imp<T, true, b1, b2>
|
||||
{
|
||||
typedef T const param_type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct call_traits
|
||||
{
|
||||
public:
|
||||
typedef T value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
//
|
||||
// C++ Builder workaround: we should be able to define a compile time
|
||||
// constant and pass that as a single template parameter to ct_imp<T,bool>,
|
||||
// however compiler bugs prevent this - instead pass three bool's to
|
||||
// ct_imp<T,bool,bool,bool> and add an extra partial specialisation
|
||||
// of ct_imp to handle the logic. (JM)
|
||||
typedef typename detail::ct_imp<T, ::boost::is_pointer<typename remove_const<T>::type>::value, ::boost::is_arithmetic<typename remove_const<T>::type>::value, sizeof(T) <= sizeof(void*)>::param_type param_type;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct call_traits<T&>
|
||||
{
|
||||
typedef T& value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef T& param_type; // hh removed const
|
||||
};
|
||||
|
||||
#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)
|
||||
// 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 call_traits<T&const>
|
||||
{
|
||||
typedef T& value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef T& param_type; // hh removed const
|
||||
};
|
||||
template <typename T>
|
||||
struct call_traits<T&volatile>
|
||||
{
|
||||
typedef T& value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef T& param_type; // hh removed const
|
||||
};
|
||||
template <typename T>
|
||||
struct call_traits<T&const volatile>
|
||||
{
|
||||
typedef T& value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef T& param_type; // hh removed const
|
||||
};
|
||||
#endif
|
||||
|
||||
template <typename T, std::size_t N>
|
||||
struct call_traits<T [N]>
|
||||
{
|
||||
private:
|
||||
typedef T array_type[N];
|
||||
public:
|
||||
// degrades array to pointer:
|
||||
typedef const T* value_type;
|
||||
typedef array_type& reference;
|
||||
typedef const array_type& const_reference;
|
||||
typedef const T* const param_type;
|
||||
};
|
||||
|
||||
template <typename T, std::size_t N>
|
||||
struct call_traits<const T [N]>
|
||||
{
|
||||
private:
|
||||
typedef const T array_type[N];
|
||||
public:
|
||||
// degrades array to pointer:
|
||||
typedef const T* value_type;
|
||||
typedef array_type& reference;
|
||||
typedef const array_type& const_reference;
|
||||
typedef const T* const param_type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // BOOST_DETAIL_CALL_TRAITS_HPP
|
||||
@ -1,125 +0,0 @@
|
||||
// (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.
|
||||
//
|
||||
// Crippled version for crippled compilers:
|
||||
// see libs/utility/call_traits.htm
|
||||
//
|
||||
|
||||
/* Release notes:
|
||||
01st October 2000:
|
||||
Fixed call_traits on VC6, using "poor man's partial specialisation",
|
||||
using ideas taken from "Generative programming" by Krzysztof Czarnecki
|
||||
& Ulrich Eisenecker.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_OB_CALL_TRAITS_HPP
|
||||
#define BOOST_OB_CALL_TRAITS_HPP
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
#include <boost/config.hpp>
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
|
||||
#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
|
||||
//
|
||||
// use member templates to emulate
|
||||
// partial specialisation:
|
||||
//
|
||||
namespace detail{
|
||||
|
||||
template <class T>
|
||||
struct standard_call_traits
|
||||
{
|
||||
typedef T value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef const T& param_type;
|
||||
};
|
||||
template <class T>
|
||||
struct simple_call_traits
|
||||
{
|
||||
typedef T value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef const T param_type;
|
||||
};
|
||||
template <class T>
|
||||
struct reference_call_traits
|
||||
{
|
||||
typedef T value_type;
|
||||
typedef T reference;
|
||||
typedef T const_reference;
|
||||
typedef T param_type;
|
||||
};
|
||||
template <bool simple, bool reference>
|
||||
struct call_traits_chooser
|
||||
{
|
||||
template <class T>
|
||||
struct rebind
|
||||
{
|
||||
typedef standard_call_traits<T> type;
|
||||
};
|
||||
};
|
||||
template <>
|
||||
struct call_traits_chooser<true, false>
|
||||
{
|
||||
template <class T>
|
||||
struct rebind
|
||||
{
|
||||
typedef simple_call_traits<T> type;
|
||||
};
|
||||
};
|
||||
template <>
|
||||
struct call_traits_chooser<false, true>
|
||||
{
|
||||
template <class T>
|
||||
struct rebind
|
||||
{
|
||||
typedef reference_call_traits<T> type;
|
||||
};
|
||||
};
|
||||
} // namespace detail
|
||||
template <typename T>
|
||||
struct call_traits
|
||||
{
|
||||
private:
|
||||
typedef detail::call_traits_chooser<(is_pointer<T>::value || is_arithmetic<T>::value) && sizeof(T) <= sizeof(void*), is_reference<T>::value> chooser;
|
||||
typedef typename chooser::template rebind<T> bound_type;
|
||||
typedef typename bound_type::type call_traits_type;
|
||||
public:
|
||||
typedef typename call_traits_type::value_type value_type;
|
||||
typedef typename call_traits_type::reference reference;
|
||||
typedef typename call_traits_type::const_reference const_reference;
|
||||
typedef typename call_traits_type::param_type param_type;
|
||||
};
|
||||
|
||||
#else
|
||||
//
|
||||
// sorry call_traits is completely non-functional
|
||||
// blame your broken compiler:
|
||||
//
|
||||
|
||||
template <typename T>
|
||||
struct call_traits
|
||||
{
|
||||
typedef T value_type;
|
||||
typedef T& reference;
|
||||
typedef const T& const_reference;
|
||||
typedef const T& param_type;
|
||||
};
|
||||
|
||||
#endif // member templates
|
||||
|
||||
}
|
||||
|
||||
#endif // BOOST_OB_CALL_TRAITS_HPP
|
||||
@ -1,379 +0,0 @@
|
||||
// Boost smart_ptr.hpp header file -----------------------------------------//
|
||||
|
||||
// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. 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.
|
||||
|
||||
// Revision History
|
||||
// 19 Oct 00 Make shared_ptr ctor from auto_ptr explicit. (Robert Vugts)
|
||||
// 24 Jul 00 Change throw() to // never throws. See lib guidelines
|
||||
// Exception-specification rationale. (Beman Dawes)
|
||||
// 22 Jun 00 Remove #if continuations to fix GCC 2.95.2 problem (Beman Dawes)
|
||||
// 1 Feb 00 Additional shared_ptr BOOST_NO_MEMBER_TEMPLATES workarounds
|
||||
// (Dave Abrahams)
|
||||
// 31 Dec 99 Condition tightened for no member template friend workaround
|
||||
// (Dave Abrahams)
|
||||
// 30 Dec 99 Moved BOOST_NMEMBER_TEMPLATES compatibility code to config.hpp
|
||||
// (Dave Abrahams)
|
||||
// 30 Nov 99 added operator ==, operator !=, and std::swap and std::less
|
||||
// specializations for shared types (Darin Adler)
|
||||
// 11 Oct 99 replaced op[](int) with op[](std::size_t) (Ed Brey, Valentin
|
||||
// Bonnard), added shared_ptr workaround for no member template
|
||||
// friends (Matthew Langston)
|
||||
// 25 Sep 99 added shared_ptr::swap and shared_array::swap (Luis Coelho).
|
||||
// 20 Jul 99 changed name to smart_ptr.hpp, #include <boost/config.hpp>,
|
||||
// #include <boost/utility.hpp> and use boost::noncopyable
|
||||
// 17 May 99 remove scoped_array and shared_array operator*() as
|
||||
// unnecessary (Beman Dawes)
|
||||
// 14 May 99 reorder code so no effects when bad_alloc thrown (Abrahams/Dawes)
|
||||
// 13 May 99 remove certain throw() specifiers to avoid generated try/catch
|
||||
// code cost (Beman Dawes)
|
||||
// 11 May 99 get() added, conversion to T* placed in macro guard (Valentin
|
||||
// Bonnard, Dave Abrahams, and others argued for elimination
|
||||
// of the automatic conversion)
|
||||
// 28 Apr 99 #include <memory> fix (Valentin Bonnard)
|
||||
// 28 Apr 99 rename transfer() to share() for clarity (Dave Abrahams)
|
||||
// 28 Apr 99 remove unsafe shared_array template conversions(Valentin Bonnard)
|
||||
// 28 Apr 99 p(r) changed to p(r.px) for clarity (Dave Abrahams)
|
||||
// 21 Apr 99 reset() self assignment fix (Valentin Bonnard)
|
||||
// 21 Apr 99 dispose() provided to improve clarity (Valentin Bonnard)
|
||||
// 27 Apr 99 leak when new throws fixes (Dave Abrahams)
|
||||
// 21 Oct 98 initial Version (Greg Colvin/Beman Dawes)
|
||||
|
||||
#ifndef BOOST_SMART_PTR_HPP
|
||||
#define BOOST_SMART_PTR_HPP
|
||||
|
||||
#include <boost/config.hpp> // for broken compiler workarounds
|
||||
#include <cstddef> // for std::size_t
|
||||
#include <memory> // for std::auto_ptr
|
||||
#include <algorithm> // for std::swap
|
||||
#include <boost/utility.hpp> // for boost::noncopyable
|
||||
#include <functional> // for std::less
|
||||
|
||||
namespace boost {
|
||||
|
||||
// scoped_ptr --------------------------------------------------------------//
|
||||
|
||||
// scoped_ptr mimics a built-in pointer except that it guarantees deletion
|
||||
// of the object pointed to, either on destruction of the scoped_ptr or via
|
||||
// an explicit reset(). scoped_ptr is a simple solution for simple needs;
|
||||
// see shared_ptr (below) or std::auto_ptr if your needs are more complex.
|
||||
|
||||
template<typename T> class scoped_ptr : noncopyable {
|
||||
|
||||
T* ptr;
|
||||
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
explicit scoped_ptr( T* p=0 ) : ptr(p) {} // never throws
|
||||
~scoped_ptr() { delete ptr; }
|
||||
|
||||
void reset( T* p=0 ) { if ( ptr != p ) { delete ptr; ptr = p; } }
|
||||
T& operator*() const { return *ptr; } // never throws
|
||||
T* operator->() const { return ptr; } // never throws
|
||||
T* get() const { return ptr; } // never throws
|
||||
#ifdef BOOST_SMART_PTR_CONVERSION
|
||||
// get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
|
||||
operator T*() const { return ptr; } // never throws
|
||||
#endif
|
||||
}; // scoped_ptr
|
||||
|
||||
// scoped_array ------------------------------------------------------------//
|
||||
|
||||
// scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
|
||||
// is guaranteed, either on destruction of the scoped_array or via an explicit
|
||||
// reset(). See shared_array or std::vector if your needs are more complex.
|
||||
|
||||
template<typename T> class scoped_array : noncopyable {
|
||||
|
||||
T* ptr;
|
||||
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
explicit scoped_array( T* p=0 ) : ptr(p) {} // never throws
|
||||
~scoped_array() { delete [] ptr; }
|
||||
|
||||
void reset( T* p=0 ) { if ( ptr != p ) {delete [] ptr; ptr=p;} }
|
||||
|
||||
T* get() const { return ptr; } // never throws
|
||||
#ifdef BOOST_SMART_PTR_CONVERSION
|
||||
// get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
|
||||
operator T*() const { return ptr; } // never throws
|
||||
#else
|
||||
T& operator[](std::size_t i) const { return ptr[i]; } // never throws
|
||||
#endif
|
||||
}; // scoped_array
|
||||
|
||||
// shared_ptr --------------------------------------------------------------//
|
||||
|
||||
// An enhanced relative of scoped_ptr with reference counted copy semantics.
|
||||
// The object pointed to is deleted when the last shared_ptr pointing to it
|
||||
// is destroyed or reset.
|
||||
|
||||
template<typename T> class shared_ptr {
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
explicit shared_ptr(T* p =0) : px(p) {
|
||||
try { pn = new long(1); } // fix: prevent leak if new throws
|
||||
catch (...) { delete p; throw; }
|
||||
}
|
||||
|
||||
shared_ptr(const shared_ptr& r) : px(r.px) { ++*(pn = r.pn); } // never throws
|
||||
|
||||
~shared_ptr() { dispose(); }
|
||||
|
||||
shared_ptr& operator=(const shared_ptr& r) {
|
||||
share(r.px,r.pn);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#if !defined( BOOST_NO_MEMBER_TEMPLATES )
|
||||
template<typename Y>
|
||||
shared_ptr(const shared_ptr<Y>& r) : px(r.px) { // never throws
|
||||
++*(pn = r.pn);
|
||||
}
|
||||
#ifndef BOOST_NO_AUTO_PTR
|
||||
template<typename Y>
|
||||
explicit shared_ptr(std::auto_ptr<Y>& r) {
|
||||
pn = new long(1); // may throw
|
||||
px = r.release(); // fix: moved here to stop leak if new throws
|
||||
}
|
||||
#endif
|
||||
|
||||
template<typename Y>
|
||||
shared_ptr& operator=(const shared_ptr<Y>& r) {
|
||||
share(r.px,r.pn);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_AUTO_PTR
|
||||
template<typename Y>
|
||||
shared_ptr& operator=(std::auto_ptr<Y>& r) {
|
||||
// code choice driven by guarantee of "no effect if new throws"
|
||||
if (*pn == 1) { delete px; }
|
||||
else { // allocate new reference counter
|
||||
long * tmp = new long(1); // may throw
|
||||
--*pn; // only decrement once danger of new throwing is past
|
||||
pn = tmp;
|
||||
} // allocate new reference counter
|
||||
px = r.release(); // fix: moved here so doesn't leak if new throws
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
#ifndef BOOST_NO_AUTO_PTR
|
||||
explicit shared_ptr(std::auto_ptr<T>& r) {
|
||||
pn = new long(1); // may throw
|
||||
px = r.release(); // fix: moved here to stop leak if new throws
|
||||
}
|
||||
|
||||
shared_ptr& operator=(std::auto_ptr<T>& r) {
|
||||
// code choice driven by guarantee of "no effect if new throws"
|
||||
if (*pn == 1) { delete px; }
|
||||
else { // allocate new reference counter
|
||||
long * tmp = new long(1); // may throw
|
||||
--*pn; // only decrement once danger of new throwing is past
|
||||
pn = tmp;
|
||||
} // allocate new reference counter
|
||||
px = r.release(); // fix: moved here so doesn't leak if new throws
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
void reset(T* p=0) {
|
||||
if ( px == p ) return; // fix: self-assignment safe
|
||||
if (--*pn == 0) { delete px; }
|
||||
else { // allocate new reference counter
|
||||
try { pn = new long; } // fix: prevent leak if new throws
|
||||
catch (...) {
|
||||
++*pn; // undo effect of --*pn above to meet effects guarantee
|
||||
delete p;
|
||||
throw;
|
||||
} // catch
|
||||
} // allocate new reference counter
|
||||
*pn = 1;
|
||||
px = p;
|
||||
} // reset
|
||||
|
||||
T& operator*() const { return *px; } // never throws
|
||||
T* operator->() const { return px; } // never throws
|
||||
T* get() const { return px; } // never throws
|
||||
#ifdef BOOST_SMART_PTR_CONVERSION
|
||||
// get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
|
||||
operator T*() const { return px; } // never throws
|
||||
#endif
|
||||
|
||||
long use_count() const { return *pn; } // never throws
|
||||
bool unique() const { return *pn == 1; } // never throws
|
||||
|
||||
void swap(shared_ptr<T>& other) // never throws
|
||||
{ std::swap(px,other.px); std::swap(pn,other.pn); }
|
||||
|
||||
// Tasteless as this may seem, making all members public allows member templates
|
||||
// to work in the absence of member template friends. (Matthew Langston)
|
||||
// Don't split this line into two; that causes problems for some GCC 2.95.2 builds
|
||||
#if defined(BOOST_NO_MEMBER_TEMPLATES) || !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS )
|
||||
private:
|
||||
#endif
|
||||
|
||||
T* px; // contained pointer
|
||||
long* pn; // ptr to reference counter
|
||||
|
||||
// Don't split this line into two; that causes problems for some GCC 2.95.2 builds
|
||||
#if !defined( BOOST_NO_MEMBER_TEMPLATES ) && !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS )
|
||||
template<typename Y> friend class shared_ptr;
|
||||
#endif
|
||||
|
||||
void dispose() { if (--*pn == 0) { delete px; delete pn; } }
|
||||
|
||||
void share(T* rpx, long* rpn) {
|
||||
if (pn != rpn) {
|
||||
dispose();
|
||||
px = rpx;
|
||||
++*(pn = rpn);
|
||||
}
|
||||
} // share
|
||||
}; // shared_ptr
|
||||
|
||||
template<typename T, typename U>
|
||||
inline bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b)
|
||||
{ return a.get() == b.get(); }
|
||||
|
||||
template<typename T, typename U>
|
||||
inline bool operator!=(const shared_ptr<T>& a, const shared_ptr<U>& b)
|
||||
{ return a.get() != b.get(); }
|
||||
|
||||
// shared_array ------------------------------------------------------------//
|
||||
|
||||
// shared_array extends shared_ptr to arrays.
|
||||
// The array pointed to is deleted when the last shared_array pointing to it
|
||||
// is destroyed or reset.
|
||||
|
||||
template<typename T> class shared_array {
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
explicit shared_array(T* p =0) : px(p) {
|
||||
try { pn = new long(1); } // fix: prevent leak if new throws
|
||||
catch (...) { delete [] p; throw; }
|
||||
}
|
||||
|
||||
shared_array(const shared_array& r) : px(r.px) // never throws
|
||||
{ ++*(pn = r.pn); }
|
||||
|
||||
~shared_array() { dispose(); }
|
||||
|
||||
shared_array& operator=(const shared_array& r) {
|
||||
if (pn != r.pn) {
|
||||
dispose();
|
||||
px = r.px;
|
||||
++*(pn = r.pn);
|
||||
}
|
||||
return *this;
|
||||
} // operator=
|
||||
|
||||
void reset(T* p=0) {
|
||||
if ( px == p ) return; // fix: self-assignment safe
|
||||
if (--*pn == 0) { delete [] px; }
|
||||
else { // allocate new reference counter
|
||||
try { pn = new long; } // fix: prevent leak if new throws
|
||||
catch (...) {
|
||||
++*pn; // undo effect of --*pn above to meet effects guarantee
|
||||
delete [] p;
|
||||
throw;
|
||||
} // catch
|
||||
} // allocate new reference counter
|
||||
*pn = 1;
|
||||
px = p;
|
||||
} // reset
|
||||
|
||||
T* get() const { return px; } // never throws
|
||||
#ifdef BOOST_SMART_PTR_CONVERSION
|
||||
// get() is safer! Define BOOST_SMART_PTR_CONVERSION at your own risk!
|
||||
operator T*() const { return px; } // never throws
|
||||
#else
|
||||
T& operator[](std::size_t i) const { return px[i]; } // never throws
|
||||
#endif
|
||||
|
||||
long use_count() const { return *pn; } // never throws
|
||||
bool unique() const { return *pn == 1; } // never throws
|
||||
|
||||
void swap(shared_array<T>& other) // never throws
|
||||
{ std::swap(px,other.px); std::swap(pn,other.pn); }
|
||||
|
||||
private:
|
||||
|
||||
T* px; // contained pointer
|
||||
long* pn; // ptr to reference counter
|
||||
|
||||
void dispose() { if (--*pn == 0) { delete [] px; delete pn; } }
|
||||
|
||||
}; // shared_array
|
||||
|
||||
template<typename T>
|
||||
inline bool operator==(const shared_array<T>& a, const shared_array<T>& b)
|
||||
{ return a.get() == b.get(); }
|
||||
|
||||
template<typename T>
|
||||
inline bool operator!=(const shared_array<T>& a, const shared_array<T>& b)
|
||||
{ return a.get() != b.get(); }
|
||||
|
||||
} // namespace boost
|
||||
|
||||
// specializations for things in namespace std -----------------------------//
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
namespace std {
|
||||
|
||||
// Specialize std::swap to use the fast, non-throwing swap that's provided
|
||||
// as a member function instead of using the default algorithm which creates
|
||||
// a temporary and uses assignment.
|
||||
|
||||
template<typename T>
|
||||
inline void swap(boost::shared_ptr<T>& a, boost::shared_ptr<T>& b)
|
||||
{ a.swap(b); }
|
||||
|
||||
template<typename T>
|
||||
inline void swap(boost::shared_array<T>& a, boost::shared_array<T>& b)
|
||||
{ a.swap(b); }
|
||||
|
||||
// Specialize std::less so we can use shared pointers and arrays as keys in
|
||||
// associative collections.
|
||||
|
||||
// It's still a controversial question whether this is better than supplying
|
||||
// a full range of comparison operators (<, >, <=, >=).
|
||||
|
||||
template<typename T>
|
||||
struct less< boost::shared_ptr<T> >
|
||||
: binary_function<boost::shared_ptr<T>, boost::shared_ptr<T>, bool>
|
||||
{
|
||||
bool operator()(const boost::shared_ptr<T>& a,
|
||||
const boost::shared_ptr<T>& b) const
|
||||
{ return less<T*>()(a.get(),b.get()); }
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct less< boost::shared_array<T> >
|
||||
: binary_function<boost::shared_array<T>, boost::shared_array<T>, bool>
|
||||
{
|
||||
bool operator()(const boost::shared_array<T>& a,
|
||||
const boost::shared_array<T>& b) const
|
||||
{ return less<T*>()(a.get(),b.get()); }
|
||||
};
|
||||
|
||||
} // namespace std
|
||||
|
||||
#endif // ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
#endif // BOOST_SMART_PTR_HPP
|
||||
|
||||
|
||||
@ -1,57 +0,0 @@
|
||||
// boost timer.hpp header file ---------------------------------------------//
|
||||
|
||||
// (C) Copyright Beman Dawes 1994-99. 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.
|
||||
|
||||
// Revision History
|
||||
// 25 Sep 99 elapsed_max() and elapsed_min() added (John Maddock)
|
||||
// 16 Jul 99 Second beta
|
||||
// 6 Jul 99 Initial boost version
|
||||
|
||||
#ifndef BOOST_TIMER_HPP
|
||||
#define BOOST_TIMER_HPP
|
||||
|
||||
#include <boost/smart_ptr.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
// timer -------------------------------------------------------------------//
|
||||
|
||||
// A timer object measures elapsed time.
|
||||
|
||||
// It is recommended that implementations measure wall clock rather than CPU
|
||||
// time since the intended use is performance measurement on systems where
|
||||
// total elapsed time is more important than just process or CPU time.
|
||||
|
||||
// Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
|
||||
// due to implementation limitations. The accuracy of timings depends on the
|
||||
// accuracy of timing information provided by the underlying platform, and
|
||||
// this varies a great deal from platform to platform.
|
||||
|
||||
class timer {
|
||||
|
||||
public:
|
||||
timer(); // postcondition: elapsed()==0
|
||||
timer( const timer& src ); // post: elapsed()==src.elapsed()
|
||||
~timer();
|
||||
timer& operator=( const timer& src ); // post: elapsed()==src.elapsed()
|
||||
void restart(); // post: elapsed()==0
|
||||
double elapsed() const; // return elapsed time in seconds
|
||||
|
||||
double elapsed_max() const; // return estimated maximum value for elapsed()
|
||||
// Portability warning: elapsed_max() may return too high a value on systems
|
||||
// where std::clock_t overflows or resets at surprising values.
|
||||
double elapsed_min() const; // return minimum value for elapsed()
|
||||
|
||||
private:
|
||||
class _timer;
|
||||
scoped_ptr<_timer> _imp; // hide implementation details
|
||||
}; // timer
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_TIMER_HPP
|
||||
@ -1,42 +0,0 @@
|
||||
// (C) Copyright Boost.org 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.
|
||||
// See boost/detail/type_traits.hpp and boost/detail/ob_type_traits.hpp
|
||||
// for full copyright notices.
|
||||
|
||||
#ifndef BOOST_TYPE_TRAITS_HPP
|
||||
#define BOOST_TYPE_TRAITS_HPP
|
||||
|
||||
#include <boost/type_traits/fwd.hpp>
|
||||
#include <boost/type_traits/ice.hpp>
|
||||
#include <boost/type_traits/conversion_traits.hpp>
|
||||
#include <boost/type_traits/arithmetic_traits.hpp>
|
||||
#include <boost/type_traits/cv_traits.hpp>
|
||||
#include <boost/type_traits/composite_traits.hpp>
|
||||
#include <boost/type_traits/alignment_traits.hpp>
|
||||
#include <boost/type_traits/object_traits.hpp>
|
||||
#include <boost/type_traits/transform_traits.hpp>
|
||||
#include <boost/type_traits/same_traits.hpp>
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
//
|
||||
// undefine helper macro's:
|
||||
//
|
||||
#undef BOOST_IS_CLASS
|
||||
#undef BOOST_IS_ENUM
|
||||
#undef BOOST_IS_UNION
|
||||
#undef BOOST_IS_POD
|
||||
#undef BOOST_IS_EMPTY
|
||||
#undef BOOST_HAS_TRIVIAL_CONSTRUCTOR
|
||||
#undef BOOST_HAS_TRIVIAL_COPY
|
||||
#undef BOOST_HAS_TRIVIAL_ASSIGN
|
||||
#undef BOOST_HAS_TRIVIAL_DESTRUCTOR
|
||||
|
||||
#endif // BOOST_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
@ -1,82 +0,0 @@
|
||||
|
||||
// (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>
|
||||
#ifndef BOOST_ICE_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits/ice.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
//
|
||||
// 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_DECL_MC(std::size_t, value, A < S ? A : S);
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <class T>
|
||||
struct alignment_of
|
||||
{
|
||||
BOOST_DECL_MC(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_DECL_MC(std::size_t, value, alignment_of<T*>::value);
|
||||
};
|
||||
#endif
|
||||
//
|
||||
// void has to be treated specially:
|
||||
template <>
|
||||
struct alignment_of<void>
|
||||
{ BOOST_DECL_MC(std::size_t, value, 0); };
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct alignment_of<const void>
|
||||
{ BOOST_DECL_MC(std::size_t, value, 0); };
|
||||
template <>
|
||||
struct alignment_of<volatile void>
|
||||
{ BOOST_DECL_MC(std::size_t, value, 0); };
|
||||
template <>
|
||||
struct alignment_of<const volatile void>
|
||||
{ BOOST_DECL_MC(std::size_t, value, 0); };
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // ALIGNMENT_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
@ -1,262 +0,0 @@
|
||||
// (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.
|
||||
//
|
||||
|
||||
|
||||
#ifndef ARITHMETIC_TYPE_TRAITS_HPP
|
||||
#define 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
|
||||
|
||||
namespace boost{
|
||||
|
||||
//* is a type T void - is_void<T>
|
||||
template <typename T> struct is_void{ BOOST_DECL_MC(bool, value, false); };
|
||||
template <> struct is_void<void>{ BOOST_DECL_MC(bool, value, true); };
|
||||
|
||||
//* is a type T an integral type described in the standard (3.9.1p3)
|
||||
template <typename T> struct is_integral
|
||||
{ BOOST_DECL_MC(bool, value, false); };
|
||||
template <> struct is_integral<unsigned char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<unsigned short>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<unsigned int>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<unsigned long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<signed char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<signed short>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<signed int>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<signed long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#ifndef BOOST_MSVC
|
||||
template <> struct is_integral<wchar_t>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif
|
||||
template <> struct is_integral<bool>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
|
||||
#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
|
||||
template <> struct is_integral<unsigned long long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<long long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
|
||||
template <> struct is_integral<unsigned __int64>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<__int64>
|
||||
{ BOOST_DECL_MC(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_DECL_MC(bool, value, false); };
|
||||
template <> struct is_float<float>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_float<double>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_float<long double>
|
||||
{ BOOST_DECL_MC(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_DECL_MC(bool, value, true); };
|
||||
template <> struct is_void<volatile void>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_void<const volatile void>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif
|
||||
#ifndef BOOST_NO_CV_SPECIALIZATIONS
|
||||
// const-variations:
|
||||
template <> struct is_integral<const unsigned char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const unsigned short>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const unsigned int>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const unsigned long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const signed char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const signed short>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const signed int>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const signed long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#ifndef BOOST_MSVC
|
||||
template <> struct is_integral<const wchar_t>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif
|
||||
template <> struct is_integral<const bool>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
|
||||
#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
|
||||
template <> struct is_integral<const unsigned long long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const long long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif // ULLONG_MAX
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
|
||||
template <> struct is_integral<const unsigned __int64>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const __int64>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif //__int64
|
||||
|
||||
template <> struct is_float<const float>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_float<const double>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_float<const long double>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
|
||||
// volatile-variations:
|
||||
template <> struct is_integral<volatile unsigned char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<volatile unsigned short>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<volatile unsigned int>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<volatile unsigned long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<volatile signed char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<volatile signed short>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<volatile signed int>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<volatile signed long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<volatile char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#ifndef BOOST_MSVC
|
||||
template <> struct is_integral<volatile wchar_t>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif
|
||||
template <> struct is_integral<volatile bool>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
|
||||
#ifdef ULLONG_MAX
|
||||
template <> struct is_integral<volatile unsigned long long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<volatile long long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif // ULLONG_MAX
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
|
||||
template <> struct is_integral<volatile unsigned __int64>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<volatile __int64>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif //__int64
|
||||
|
||||
template <> struct is_float<volatile float>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_float<volatile double>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_float<volatile long double>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
|
||||
// const-volatile-variations:
|
||||
template <> struct is_integral<const volatile unsigned char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const volatile unsigned short>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const volatile unsigned int>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const volatile unsigned long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const volatile signed char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const volatile signed short>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const volatile signed int>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const volatile signed long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const volatile char>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#ifndef BOOST_MSVC
|
||||
template <> struct is_integral<const volatile wchar_t>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif
|
||||
template <> struct is_integral<const volatile bool>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
|
||||
#ifdef ULLONG_MAX
|
||||
template <> struct is_integral<const volatile unsigned long long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const volatile long long>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif // ULLONG_MAX
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
|
||||
template <> struct is_integral<const volatile unsigned __int64>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_integral<const volatile __int64>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif //__int64
|
||||
|
||||
template <> struct is_float<const volatile float>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_float<const volatile double>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <> struct is_float<const volatile long double>
|
||||
{ BOOST_DECL_MC(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_DECL_MC(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_DECL_MC(bool, value,
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::is_arithmetic<T>::value,
|
||||
::boost::is_void<T>::value
|
||||
>::value));
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,357 +0,0 @@
|
||||
// (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 composite types:
|
||||
// is_array, is_pointer, is_reference, is_member_pointer, is_enum, is_union.
|
||||
//
|
||||
// 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).
|
||||
// Mat Marcus and Jesse Jones posted a version of is_pointer very similar to this one
|
||||
// on the boost list (Copyright 2000 Adobe Systems Incorporated and others.
|
||||
// All rights reserved.).
|
||||
// Fixes for is_array are based on a newgroup posting by Jonathan Lundquist.
|
||||
|
||||
#ifndef COMPOSITE_TYPE_TRAITS_HPP
|
||||
#define 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 CV_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits/cv_traits.hpp>
|
||||
#endif
|
||||
#ifndef ARITHMETIC_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits/arithmetic_traits.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_array
|
||||
*
|
||||
**********************************************/
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <typename T> struct is_array
|
||||
{ BOOST_DECL_MC(bool, value, false); };
|
||||
template <typename T, std::size_t N> struct is_array<T[N]>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T, std::size_t N> struct is_array<const T[N]>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T, std::size_t N> struct is_array<volatile T[N]>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T, std::size_t N> struct is_array<const volatile T[N]>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
namespace detail{
|
||||
struct pointer_helper
|
||||
{
|
||||
pointer_helper(const volatile void*);
|
||||
};
|
||||
yes_type is_pointer_helper(pointer_helper);
|
||||
no_type is_pointer_helper(...);
|
||||
template <class T>
|
||||
yes_type is_pointer_helper3(T (*)(void));
|
||||
template <class T, class A1>
|
||||
yes_type is_pointer_helper3(T (*)(A1));
|
||||
template <class T, class A1, class A2>
|
||||
yes_type is_pointer_helper3(T (*)(A1, A2));
|
||||
template <class T, class A1, class A2, class A3>
|
||||
yes_type is_pointer_helper3(T (*)(A1, A2, A3));
|
||||
no_type is_pointer_helper3(...);
|
||||
|
||||
yes_type is_array_helper(const volatile void*, const volatile void*);
|
||||
template <class T>
|
||||
no_type is_array_helper(T*const volatile*, const volatile void*);
|
||||
no_type is_array_helper(...);
|
||||
} // namespace detail
|
||||
template <typename T>
|
||||
struct is_array
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
BOOST_DECL_MC(bool, value, (1 == sizeof(detail::is_array_helper(&t, t)))
|
||||
& !is_reference<T>::value
|
||||
& !(1 == sizeof(detail::is_pointer_helper3(t))) );
|
||||
};
|
||||
template <>
|
||||
struct is_array<void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct is_array<const void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
template <>
|
||||
struct is_array<volatile void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
template <>
|
||||
struct is_array<const volatile void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_pointer
|
||||
*
|
||||
**********************************************/
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
namespace detail{
|
||||
template <typename T> struct is_pointer_helper
|
||||
{ BOOST_DECL_MC(bool, value, false); };
|
||||
template <typename T> struct is_pointer_helper<T*>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T> struct is_pointer_helper<T*const>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T> struct is_pointer_helper<T*volatile>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T> struct is_pointer_helper<T*const volatile>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
} // namespace detail
|
||||
template <typename T> struct is_pointer
|
||||
{ BOOST_DECL_MC(bool, value, (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<T>::value, !::boost::is_member_pointer<T>::value>::value)); };
|
||||
#else
|
||||
template <typename T>
|
||||
struct is_pointer
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
BOOST_DECL_MC(bool, value,
|
||||
(::boost::type_traits::ice_and<
|
||||
!::boost::is_reference<T>::value,
|
||||
!::boost::is_array<T>::value,
|
||||
(::boost::type_traits::ice_or<
|
||||
(1 == sizeof(detail::is_pointer_helper(t))),
|
||||
(1 == sizeof(detail::is_pointer_helper3(t)))
|
||||
>::value)
|
||||
>::value ) );
|
||||
};
|
||||
template <>
|
||||
struct is_pointer <void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct is_pointer <const void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
template <>
|
||||
struct is_pointer <volatile void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
template <>
|
||||
struct is_pointer <const volatile void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_reference
|
||||
*
|
||||
**********************************************/
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <typename T> struct is_reference
|
||||
{ BOOST_DECL_MC(bool, value, false); };
|
||||
template <typename T> struct is_reference<T&>
|
||||
{ BOOST_DECL_MC(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_DECL_MC(bool, value, true); };
|
||||
template <typename T> struct is_reference<T&volatile>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T> struct is_reference<T&const volatile>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif
|
||||
#else
|
||||
# ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 4181)
|
||||
# endif // BOOST_MSVC
|
||||
template <typename T> struct is_reference
|
||||
{
|
||||
private:
|
||||
typedef T const volatile cv_t;
|
||||
public:
|
||||
BOOST_DECL_MC(bool, value, (::boost::type_traits::ice_or<!::boost::is_const<cv_t>::value, !::boost::is_volatile<cv_t>::value>::value));
|
||||
};
|
||||
template <> struct is_reference<void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <> struct is_reference<const void>
|
||||
{ BOOST_DECL_MC(bool, value, false); };
|
||||
template <> struct is_reference<volatile void>
|
||||
{ BOOST_DECL_MC(bool, value, false); };
|
||||
template <> struct is_reference<const volatile void>
|
||||
{ BOOST_DECL_MC(bool, value, false); };
|
||||
#endif
|
||||
|
||||
# ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
# endif // BOOST_MSVC
|
||||
#endif
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_union
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T> struct is_union
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
BOOST_DECL_MC(bool, value, BOOST_IS_UNION(cvt));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_enum
|
||||
*
|
||||
**********************************************/
|
||||
namespace detail{
|
||||
struct int_convertible
|
||||
{
|
||||
int_convertible(int);
|
||||
};
|
||||
} // namespace detail
|
||||
#ifndef __BORLANDC__
|
||||
template <typename T> struct is_enum
|
||||
{
|
||||
BOOST_DECL_MC(bool, value,
|
||||
(::boost::type_traits::ice_and<
|
||||
!::boost::is_arithmetic<T>::value,
|
||||
!::boost::is_reference<T>::value,
|
||||
::boost::is_convertible<T, detail::int_convertible>::value
|
||||
>::value));
|
||||
};
|
||||
#else // __BORLANDC__
|
||||
//
|
||||
// buggy is_convertible prevents working
|
||||
// implementation of is_enum:
|
||||
template <typename T> struct is_enum
|
||||
{
|
||||
public:
|
||||
BOOST_DECL_MC(bool, value, BOOST_IS_ENUM(T));
|
||||
};
|
||||
#endif
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_member_pointer
|
||||
*
|
||||
**********************************************/
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <typename T> struct is_member_pointer
|
||||
{ BOOST_DECL_MC(bool, value, false); };
|
||||
template <typename T, typename U> struct is_member_pointer<U T::*>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#ifdef __GNUC__
|
||||
// gcc workaround (JM 02 Oct 2000)
|
||||
template <typename T, typename U> struct is_member_pointer<U (T::*)(void)>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T, typename U, typename A1> struct is_member_pointer<U (T::*)(A1)>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T, typename U, typename A1, typename A2> struct is_member_pointer<U (T::*)(A1, A2)>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T, typename U, typename A1, typename A2, typename A3> struct is_member_pointer<U (T::*)(A1, A2, A3)>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T, typename U, typename A1, typename A2, typename A3, typename A4> struct is_member_pointer<U (T::*)(A1, A2, A3, A4)>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <typename T, typename U, typename A1, typename A2, typename A3, typename A4, typename A5> struct is_member_pointer<U (T::*)(A1, A2, A3, A4, A5)>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
#endif
|
||||
#else
|
||||
namespace detail{
|
||||
template <class T, class U>
|
||||
yes_type is_member_pointer_helper(T (U::*));
|
||||
template <class T, class U>
|
||||
yes_type is_member_pointer_helper(T (U::*)(void));
|
||||
template <class T, class U, class A1>
|
||||
yes_type is_member_pointer_helper(T (U::*)(A1));
|
||||
template <class T, class U, class A1, class A2>
|
||||
yes_type is_member_pointer_helper(T (U::*)(A1, A2));
|
||||
template <class T, class U, class A1, class A2, class A3>
|
||||
yes_type is_member_pointer_helper(T (U::*)(A1, A2, A3));
|
||||
template <class T, class U, class A1, class A2, class A3, class A4>
|
||||
yes_type is_member_pointer_helper(T (U::*)(A1, A2, A3, A4));
|
||||
template <class T, class U, class A1, class A2, class A3, class A4, class A5>
|
||||
yes_type is_member_pointer_helper(T (U::*)(A1, A2, A3, A4, A5));
|
||||
no_type is_member_pointer_helper(...);
|
||||
}
|
||||
template <typename T>
|
||||
struct is_member_pointer
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
BOOST_DECL_MC(bool, value, (1 == sizeof(detail::is_member_pointer_helper(t))) );
|
||||
};
|
||||
template <>
|
||||
struct is_member_pointer<void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct is_member_pointer<const void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
template <>
|
||||
struct is_member_pointer<volatile void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
template <>
|
||||
struct is_member_pointer<const volatile void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // COMPOSITE_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,224 +0,0 @@
|
||||
|
||||
// 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 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 bind {
|
||||
static no_type check(...);
|
||||
static yes_type check(To);
|
||||
public:
|
||||
void foo(); // avoid warning about all members being private
|
||||
static From from;
|
||||
enum { exists = sizeof( check(from) ) == sizeof(yes_type) };
|
||||
};
|
||||
};
|
||||
struct from_is_void_conversion {
|
||||
template <class From, class To>
|
||||
struct 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 Selector::template 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_helper
|
||||
{
|
||||
private:
|
||||
// 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 check(...);
|
||||
static type_traits::yes_type check(T);
|
||||
};
|
||||
static From from;
|
||||
public:
|
||||
static const bool value = sizeof( checker<To>::check(from) ) == sizeof(type_traits::yes_type);
|
||||
|
||||
void foo(); // avoid warning about all members being private
|
||||
};
|
||||
|
||||
template <class From, class To>
|
||||
struct is_convertible
|
||||
{
|
||||
private:
|
||||
typedef is_convertible_helper<From, To> c_type;
|
||||
enum{ v = c_type::value };
|
||||
char force_it[v ? 1 : 2];
|
||||
public:
|
||||
static const bool value = is_convertible_helper<From, To>::value;
|
||||
};
|
||||
|
||||
template <class From>
|
||||
struct is_convertible<From, void>
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
template <class To>
|
||||
struct is_convertible<void, To>
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<void, void>
|
||||
{
|
||||
static const bool value = true;
|
||||
};
|
||||
|
||||
#elif defined(__GNUC__)
|
||||
//
|
||||
// special version for gcc compiler
|
||||
//
|
||||
namespace detail{
|
||||
struct any_conversion
|
||||
{
|
||||
template <class T>
|
||||
any_conversion(const T&);
|
||||
};
|
||||
template <class T>
|
||||
struct checker
|
||||
{
|
||||
static boost::type_traits::no_type check(any_conversion ...);
|
||||
static boost::type_traits::yes_type check(T, int);
|
||||
};
|
||||
} // namespace detail
|
||||
template <class From, class To>
|
||||
struct is_convertible
|
||||
{
|
||||
private:
|
||||
static From from;
|
||||
public:
|
||||
static const bool value = sizeof( detail::checker<To>::check(from, 0) ) == sizeof(type_traits::yes_type);
|
||||
|
||||
void foo(); // avoid warning about all members being private
|
||||
};
|
||||
|
||||
template <class From>
|
||||
struct is_convertible<From, void>
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
template <class To>
|
||||
struct is_convertible<void, To>
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<void, void>
|
||||
{
|
||||
static const bool value = true;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
template <class From, class To>
|
||||
struct is_convertible
|
||||
{
|
||||
private:
|
||||
static type_traits::no_type check(...);
|
||||
static type_traits::yes_type check(To);
|
||||
static From from;
|
||||
public:
|
||||
BOOST_DECL_MC(bool, value, sizeof( check(from) ) == sizeof(type_traits::yes_type));
|
||||
void foo(); // avoid warning about all members being private
|
||||
};
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <class From>
|
||||
struct is_convertible<From, void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
|
||||
template <class To>
|
||||
struct is_convertible<void, To>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
|
||||
template <>
|
||||
struct is_convertible<void, void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, true);
|
||||
};
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
#endif // is_convertible
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // include guard
|
||||
@ -1,214 +0,0 @@
|
||||
// (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 cv-qualified types:
|
||||
// is_const, is_volatile, remove_const, remove_volatile, remove_cv.
|
||||
//
|
||||
|
||||
#ifndef CV_TYPE_TRAITS_HPP
|
||||
#define 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
|
||||
|
||||
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_DECL_MC(bool, is_const, false);
|
||||
BOOST_DECL_MC(bool, is_volatile, false);
|
||||
typedef T unqualified_type;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct cv_traits_imp<const T*>
|
||||
{
|
||||
BOOST_DECL_MC(bool, is_const, true);
|
||||
BOOST_DECL_MC(bool, is_volatile, false);
|
||||
typedef T unqualified_type;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct cv_traits_imp<volatile T*>
|
||||
{
|
||||
BOOST_DECL_MC(bool, is_const, false);
|
||||
BOOST_DECL_MC(bool, is_volatile, true);
|
||||
typedef T unqualified_type;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct cv_traits_imp<const volatile T*>
|
||||
{
|
||||
BOOST_DECL_MC(bool, is_const, true);
|
||||
BOOST_DECL_MC(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; };
|
||||
|
||||
// * 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; };
|
||||
|
||||
// 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; };
|
||||
|
||||
//* is a type T declared const - is_const<T>
|
||||
template <typename T>
|
||||
struct is_const
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, detail::cv_traits_imp<T*>::is_const);
|
||||
};
|
||||
|
||||
//* is a type T declared volatile - is_volatile<T>
|
||||
template <typename T>
|
||||
struct is_volatile
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, detail::cv_traits_imp<T*>::is_volatile);
|
||||
};
|
||||
|
||||
#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 *);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct is_const
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
BOOST_DECL_MC(bool, value, (sizeof(detail::yes_type) == sizeof(detail::is_const_helper(&t))));
|
||||
};
|
||||
|
||||
template <>
|
||||
struct is_const<void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct is_const<const void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, true);
|
||||
};
|
||||
template <>
|
||||
struct is_const<volatile void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
template <>
|
||||
struct is_const<const volatile void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, true);
|
||||
};
|
||||
#endif
|
||||
|
||||
template <typename T>
|
||||
struct is_volatile
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
BOOST_DECL_MC(bool, value, (sizeof(detail::yes_type) == sizeof(detail::is_volatile_helper(&t))));
|
||||
};
|
||||
|
||||
template <>
|
||||
struct is_volatile<void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
|
||||
template <>
|
||||
struct is_volatile<const void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, false);
|
||||
};
|
||||
template <>
|
||||
struct is_volatile<volatile void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, true);
|
||||
};
|
||||
template <>
|
||||
struct is_volatile<const volatile void>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, true);
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
} // namespace boost
|
||||
|
||||
|
||||
#endif // CV_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
@ -1,140 +0,0 @@
|
||||
// (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>
|
||||
|
||||
#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
|
||||
|
||||
#define BOOST_IS_CLASS(T) false
|
||||
#define BOOST_IS_ENUM(T) false
|
||||
#define BOOST_IS_UNION(T) false
|
||||
#define BOOST_IS_POD(T) false
|
||||
#define BOOST_IS_EMPTY(T) false
|
||||
#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false
|
||||
#define BOOST_HAS_TRIVIAL_COPY(T) false
|
||||
#define BOOST_HAS_TRIVIAL_ASSIGN(T) false
|
||||
#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false
|
||||
|
||||
|
||||
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;
|
||||
|
||||
// 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_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 is_empty;
|
||||
|
||||
// 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
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,76 +0,0 @@
|
||||
|
||||
// (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
|
||||
|
||||
#ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||
#define BOOST_DECL_MC(type, name, value) enum{name = value }
|
||||
#define BOOST_DECL_MC2(type, name, v1, v2) enum{name = v1,v2 }
|
||||
#else
|
||||
#define BOOST_DECL_MC(type, name, value) static const type name = value
|
||||
#define BOOST_DECL_MC2(type, name, v1, v2) static const type name = v1,v2
|
||||
#endif
|
||||
|
||||
|
||||
namespace boost{
|
||||
namespace type_traits{
|
||||
|
||||
typedef char yes_type;
|
||||
typedef double no_type;
|
||||
|
||||
template <bool b>
|
||||
struct ice_not
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
template <>
|
||||
struct ice_not<true>
|
||||
{ BOOST_DECL_MC(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_DECL_MC(bool, value, true);
|
||||
};
|
||||
template <>
|
||||
struct ice_or<false, false, false, false, false, false, false>
|
||||
{
|
||||
BOOST_DECL_MC(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_DECL_MC(bool, value, false);
|
||||
};
|
||||
template <>
|
||||
struct ice_and<true, true, true, true, true, true, true>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, true);
|
||||
};
|
||||
|
||||
|
||||
} // namespace type_traits
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_ICE_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,318 +0,0 @@
|
||||
// (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 OBJECT_TYPE_TRAITS_HPP
|
||||
#define 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 COMPOSITE_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits/composite_traits.hpp>
|
||||
#endif
|
||||
#ifndef ARITHMETIC_TYPE_TRAITS_HPP
|
||||
#include <boost/type_traits/arithmetic_traits.hpp>
|
||||
#endif
|
||||
|
||||
namespace boost{
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_object
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct is_object
|
||||
{
|
||||
BOOST_DECL_MC(bool, value,
|
||||
(::boost::type_traits::ice_and<
|
||||
!::boost::is_reference<T>::value,
|
||||
!::boost::is_void<T>::value
|
||||
>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_scalar
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct is_scalar
|
||||
{
|
||||
BOOST_DECL_MC(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));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_class
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct is_class
|
||||
{
|
||||
BOOST_DECL_MC(bool, value,
|
||||
(::boost::type_traits::ice_and<
|
||||
!::boost::is_union<T>::value,
|
||||
!::boost::is_scalar<T>::value,
|
||||
!::boost::is_array<T>::value,
|
||||
!::boost::is_reference<T>::value,
|
||||
!::boost::is_void<T>::value
|
||||
>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* is_compound
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T> struct is_compound
|
||||
{
|
||||
BOOST_DECL_MC(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
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T> struct is_POD
|
||||
{
|
||||
BOOST_DECL_MC(bool, value,
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::is_scalar<T>::value,
|
||||
::boost::is_void<T>::value,
|
||||
BOOST_IS_POD(T)
|
||||
>::value));
|
||||
};
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <typename T, std::size_t sz>
|
||||
struct is_POD<T[sz]>
|
||||
{
|
||||
BOOST_DECL_MC(bool, value, ::boost::is_POD<T>::value);
|
||||
};
|
||||
#endif
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* has_trivial_constructor
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct has_trivial_constructor
|
||||
{
|
||||
BOOST_DECL_MC(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_DECL_MC(bool, value,
|
||||
(::boost::type_traits::ice_and<
|
||||
::boost::type_traits::ice_or<
|
||||
::boost::is_POD<T>::value,
|
||||
BOOST_HAS_TRIVIAL_COPY(T)
|
||||
>::value,
|
||||
!::boost::is_volatile<T>::value
|
||||
>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* has_trivial_assign
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct has_trivial_assign
|
||||
{
|
||||
BOOST_DECL_MC(bool, value,
|
||||
(::boost::type_traits::ice_and<
|
||||
::boost::type_traits::ice_or<
|
||||
::boost::is_POD<T>::value,
|
||||
BOOST_HAS_TRIVIAL_ASSIGN(T)
|
||||
>::value,
|
||||
!::boost::is_const<T>::value,
|
||||
!::boost::is_volatile<T>::value
|
||||
>::value));
|
||||
};
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* has_trivial_destructor
|
||||
*
|
||||
**********************************************/
|
||||
template <typename T>
|
||||
struct has_trivial_destructor
|
||||
{
|
||||
BOOST_DECL_MC(bool, value,
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::is_POD<T>::value,
|
||||
BOOST_HAS_TRIVIAL_DESTRUCTOR(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]; };
|
||||
|
||||
template <typename T, bool b, bool b2>
|
||||
struct empty_helper{ BOOST_DECL_MC(bool, value, false); };
|
||||
|
||||
template <typename T>
|
||||
struct empty_helper<T, true, false>
|
||||
{
|
||||
BOOST_DECL_MC(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_DECL_MC(bool, value,
|
||||
(::boost::type_traits::ice_or<
|
||||
::boost::detail::empty_helper<T,
|
||||
::boost::is_class<T>::value ,
|
||||
::boost::is_convertible<T,int>::value
|
||||
>::value,
|
||||
BOOST_IS_EMPTY(cvt)
|
||||
>::value));
|
||||
};
|
||||
|
||||
#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <typename T>
|
||||
struct empty_helper_t1 : public T
|
||||
{
|
||||
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::is_convertible<T,int>::value,
|
||||
!::boost::is_convertible<T,double>::value,
|
||||
!::boost::is_pointer<T>::value,
|
||||
!::boost::is_member_pointer<T>::value,
|
||||
!::boost::is_array<T>::value,
|
||||
!::boost::is_void<T>::value,
|
||||
!::boost::is_convertible<T, const volatile void*>::value
|
||||
>::value> chooser;
|
||||
typedef typename chooser::template rebind<T> bound_type;
|
||||
typedef typename bound_type::type eh_type;
|
||||
public:
|
||||
BOOST_DECL_MC(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 // defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
|
||||
|
||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // OBJECT_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,90 +0,0 @@
|
||||
// (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:
|
||||
|
||||
#ifndef SAME_TRAITS_HPP
|
||||
#define 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(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_DECL_MC(bool, value, false); };
|
||||
|
||||
template <typename T>
|
||||
struct is_same<T, T>
|
||||
{ BOOST_DECL_MC(bool, value, true); };
|
||||
|
||||
#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
|
||||
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 : detail::is_same_part_1<T1>::template part_2<T2> {};
|
||||
|
||||
#else // BOOST_MSVC
|
||||
|
||||
namespace detail{
|
||||
template <class T>
|
||||
::boost::type_traits::yes_type is_same_helper(T*, T*);
|
||||
::boost::type_traits::no_type is_same_helper(...);
|
||||
}
|
||||
|
||||
template <typename T, typename U>
|
||||
struct is_same
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
static U u;
|
||||
public:
|
||||
BOOST_DECL_MC(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 // SAME_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
@ -1,187 +0,0 @@
|
||||
// (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.
|
||||
//
|
||||
|
||||
#ifndef TRANSFORM_TRAITS_HPP
|
||||
#define 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(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) || !defined(BOOST_NO_MEMBER_TEMPLATES)
|
||||
namespace detail{
|
||||
|
||||
template <bool>
|
||||
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
|
||||
|
||||
/**********************************************
|
||||
*
|
||||
* 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;
|
||||
typedef typename remove_bounds<no_ref_type>::type no_b_type;
|
||||
public:
|
||||
typedef no_b_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 // TRANSFORM_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,74 +0,0 @@
|
||||
|
||||
// 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(char)
|
||||
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
|
||||
|
||||
@ -1,361 +0,0 @@
|
||||
// (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>
|
||||
//
|
||||
// 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;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// this one is to verify that a constant is indeed a
|
||||
// constant-integral-expression:
|
||||
//
|
||||
template <bool>
|
||||
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, class U>
|
||||
struct type_checker
|
||||
{
|
||||
static void check(const char* TT, const char* TU, const char* expression)
|
||||
{
|
||||
++test_count;
|
||||
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
if((typeid(T) != typeid(U))
|
||||
|| (::boost::is_reference<T>::value != ::boost::is_reference<U>::value)
|
||||
|| (::boost::is_const<T>::value != ::boost::is_const<U>::value)
|
||||
|| (::boost::is_volatile<T>::value != ::boost::is_volatile<U>::value))
|
||||
{
|
||||
#endif
|
||||
++failures;
|
||||
std::cout << "checking type of " << expression << "...failed" << std::endl;
|
||||
std::cout << " expected type was " << TT << std::endl;
|
||||
std::cout << " typeid(" << TT << ") was: " << typeid(T).name() << std::endl;
|
||||
std::cout << " typeid(" << TU << ") was: " << typeid(U).name() << std::endl;
|
||||
std::cout << " In template class " << typeid(type_checker<T,U>).name() << std::endl;
|
||||
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
}
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
#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; \
|
||||
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()
|
||||
|
||||
//
|
||||
// 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;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
#define NESTED_DECL(what)\
|
||||
template <class T> \
|
||||
struct BOOST_TT_JOIN(nested_tester_,what){\
|
||||
nested_test< (0 != ::boost::what<T>::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;}
|
||||
|
||||
#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);
|
||||
|
||||
// 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)
|
||||
# endif // BOOST_MSVC
|
||||
typedef int& r_type;
|
||||
typedef const r_type cr_type;
|
||||
# ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
# endif // BOOST_MSVC
|
||||
|
||||
struct POD_UDT { int x; };
|
||||
struct empty_UDT{ ~empty_UDT(){}; };
|
||||
struct empty_POD_UDT{};
|
||||
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 Deriverd : 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 : boost::noncopyable
|
||||
{
|
||||
int i;
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif // BOOST_TYPE_TRAITS_TEST_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,96 +0,0 @@
|
||||
// boost utility.hpp header file -------------------------------------------//
|
||||
|
||||
// (C) Copyright boost.org 1999. 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.
|
||||
|
||||
// Classes appear in alphabetical order
|
||||
|
||||
// Revision History
|
||||
// 26 Jan 00 protected noncopyable destructor added (Miki Jovanovic)
|
||||
// 10 Dec 99 next() and prior() templates added (Dave Abrahams)
|
||||
// 30 Aug 99 moved cast templates to cast.hpp (Beman Dawes)
|
||||
// 3 Aug 99 cast templates added
|
||||
// 20 Jul 99 name changed to utility.hpp
|
||||
// 9 Jun 99 protected noncopyable default ctor
|
||||
// 2 Jun 99 Initial Version. Class noncopyable only contents (Dave Abrahams)
|
||||
|
||||
#ifndef BOOST_UTILITY_HPP
|
||||
#define BOOST_UTILITY_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <cstddef> // for size_t
|
||||
#include <utility> // for std::pair
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
// next() and prior() template functions -----------------------------------//
|
||||
|
||||
// Helper functions for classes like bidirectional iterators not supporting
|
||||
// operator+ and operator-.
|
||||
//
|
||||
// Usage:
|
||||
// const std::list<T>::iterator p = get_some_iterator();
|
||||
// const std::list<T>::iterator prev = boost::prior(p);
|
||||
|
||||
// Contributed by Dave Abrahams
|
||||
|
||||
template <class T>
|
||||
T next(T x) { return ++x; }
|
||||
|
||||
template <class T>
|
||||
T prior(T x) { return --x; }
|
||||
|
||||
|
||||
// class noncopyable -------------------------------------------------------//
|
||||
|
||||
// Private copy constructor and copy assignment ensure classes derived from
|
||||
// class noncopyable cannot be copied.
|
||||
|
||||
// Contributed by Dave Abrahams
|
||||
|
||||
class noncopyable
|
||||
{
|
||||
protected:
|
||||
noncopyable(){}
|
||||
~noncopyable(){}
|
||||
private: // emphasize the following members are private
|
||||
noncopyable( const noncopyable& );
|
||||
const noncopyable& operator=( const noncopyable& );
|
||||
}; // noncopyable
|
||||
|
||||
// class tied -------------------------------------------------------//
|
||||
|
||||
// A helper for conveniently assigning the two values from a pair
|
||||
// into separate variables. The idea for this comes from Jaakko J<>rvi's
|
||||
// Binder/Lambda Library.
|
||||
|
||||
// Constributed by Jeremy Siek
|
||||
|
||||
template <class A, class B>
|
||||
class tied {
|
||||
public:
|
||||
inline tied(A& a, B& b) : _a(a), _b(b) { }
|
||||
template <class U, class V>
|
||||
inline tied& operator=(const std::pair<U,V>& p) {
|
||||
_a = p.first;
|
||||
_b = p.second;
|
||||
return *this;
|
||||
}
|
||||
protected:
|
||||
A& _a;
|
||||
B& _b;
|
||||
};
|
||||
|
||||
template <class A, class B>
|
||||
inline tied<A,B> tie(A& a, B& b) { return tied<A,B>(a, b); }
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_UTILITY_HPP
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,72 +0,0 @@
|
||||
|
||||
// (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.
|
||||
|
||||
#include <boost/type_traits/conversion_traits.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
#include "boost/type_traits/type_traits_test.hpp"
|
||||
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
value_test(true, (boost::is_convertible<Deriverd,Base>::value));
|
||||
value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
|
||||
value_test(true, (boost::is_convertible<Base,Base>::value));
|
||||
value_test(false, (boost::is_convertible<Base,Deriverd>::value));
|
||||
value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
|
||||
value_test(false, (boost::is_convertible<NonDerived,Base>::value));
|
||||
value_test(false, (boost::is_convertible<boost::noncopyable, int>::value));
|
||||
value_test(true, (boost::is_convertible<float,int>::value));
|
||||
#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
value_test(false, (boost::is_convertible<float,void>::value));
|
||||
value_test(false, (boost::is_convertible<void,float>::value));
|
||||
value_test(true, (boost::is_convertible<void,void>::value));
|
||||
#endif
|
||||
value_test(true, (boost::is_convertible<enum1, int>::value));
|
||||
value_test(true, (boost::is_convertible<Deriverd*, Base*>::value));
|
||||
value_test(false, (boost::is_convertible<Base*, Deriverd*>::value));
|
||||
value_test(true, (boost::is_convertible<Deriverd&, Base&>::value));
|
||||
value_test(false, (boost::is_convertible<Base&, Deriverd&>::value));
|
||||
value_test(true, (boost::is_convertible<const Deriverd*, const Base*>::value));
|
||||
value_test(false, (boost::is_convertible<const Base*, const Deriverd*>::value));
|
||||
value_test(true, (boost::is_convertible<const Deriverd&, const Base&>::value));
|
||||
value_test(false, (boost::is_convertible<const Base&, const Deriverd&>::value));
|
||||
|
||||
value_test(false, (boost::is_convertible<const int *, int*>::value));
|
||||
value_test(false, (boost::is_convertible<const int&, int&>::value));
|
||||
value_test(true, (boost::is_convertible<int*, int[2]>::value));
|
||||
value_test(false, (boost::is_convertible<const int*, int[3]>::value));
|
||||
value_test(true, (boost::is_convertible<const int&, int>::value));
|
||||
value_test(true, (boost::is_convertible<int(&)[4], const int*>::value));
|
||||
value_test(true, (boost::is_convertible<int(&)(int), int(*)(int)>::value));
|
||||
value_test(true, (boost::is_convertible<int *, const int*>::value));
|
||||
value_test(true, (boost::is_convertible<int&, const int&>::value));
|
||||
value_test(true, (boost::is_convertible<int[2], int*>::value));
|
||||
value_test(true, (boost::is_convertible<int[2], const int*>::value));
|
||||
value_test(false, (boost::is_convertible<const int[2], int*>::value));
|
||||
|
||||
value_test(true, (boost::is_convertible<non_pointer, void*>::value));
|
||||
value_test(false, (boost::is_convertible<non_pointer, int*>::value));
|
||||
value_test(true, (boost::is_convertible<non_int_pointer, int*>::value));
|
||||
value_test(true, (boost::is_convertible<non_int_pointer, void*>::value));
|
||||
value_test(true, (boost::is_convertible<int, int_constructible>::value));
|
||||
|
||||
return check_result(argc, argv);
|
||||
}
|
||||
|
||||
//
|
||||
// define the number of failures expected for given compilers:
|
||||
#ifdef __BORLANDC__
|
||||
unsigned int expected_failures = 1;
|
||||
#else
|
||||
unsigned int expected_failures = 0;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,42 +0,0 @@
|
||||
|
||||
// (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.
|
||||
|
||||
#include <boost/type_traits/same_traits.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hrdstop
|
||||
#endif
|
||||
#include "boost/type_traits/type_traits_test.hpp"
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
value_test(true, (::boost::is_same<int, int>::value))
|
||||
value_test(false, (::boost::is_same<int, const int>::value))
|
||||
value_test(false, (::boost::is_same<int, int&>::value))
|
||||
value_test(false, (::boost::is_same<const int, int&>::value))
|
||||
value_test(false, (::boost::is_same<int, const int&>::value))
|
||||
value_test(false, (::boost::is_same<int*, const int*>::value))
|
||||
value_test(false, (::boost::is_same<int*, int*const>::value))
|
||||
value_test(false, (::boost::is_same<int, int[2]>::value))
|
||||
value_test(false, (::boost::is_same<int*, int[2]>::value))
|
||||
value_test(false, (::boost::is_same<int[4], int[2]>::value))
|
||||
value_test(false, (::boost::is_same<void, int>::value))
|
||||
value_test(true, (::boost::is_same<void, void>::value))
|
||||
value_test(false, (::boost::is_same<void, const void>::value))
|
||||
|
||||
return check_result(argc, argv);
|
||||
}
|
||||
|
||||
//
|
||||
// define the number of failures expected for given compilers:
|
||||
#ifdef BOOST_MSVC
|
||||
// can't separate void and cv-void:
|
||||
unsigned int expected_failures = 1;
|
||||
#else
|
||||
unsigned int expected_failures = 0;
|
||||
#endif
|
||||
|
||||
@ -1,110 +0,0 @@
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1999
|
||||
* Dr John Maddock
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Dr John Maddock makes no representations
|
||||
* about the suitability of this software for any purpose.
|
||||
* It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* This file provides some example of type_traits usage -
|
||||
* by "optimising" various algorithms:
|
||||
*
|
||||
* opt::iter_swap - uses type_traits to determine whether the iterator is a proxy
|
||||
* in which case it uses a "safe" approach, otherwise calls swap
|
||||
* on the assumption that swap may be specialised for the pointed-to type.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <typeinfo>
|
||||
#include <algorithm>
|
||||
#include <iterator>
|
||||
#include <vector>
|
||||
#include <memory>
|
||||
|
||||
#include <boost/type_traits.hpp>
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::cin;
|
||||
|
||||
namespace opt{
|
||||
|
||||
//
|
||||
// iter_swap:
|
||||
// tests whether iterator is a proxying iterator or not, and
|
||||
// uses optimal form accordingly:
|
||||
//
|
||||
namespace detail{
|
||||
|
||||
template <bool b>
|
||||
struct swapper
|
||||
{
|
||||
template <typename I>
|
||||
static void do_swap(I one, I two)
|
||||
{
|
||||
typedef typename std::iterator_traits<I>::value_type v_t;
|
||||
v_t v = *one;
|
||||
*one = *two;
|
||||
*two = v;
|
||||
}
|
||||
};
|
||||
|
||||
#ifdef __GNUC__
|
||||
using std::swap;
|
||||
#endif
|
||||
|
||||
template <>
|
||||
struct swapper<true>
|
||||
{
|
||||
template <typename I>
|
||||
static void do_swap(I one, I two)
|
||||
{
|
||||
using std::swap;
|
||||
swap(*one, *two);
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template <typename I1, typename I2>
|
||||
inline void iter_swap(I1 one, I2 two)
|
||||
{
|
||||
typedef typename std::iterator_traits<I1>::reference r1_t;
|
||||
typedef typename std::iterator_traits<I2>::reference r2_t;
|
||||
detail::swapper<
|
||||
::boost::type_traits::ice_and<
|
||||
::boost::is_reference<r1_t>::value,
|
||||
::boost::is_reference<r2_t>::value,
|
||||
::boost::is_same<r1_t, r2_t>::value
|
||||
>::value>::do_swap(one, two);
|
||||
}
|
||||
|
||||
|
||||
}; // namespace opt
|
||||
|
||||
int main()
|
||||
{
|
||||
//
|
||||
// testing iter_swap
|
||||
// really just a check that it does in fact compile...
|
||||
std::vector<int> v1;
|
||||
v1.push_back(0);
|
||||
v1.push_back(1);
|
||||
std::vector<bool> v2;
|
||||
v2.push_back(0);
|
||||
v2.push_back(1);
|
||||
opt::iter_swap(v1.begin(), v1.begin()+1);
|
||||
opt::iter_swap(v2.begin(), v2.begin()+1);
|
||||
|
||||
cout << "Press any key to exit...";
|
||||
cin.get();
|
||||
}
|
||||
|
||||
|
||||
@ -1,580 +0,0 @@
|
||||
*** libs/type_traits/alignment_test.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/alignment_test.cpp
|
||||
./boosttmp.exe
|
||||
13 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/alignment_test.cpp
|
||||
./boosttmp.exe
|
||||
13 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -o boosttmp.exe -I../.. ../../libs/type_traits/alignment_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
./boosttmp.exe
|
||||
checking value of boost::alignment_of<double>...failed
|
||||
found: 4 expected 8
|
||||
13 tests completed, 1 failures found, 0 failures expected from this compiler.
|
||||
Fail
|
||||
|
||||
*** libs/type_traits/arithmetic_traits_test.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/arithmetic_traits_test.cpp
|
||||
./boosttmp.exe
|
||||
111 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/arithmetic_traits_test.cpp
|
||||
./boosttmp.exe
|
||||
111 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -o boosttmp.exe -I../.. ../../libs/type_traits/arithmetic_traits_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
./boosttmp.exe
|
||||
111 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
*** libs/type_traits/composite_traits_test.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/composite_traits_test.cpp
|
||||
./boosttmp.exe
|
||||
checking value of boost::is_reference<cr_type>::value...failed
|
||||
found: 0 expected 1
|
||||
65 tests completed, 1 failures found, 1 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/composite_traits_test.cpp
|
||||
./boosttmp.exe
|
||||
checking value of boost::is_reference<cr_type>::value...failed
|
||||
found: 0 expected 1
|
||||
65 tests completed, 1 failures found, 1 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -o boosttmp.exe -I../.. ../../libs/type_traits/composite_traits_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=bool] assigned to file composite_traits_test.o
|
||||
C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/composite_traits_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=unsigned long] assigned to file composite_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_inf [with T1=bool] assigned to file composite_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_inf [with T1=bool] assigned to file composite_traits_test.o
|
||||
C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/composite_traits_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=bool, N2=false, N3=true, N4=(int)0, N5=false] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=char, N2=(char)-128, N3=(char)127, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=signed char, N2=(signed char)-128, N3=(signed char)127, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned char, N2=(unsigned char)0, N3=(unsigned char)255, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=wchar_t, N2=(wchar_t)-2147483648, N3=(wchar_t)2147483647, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=short, N2=(short)-32768, N3=(short)32767, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned short, N2=(unsigned short)0, N3=(unsigned short)65535, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=int, N2=(int)-2147483648, N3=(int)2147483647, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned int, N2=(unsigned int)0, N3=(unsigned int)4294967295, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long, N2=(long)-2147483648, N3=(long)2147483647, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long, N2=(unsigned long)0, N3=(unsigned long)4294967295, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long long, N2=(long long)-9223372036854775808, N3=(long long)9223372036854775807, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long long, N2=(unsigned long long)0, N3=(unsigned long long)18446744073709551615, N4=(int)-1, N5=true] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_inf [with T1=bool] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_qNaN [with T1=bool] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_sNaN [with T1=bool] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_qNaN [with T1=bool] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_sNaN [with T1=bool] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_qNaN [with T1=bool] adopted by file composite_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_sNaN [with T1=bool] adopted by file composite_traits_test.o
|
||||
./boosttmp.exe
|
||||
65 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
*** libs/type_traits/cv_traits_test.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/cv_traits_test.cpp
|
||||
./boosttmp.exe
|
||||
18 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/cv_traits_test.cpp
|
||||
./boosttmp.exe
|
||||
18 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -o boosttmp.exe -I../.. ../../libs/type_traits/cv_traits_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=bool] assigned to file cv_traits_test.o
|
||||
C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/cv_traits_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=unsigned long] assigned to file cv_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_inf [with T1=bool] assigned to file cv_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_inf [with T1=bool] assigned to file cv_traits_test.o
|
||||
C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/cv_traits_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=bool, N2=false, N3=true, N4=(int)0, N5=false] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=char, N2=(char)-128, N3=(char)127, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=signed char, N2=(signed char)-128, N3=(signed char)127, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned char, N2=(unsigned char)0, N3=(unsigned char)255, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=wchar_t, N2=(wchar_t)-2147483648, N3=(wchar_t)2147483647, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=short, N2=(short)-32768, N3=(short)32767, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned short, N2=(unsigned short)0, N3=(unsigned short)65535, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=int, N2=(int)-2147483648, N3=(int)2147483647, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned int, N2=(unsigned int)0, N3=(unsigned int)4294967295, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long, N2=(long)-2147483648, N3=(long)2147483647, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long, N2=(unsigned long)0, N3=(unsigned long)4294967295, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long long, N2=(long long)-9223372036854775808, N3=(long long)9223372036854775807, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long long, N2=(unsigned long long)0, N3=(unsigned long long)18446744073709551615, N4=(int)-1, N5=true] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_inf [with T1=bool] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_qNaN [with T1=bool] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_sNaN [with T1=bool] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_qNaN [with T1=bool] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_sNaN [with T1=bool] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_qNaN [with T1=bool] adopted by file cv_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_sNaN [with T1=bool] adopted by file cv_traits_test.o
|
||||
./boosttmp.exe
|
||||
18 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
*** libs/type_traits/is_convertible_test.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/is_convertible_test.cpp
|
||||
./boosttmp.exe
|
||||
37 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/is_convertible_test.cpp
|
||||
./boosttmp.exe
|
||||
37 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -o boosttmp.exe -I../.. ../../libs/type_traits/is_convertible_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=bool] assigned to file is_convertible_test.o
|
||||
C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/is_convertible_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=unsigned long] assigned to file is_convertible_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_inf [with T1=bool] assigned to file is_convertible_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_inf [with T1=bool] assigned to file is_convertible_test.o
|
||||
C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/is_convertible_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=bool, N2=false, N3=true, N4=(int)0, N5=false] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=char, N2=(char)-128, N3=(char)127, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=signed char, N2=(signed char)-128, N3=(signed char)127, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned char, N2=(unsigned char)0, N3=(unsigned char)255, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=wchar_t, N2=(wchar_t)-2147483648, N3=(wchar_t)2147483647, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=short, N2=(short)-32768, N3=(short)32767, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned short, N2=(unsigned short)0, N3=(unsigned short)65535, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=int, N2=(int)-2147483648, N3=(int)2147483647, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned int, N2=(unsigned int)0, N3=(unsigned int)4294967295, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long, N2=(long)-2147483648, N3=(long)2147483647, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long, N2=(unsigned long)0, N3=(unsigned long)4294967295, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long long, N2=(long long)-9223372036854775808, N3=(long long)9223372036854775807, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long long, N2=(unsigned long long)0, N3=(unsigned long long)18446744073709551615, N4=(int)-1, N5=true] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_inf [with T1=bool] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_qNaN [with T1=bool] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_sNaN [with T1=bool] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_qNaN [with T1=bool] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_sNaN [with T1=bool] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_qNaN [with T1=bool] adopted by file is_convertible_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_sNaN [with T1=bool] adopted by file is_convertible_test.o
|
||||
./boosttmp.exe
|
||||
37 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
*** libs/type_traits/is_same_test.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/is_same_test.cpp
|
||||
./boosttmp.exe
|
||||
10 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/is_same_test.cpp
|
||||
./boosttmp.exe
|
||||
10 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -o boosttmp.exe -I../.. ../../libs/type_traits/is_same_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=bool] assigned to file is_same_test.o
|
||||
C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/is_same_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=unsigned long] assigned to file is_same_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_inf [with T1=bool] assigned to file is_same_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_inf [with T1=bool] assigned to file is_same_test.o
|
||||
C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/is_same_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=bool, N2=false, N3=true, N4=(int)0, N5=false] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=char, N2=(char)-128, N3=(char)127, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=signed char, N2=(signed char)-128, N3=(signed char)127, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned char, N2=(unsigned char)0, N3=(unsigned char)255, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=wchar_t, N2=(wchar_t)-2147483648, N3=(wchar_t)2147483647, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=short, N2=(short)-32768, N3=(short)32767, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned short, N2=(unsigned short)0, N3=(unsigned short)65535, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=int, N2=(int)-2147483648, N3=(int)2147483647, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned int, N2=(unsigned int)0, N3=(unsigned int)4294967295, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long, N2=(long)-2147483648, N3=(long)2147483647, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long, N2=(unsigned long)0, N3=(unsigned long)4294967295, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long long, N2=(long long)-9223372036854775808, N3=(long long)9223372036854775807, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long long, N2=(unsigned long long)0, N3=(unsigned long long)18446744073709551615, N4=(int)-1, N5=true] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_inf [with T1=bool] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_qNaN [with T1=bool] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_sNaN [with T1=bool] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_qNaN [with T1=bool] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_sNaN [with T1=bool] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_qNaN [with T1=bool] adopted by file is_same_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_sNaN [with T1=bool] adopted by file is_same_test.o
|
||||
./boosttmp.exe
|
||||
10 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
*** libs/type_traits/object_type_traits_test.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/object_type_traits_test.cpp
|
||||
./boosttmp.exe
|
||||
checking value of boost::has_trivial_constructor<empty_UDT>::value...failed
|
||||
found: 0 expected 1
|
||||
checking value of boost::has_trivial_copy<empty_UDT>::value...failed
|
||||
found: 0 expected 1
|
||||
checking value of boost::has_trivial_assign<empty_UDT>::value...failed
|
||||
found: 0 expected 1
|
||||
checking value of boost::is_empty<empty_UDT>::value...failed
|
||||
found: 0 expected 1
|
||||
checking value of boost::is_empty<empty_POD_UDT>::value...failed
|
||||
found: 0 expected 1
|
||||
checking value of boost::is_empty<empty_union_UDT>::value...failed
|
||||
boost::is_empty<empty_union_UDT>::value does not compile on this compiler
|
||||
checking value of boost::is_empty<boost::noncopyable>::value...failed
|
||||
found: 0 expected 1
|
||||
122 tests completed, 7 failures found, 7 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/object_type_traits_test.cpp
|
||||
./boosttmp.exe
|
||||
checking value of boost::has_trivial_constructor<empty_UDT>::value...failed
|
||||
found: 0 expected 1
|
||||
checking value of boost::has_trivial_copy<empty_UDT>::value...failed
|
||||
found: 0 expected 1
|
||||
checking value of boost::has_trivial_assign<empty_UDT>::value...failed
|
||||
found: 0 expected 1
|
||||
checking value of boost::is_empty<empty_union_UDT>::value...failed
|
||||
boost::is_empty<empty_union_UDT>::value does not compile on this compiler
|
||||
122 tests completed, 4 failures found, 7 failures expected from this compiler.
|
||||
Fail
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -o boosttmp.exe -I../.. ../../libs/type_traits/object_type_traits_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
./boosttmp.exe
|
||||
checking value of boost::has_trivial_constructor<empty_UDT>::value...failed
|
||||
found: 0 expected 1
|
||||
checking value of boost::has_trivial_copy<empty_UDT>::value...failed
|
||||
found: 0 expected 1
|
||||
checking value of boost::has_trivial_assign<empty_UDT>::value...failed
|
||||
found: 0 expected 1
|
||||
checking value of boost::is_empty<empty_union_UDT>::value...failed
|
||||
boost::is_empty<empty_union_UDT>::value does not compile on this compiler
|
||||
122 tests completed, 4 failures found, 0 failures expected from this compiler.
|
||||
Fail
|
||||
|
||||
*** libs/type_traits/transform_traits_test.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -o boosttmp.exe -ftemplate-depth-30 -I../.. ../../libs/type_traits/transform_traits_test.cpp
|
||||
./boosttmp.exe
|
||||
checking type of boost::remove_reference<cr_type>::type...failed
|
||||
expected type was int
|
||||
typeid(int) was: i
|
||||
typeid(boost::remove_reference<cr_type>::type) was: i
|
||||
In template class t12type_checker2ZiZCRi
|
||||
39 tests completed, 1 failures found, 1 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -o boosttmp.exe -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/transform_traits_test.cpp
|
||||
./boosttmp.exe
|
||||
checking type of boost::remove_reference<cr_type>::type...failed
|
||||
expected type was int
|
||||
typeid(int) was: i
|
||||
typeid(boost::remove_reference<cr_type>::type) was: i
|
||||
In template class t12type_checker2ZiZCRi
|
||||
39 tests completed, 1 failures found, 1 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -o boosttmp.exe -I../.. ../../libs/type_traits/transform_traits_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=bool] assigned to file transform_traits_test.o
|
||||
C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/transform_traits_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::basic_ostream<T1, T2> &_STL::_M_put_num<T1, T2, T3>(_STL::basic_ostream<T1, T2> &, T3) [with T1=char, T2=_STL::char_traits<char>, T3=unsigned long] assigned to file transform_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_inf [with T1=bool] assigned to file transform_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_inf [with T1=bool] assigned to file transform_traits_test.o
|
||||
C++ prelinker: executing: /usr/local/bin/realcomo -c --version --display_mode --wchar_t_keyword --bool --enum_overloading --explicit --typename --extern_inline --new_for_init --exceptions --alternative_tokens --diag_suppress=161 -I../.. ../../libs/type_traits/transform_traits_test.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../boost/type_traits/type_traits_test.hpp", line 236: warning: type
|
||||
qualifiers are meaningless in this declaration
|
||||
typedef const r_type cr_type;
|
||||
^
|
||||
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=bool, N2=false, N3=true, N4=(int)0, N5=false] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=char, N2=(char)-128, N3=(char)127, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=signed char, N2=(signed char)-128, N3=(signed char)127, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned char, N2=(unsigned char)0, N3=(unsigned char)255, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=wchar_t, N2=(wchar_t)-2147483648, N3=(wchar_t)2147483647, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=short, N2=(short)-32768, N3=(short)32767, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned short, N2=(unsigned short)0, N3=(unsigned short)65535, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=int, N2=(int)-2147483648, N3=(int)2147483647, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned int, N2=(unsigned int)0, N3=(unsigned int)4294967295, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long, N2=(long)-2147483648, N3=(long)2147483647, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long, N2=(unsigned long)0, N3=(unsigned long)4294967295, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=long long, N2=(long long)-9223372036854775808, N3=(long long)9223372036854775807, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_Integer_limits<T1, N2, N3, N4, N5>::digits [with T1=unsigned long long, N2=(unsigned long long)0, N3=(unsigned long long)18446744073709551615, N4=(int)-1, N5=true] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_inf [with T1=bool] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_qNaN [with T1=bool] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_F_sNaN [with T1=bool] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_qNaN [with T1=bool] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_D_sNaN [with T1=bool] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_qNaN [with T1=bool] adopted by file transform_traits_test.o
|
||||
C++ prelinker: _STL::_LimG<T1>::_L_sNaN [with T1=bool] adopted by file transform_traits_test.o
|
||||
./boosttmp.exe
|
||||
39 tests completed, 0 failures found, 0 failures expected from this compiler.
|
||||
Pass
|
||||
|
||||
*** libs/type_traits/trivial_destructor_example.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -c -ftemplate-depth-30 -I../.. ../../libs/type_traits/trivial_destructor_example.cpp
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -c -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/trivial_destructor_example.cpp
|
||||
Pass
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -c -I../.. ../../libs/type_traits/trivial_destructor_example.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
"../../libs/type_traits/trivial_destructor_example.cpp", line 99: warning:
|
||||
variable "ci_array" was declared but never referenced
|
||||
const int ci_array[array_size] = {0,};
|
||||
^
|
||||
|
||||
"../../libs/type_traits/trivial_destructor_example.cpp", line 101: warning:
|
||||
variable "cc_array" was declared but never referenced
|
||||
const char cc_array[array_size] = { 0,};
|
||||
^
|
||||
|
||||
Pass
|
||||
|
||||
*** libs/type_traits/copy_example.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -c -ftemplate-depth-30 -I../.. ../../libs/type_traits/copy_example.cpp
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -c -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/copy_example.cpp
|
||||
Pass
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -c -I../.. ../../libs/type_traits/copy_example.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
Pass
|
||||
|
||||
*** libs/type_traits/fill_example.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -c -ftemplate-depth-30 -I../.. ../../libs/type_traits/fill_example.cpp
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -c -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/fill_example.cpp
|
||||
Pass
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -c -I../.. ../../libs/type_traits/fill_example.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
Pass
|
||||
|
||||
*** libs/type_traits/iter_swap_example.cpp ***
|
||||
|
||||
** GCC 2.95.2
|
||||
g++ -c -ftemplate-depth-30 -I../.. ../../libs/type_traits/iter_swap_example.cpp
|
||||
Pass
|
||||
|
||||
** GCC 2.95.2 STLport 4.0
|
||||
g++ -c -V 2.95.2-stlport -ftemplate-depth-30 -I../.. ../../libs/type_traits/iter_swap_example.cpp
|
||||
Pass
|
||||
|
||||
** Comeau C++ 4.2.44 beta3
|
||||
como -c -I../.. ../../libs/type_traits/iter_swap_example.cpp
|
||||
Comeau C/C++ 4.2.44 (Aug 2 2000 16:10:16) for RedHat_LINUX_INTEL_ELF_BETA3
|
||||
Copyright 1988-2000 Comeau Computing. All rights reserved.
|
||||
MODE:non-strict C++
|
||||
|
||||
Pass
|
||||
|
||||
@ -1,191 +0,0 @@
|
||||
|
||||
// (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.
|
||||
|
||||
#include <boost/type_traits/object_traits.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hrdstop
|
||||
#endif
|
||||
#include "boost/type_traits/type_traits_test.hpp"
|
||||
|
||||
NESTED_DECL(is_class)
|
||||
NESTED_DECL(is_object)
|
||||
NESTED_DECL(is_scalar)
|
||||
NESTED_DECL(is_compound)
|
||||
NESTED_DECL(is_POD)
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
NESTED_TEST(is_class, int)
|
||||
NESTED_TEST(is_class, UDT)
|
||||
NESTED_TEST(is_object, int)
|
||||
NESTED_TEST(is_object, void)
|
||||
NESTED_TEST(is_object, UDT)
|
||||
NESTED_TEST(is_scalar, void)
|
||||
NESTED_TEST(is_scalar, int)
|
||||
NESTED_TEST(is_compound, int)
|
||||
NESTED_TEST(is_compound, UDT)
|
||||
NESTED_TEST(is_POD, int)
|
||||
NESTED_TEST(is_POD, UDT)
|
||||
|
||||
value_test(false, boost::is_class<int>::value)
|
||||
value_test(false, boost::is_class<const int>::value)
|
||||
value_test(false, boost::is_class<volatile int>::value)
|
||||
value_test(false, boost::is_class<int*>::value)
|
||||
value_test(false, boost::is_class<int* const>::value)
|
||||
value_test(false, boost::is_class<int[2]>::value)
|
||||
value_test(false, boost::is_class<int&>::value)
|
||||
value_test(false, boost::is_class<mf4>::value)
|
||||
value_test(false, boost::is_class<f1>::value)
|
||||
value_test(false, boost::is_class<enum_UDT>::value)
|
||||
value_test(true, boost::is_class<UDT>::value)
|
||||
value_test(true, boost::is_class<UDT const>::value)
|
||||
value_test(true, boost::is_class<UDT volatile>::value)
|
||||
value_test(true, boost::is_class<empty_UDT>::value)
|
||||
value_test(true, boost::is_class<std::iostream>::value)
|
||||
value_test(false, boost::is_class<UDT*>::value)
|
||||
value_test(false, boost::is_class<UDT[2]>::value)
|
||||
value_test(false, boost::is_class<UDT&>::value)
|
||||
value_test(false, boost::is_class<void>::value)
|
||||
|
||||
value_test(true, boost::is_object<int>::value)
|
||||
value_test(true, boost::is_object<UDT>::value)
|
||||
value_test(false, boost::is_object<int&>::value)
|
||||
value_test(false, boost::is_object<void>::value)
|
||||
|
||||
value_test(true, boost::is_scalar<int>::value)
|
||||
value_test(true, boost::is_scalar<void*>::value)
|
||||
value_test(false, boost::is_scalar<void>::value)
|
||||
value_test(false, boost::is_scalar<UDT>::value)
|
||||
value_test(false, boost::is_scalar<int&>::value)
|
||||
|
||||
value_test(true, boost::is_compound<UDT>::value)
|
||||
value_test(true, boost::is_compound<void*>::value)
|
||||
value_test(false, boost::is_compound<void>::value)
|
||||
value_test(false, boost::is_compound<int>::value)
|
||||
|
||||
value_test(true, boost::is_POD<int>::value)
|
||||
value_test(true, boost::is_POD<int*>::value)
|
||||
value_test(false, boost::is_POD<int&>::value)
|
||||
value_test(true, boost::is_POD<int*const>::value)
|
||||
value_test(true, boost::is_POD<const int>::value)
|
||||
value_test(true, boost::is_POD<volatile int>::value)
|
||||
value_test(false, boost::is_POD<const int&>::value)
|
||||
value_test(true, boost::is_POD<int[2]>::value)
|
||||
value_test(true, boost::is_POD<int[3][2]>::value)
|
||||
value_test(true, boost::is_POD<int[2][4][5][6][3]>::value)
|
||||
value_test(true, boost::is_POD<f1>::value)
|
||||
value_test(true, boost::is_POD<mf2>::value)
|
||||
value_test(false, boost::is_POD<UDT>::value)
|
||||
value_test(false, boost::is_POD<empty_UDT>::value)
|
||||
value_test(true, boost::is_POD<enum_UDT>::value)
|
||||
value_test(true, boost::is_POD<void>::value)
|
||||
|
||||
value_test(true, boost::has_trivial_constructor<int>::value)
|
||||
value_test(true, boost::has_trivial_constructor<int*>::value)
|
||||
value_test(true, boost::has_trivial_constructor<int*const>::value)
|
||||
value_test(true, boost::has_trivial_constructor<const int>::value)
|
||||
value_test(true, boost::has_trivial_constructor<volatile int>::value)
|
||||
value_test(true, boost::has_trivial_constructor<int[2]>::value)
|
||||
value_test(true, boost::has_trivial_constructor<int[3][2]>::value)
|
||||
value_test(true, boost::has_trivial_constructor<int[2][4][5][6][3]>::value)
|
||||
value_test(true, boost::has_trivial_constructor<f1>::value)
|
||||
value_test(true, boost::has_trivial_constructor<mf2>::value)
|
||||
value_test(false, boost::has_trivial_constructor<UDT>::value)
|
||||
value_test(true, boost::has_trivial_constructor<empty_UDT>::value)
|
||||
value_test(true, boost::has_trivial_constructor<enum_UDT>::value)
|
||||
value_test(true, boost::has_trivial_constructor<void>::value)
|
||||
|
||||
value_test(true, boost::has_trivial_copy<int>::value)
|
||||
value_test(true, boost::has_trivial_copy<int*>::value)
|
||||
value_test(true, boost::has_trivial_copy<int*const>::value)
|
||||
value_test(true, boost::has_trivial_copy<const int>::value)
|
||||
// Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
|
||||
value_test(false, boost::has_trivial_copy<volatile int>::value)
|
||||
value_test(true, boost::has_trivial_copy<int[2]>::value)
|
||||
value_test(true, boost::has_trivial_copy<int[3][2]>::value)
|
||||
value_test(true, boost::has_trivial_copy<int[2][4][5][6][3]>::value)
|
||||
value_test(true, boost::has_trivial_copy<f1>::value)
|
||||
value_test(true, boost::has_trivial_copy<mf2>::value)
|
||||
value_test(false, boost::has_trivial_copy<UDT>::value)
|
||||
value_test(true, boost::has_trivial_copy<empty_UDT>::value)
|
||||
value_test(true, boost::has_trivial_copy<enum_UDT>::value)
|
||||
value_test(true, boost::has_trivial_copy<void>::value)
|
||||
|
||||
value_test(true, boost::has_trivial_assign<int>::value)
|
||||
value_test(true, boost::has_trivial_assign<int*>::value)
|
||||
value_test(false, boost::has_trivial_assign<int*const>::value)
|
||||
value_test(false, boost::has_trivial_assign<const int>::value)
|
||||
// Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
|
||||
value_test(false, boost::has_trivial_assign<volatile int>::value)
|
||||
value_test(true, boost::has_trivial_assign<int[2]>::value)
|
||||
value_test(true, boost::has_trivial_assign<int[3][2]>::value)
|
||||
value_test(true, boost::has_trivial_assign<int[2][4][5][6][3]>::value)
|
||||
value_test(true, boost::has_trivial_assign<f1>::value)
|
||||
value_test(true, boost::has_trivial_assign<mf2>::value)
|
||||
value_test(false, boost::has_trivial_assign<UDT>::value)
|
||||
value_test(true, boost::has_trivial_assign<empty_UDT>::value)
|
||||
value_test(true, boost::has_trivial_assign<enum_UDT>::value)
|
||||
value_test(true, boost::has_trivial_assign<void>::value)
|
||||
|
||||
value_test(true, boost::has_trivial_destructor<int>::value)
|
||||
value_test(true, boost::has_trivial_destructor<int*>::value)
|
||||
value_test(true, boost::has_trivial_destructor<int*const>::value)
|
||||
value_test(true, boost::has_trivial_destructor<const int>::value)
|
||||
value_test(true, boost::has_trivial_destructor<volatile int>::value)
|
||||
value_test(true, boost::has_trivial_destructor<int[2]>::value)
|
||||
value_test(true, boost::has_trivial_destructor<int[3][2]>::value)
|
||||
value_test(true, boost::has_trivial_destructor<int[2][4][5][6][3]>::value)
|
||||
value_test(true, boost::has_trivial_destructor<f1>::value)
|
||||
value_test(true, boost::has_trivial_destructor<mf2>::value)
|
||||
value_test(false, boost::has_trivial_destructor<UDT>::value)
|
||||
value_test(false, boost::has_trivial_destructor<empty_UDT>::value)
|
||||
value_test(true, boost::has_trivial_destructor<enum_UDT>::value)
|
||||
value_test(true, boost::has_trivial_destructor<void>::value)
|
||||
|
||||
soft_value_test(false, boost::is_empty<int>::value)
|
||||
soft_value_test(false, boost::is_empty<int*>::value)
|
||||
soft_value_test(false, boost::is_empty<int&>::value)
|
||||
soft_value_test(false, boost::is_empty<void>::value)
|
||||
#if defined(__MWERKS__)
|
||||
// apparent compiler bug causes this to fail to compile:
|
||||
value_fail(false, boost::is_empty<int[2]>::value)
|
||||
#else
|
||||
soft_value_test(false, boost::is_empty<int[2]>::value)
|
||||
#endif
|
||||
soft_value_test(false, boost::is_empty<f1>::value)
|
||||
soft_value_test(false, boost::is_empty<mf1>::value)
|
||||
soft_value_test(false, boost::is_empty<UDT>::value)
|
||||
soft_value_test(true, boost::is_empty<empty_UDT>::value)
|
||||
soft_value_test(true, boost::is_empty<empty_POD_UDT>::value)
|
||||
// this one will not compile on most compilers,
|
||||
// because we can't tell the difference between
|
||||
// unions and classes:
|
||||
value_fail(true, boost::is_empty<empty_union_UDT>::value)
|
||||
soft_value_test(false, boost::is_empty<enum_UDT>::value)
|
||||
soft_value_test(true, boost::is_empty<boost::noncopyable>::value)
|
||||
soft_value_test(false, boost::is_empty<non_empty>::value)
|
||||
|
||||
return check_result(argc, argv);
|
||||
}
|
||||
|
||||
//
|
||||
// define the number of failures expected for given compilers:
|
||||
#ifdef __BORLANDC__
|
||||
// can't handle enum's or classes that are POD's
|
||||
unsigned int expected_failures = 10;
|
||||
#elif defined(__GNUC__)
|
||||
// classes that are POD's, or empty:
|
||||
unsigned int expected_failures = 4;
|
||||
#elif defined(BOOST_MSVC)
|
||||
// can't handle classes that are POD's or arrays that are POD's
|
||||
unsigned int expected_failures = 19;
|
||||
#else
|
||||
unsigned int expected_failures = 4;
|
||||
#endif
|
||||
|
||||
|
||||
@ -1,14 +0,0 @@
|
||||
run libs/type_traits/alignment_test.cpp
|
||||
run libs/type_traits/arithmetic_traits_test.cpp
|
||||
run libs/type_traits/composite_traits_test.cpp
|
||||
run libs/type_traits/cv_traits_test.cpp
|
||||
run libs/type_traits/is_convertible_test.cpp
|
||||
run libs/type_traits/is_same_test.cpp
|
||||
run libs/type_traits/object_type_traits_test.cpp
|
||||
run libs/type_traits/transform_traits_test.cpp
|
||||
compile libs/type_traits/trivial_destructor_example.cpp
|
||||
compile libs/type_traits/copy_example.cpp
|
||||
compile libs/type_traits/fill_example.cpp
|
||||
compile libs/type_traits/iter_swap_example.cpp
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,395 +0,0 @@
|
||||
|
||||
// (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.
|
||||
|
||||
#include <boost/type_traits/transform_traits.hpp>
|
||||
#include <boost/type_traits/cv_traits.hpp>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hrdstop
|
||||
#endif
|
||||
|
||||
//
|
||||
// some of these tests, particularly those involving
|
||||
// the use of the transform_check macro are tantamount
|
||||
// to "compiler-abuse", and actually hide a *lot* of
|
||||
// template test code. To prevent "Internal Compiler Error"
|
||||
// type messages, we have to split these up into lots of
|
||||
// separate functions:
|
||||
#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && (__BORLANDC__ < 0x550))
|
||||
#define SHORT_TRANSFORM_TEST
|
||||
#endif
|
||||
#include "boost/type_traits/type_traits_test.hpp"
|
||||
|
||||
#define BOOST_DECL_TRANSFORM_TEST(name, type, from, to)\
|
||||
void name(){ transform_check(type, from, to) }
|
||||
#define BOOST_DECL_TRANSFORM_TEST3(name, type, from)\
|
||||
void name(){ transform_check(type, from, boost_dummy_macro_param) }
|
||||
#define BOOST_DECL_TRANSFORM_TEST2(name, type)\
|
||||
void name(){ transform_check(type, boost_dummy_macro_param, boost_dummy_macro_param) }
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* tests for remove_const:
|
||||
*
|
||||
**********************************************************************/
|
||||
|
||||
BOOST_DECL_TRANSFORM_TEST3(remove_const_test_1, ::boost::remove_const, const)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_2, ::boost::remove_const, volatile, volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_3, ::boost::remove_const, const volatile, volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST2(remove_const_test_4, ::boost::remove_const)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_6, ::boost::remove_const, *const, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_7, ::boost::remove_const, *volatile, *volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_8, ::boost::remove_const, *const volatile, *volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_9, ::boost::remove_const, *, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_11, ::boost::remove_const, volatile*, volatile*)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_12, ::boost::remove_const, const[2], [2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_13, ::boost::remove_const, volatile[2], volatile[2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_14, ::boost::remove_const, const volatile[2], volatile[2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_15, ::boost::remove_const, [2], [2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_16, ::boost::remove_const, const*, const*)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_const_test_17, ::boost::remove_const, const*const, const*)
|
||||
|
||||
void check_remove_const()
|
||||
{
|
||||
remove_const_test_1();
|
||||
remove_const_test_2();
|
||||
remove_const_test_3();
|
||||
remove_const_test_4();
|
||||
remove_const_test_6();
|
||||
remove_const_test_7();
|
||||
remove_const_test_8();
|
||||
remove_const_test_9();
|
||||
remove_const_test_11();
|
||||
remove_const_test_12();
|
||||
remove_const_test_13();
|
||||
remove_const_test_14();
|
||||
remove_const_test_15();
|
||||
remove_const_test_16();
|
||||
remove_const_test_17();
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* tests for remove_volatile:
|
||||
*
|
||||
**********************************************************************/
|
||||
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_1, ::boost::remove_volatile, const, const)
|
||||
BOOST_DECL_TRANSFORM_TEST3(remove_volatile_test_2, ::boost::remove_volatile, volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_3, ::boost::remove_volatile, const volatile, const)
|
||||
BOOST_DECL_TRANSFORM_TEST2(remove_volatile_test_4, ::boost::remove_volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST2(remove_volatile_test_5, ::boost::remove_volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_6, ::boost::remove_volatile, *const, *const)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_7, ::boost::remove_volatile, *volatile, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_8, ::boost::remove_volatile, *const volatile, *const)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_9, ::boost::remove_volatile, *, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_10, ::boost::remove_volatile, *, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_11, ::boost::remove_volatile, volatile*, volatile*)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_12, ::boost::remove_volatile, const[2], const[2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_13, ::boost::remove_volatile, volatile[2], [2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_14, ::boost::remove_volatile, const volatile[2], const[2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_15, ::boost::remove_volatile, [2], [2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_16, ::boost::remove_volatile, const*, const*)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_volatile_test_17, ::boost::remove_volatile, const*volatile, const*)
|
||||
|
||||
void check_remove_volatile()
|
||||
{
|
||||
remove_volatile_test_1();
|
||||
remove_volatile_test_2();
|
||||
remove_volatile_test_3();
|
||||
remove_volatile_test_4();
|
||||
remove_volatile_test_5();
|
||||
remove_volatile_test_6();
|
||||
remove_volatile_test_7();
|
||||
remove_volatile_test_8();
|
||||
remove_volatile_test_9();
|
||||
remove_volatile_test_10();
|
||||
remove_volatile_test_11();
|
||||
remove_volatile_test_12();
|
||||
remove_volatile_test_13();
|
||||
remove_volatile_test_14();
|
||||
remove_volatile_test_15();
|
||||
remove_volatile_test_16();
|
||||
remove_volatile_test_17();
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* tests for remove_cv:
|
||||
*
|
||||
**********************************************************************/
|
||||
|
||||
BOOST_DECL_TRANSFORM_TEST3(remove_cv_test_1, ::boost::remove_cv, const)
|
||||
BOOST_DECL_TRANSFORM_TEST3(remove_cv_test_2, ::boost::remove_cv, volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST3(remove_cv_test_3, ::boost::remove_cv, const volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST2(remove_cv_test_4, ::boost::remove_cv)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_5, ::boost::remove_cv, const &, const&)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_6, ::boost::remove_cv, *const, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_7, ::boost::remove_cv, *volatile, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_8, ::boost::remove_cv, *const volatile, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_9, ::boost::remove_cv, *, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_10, ::boost::remove_cv, const*, const*)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_11, ::boost::remove_cv, volatile*, volatile*)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_12, ::boost::remove_cv, const[2], [2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_13, ::boost::remove_cv, volatile[2], [2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_14, ::boost::remove_cv, const volatile[2], [2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_15, ::boost::remove_cv, [2], [2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_16, ::boost::remove_cv, const*, const*)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_cv_test_17, ::boost::remove_cv, const*volatile, const*)
|
||||
|
||||
void check_remove_cv()
|
||||
{
|
||||
remove_cv_test_1();
|
||||
remove_cv_test_2();
|
||||
remove_cv_test_3();
|
||||
remove_cv_test_4();
|
||||
remove_cv_test_5();
|
||||
remove_cv_test_6();
|
||||
remove_cv_test_7();
|
||||
remove_cv_test_8();
|
||||
remove_cv_test_9();
|
||||
remove_cv_test_10();
|
||||
remove_cv_test_11();
|
||||
remove_cv_test_12();
|
||||
remove_cv_test_13();
|
||||
remove_cv_test_14();
|
||||
remove_cv_test_15();
|
||||
remove_cv_test_16();
|
||||
remove_cv_test_17();
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* tests for remove_reference:
|
||||
*
|
||||
**********************************************************************/
|
||||
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_reference_test_1, ::boost::remove_reference, const, const)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_reference_test_2, ::boost::remove_reference, volatile, volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST3(remove_reference_test_3, ::boost::remove_reference, &)
|
||||
BOOST_DECL_TRANSFORM_TEST2(remove_reference_test_4, ::boost::remove_reference)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_reference_test_5, ::boost::remove_reference, const &, const)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_reference_test_6, ::boost::remove_reference, *, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_reference_test_7, ::boost::remove_reference, *volatile, *volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST3(remove_reference_test_8, ::boost::remove_reference, &)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_reference_test_9, ::boost::remove_reference, const &, const)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_reference_test_10, ::boost::remove_reference, const*, const*)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_reference_test_11, ::boost::remove_reference, volatile*, volatile*)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_reference_test_12, ::boost::remove_reference, const[2], const[2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_reference_test_13, ::boost::remove_reference, (&)[2], [2])
|
||||
|
||||
void check_remove_reference()
|
||||
{
|
||||
remove_reference_test_1();
|
||||
remove_reference_test_2();
|
||||
remove_reference_test_3();
|
||||
remove_reference_test_4();
|
||||
remove_reference_test_5();
|
||||
remove_reference_test_6();
|
||||
remove_reference_test_7();
|
||||
remove_reference_test_8();
|
||||
remove_reference_test_9();
|
||||
remove_reference_test_10();
|
||||
remove_reference_test_11();
|
||||
remove_reference_test_12();
|
||||
remove_reference_test_13();
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* tests for remove_bounds:
|
||||
*
|
||||
**********************************************************************/
|
||||
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_1, ::boost::remove_bounds, const, const)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_2, ::boost::remove_bounds, volatile, volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST3(remove_bounds_test_3, ::boost::remove_bounds, [2])
|
||||
BOOST_DECL_TRANSFORM_TEST2(remove_bounds_test_4, ::boost::remove_bounds)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_5, ::boost::remove_bounds, const &, const&)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_6, ::boost::remove_bounds, *, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_7, ::boost::remove_bounds, *volatile, *volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_8, ::boost::remove_bounds, const [2], const)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_9, ::boost::remove_bounds, const &, const&)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_10, ::boost::remove_bounds, const*, const*)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_11, ::boost::remove_bounds, volatile*, volatile*)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_12, ::boost::remove_bounds, const[2][3], const[3])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_bounds_test_13, ::boost::remove_bounds, (&)[2], (&)[2])
|
||||
|
||||
void check_remove_bounds()
|
||||
{
|
||||
remove_bounds_test_1();
|
||||
remove_bounds_test_2();
|
||||
remove_bounds_test_3();
|
||||
remove_bounds_test_4();
|
||||
remove_bounds_test_5();
|
||||
remove_bounds_test_6();
|
||||
remove_bounds_test_7();
|
||||
remove_bounds_test_8();
|
||||
remove_bounds_test_9();
|
||||
remove_bounds_test_10();
|
||||
remove_bounds_test_11();
|
||||
remove_bounds_test_12();
|
||||
remove_bounds_test_13();
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* tests for remove_pointer:
|
||||
*
|
||||
**********************************************************************/
|
||||
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_1, ::boost::remove_pointer, const, const)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_2, ::boost::remove_pointer, volatile, volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST3(remove_pointer_test_3, ::boost::remove_pointer, *)
|
||||
BOOST_DECL_TRANSFORM_TEST2(remove_pointer_test_4, ::boost::remove_pointer)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_5, ::boost::remove_pointer, const &, const&)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_6, ::boost::remove_pointer, &, &)
|
||||
BOOST_DECL_TRANSFORM_TEST3(remove_pointer_test_7, ::boost::remove_pointer, *volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_8, ::boost::remove_pointer, const [2], const[2])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_9, ::boost::remove_pointer, const &, const&)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_10, ::boost::remove_pointer, const*, const)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_11, ::boost::remove_pointer, volatile*, volatile)
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_12, ::boost::remove_pointer, const[2][3], const[2][3])
|
||||
BOOST_DECL_TRANSFORM_TEST(remove_pointer_test_13, ::boost::remove_pointer, (&)[2], (&)[2])
|
||||
|
||||
void check_remove_pointer()
|
||||
{
|
||||
remove_pointer_test_1();
|
||||
remove_pointer_test_2();
|
||||
remove_pointer_test_3();
|
||||
remove_pointer_test_4();
|
||||
remove_pointer_test_5();
|
||||
remove_pointer_test_6();
|
||||
remove_pointer_test_7();
|
||||
remove_pointer_test_8();
|
||||
remove_pointer_test_9();
|
||||
remove_pointer_test_10();
|
||||
remove_pointer_test_11();
|
||||
remove_pointer_test_12();
|
||||
remove_pointer_test_13();
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* tests for add_reference:
|
||||
*
|
||||
**********************************************************************/
|
||||
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_1, ::boost::add_reference, const, const&)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_2, ::boost::add_reference, volatile, volatile&)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_3, ::boost::add_reference, *, *&)
|
||||
//BOOST_DECL_TRANSFORM_TEST2(add_reference_test_4, ::boost::add_reference)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_5, ::boost::add_reference, const &, const&)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_6, ::boost::add_reference, &, &)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_7, ::boost::add_reference, *volatile, *volatile&)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_8, ::boost::add_reference, const [2], const (&)[2])
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_9, ::boost::add_reference, const &, const&)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_10, ::boost::add_reference, const*, const*&)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_11, ::boost::add_reference, volatile*, volatile*&)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_12, ::boost::add_reference, const[2][3], const (&)[2][3])
|
||||
BOOST_DECL_TRANSFORM_TEST(add_reference_test_13, ::boost::add_reference, (&)[2], (&)[2])
|
||||
|
||||
void check_add_reference()
|
||||
{
|
||||
add_reference_test_1();
|
||||
add_reference_test_2();
|
||||
add_reference_test_3();
|
||||
//add_reference_test_4();
|
||||
add_reference_test_5();
|
||||
add_reference_test_6();
|
||||
add_reference_test_7();
|
||||
add_reference_test_8();
|
||||
add_reference_test_9();
|
||||
add_reference_test_10();
|
||||
add_reference_test_11();
|
||||
add_reference_test_12();
|
||||
add_reference_test_13();
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* tests for add_pointer:
|
||||
*
|
||||
**********************************************************************/
|
||||
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_1, ::boost::add_pointer, const, const*)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_2, ::boost::add_pointer, volatile, volatile*)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_3, ::boost::add_pointer, *, **)
|
||||
//BOOST_DECL_TRANSFORM_TEST2(add_pointer_test_4, ::boost::add_pointer)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_7, ::boost::add_pointer, *volatile, *volatile*)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_10, ::boost::add_pointer, const*, const**)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_11, ::boost::add_pointer, volatile*, volatile**)
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_5, ::boost::add_pointer, const &, const*)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_6, ::boost::add_pointer, &, *)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_8, ::boost::add_pointer, const [2], const *)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_9, ::boost::add_pointer, const &, const*)
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_12, ::boost::add_pointer, const[2][3], const (*)[3])
|
||||
BOOST_DECL_TRANSFORM_TEST(add_pointer_test_13, ::boost::add_pointer, (&)[2], *)
|
||||
#endif
|
||||
|
||||
void check_add_pointer()
|
||||
{
|
||||
add_pointer_test_1();
|
||||
add_pointer_test_2();
|
||||
add_pointer_test_3();
|
||||
//add_pointer_test_4();
|
||||
add_pointer_test_7();
|
||||
add_pointer_test_10();
|
||||
add_pointer_test_11();
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
add_pointer_test_5();
|
||||
add_pointer_test_6();
|
||||
add_pointer_test_8();
|
||||
add_pointer_test_9();
|
||||
add_pointer_test_12();
|
||||
add_pointer_test_13();
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
check_remove_const();
|
||||
check_remove_volatile();
|
||||
check_remove_cv();
|
||||
check_remove_reference();
|
||||
check_remove_bounds();
|
||||
check_remove_pointer();
|
||||
check_add_reference();
|
||||
check_add_pointer();
|
||||
|
||||
type_test(void, boost::remove_const<void>::type)
|
||||
type_test(void, boost::remove_volatile<void>::type)
|
||||
type_test(void, boost::remove_cv<void>::type)
|
||||
|
||||
type_test(int, boost::remove_reference<cr_type>::type)
|
||||
type_test(void, boost::remove_reference<void>::type)
|
||||
|
||||
type_test(void, boost::remove_bounds<void>::type)
|
||||
type_test(void, boost::remove_pointer<void>::type)
|
||||
|
||||
return check_result(argc, argv);
|
||||
}
|
||||
|
||||
//
|
||||
// define the number of failures expected for given compilers:
|
||||
#ifdef __BORLANDC__
|
||||
#ifdef SHORT_TRANSFORM_TEST
|
||||
unsigned int expected_failures = 97; // cv-qualifiers
|
||||
#else
|
||||
unsigned int expected_failures = 422; // cv-qualifiers
|
||||
#endif
|
||||
#elif defined(__GNUC__)
|
||||
unsigned int expected_failures = 1; // cv-qualified references
|
||||
#else
|
||||
unsigned int expected_failures = 0;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,166 +0,0 @@
|
||||
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 1999
|
||||
* Dr John Maddock
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Dr John Maddock makes no representations
|
||||
* about the suitability of this software for any purpose.
|
||||
* It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
* This file provides some example of type_traits usage -
|
||||
* by "optimising" various algorithms:
|
||||
*
|
||||
* opt::destroy_array - an example of optimisation based upon omitted destructor calls
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include <boost/timer.hpp>
|
||||
#include <boost/type_traits.hpp>
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::cin;
|
||||
|
||||
namespace opt{
|
||||
|
||||
//
|
||||
// algorithm destroy_array:
|
||||
// The reverse of std::unitialized_copy, takes a block of
|
||||
// initialized memory and calls destructors on all objects therein.
|
||||
//
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <bool>
|
||||
struct array_destroyer
|
||||
{
|
||||
template <class T>
|
||||
static void destroy_array(T* i, T* j){ do_destroy_array(i, j); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct array_destroyer<true>
|
||||
{
|
||||
template <class T>
|
||||
static void destroy_array(T*, T*){}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
void do_destroy_array(T* first, T* last)
|
||||
{
|
||||
while(first != last)
|
||||
{
|
||||
first->~T();
|
||||
++first;
|
||||
}
|
||||
}
|
||||
|
||||
}; // namespace detail
|
||||
|
||||
template <class T>
|
||||
inline void destroy_array(T* p1, T* p2)
|
||||
{
|
||||
detail::array_destroyer<boost::has_trivial_destructor<T>::value>::destroy_array(p1, p2);
|
||||
}
|
||||
|
||||
//
|
||||
// unoptimised versions of destroy_array:
|
||||
//
|
||||
template <class T>
|
||||
void destroy_array1(T* first, T* last)
|
||||
{
|
||||
while(first != last)
|
||||
{
|
||||
first->~T();
|
||||
++first;
|
||||
}
|
||||
}
|
||||
template <class T>
|
||||
void destroy_array2(T* first, T* last)
|
||||
{
|
||||
for(; first != last; ++first) first->~T();
|
||||
}
|
||||
|
||||
} // namespace opt
|
||||
|
||||
//
|
||||
// define some global data:
|
||||
//
|
||||
const int array_size = 1000;
|
||||
int i_array[array_size] = {0,};
|
||||
const int ci_array[array_size] = {0,};
|
||||
char c_array[array_size] = {0,};
|
||||
const char cc_array[array_size] = { 0,};
|
||||
|
||||
const int iter_count = 1000000;
|
||||
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::timer t;
|
||||
double result;
|
||||
int i;
|
||||
//
|
||||
// test destroy_array,
|
||||
// compare destruction time of an array of ints
|
||||
// with unoptimised form.
|
||||
//
|
||||
cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl;
|
||||
cout << "testing destroy_array...\n"
|
||||
"[Some compilers may be able to optimise the \"unoptimised\"\n versions as well as type_traits does.]" << endl;
|
||||
|
||||
// cache load:
|
||||
opt::destroy_array(i_array, i_array + array_size);
|
||||
|
||||
// time optimised version:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
opt::destroy_array(i_array, i_array + array_size);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "destroy_array<int>: " << result << endl;
|
||||
|
||||
// cache load:
|
||||
opt::destroy_array1(i_array, i_array + array_size);
|
||||
|
||||
// time unoptimised version #1:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
opt::destroy_array1(i_array, i_array + array_size);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "destroy_array<int>(unoptimised#1): " << result << endl;
|
||||
|
||||
// cache load:
|
||||
opt::destroy_array2(i_array, i_array + array_size);
|
||||
|
||||
// time unoptimised version #2:
|
||||
t.restart();
|
||||
for(i = 0; i < iter_count; ++i)
|
||||
{
|
||||
opt::destroy_array2(i_array, i_array + array_size);
|
||||
}
|
||||
result = t.elapsed();
|
||||
cout << "destroy_array<int>(unoptimised#2): " << result << endl << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,609 +0,0 @@
|
||||
// (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.
|
||||
//
|
||||
// Crippled version of type traits for compilers that don't
|
||||
// support partial specialisation. (C) John Maddock 2000
|
||||
|
||||
/* Release notes:
|
||||
20 Jan 2001:
|
||||
Fixed is_same<T,U> so it would work with T == void or U == void
|
||||
Suppressed some warnings in from_not_void_conversion<> for MSVC
|
||||
Fixed a spelling error
|
||||
(David Abrahams)
|
||||
07 Oct 2000:
|
||||
Added more fixes for is_array (based on a newgroup posting by Jonathan Lundquist).
|
||||
03 Oct 2000:
|
||||
Added more fixes to is_pointer and is_array (JM).
|
||||
01st October 2000:
|
||||
Fixed is_pointer, is_reference, is_const, is_volatile, is_same, is_member_pointer
|
||||
using ideas suggested from "Generic<Programming>: Mappings between Types and Values"
|
||||
by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html).
|
||||
Mat Marcus and Jesse Jones posted a version of is_pointer very similar to this one
|
||||
on the boost list (Copyright 2000 Adobe Systems Incorporated and others.
|
||||
All rights reserved.).
|
||||
31st July 2000:
|
||||
Added is_convertible, alignment_of.
|
||||
23rd July 2000:
|
||||
Fixed is_void specialization. (JM)
|
||||
*/
|
||||
|
||||
//
|
||||
// partial copyright for is_convertible:
|
||||
//
|
||||
// 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_OB_TYPE_TRAITS_HPP
|
||||
#define BOOST_OB_TYPE_TRAITS_HPP
|
||||
|
||||
#include <boost/type.hpp>
|
||||
|
||||
#ifndef BOOST_TYPE_TRAITS_HPP
|
||||
#error Internal header file: This header must be included by <boost/type_traits.hpp> only.
|
||||
#endif
|
||||
|
||||
// **************************************************************************
|
||||
// Helper macros for builitin 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:
|
||||
|
||||
#define BOOST_IS_CLASS(T) !is_union<T>::value & \
|
||||
!is_scalar<T>::value & \
|
||||
!is_array<T>::value & \
|
||||
!is_reference<T>::value & \
|
||||
!is_void<T>::value
|
||||
#define BOOST_IS_ENUM(T) false
|
||||
#define BOOST_IS_UNION(T) false
|
||||
#define BOOST_IS_POD(T) false
|
||||
#define BOOST_IS_EMPTY(T) false
|
||||
#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false
|
||||
#define BOOST_HAS_TRIVIAL_COPY(T) false
|
||||
#define BOOST_HAS_TRIVIAL_ASSIGN(T) false
|
||||
#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
namespace boost{
|
||||
//
|
||||
// start with fundamental type operations:
|
||||
// these don't actually 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; };
|
||||
template <typename T> struct remove_reference{ typedef T type; };
|
||||
template <typename T> struct add_reference{ typedef T& type; };
|
||||
template <typename T> struct remove_bounds{ typedef T type; };
|
||||
|
||||
/**************************************************************************/
|
||||
//
|
||||
// fundamental property classes:
|
||||
|
||||
//* is a type T declared const - is_const<T>
|
||||
namespace detail{
|
||||
typedef char yes_result;
|
||||
typedef char (&no_result)[8];
|
||||
yes_result is_const_helper(const volatile void*);
|
||||
no_result is_const_helper(volatile void *);
|
||||
yes_result is_volatile_helper(const volatile void*);
|
||||
no_result is_volatile_helper(const void *);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
struct is_const
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
enum{ value = (sizeof(detail::yes_result) == sizeof(detail::is_const_helper(&t))) };
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct is_volatile
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
enum{ value = (sizeof(detail::yes_result) == sizeof(detail::is_volatile_helper(&t))) };
|
||||
};
|
||||
|
||||
namespace detail{
|
||||
template <class T>
|
||||
yes_result is_same_helper(T*, T*);
|
||||
no_result is_same_helper(...);
|
||||
|
||||
template <class T>
|
||||
struct size_of
|
||||
{
|
||||
enum { value = sizeof(T) };
|
||||
};
|
||||
|
||||
template <>
|
||||
struct size_of<void>
|
||||
{
|
||||
enum { value = 0 };
|
||||
};
|
||||
}
|
||||
|
||||
template <typename T> struct is_reference;
|
||||
template <typename T, typename U> struct is_same
|
||||
{
|
||||
private:
|
||||
static type<T> t;
|
||||
static type<U> u;
|
||||
public:
|
||||
enum{ value = (sizeof(detail::yes_result) == sizeof(detail::is_same_helper(&t,&u)))
|
||||
& (is_reference<T>::value == is_reference<U>::value)
|
||||
& (detail::size_of<T>::value == detail::size_of<U>::value) };
|
||||
};
|
||||
|
||||
template <typename T> struct is_void{ enum{ value = false }; };
|
||||
template <> struct is_void<void>{ enum{ value = true }; };
|
||||
|
||||
//* is a type T an unsigned integral type described in the standard (3.9.1p3)
|
||||
template <typename T> struct is_standard_unsigned_integral
|
||||
{ enum{ value = false}; };
|
||||
template <> struct is_standard_unsigned_integral<unsigned char>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_standard_unsigned_integral<unsigned short>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_standard_unsigned_integral<unsigned int>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_standard_unsigned_integral<unsigned long>
|
||||
{ enum{ value = true}; };
|
||||
|
||||
//* is a type T a signed integral type described in the standard (3.9.1p2)
|
||||
template <typename T> struct is_standard_signed_integral
|
||||
{ enum{ value = false}; };
|
||||
template <> struct is_standard_signed_integral<signed char>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_standard_signed_integral<signed short>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_standard_signed_integral<signed int>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_standard_signed_integral<signed long>
|
||||
{ enum{ value = true}; };
|
||||
|
||||
//* is a type T an integral type described in the standard (3.9.1p7)
|
||||
template <typename T> struct is_standard_integral
|
||||
{ enum{ value = is_standard_unsigned_integral<T>::value |
|
||||
is_standard_signed_integral<T>::value }; };
|
||||
template <> struct is_standard_integral<char>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_standard_integral<wchar_t>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_standard_integral<bool>
|
||||
{ enum{ value = true}; };
|
||||
|
||||
//* is a type T a floating-point type described in the standard (3.9.1p8)
|
||||
template <typename T> struct is_standard_float
|
||||
{ enum{ value = false}; };
|
||||
template <> struct is_standard_float<float>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_standard_float<double>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_standard_float<long double>
|
||||
{ enum{ value = true}; };
|
||||
|
||||
//* is a type T an arithmetic type described in the standard (3.9.1p8)
|
||||
template <typename T> struct is_standard_arithmetic
|
||||
{ enum{ value = is_standard_integral<T>::value | is_standard_float<T>::value}; };
|
||||
|
||||
//* is a type T a fundamental type described in the standard (3.9.1)
|
||||
template <typename T> struct is_standard_fundamental
|
||||
{ enum{ value = is_standard_arithmetic<T>::value | is_void<T>::value}; };
|
||||
|
||||
//* is a type T an unsigned integral type provided by a compiler extension
|
||||
// specialise for compiler defined extentions:
|
||||
template <typename T> struct is_extension_unsigned_integral
|
||||
{ enum{ value = false}; };
|
||||
|
||||
//* is a type T a signed integral type provided by a compiler extension
|
||||
// specialise for compiler defined extentions:
|
||||
template <typename T> struct is_extension_signed_integral
|
||||
{ enum{ value = false}; };
|
||||
|
||||
#ifdef ULLONG_MAX
|
||||
template <> struct is_extension_unsigned_integral<unsigned long long>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_extension_signed_integral<long long>
|
||||
{ enum{ value = true}; };
|
||||
#endif
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
|
||||
template <> struct is_extension_unsigned_integral<unsigned __int64>
|
||||
{ enum{ value = true}; };
|
||||
template <> struct is_extension_signed_integral<__int64>
|
||||
{ enum{ value = true}; };
|
||||
#endif
|
||||
|
||||
//* is a type T an integral type provided by a compiler extension
|
||||
template <typename T> struct is_extension_integral
|
||||
{ enum{ value = is_extension_signed_integral<T>::value |
|
||||
is_extension_unsigned_integral<T>::value }; };
|
||||
|
||||
//* is a type T a floating-point type provided by a compiler extension
|
||||
template <typename T> struct is_extension_float
|
||||
{ enum{ value = false}; };
|
||||
|
||||
//* is a type T an arithmetic type provided by a compiler extension
|
||||
template <typename T> struct is_extension_arithmetic
|
||||
{ enum{ value = is_extension_integral<T>::value | is_extension_float<T>::value}; };
|
||||
|
||||
//* is a type T a fundamental type provided by a compiler extension
|
||||
template <typename T> struct is_extension_fundamental
|
||||
{ enum{ value = is_extension_arithmetic<T>::value | is_void<T>::value}; };
|
||||
|
||||
//* is a type T an unsigned integral type provided by the compiler or standard
|
||||
template <typename T> struct is_unsigned_integral
|
||||
{ enum{ value = is_standard_unsigned_integral<T>::value | is_extension_unsigned_integral<T>::value}; };
|
||||
|
||||
//* is a type T a signed integral type provided by the compiler or standard
|
||||
template <typename T> struct is_signed_integral
|
||||
{ enum{ value = is_standard_signed_integral<T>::value | is_extension_signed_integral<T>::value}; };
|
||||
|
||||
//* is a type T an integral type provided by the compiler or standard
|
||||
template <typename T> struct is_integral
|
||||
{ enum{ value = is_standard_integral<T>::value | is_extension_integral<T>::value}; };
|
||||
|
||||
//* is a type T a floating-point type provided by the compiler or standard
|
||||
template <typename T> struct is_float
|
||||
{ enum{ value = is_standard_float<T>::value | is_extension_float<T>::value}; };
|
||||
|
||||
//* is a type T an arithmetic type provided by the compiler or standard
|
||||
template <typename T> struct is_arithmetic
|
||||
{ enum{ value = is_standard_arithmetic<T>::value | is_extension_arithmetic<T>::value}; };
|
||||
|
||||
//* is a type T a fundamental type provided by the compiler or standard
|
||||
template <typename T> struct is_fundamental
|
||||
{ enum{ value = is_standard_fundamental<T>::value | is_extension_fundamental<T>::value}; };
|
||||
|
||||
//* is a type T an array - is_array<T>
|
||||
namespace detail{
|
||||
struct pointer_helper
|
||||
{
|
||||
pointer_helper(const volatile void*);
|
||||
};
|
||||
yes_result is_pointer_helper(pointer_helper);
|
||||
no_result is_pointer_helper(...);
|
||||
template <class T>
|
||||
yes_result is_pointer_helper3(T (*)(void));
|
||||
template <class T, class A1>
|
||||
yes_result is_pointer_helper3(T (*)(A1));
|
||||
template <class T, class A1, class A2>
|
||||
yes_result is_pointer_helper3(T (*)(A1, A2));
|
||||
template <class T, class A1, class A2, class A3>
|
||||
yes_result is_pointer_helper3(T (*)(A1, A2, A3));
|
||||
no_result is_pointer_helper3(...);
|
||||
|
||||
yes_result is_array_helper(const volatile void*, const volatile void*);
|
||||
template <class T>
|
||||
no_result is_array_helper(T**, const volatile void*);
|
||||
no_result is_array_helper(...);
|
||||
}
|
||||
template <typename T> struct is_array
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
enum{ value = (1 == sizeof(detail::is_pointer_helper(t)))
|
||||
& (1 == sizeof(detail::is_array_helper(&t, t)))
|
||||
& !is_reference<T>::value
|
||||
& !(1 == sizeof(detail::is_pointer_helper3(t))) };
|
||||
};
|
||||
|
||||
//* is a type T a pointer type (including function pointers) - is_pointer<T>
|
||||
template <typename T> struct is_pointer
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
enum{ value = (!is_const<T>::value
|
||||
& !is_volatile<T>::value
|
||||
& !is_reference<T>::value
|
||||
& !is_array<T>::value)
|
||||
& ((1 == sizeof(detail::is_pointer_helper(t)))
|
||||
| (1 == sizeof(detail::is_pointer_helper3(t)))) };
|
||||
};
|
||||
|
||||
# ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 4181)
|
||||
# endif // BOOST_MSVC
|
||||
|
||||
//* is a type T a reference type - is_reference<T>
|
||||
template <typename T> struct is_reference
|
||||
{
|
||||
private:
|
||||
typedef T const volatile cv_t;
|
||||
public:
|
||||
enum // dwa 10/27/00 - VC6.4 seems to choke on short-circuit (&&,||)
|
||||
{ // evaluations in constant expressions
|
||||
value = !is_const<cv_t>::value | !is_volatile<cv_t>::value
|
||||
};
|
||||
};
|
||||
template <> struct is_reference<void>
|
||||
{
|
||||
enum{ value = false };
|
||||
};
|
||||
|
||||
# ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
# endif // BOOST_MSVC
|
||||
|
||||
//*? is a type T a union type - is_union<T>
|
||||
template <typename T> struct is_union
|
||||
{ enum{ value = BOOST_IS_UNION(T) }; };
|
||||
|
||||
//*? is a type T an enum - is_enum<T>
|
||||
template <typename T> struct is_enum
|
||||
{ enum{ value = BOOST_IS_ENUM(T) }; };
|
||||
|
||||
//* is a type T a member function pointer - is_member_pointer<T>
|
||||
namespace detail{
|
||||
template <class T, class U>
|
||||
yes_result is_member_pointer_helper(T (U::*));
|
||||
template <class T, class U>
|
||||
yes_result is_member_pointer_helper(T (U::*)(void));
|
||||
template <class T, class U, class A1>
|
||||
yes_result is_member_pointer_helper(T (U::*)(A1));
|
||||
template <class T, class U, class A1, class A2>
|
||||
yes_result is_member_pointer_helper(T (U::*)(A1, A2));
|
||||
no_result is_member_pointer_helper(...);
|
||||
}
|
||||
template <typename T> struct is_member_pointer
|
||||
{
|
||||
private:
|
||||
static T t;
|
||||
public:
|
||||
enum{ value = (1 == sizeof(detail::is_member_pointer_helper(t))) };
|
||||
};
|
||||
|
||||
//* is type T an object type (allows cv-qual)
|
||||
template <typename T> struct is_object
|
||||
{ enum{ value = !is_reference<T>::value & !is_void<T>::value }; };
|
||||
|
||||
//* is type T a standard scalar type (allows cv-qual)
|
||||
template <typename T> struct is_standard_scalar
|
||||
{ enum{ value = is_standard_arithmetic<T>::value
|
||||
| is_enum<T>::value
|
||||
| is_pointer<T>::value
|
||||
| is_member_pointer<T>::value }; };
|
||||
|
||||
//* is type T an extension scalar type (allows cv-qual)
|
||||
template <typename T> struct is_extension_scalar
|
||||
{ enum{ value = is_extension_arithmetic<T>::value
|
||||
| is_enum<T>::value
|
||||
| is_pointer<T>::value
|
||||
| is_member_pointer<T>::value }; };
|
||||
|
||||
//* is type T a builtin scalar type (allows cv-qual)
|
||||
template <typename T> struct is_scalar
|
||||
{ enum{ value = is_arithmetic<T>::value
|
||||
| is_enum<T>::value
|
||||
| is_pointer<T>::value
|
||||
| is_member_pointer<T>::value }; };
|
||||
|
||||
//*? is a type T a class type (class/struct) - is_class<T>
|
||||
template <typename T> struct is_class
|
||||
{ enum{ value = BOOST_IS_CLASS(T) }; };
|
||||
|
||||
//*? is a type T a compound type
|
||||
template <typename T> struct is_compound
|
||||
{ enum{ value = is_array<T>::value | is_pointer<T>::value
|
||||
| is_reference<T>::value | is_class<T>::value | is_union<T>::value
|
||||
| is_enum<T>::value | is_member_pointer<T>::value }; };
|
||||
|
||||
//*? is type T a POD type (allows cv-qual)
|
||||
template <typename T> struct is_POD
|
||||
{ enum{ value = is_scalar<T>::value //JM 7Jan2000
|
||||
| BOOST_IS_POD(T) }; };
|
||||
|
||||
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.
|
||||
#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
|
||||
struct from_not_void_conversion {
|
||||
template <class From, class To>
|
||||
struct bind {
|
||||
static no_result check(...);
|
||||
static yes_result check(To);
|
||||
public:
|
||||
void foo(); // avoid warning about all members being private
|
||||
static From from;
|
||||
# ifdef BOOST_MSVC
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable:4244 4245 4135 4136 4051 4134) // disable all conversion warnings
|
||||
# endif
|
||||
enum { exists = sizeof( check(from) ) == sizeof(yes_result) };
|
||||
# ifdef BOOST_MSVC
|
||||
# pragma warning(pop)
|
||||
# endif
|
||||
};
|
||||
};
|
||||
struct from_is_void_conversion {
|
||||
template <class From, class To>
|
||||
struct bind {
|
||||
enum { exists = 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;
|
||||
};
|
||||
#endif
|
||||
} // namespace detail
|
||||
|
||||
template <class From, class To>
|
||||
class is_convertible
|
||||
{
|
||||
#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
|
||||
typedef typename detail::conversion_helper<From>::type Selector;
|
||||
typedef Selector::template bind<From,To> Conversion;
|
||||
public:
|
||||
enum { value = Conversion::exists };
|
||||
#else
|
||||
static detail::no_result check(...);
|
||||
static detail::yes_result check(To);
|
||||
public:
|
||||
void foo(); // avoid warning about all members being private
|
||||
static From from;
|
||||
enum { value = sizeof( check(from) ) == sizeof(detail::yes_result) };
|
||||
#endif
|
||||
};
|
||||
|
||||
template <class T>
|
||||
class alignment_of
|
||||
{
|
||||
struct padded
|
||||
{
|
||||
char c;
|
||||
T t;
|
||||
padded();
|
||||
};
|
||||
public:
|
||||
enum{ value = sizeof(padded) - sizeof(T) };
|
||||
};
|
||||
|
||||
//*? is type T an empty composite type (allows cv-qual)
|
||||
#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_MEMBER_TEMPLATES)
|
||||
|
||||
namespace detail{
|
||||
|
||||
template <typename T>
|
||||
struct empty_helper_t1 : public T
|
||||
{
|
||||
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 detail::empty_helper_chooser<
|
||||
!is_convertible<T,int>::value
|
||||
& !is_convertible<T,double>::value
|
||||
& !is_pointer<T>::value
|
||||
& !is_member_pointer<T>::value
|
||||
& !is_array<T>::value
|
||||
& !is_convertible<T, const volatile void*>::value> chooser;
|
||||
typedef typename chooser::template rebind<T> bound_type;
|
||||
typedef typename bound_type::type eh_type;
|
||||
public:
|
||||
enum{ value = eh_type::value | BOOST_IS_EMPTY(T) };
|
||||
};
|
||||
|
||||
#else
|
||||
template <typename T> struct is_empty
|
||||
{ enum{ value = BOOST_IS_EMPTY(T) }; };
|
||||
#endif
|
||||
|
||||
//*? T has trivial default constructor (allows cv-qual)
|
||||
template <typename T> struct has_trivial_constructor
|
||||
{
|
||||
enum{ value = is_POD<T>::value | BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) };
|
||||
};
|
||||
|
||||
//*? T has trivial copy constructor (allows cv-qual)
|
||||
template <typename T> struct has_trivial_copy
|
||||
{
|
||||
enum{ value = is_POD<T>::value | BOOST_HAS_TRIVIAL_COPY(T) };
|
||||
};
|
||||
|
||||
//*? T has trivial assignment operator (allows cv-qual)
|
||||
template <typename T>
|
||||
struct has_trivial_assign
|
||||
{
|
||||
enum{ value = is_POD<T>::value | BOOST_HAS_TRIVIAL_ASSIGN(T) };
|
||||
};
|
||||
|
||||
//*? T has trivial destructor (allows cv-qual)
|
||||
template <typename T>
|
||||
struct has_trivial_destructor
|
||||
{
|
||||
enum{ value = is_POD<T>::value | BOOST_HAS_TRIVIAL_DESTRUCTOR(T) };
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
//
|
||||
// undefine helper macro's:
|
||||
//
|
||||
#undef BOOST_IS_CLASS
|
||||
#undef BOOST_IS_ENUM
|
||||
#undef BOOST_IS_UNION
|
||||
#undef BOOST_IS_POD
|
||||
#undef BOOST_IS_EMPTY
|
||||
#undef BOOST_HAS_TRIVIAL_CONSTRUCTOR
|
||||
#undef BOOST_HAS_TRIVIAL_COPY
|
||||
#undef BOOST_HAS_TRIVIAL_ASSIGN
|
||||
#undef BOOST_HAS_TRIVIAL_DESTRUCTOR
|
||||
|
||||
#endif // BOOST_OB_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,675 +0,0 @@
|
||||
// (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.
|
||||
//
|
||||
// misc traits classes that operate on or describe a type.
|
||||
// see libs/utility/type_traits.htm
|
||||
|
||||
/* Release notes:
|
||||
31 Jan 2001:
|
||||
Fixed is_convertible warning for g++. Added specialization of
|
||||
is_array to handle the const array case. Added parenthesis are
|
||||
body of BOOST_IS_CLASS to prevent macro mistakes. (Jeremy Siek)
|
||||
21 Jan 2001:
|
||||
Fixed tests for long long to detect its presence on GCC (David Abrahams)
|
||||
03 Oct 2000:
|
||||
Added gcc specific fixes for memeber pointers (JM).
|
||||
31st July 2000:
|
||||
Added is_convertable, alignment_of, modified is_empty.
|
||||
23rd July 2000:
|
||||
Added Borland specific fixes for reference types (Steve Cleary).
|
||||
*/
|
||||
|
||||
//
|
||||
// partial copyright for is_convertible:
|
||||
//
|
||||
// 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_DETAIL_TYPE_TRAITS_HPP
|
||||
#define BOOST_DETAIL_TYPE_TRAITS_HPP
|
||||
|
||||
#ifndef BOOST_TYPE_TRAITS_HPP
|
||||
#error Internal header file: This header must be included by <boost/type_traits.hpp> only.
|
||||
#endif
|
||||
|
||||
#include <cstddef>
|
||||
#include <climits>
|
||||
|
||||
//
|
||||
// Helper macros for builitin 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 return false if T is cv-qualified; the type traits that use these
|
||||
// will strip cv-qualification if necessary before passing T)
|
||||
// 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
|
||||
|
||||
#define BOOST_IS_CLASS(T) (!is_union<T>::value && \
|
||||
!is_scalar<T>::value && \
|
||||
!is_array<T>::value && \
|
||||
!is_reference<T>::value && \
|
||||
!is_void<T>::value)
|
||||
#define BOOST_IS_ENUM(T) false
|
||||
#define BOOST_IS_UNION(T) false
|
||||
#define BOOST_IS_POD(T) false
|
||||
#define BOOST_IS_EMPTY(T) false
|
||||
#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false
|
||||
#define BOOST_HAS_TRIVIAL_COPY(T) false
|
||||
#define BOOST_HAS_TRIVIAL_ASSIGN(T) false
|
||||
#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false
|
||||
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
namespace boost{
|
||||
//
|
||||
// start with fundamental type operations:
|
||||
|
||||
namespace details {
|
||||
//
|
||||
// implementation helper:
|
||||
//
|
||||
template <class T>
|
||||
struct cv_traits_imp{};
|
||||
|
||||
template <class T>
|
||||
struct cv_traits_imp<T*>
|
||||
{
|
||||
static const bool is_const = false;
|
||||
static const bool is_volatile = false;
|
||||
typedef T non_const_type;
|
||||
typedef T non_volatile_type;
|
||||
typedef T unqualified_type;
|
||||
static const char* what() { return ""; }
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct cv_traits_imp<const T*>
|
||||
{
|
||||
static const bool is_const = true;
|
||||
static const bool is_volatile = false;
|
||||
typedef T non_const_type;
|
||||
typedef const T non_volatile_type;
|
||||
typedef T unqualified_type;
|
||||
static const char* what() { return "const"; }
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct cv_traits_imp<volatile T*>
|
||||
{
|
||||
static const bool is_const = false;
|
||||
static const bool is_volatile = true;
|
||||
typedef volatile T non_const_type;
|
||||
typedef T non_volatile_type;
|
||||
typedef T unqualified_type;
|
||||
static const char* what() { return "volatile"; }
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct cv_traits_imp<const volatile T*>
|
||||
{
|
||||
static const bool is_const = true;
|
||||
static const bool is_volatile = true;
|
||||
typedef volatile T non_const_type;
|
||||
typedef const T non_volatile_type;
|
||||
typedef T unqualified_type;
|
||||
static const char* what() { return "const volatile"; }
|
||||
};
|
||||
|
||||
} // namespace details
|
||||
|
||||
// * convert a type T to a non-volatile type - remove_volatile<T>
|
||||
template <typename T>
|
||||
struct remove_volatile
|
||||
{
|
||||
typedef typename details::cv_traits_imp<T*>::non_volatile_type type;
|
||||
};
|
||||
template <typename T> struct remove_volatile<T&>{ typedef T& type; };
|
||||
|
||||
// * convert a type T to non-const type - remove_const<T>
|
||||
template <typename T>
|
||||
struct remove_const
|
||||
{
|
||||
typedef typename details::cv_traits_imp<T*>::non_const_type type;
|
||||
};
|
||||
template <typename T> struct remove_const<T&>{ typedef T& type; };
|
||||
|
||||
// convert a type T to a non-cv-qualified type - remove_cv<T>
|
||||
template <typename T>
|
||||
struct remove_cv
|
||||
{
|
||||
typedef typename details::cv_traits_imp<T*>::unqualified_type type;
|
||||
};
|
||||
template <typename T> struct remove_cv<T&>{ typedef T& type; };
|
||||
|
||||
// * convert a type T to a non-reference if it is one - remove_reference<T>
|
||||
template <typename T> struct remove_reference{ typedef T type; };
|
||||
template <typename T> struct remove_reference<T&>{ typedef T type; };
|
||||
#if (defined(__BORLANDC__) && (__BORLANDC__ <= 0x550))
|
||||
// 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
|
||||
// * convert a type T to a reference unless it is one - add_reference<T>
|
||||
template <typename T> struct add_reference{ typedef T& type; };
|
||||
template <typename T> struct add_reference<T&>{ typedef T& type; };
|
||||
|
||||
// * convert an array type to underlying non-array type - remove_bounds<T>
|
||||
template <typename T> struct remove_bounds{ typedef T type; };
|
||||
template <typename T, std::size_t N> struct remove_bounds<T[N]>{ typedef T type; };
|
||||
|
||||
/**************************************************************************/
|
||||
//
|
||||
// fundamental property classes:
|
||||
|
||||
//* is a type T declared const - is_const<T>
|
||||
template <typename T>
|
||||
struct is_const
|
||||
{
|
||||
static const bool value = details::cv_traits_imp<T*>::is_const;
|
||||
};
|
||||
|
||||
//* is a type T declared volatile - is_volatile<T>
|
||||
template <typename T>
|
||||
struct is_volatile
|
||||
{
|
||||
static const bool value = details::cv_traits_imp<T*>::is_volatile;
|
||||
};
|
||||
|
||||
//* is a type T the same as type U - is_same<T,U>
|
||||
template <typename T, typename U> struct is_same { static const bool value = false; };
|
||||
template <typename T> struct is_same<T, T> { static const bool value = true; };
|
||||
|
||||
//* is a type T void - is_void<T>
|
||||
template <typename T> struct is_void{ static const bool value = false; };
|
||||
template <> struct is_void<void>{ static const bool value = true; };
|
||||
|
||||
//* is a type T an unsigned integral type described in the standard (3.9.1p3)
|
||||
template <typename T> struct is_standard_unsigned_integral
|
||||
{ static const bool value = false; };
|
||||
template <> struct is_standard_unsigned_integral<unsigned char>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_standard_unsigned_integral<unsigned short>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_standard_unsigned_integral<unsigned int>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_standard_unsigned_integral<unsigned long>
|
||||
{ static const bool value = true; };
|
||||
|
||||
//* is a type T a signed integral type described in the standard (3.9.1p2)
|
||||
template <typename T> struct is_standard_signed_integral
|
||||
{ static const bool value = false; };
|
||||
template <> struct is_standard_signed_integral<signed char>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_standard_signed_integral<signed short>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_standard_signed_integral<signed int>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_standard_signed_integral<signed long>
|
||||
{ static const bool value = true; };
|
||||
|
||||
//* is a type T an integral type described in the standard (3.9.1p7)
|
||||
template <typename T> struct is_standard_integral
|
||||
{ static const bool value = is_standard_unsigned_integral<T>::value ||
|
||||
is_standard_signed_integral<T>::value; };
|
||||
template <> struct is_standard_integral<char>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_standard_integral<wchar_t>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_standard_integral<bool>
|
||||
{ static const bool value = true; };
|
||||
|
||||
//* is a type T a floating-point type described in the standard (3.9.1p8)
|
||||
template <typename T> struct is_standard_float
|
||||
{ static const bool value = false; };
|
||||
template <> struct is_standard_float<float>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_standard_float<double>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_standard_float<long double>
|
||||
{ static const bool value = true; };
|
||||
|
||||
//* is a type T an arithmetic type described in the standard (3.9.1p8)
|
||||
template <typename T> struct is_standard_arithmetic
|
||||
{ static const bool value = is_standard_integral<T>::value || is_standard_float<T>::value; };
|
||||
|
||||
//* is a type T a fundamental type described in the standard (3.9.1)
|
||||
template <typename T> struct is_standard_fundamental
|
||||
{ static const bool value = is_standard_arithmetic<T>::value || is_void<T>::value; };
|
||||
|
||||
//* is a type T an unsigned integral type provided by a compiler extension
|
||||
// specialise for compiler defined extentions:
|
||||
template <typename T> struct is_extension_unsigned_integral
|
||||
{ static const bool value = false; };
|
||||
|
||||
//* is a type T a signed integral type provided by a compiler extension
|
||||
// specialise for compiler defined extentions:
|
||||
template <typename T> struct is_extension_signed_integral
|
||||
{ static const bool value = false; };
|
||||
|
||||
#if defined(ULLONG_MAX) || defined(ULONG_LONG_MAX)
|
||||
template <> struct is_extension_unsigned_integral<unsigned long long>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_extension_signed_integral<long long>
|
||||
{ static const bool value = true; };
|
||||
#endif
|
||||
#if defined(__BORLANDC__) || defined(_MSC_VER) && !defined(__MWERKS__)
|
||||
template <> struct is_extension_unsigned_integral<unsigned __int64>
|
||||
{ static const bool value = true; };
|
||||
template <> struct is_extension_signed_integral<__int64>
|
||||
{ static const bool value = true; };
|
||||
#endif
|
||||
|
||||
//* is a type T an integral type provided by a compiler extension
|
||||
template <typename T> struct is_extension_integral
|
||||
{ static const bool value = is_extension_signed_integral<T>::value ||
|
||||
is_extension_unsigned_integral<T>::value; };
|
||||
|
||||
//* is a type T a floating-point type provided by a compiler extension
|
||||
template <typename T> struct is_extension_float
|
||||
{ static const bool value = false; };
|
||||
|
||||
//* is a type T an arithmetic type provided by a compiler extension
|
||||
template <typename T> struct is_extension_arithmetic
|
||||
{ static const bool value = is_extension_integral<T>::value || is_extension_float<T>::value; };
|
||||
|
||||
//* is a type T a fundamental type provided by a compiler extension
|
||||
template <typename T> struct is_extension_fundamental
|
||||
{ static const bool value = is_extension_arithmetic<T>::value || is_void<T>::value; };
|
||||
|
||||
//* is a type T an unsigned integral type provided by the compiler or standard
|
||||
template <typename T> struct is_unsigned_integral
|
||||
{ static const bool value = is_standard_unsigned_integral<T>::value || is_extension_unsigned_integral<T>::value; };
|
||||
|
||||
//* is a type T a signed integral type provided by the compiler or standard
|
||||
template <typename T> struct is_signed_integral
|
||||
{ static const bool value = is_standard_signed_integral<T>::value || is_extension_signed_integral<T>::value; };
|
||||
|
||||
//* is a type T an integral type provided by the compiler or standard
|
||||
template <typename T> struct is_integral
|
||||
{ static const bool value = is_standard_integral<T>::value || is_extension_integral<T>::value; };
|
||||
|
||||
//* is a type T a floating-point type provided by the compiler or standard
|
||||
template <typename T> struct is_float
|
||||
{ static const bool value = is_standard_float<T>::value || is_extension_float<T>::value; };
|
||||
|
||||
//* is a type T an arithmetic type provided by the compiler or standard
|
||||
template <typename T> struct is_arithmetic
|
||||
{ static const bool value = is_standard_arithmetic<T>::value || is_extension_arithmetic<T>::value; };
|
||||
|
||||
//* is a type T a fundamental type provided by the compiler or standard
|
||||
template <typename T> struct is_fundamental
|
||||
{ static const bool value = is_standard_fundamental<T>::value || is_extension_fundamental<T>::value; };
|
||||
|
||||
//* is a type T an array - is_array<T>
|
||||
template <typename T> struct is_array
|
||||
{ static const bool value = false; };
|
||||
template <typename T, std::size_t N> struct is_array<T[N]>
|
||||
{ static const bool value = true; };
|
||||
template <typename T, std::size_t N> struct is_array<const T[N]>
|
||||
{ static const bool value = true; };
|
||||
|
||||
//* is a type T a pointer type (including function pointers) - is_pointer<T>
|
||||
template <typename T> struct is_pointer { static const bool value = false; };
|
||||
template <typename T> struct is_pointer<T*> { static const bool value = true; };
|
||||
#ifdef __GNUC__
|
||||
// gcc workarounds: these partial specialisations should not be needed:
|
||||
template <typename T, typename U> struct is_pointer<U T::*>
|
||||
{ static const bool value = false; };
|
||||
template <typename T, typename U> struct is_pointer<U (T::*)(void)>
|
||||
{ static const bool value = false; };
|
||||
template <typename T, typename U, typename A1> struct is_pointer<U (T::*)(A1)>
|
||||
{ static const bool value = false; };
|
||||
template <typename T, typename U, typename A1, typename A2> struct is_pointer<U (T::*)(A1, A2)>
|
||||
{ static const bool value = false; };
|
||||
#endif
|
||||
|
||||
//* is a type T a reference type - is_reference<T>
|
||||
template <typename T> struct is_reference { static const bool value = false; };
|
||||
template <typename T> struct is_reference<T&> { static const bool value = true; };
|
||||
#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)
|
||||
// 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> { static const bool value = true; };
|
||||
template <typename T> struct is_reference<T&volatile> { static const bool value = true; };
|
||||
template <typename T> struct is_reference<T&const volatile> { static const bool value = true; };
|
||||
#endif
|
||||
|
||||
//*? is a type T a union type - is_union<T>
|
||||
template <typename T> struct is_union
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = BOOST_IS_UNION(cvt);
|
||||
};
|
||||
|
||||
//*? is a type T an enum - is_enum<T>
|
||||
template <typename T> struct is_enum
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = BOOST_IS_ENUM(cvt);
|
||||
};
|
||||
|
||||
//* is a type T a member function pointer - is_member_pointer<T>
|
||||
template <typename T> struct is_member_pointer
|
||||
{ static const bool value = false; };
|
||||
template <typename T, typename U> struct is_member_pointer<U T::*>
|
||||
{ static const bool value = true; };
|
||||
#ifdef __GNUC__
|
||||
// gcc workaround (JM 02 Oct 2000)
|
||||
template <typename T, typename U> struct is_member_pointer<U (T::*)(void)>
|
||||
{ static const bool value = true; };
|
||||
template <typename T, typename U, typename A1> struct is_member_pointer<U (T::*)(A1)>
|
||||
{ static const bool value = true; };
|
||||
template <typename T, typename U, typename A1, typename A2> struct is_member_pointer<U (T::*)(A1, A2)>
|
||||
{ static const bool value = true; };
|
||||
#endif
|
||||
|
||||
//* is type T an object type (allows cv-qual)
|
||||
template <typename T> struct is_object
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = !::boost::is_reference<cvt>::value
|
||||
&& !::boost::is_void<cvt>::value;
|
||||
};
|
||||
|
||||
//* is type T a standard scalar type (allows cv-qual)
|
||||
template <typename T> struct is_standard_scalar
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = is_standard_arithmetic<cvt>::value
|
||||
|| is_enum<cvt>::value
|
||||
|| is_pointer<cvt>::value
|
||||
|| is_member_pointer<cvt>::value;
|
||||
};
|
||||
|
||||
//* is type T an extension scalar type (allows cv-qual)
|
||||
template <typename T> struct is_extension_scalar
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = is_extension_arithmetic<cvt>::value
|
||||
|| is_enum<cvt>::value
|
||||
|| is_pointer<cvt>::value
|
||||
|| is_member_pointer<cvt>::value;
|
||||
};
|
||||
|
||||
//* is type T a builtin scalar type (allows cv-qual)
|
||||
template <typename T> struct is_scalar
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = is_arithmetic<cvt>::value
|
||||
|| is_enum<cvt>::value
|
||||
|| is_pointer<cvt>::value
|
||||
|| is_member_pointer<cvt>::value;
|
||||
};
|
||||
|
||||
//*? is a type T a class type (class/struct) - is_class<T>
|
||||
template <typename T> struct is_class
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = BOOST_IS_CLASS(cvt);
|
||||
};
|
||||
|
||||
//*? is a type T a compound type
|
||||
template <typename T> struct is_compound
|
||||
{ static const bool value = is_array<T>::value || is_pointer<T>::value
|
||||
|| is_reference<T>::value || is_class<T>::value || is_union<T>::value
|
||||
|| is_enum<T>::value || is_member_pointer<T>::value; };
|
||||
|
||||
//*? is type T a POD type (allows cv-qual)
|
||||
template <typename T> struct is_POD
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = is_scalar<cvt>::value || BOOST_IS_POD(cvt);
|
||||
};
|
||||
template <typename T, std::size_t sz> struct is_POD<T[sz]>
|
||||
{ static const bool value = is_POD<T>::value; };
|
||||
|
||||
//
|
||||
// Thanks to Andrei Alexandrescu for the original version of this
|
||||
// conversion class!
|
||||
//
|
||||
// is one type convertable to another?
|
||||
template <class From, class To>
|
||||
struct is_convertible
|
||||
{
|
||||
private:
|
||||
typedef char (&no)[1];
|
||||
typedef char (&yes)[2];
|
||||
// The workarounds for Borland and GNU C++ break the EDG C++ frontend,
|
||||
// so we only use them for those compilers.
|
||||
#if defined(__GNUC__)
|
||||
struct accept_any {
|
||||
template <class T> accept_any(const T&);
|
||||
};
|
||||
template <class T>
|
||||
struct checker
|
||||
{
|
||||
// Need two arguments in the check functions to bias resolution
|
||||
// towards the "yes" in the case when the From type has an implicit
|
||||
// conversion operator defined for the To type, which would
|
||||
// otherwise be an ambiguous situation.
|
||||
static no check(accept_any, accept_any);
|
||||
static yes check(T, From);
|
||||
};
|
||||
static From from;
|
||||
public:
|
||||
static const bool value =
|
||||
sizeof( checker<To>::check(from, from) ) == sizeof(yes);
|
||||
#elif defined(__BORLANDC__)
|
||||
template <class T>
|
||||
struct checker
|
||||
{
|
||||
static no check(...);
|
||||
static yes check(T);
|
||||
};
|
||||
static From from;
|
||||
public:
|
||||
static const bool value = sizeof( checker<To>::check(from) ) == sizeof(yes);
|
||||
# else // not __BORLANDC__ or __GNUC__
|
||||
static no check(...);
|
||||
static yes check(To);
|
||||
static From from;
|
||||
public:
|
||||
static const bool value = sizeof( check(from) ) == sizeof(yes);
|
||||
# endif
|
||||
void foo(); // avoid warning about all members being private
|
||||
};
|
||||
|
||||
template <class From>
|
||||
struct is_convertible<From, void>
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
template <class To>
|
||||
struct is_convertible<void, To>
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
template <>
|
||||
struct is_convertible<void, void>
|
||||
{
|
||||
static const bool value = true;
|
||||
};
|
||||
//
|
||||
// get the alignment of some arbitrary type:
|
||||
namespace detail{
|
||||
// hack for MWCW:
|
||||
template <class T>
|
||||
class alignment_of_hack
|
||||
{
|
||||
char c;
|
||||
T t;
|
||||
alignment_of_hack();
|
||||
};
|
||||
}
|
||||
template <class T>
|
||||
class alignment_of
|
||||
{
|
||||
public:
|
||||
static const unsigned value = sizeof(detail::alignment_of_hack<T>) - sizeof(T);
|
||||
};
|
||||
//
|
||||
// references have to be treated specially, assume
|
||||
// that a reference is just a special pointer:
|
||||
template <class T>
|
||||
class alignment_of<T&>
|
||||
{
|
||||
public:
|
||||
static const unsigned value = alignment_of<T*>::value;
|
||||
};
|
||||
|
||||
//
|
||||
// JM 7Jan2000
|
||||
//
|
||||
namespace detail{
|
||||
template <typename T, bool b, bool b2>
|
||||
struct empty_helper{ static const bool value = false; };
|
||||
|
||||
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]; };
|
||||
|
||||
template <typename T>
|
||||
struct empty_helper<T, true, false>
|
||||
{
|
||||
static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2));
|
||||
};
|
||||
}
|
||||
|
||||
//*? is type T an empty composite type (allows cv-qual)
|
||||
template <typename T> struct is_empty
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
#ifdef __GNUC__
|
||||
// is_convertible gives a warning for g++
|
||||
static const bool value = ::boost::detail::empty_helper<T, is_class<T>::value , false>::value
|
||||
|| BOOST_IS_EMPTY(cvt);
|
||||
|
||||
#else
|
||||
static const bool value = ::boost::detail::empty_helper<T, is_class<T>::value , is_convertible<T,int>::value>::value
|
||||
|| BOOST_IS_EMPTY(cvt);
|
||||
#endif
|
||||
};
|
||||
|
||||
//*? T has trivial default constructor (allows cv-qual)
|
||||
template <typename T> struct has_trivial_constructor
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = is_POD<T>::value
|
||||
|| BOOST_HAS_TRIVIAL_CONSTRUCTOR(cvt);
|
||||
};
|
||||
|
||||
//*? T has trivial copy constructor (allows cv-qual)
|
||||
template <typename T> struct has_trivial_copy
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = is_POD<T>::value
|
||||
|| BOOST_HAS_TRIVIAL_COPY(cvt);
|
||||
};
|
||||
|
||||
//*? T has trivial assignment operator (allows cv-qual)
|
||||
template <typename T>
|
||||
struct has_trivial_assign
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = is_POD<T>::value
|
||||
|| BOOST_HAS_TRIVIAL_ASSIGN(cvt);
|
||||
};
|
||||
|
||||
//*? T has trivial destructor (allows cv-qual)
|
||||
template <typename T>
|
||||
struct has_trivial_destructor
|
||||
{
|
||||
private:
|
||||
typedef typename remove_cv<T>::type cvt;
|
||||
public:
|
||||
static const bool value = is_POD<T>::value
|
||||
|| BOOST_HAS_TRIVIAL_DESTRUCTOR(cvt);
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
/**************************************************************************/
|
||||
|
||||
//
|
||||
// undefine helper macro's:
|
||||
//
|
||||
#undef BOOST_IS_CLASS
|
||||
#undef BOOST_IS_ENUM
|
||||
#undef BOOST_IS_UNION
|
||||
#undef BOOST_IS_POD
|
||||
#undef BOOST_IS_EMPTY
|
||||
#undef BOOST_HAS_TRIVIAL_CONSTRUCTOR
|
||||
#undef BOOST_HAS_TRIVIAL_COPY
|
||||
#undef BOOST_HAS_TRIVIAL_ASSIGN
|
||||
#undef BOOST_HAS_TRIVIAL_DESTRUCTOR
|
||||
|
||||
#endif // BOOST_DETAIL_TYPE_TRAITS_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -11,6 +11,7 @@
|
||||
#define BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
|
||||
|
||||
#include "boost/type_traits/is_reference.hpp"
|
||||
#include "boost/detail/workaround.hpp"
|
||||
#include "boost/config.hpp"
|
||||
|
||||
// should be the last #include
|
||||
@ -76,6 +77,12 @@ BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const volatile,void const
|
||||
|
||||
BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_reference,T,typename detail::add_reference_impl<T>::type)
|
||||
|
||||
// agurt, 07/mar/03: workaround Borland's ill-formed sensitivity to an additional
|
||||
// level of indirection, here
|
||||
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561))
|
||||
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&)
|
||||
#endif
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#include "boost/type_traits/detail/type_trait_undef.hpp"
|
||||
|
||||
@ -33,291 +33,291 @@ struct is_mem_fun_pointer_impl
|
||||
#if !defined(BOOST_TT_PREPROCESSING_MODE)
|
||||
// preprocessor-generated part, don't edit by hand!
|
||||
|
||||
template <class R,class T>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)()> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)() const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)() volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)() const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T >
|
||||
struct is_mem_fun_pointer_impl<R (T::*)() > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T >
|
||||
struct is_mem_fun_pointer_impl<R (T::*)() const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T >
|
||||
struct is_mem_fun_pointer_impl<R (T::*)() volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T >
|
||||
struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24)> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) const> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
template <class R,class T,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) const volatile> { BOOST_STATIC_CONSTANT(bool,value = true); };
|
||||
#endif // __MWERKS__ < 0x3000
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
@ -341,8 +341,8 @@ struct is_mem_fun_pointer_impl<R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T1
|
||||
template <class R, class T BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T)>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(i,T)) > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
|
||||
// Metrowerks thinks this creates ambiguities
|
||||
//: #if !defined(__MWERKS__) || __MWERKS__ >= 0x3000
|
||||
// Metrowerks and Visual Age think this creates ambiguities
|
||||
//: #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600))
|
||||
template <class R, class T BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T)>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(i,T)) const > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
|
||||
@ -351,7 +351,7 @@ struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(i,T)) volatile > {
|
||||
|
||||
template <class R, class T BOOST_PP_COMMA_IF(i) BOOST_PP_ENUM_PARAMS(i,class T)>
|
||||
struct is_mem_fun_pointer_impl<R (T::*)(BOOST_PP_ENUM_PARAMS(i,T)) const volatile > { BOOST_STATIC_CONSTANT(bool, value = true); };
|
||||
//: #endif // __MWERKS__ < 0x3000
|
||||
//: #endif
|
||||
|
||||
|
||||
#undef i
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
// no include guards, the header is intended for multiple inclusion!
|
||||
|
||||
#include "boost/type_traits/detail/template_arity_spec.hpp"
|
||||
#include "boost/mpl/size_t_c.hpp"
|
||||
#include "boost/mpl/size_t.hpp"
|
||||
#include "boost/mpl/aux_/lambda_support.hpp"
|
||||
|
||||
#include <cstddef>
|
||||
@ -26,7 +26,7 @@
|
||||
# define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/
|
||||
#else
|
||||
# define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
|
||||
typedef mpl::size_t_c< C > base_; \
|
||||
typedef mpl::size_t< C > base_; \
|
||||
using base_::value; \
|
||||
/**/
|
||||
#endif
|
||||
@ -34,7 +34,7 @@
|
||||
|
||||
#define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) \
|
||||
template< typename T > struct trait \
|
||||
: mpl::size_t_c< C > \
|
||||
: mpl::size_t< C > \
|
||||
{ \
|
||||
BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
|
||||
@ -45,7 +45,7 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
|
||||
|
||||
#define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) \
|
||||
template<> struct trait<spec> \
|
||||
: mpl::size_t_c< C > \
|
||||
: mpl::size_t< C > \
|
||||
{ \
|
||||
BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
|
||||
@ -54,7 +54,7 @@ template<> struct trait<spec> \
|
||||
|
||||
#define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) \
|
||||
template< param > struct trait<spec> \
|
||||
: mpl::size_t_c< C > \
|
||||
: mpl::size_t< C > \
|
||||
{ \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
|
||||
// (C) Copyright Rani Sharoni 2002.
|
||||
// (C) Copyright Rani Sharoni 2003.
|
||||
// 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
|
||||
@ -24,65 +24,85 @@ namespace boost {
|
||||
|
||||
namespace detail {
|
||||
|
||||
#if !defined(__BORLANDC__)
|
||||
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)) \
|
||||
&& !BOOST_WORKAROUND(__SUNPRO_CC , BOOST_TESTED_AT(0x540)) \
|
||||
&& !BOOST_WORKAROUND(__EDG_VERSION__, <= 243)
|
||||
// The EDG version number is a lower estimate.
|
||||
// It is not currently known which EDG version
|
||||
// exactly fixes the problem.
|
||||
|
||||
/*************************************************************************
|
||||
|
||||
This version detects ambiguous base classes and private base classes
|
||||
correctly, and was devised by Rani Sharoni.
|
||||
|
||||
The following explanation is by Terje Slettebo:
|
||||
Explanation by Terje Sletteb<EFBFBD> and Rani Sharoni.
|
||||
|
||||
Let's take the multiple base class below as an example, and the
|
||||
following will also show why there's not a problem with ambiguous base
|
||||
Let's take the multiple base class below as an example, and the following
|
||||
will also show why there's not a problem with private or ambiguous base
|
||||
class:
|
||||
|
||||
struct B {};
|
||||
struct B1 : B {};
|
||||
struct B2 : B {};
|
||||
struct D : B1, private B2 {};
|
||||
struct D : private B1, private B2 {};
|
||||
|
||||
typedef char Test[is_base_and_derived<B, D>::result]; // improvement 1 -
|
||||
multiple base
|
||||
is_base_and_derived<B, D>::value;
|
||||
|
||||
First, some terminology:
|
||||
|
||||
We have several possible conversion sequences:
|
||||
SC - Standard conversion
|
||||
UDC - User-defined conversion
|
||||
|
||||
For "static no check(B const volatile *, int)" we have the conversion
|
||||
A user-defined conversion sequence consists of an SC, followed by an UDC,
|
||||
followed by another SC. Either SC may be the identity conversion.
|
||||
|
||||
When passing the default-constructed Host object to the overloaded check()
|
||||
functions (initialization 8.5/14/4/3), we have several viable implicit
|
||||
conversion sequences:
|
||||
|
||||
For "static no_type check(B const volatile *, int)" we have the conversion
|
||||
sequences:
|
||||
C -> C const -> B*
|
||||
and
|
||||
C -> D* -> B1*|B2* -> B*
|
||||
|
||||
For "static yes check(D const volatile *, T)" we have the conversion
|
||||
C -> C const (SC - Qualification Adjustment) -> B const volatile* (UDC)
|
||||
C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* ->
|
||||
B const volatile* (SC - Conversion)
|
||||
|
||||
For "static yes_type check(D const volatile *, T)" we have the conversion
|
||||
sequence:
|
||||
C -> D*
|
||||
|
||||
Since, for the purpose of selecting the appropriate user-defined conversion
|
||||
for a given function, it only considers up to the user-defined conversion,
|
||||
for the first function this means choosing between C -> C const and C -> C,
|
||||
and it chooses the latter. Therefore, we have:
|
||||
C -> D const volatile* (UDC)
|
||||
|
||||
C -> D* -> B1*|B2* -> B*
|
||||
C -> D*
|
||||
According to 13.3.3.1/4, in context of user-defined conversion only the
|
||||
standard conversion sequence is considered when selecting the best viable
|
||||
function, so it only considers up to the user-defined conversion. For the
|
||||
first function this means choosing between C -> C const and C -> C, and it
|
||||
chooses the latter, because it's a proper subset (13.3.3.2/3/2) of the
|
||||
former. Therefore, we have:
|
||||
|
||||
Here, the principle of the "shortest subsequence" applies, and it chooses
|
||||
C -> D*. This shows that it doesn't even need to consider the multiple paths
|
||||
to B, as that possibility is eliminated before it could possibly cause
|
||||
ambiguity. Nifty. :)
|
||||
C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* ->
|
||||
B const volatile* (SC - Conversion)
|
||||
C -> D const volatile* (UDC)
|
||||
|
||||
As Daveed notes in the posting Rani gives a link to in the clc++m posting,
|
||||
if D is not derived from B, it has to choose between C -> C const -> B* for
|
||||
the first function, and C -> D* for the second function, which are just as
|
||||
good, _had it not been for the fact that "static no check(B const volatile
|
||||
&, int)" is not templated (as Rani points out in the posting)_, which makes
|
||||
C -> C const -> B* the best choice, resulting in "no".
|
||||
Here, the principle of the "shortest subsequence" applies again, and it
|
||||
chooses C -> D const volatile*. This shows that it doesn't even need to
|
||||
consider the multiple paths to B, or accessibility, as that possibility is
|
||||
eliminated before it could possibly cause ambiguity or access violation.
|
||||
|
||||
Also, if C::operator B* hadn't been const, the two conversion sequences for
|
||||
"static no check(B const volatile *, int)" would have been ambiguous.
|
||||
If D is not derived from B, it has to choose between C -> C const -> B const
|
||||
volatile* for the first function, and C -> D const volatile* for the second
|
||||
function, which are just as good (both requires a UDC, 13.3.3.2), had it not
|
||||
been for the fact that "static no_type check(B const volatile *, int)" is
|
||||
not templated, which makes C -> C const -> B const volatile* the best choice
|
||||
(13.3.3/1/4), resulting in "no".
|
||||
|
||||
See also http://groups.google.com/groups?selm=df893da6.0301280859.522081f7%40posting.google.com
|
||||
and links therein.
|
||||
Also, if Host::operator B const volatile* hadn't been const, the two
|
||||
conversion sequences for "static no_type check(B const volatile *, int)", in
|
||||
the case where D is derived from B, would have been ambiguous.
|
||||
|
||||
See also
|
||||
http://groups.google.com/groups?selm=df893da6.0301280859.522081f7%40posting.
|
||||
google.com and links therein.
|
||||
|
||||
*************************************************************************/
|
||||
|
||||
@ -185,5 +205,3 @@ BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_a
|
||||
#include "boost/type_traits/detail/bool_trait_undef.hpp"
|
||||
|
||||
#endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED
|
||||
|
||||
|
||||
|
||||
@ -128,7 +128,7 @@ struct is_convertible_basic_impl
|
||||
== sizeof(::boost::type_traits::yes_type);
|
||||
};
|
||||
|
||||
#elif (defined(BOOST_MSVC) && (BOOST_MSVC >= 1310) && _MSC_FULL_VER > 13102292) \
|
||||
#elif (defined(BOOST_MSVC) && (BOOST_MSVC > 1310)) \
|
||||
|| (defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 245) && !defined(__ICL))
|
||||
//
|
||||
// This is *almost* an ideal world implementation as it doesn't rely
|
||||
|
||||
@ -10,6 +10,7 @@
|
||||
#include <boost/type_traits/remove_cv.hpp>
|
||||
// should be the last #include
|
||||
#include "boost/type_traits/detail/bool_trait_def.hpp"
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
namespace boost{
|
||||
namespace detail{
|
||||
@ -17,25 +18,29 @@ namespace detail{
|
||||
template <class T>
|
||||
struct is_polymorphic_imp1
|
||||
{
|
||||
# if BOOST_WORKAROUND(__MWERKS__, <= 0x2407) // CWPro7 should return false always.
|
||||
typedef char d1, (&d2)[2];
|
||||
# else
|
||||
typedef typename remove_cv<T>::type ncvT;
|
||||
struct d1 : public ncvT
|
||||
{
|
||||
d1();
|
||||
# if !defined(__GNUC__) // this raises warnings with some classes, and buys nothing with GCC
|
||||
# if !defined(__GNUC__) // this raises warnings with some classes, and buys nothing with GCC
|
||||
~d1()throw();
|
||||
# endif
|
||||
# endif
|
||||
char padding[256];
|
||||
};
|
||||
struct d2 : public ncvT
|
||||
{
|
||||
d2();
|
||||
virtual ~d2()throw();
|
||||
#ifndef BOOST_MSVC
|
||||
# ifndef BOOST_MSVC
|
||||
// for some reason this messes up VC++ when T has virtual bases:
|
||||
virtual void foo();
|
||||
#endif
|
||||
# endif
|
||||
char padding[256];
|
||||
};
|
||||
# endif
|
||||
BOOST_STATIC_CONSTANT(bool, value = (sizeof(d2) == sizeof(d1)));
|
||||
};
|
||||
|
||||
|
||||
11
index.htm
11
index.htm
@ -5,7 +5,7 @@
|
||||
content="text/html; charset=iso-8859-1">
|
||||
<meta name="Template"
|
||||
content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
|
||||
<title>Type Traits</title>
|
||||
</head>
|
||||
|
||||
@ -198,7 +198,7 @@ template instead.</p>
|
||||
<td valign="top" width="25%" bgcolor="#C0C0C0">Without (some
|
||||
as yet unspecified) help from the compiler, we cannot
|
||||
distinguish between union and class types, as a result
|
||||
this expression will eroneously evaluate to true for
|
||||
this expression will erroneously evaluate to true for
|
||||
union types.</td>
|
||||
<td valign="top" width="5%"> </td>
|
||||
</tr>
|
||||
@ -428,14 +428,13 @@ has.</p>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top" width="5%"> </td>
|
||||
<td valign="top" width="23%" bgcolor="#C0C0C0"><font
|
||||
face="Courier New">::boost::is_polymorphic<T>::value</font></td>
|
||||
<td valign="top" width="23%" bgcolor="#C0C0C0"><code>::boost::is_polymorphic<T>::value</code></td>
|
||||
<td valign="top" width="28%" bgcolor="#C0C0C0">Evaluates
|
||||
to true only if T is a polymorphic type.</td>
|
||||
<td valign="top" width="13%" bgcolor="#C0C0C0">10.3</td>
|
||||
<td valign="top" width="25%" bgcolor="#C0C0C0">Requires
|
||||
knowledge of the compilers ABI, does actually seem to
|
||||
work with the magority of compilers though.</td>
|
||||
work with the majority of compilers though.</td>
|
||||
<td valign="top" width="5%"> </td>
|
||||
</tr>
|
||||
<tr>
|
||||
@ -1302,4 +1301,4 @@ href="http://www.boost.org/">www.boost.org</a>, and the boost
|
||||
discussion list at <a href="mailto:boost@lists.boost.org">boost@lists.boost.org</a>
|
||||
(see <a href="http://www.boost.org/more/mailing_lists.htm#main">http://www.boost.org/more/mailing_lists.htm#main</a>).</p>
|
||||
</body>
|
||||
</html>
|
||||
</html>
|
||||
Reference in New Issue
Block a user