feedc0de/boost_type_traits
1
0
Fork 0
forked from boostorg/type_traits
Code Pull Requests Activity

TypeTraits: Remove obsolete MSVC version checks.

Browse Source 
[SVN r85919]
This commit is contained in:
Stephen Kelly
2013-09-25 21:15:34 +00:00
parent dc676dc982
commit 81918230c6
30 changed files with 12 additions and 885 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/boost/type_traits/config.hpp
View File

@ -27,7 +27,6 @@
#endif
# if (BOOST_WORKAROUND(__MWERKS__, < 0x3000) \
|| BOOST_WORKAROUND(BOOST_MSVC, <= 1301) \
|| !defined(__EDG_VERSION__) && BOOST_WORKAROUND(__GNUC__, < 3) \
|| BOOST_WORKAROUND(__IBMCPP__, < 600 ) \
|| BOOST_WORKAROUND(__BORLANDC__, < 0x5A0) \

8
include/boost/type_traits/detail/bool_trait_def.hpp
View File

@ -45,14 +45,6 @@
enum { value = type::value }; \
/**/
# define BOOST_TT_AUX_BOOL_C_BASE(C)
#elif defined(BOOST_MSVC) && BOOST_MSVC < 1300
# define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
typedef ::boost::integral_constant<bool,C> base_; \
using base_::value; \
/**/
#endif
#ifndef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL

4
include/boost/type_traits/extent.hpp
View File

@ -131,10 +131,6 @@ template <class T, std::size_t N = 0>
struct extent
: public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
{
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
typedef ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value> base_;
using base_::value;
#endif
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,extent,(T))
};

14
include/boost/type_traits/integral_constant.hpp Executable file → Normal file
View File

@ -24,24 +24,10 @@ struct integral_constant : public mpl::integral_c<T, val>
template<> struct integral_constant<bool,true> : public mpl::true_
{
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
# pragma warning(push)
# pragma warning(disable:4097)
typedef mpl::true_ base_;
using base_::value;
# pragma warning(pop)
#endif
typedef integral_constant<bool,true> type;
};
template<> struct integral_constant<bool,false> : public mpl::false_
{
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
# pragma warning(push)
# pragma warning(disable:4097)
typedef mpl::false_ base_;
using base_::value;
# pragma warning(pop)
#endif
typedef integral_constant<bool,false> type;
};

3
include/boost/type_traits/integral_promotion.hpp
View File

@ -43,8 +43,7 @@ template<> struct need_promotion<unsigned short int> : public true_type {};
// Same set of integral types as in boost/type_traits/is_integral.hpp.
// Please, keep in sync.
#if (defined(BOOST_MSVC) && (BOOST_MSVC < 1300)) \
|| (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
|| (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300))
// TODO: common macro for this #if. Or better yet, PP SEQ of non-standard types.
BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(__int8 )

39
include/boost/type_traits/is_convertible.hpp
View File

@ -52,44 +52,7 @@ namespace boost {
namespace detail {
// MS specific version:
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
// This workaround is necessary to handle when From is void
// which is normally taken care of by the partial specialization
// of the is_convertible typename.
using ::boost::type_traits::yes_type;
using ::boost::type_traits::no_type;
template< typename From >
struct does_conversion_exist
{
template< typename To > struct result_
{
static no_type BOOST_TT_DECL _m_check(...);
static yes_type BOOST_TT_DECL _m_check(To);
static typename add_lvalue_reference<From>::type _m_from;
enum { value = sizeof( _m_check(_m_from) ) == sizeof(yes_type) };
};
};
template<>
struct does_conversion_exist<void>
{
template< typename To > struct result_
{
enum { value = ::boost::is_void<To>::value };
};
};
template <typename From, typename To>
struct is_convertible_basic_impl
: public does_conversion_exist<From>::template result_<To>
{
};
#elif defined(__BORLANDC__) && (__BORLANDC__ < 0x560)
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x560)
//
// special version for Borland compilers
// this version breaks when used for some

5
include/boost/type_traits/is_enum.hpp
View File

@ -55,13 +55,12 @@ struct is_class_or_union
template <typename T>
struct is_class_or_union
{
# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))// we simply can't detect it this way.
# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))// we simply can't detect it this way.
BOOST_STATIC_CONSTANT(bool, value = false);
# else
template <class U> static ::boost::type_traits::yes_type is_class_or_union_tester(void(U::*)(void));
# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) \
|| BOOST_WORKAROUND(__MWERKS__, <= 0x3000) // no SFINAE
# if BOOST_WORKAROUND(__MWERKS__, <= 0x3000) // no SFINAE
static ::boost::type_traits::no_type is_class_or_union_tester(...);
BOOST_STATIC_CONSTANT(
bool, value = sizeof(is_class_or_union_tester(0)) == sizeof(::boost::type_traits::yes_type));

3
include/boost/type_traits/is_integral.hpp
View File

@ -46,8 +46,7 @@ BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,wchar_t,true)
// Same set of integral types as in boost/type_traits/integral_promotion.hpp.
// Please, keep in sync. -- Alexander Nasonov
#if (defined(BOOST_MSVC) && (BOOST_MSVC < 1300)) \
|| (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
#if (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \
|| (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER < 1300))
BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int8,true)
BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int8,true)

13
include/boost/type_traits/is_pointer.hpp
View File

@ -25,9 +25,7 @@
#include <boost/type_traits/detail/ice_and.hpp>
#include <boost/type_traits/detail/ice_not.hpp>
#include <boost/type_traits/config.hpp>
#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#include <boost/type_traits/remove_cv.hpp>
#endif
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
# include <boost/type_traits/is_reference.hpp>
@ -67,16 +65,6 @@ TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(is_pointer_helper,T*,true)
template< typename T >
struct is_pointer_impl
{
#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::detail::is_pointer_helper<T>::value
, ::boost::type_traits::ice_not<
::boost::is_member_pointer<T>::value
>::value
>::value)
);
#else
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value
@ -85,7 +73,6 @@ struct is_pointer_impl
>::value
>::value)
);
#endif
};
} // namespace detail

4
include/boost/type_traits/is_signed.hpp
View File

@ -76,11 +76,7 @@ struct is_signed_imp
> selector;
typedef typename selector::template rebind<T> binder;
typedef typename binder::type type;
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
BOOST_STATIC_CONSTANT(bool, value = is_signed_imp<T>::type::value);
#else
BOOST_STATIC_CONSTANT(bool, value = type::value);
#endif
};
#else

2
include/boost/type_traits/make_signed.hpp
View File

@ -37,11 +37,9 @@ struct make_signed_imp
{
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value));
#if !BOOST_WORKAROUND(BOOST_MSVC, <=1300)
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_not< ::boost::is_same<
typename remove_cv<T>::type, bool>::value>::value));
#endif
typedef typename remove_cv<T>::type t_no_cv;
typedef typename mpl::if_c<

2
include/boost/type_traits/make_unsigned.hpp
View File

@ -37,11 +37,9 @@ struct make_unsigned_imp
{
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value));
#if !BOOST_WORKAROUND(BOOST_MSVC, <=1300)
BOOST_STATIC_ASSERT(
(::boost::type_traits::ice_not< ::boost::is_same<
typename remove_cv<T>::type, bool>::value>::value));
#endif
typedef typename remove_cv<T>::type t_no_cv;
typedef typename mpl::if_c<

47
include/boost/type_traits/msvc/remove_all_extents.hpp
View File

@ -1,47 +0,0 @@
// Copyright (C) 2004 Peder Holt
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_ALL_EXTENT_HOLT_2004_0827
#define BOOST_TYPE_TRAITS_MSVC_REMOVE_ALL_EXTENT_HOLT_2004_0827
#include <boost/type_traits/msvc/typeof.hpp>
#include <boost/type_traits/is_array.hpp>
namespace boost {
template<typename T>
struct remove_all_extents;
namespace detail {
template<bool IsArray>
struct remove_all_extents_impl_typeof {
template<typename T,typename ID>
struct inner {
typedef T type;
};
};
template<>
struct remove_all_extents_impl_typeof<true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(U[]);
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type reduced_type;
typedef typename remove_all_extents<reduced_type>::type type;
};
};
} //namespace detail
template<typename T>
struct remove_all_extents {
typedef typename boost::detail::remove_all_extents_impl_typeof<
boost::is_array<T>::value
>::template inner<T,remove_all_extents<T> >::type type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_all_extents,T)
};
} //namespace boost
#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827

43
include/boost/type_traits/msvc/remove_bounds.hpp
View File

@ -1,43 +0,0 @@
// Copyright (C) 2004 Peder Holt
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827
#define BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827
#include <boost/type_traits/msvc/typeof.hpp>
#include <boost/type_traits/is_array.hpp>
namespace boost {
namespace detail {
template<bool IsArray>
struct remove_bounds_impl_typeof {
template<typename T,typename ID>
struct inner {
typedef T type;
};
};
template<>
struct remove_bounds_impl_typeof<true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(U[]);
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
};
} //namespace detail
template<typename T>
struct remove_bounds {
typedef typename boost::detail::remove_bounds_impl_typeof<
boost::is_array<T>::value
>::template inner<T,remove_bounds<T> >::type type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_bounds,T)
};
} //namespace boost
#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827

143
include/boost/type_traits/msvc/remove_const.hpp
View File

@ -1,143 +0,0 @@
// Copyright (C) 2004 Peder Holt
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_CONST_HOLT_2004_0828
#define BOOST_TYPE_TRAITS_MSVC_REMOVE_CONST_HOLT_2004_0828
#include <boost/type_traits/msvc/typeof.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_array.hpp>
namespace boost {
namespace detail {
template<bool IsPointer,bool IsArray,bool IsConst,bool IsVolatile>
struct remove_const_impl_typeof {
template<typename T,typename ID>
struct inner {
typedef T type;
};
template<typename T>
struct transform_type {
typedef T type;
};
};
template<> //Const
struct remove_const_impl_typeof<false,false,true,false> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(U const&(*)());
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T& type;
};
};
template<> //CV
struct remove_const_impl_typeof<false,false,true,true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U volatile,ID> test(U const volatile&(*)());
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T& type;
};
};
template<> //Const Pointer
struct remove_const_impl_typeof<true,false,true,false> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(void(*)(U const[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type[];
};
};
template<> //CV Pointer
struct remove_const_impl_typeof<true,false,true,true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U volatile,ID> test(void(*)(U const volatile[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type[];
};
};
template<> //Const Array
struct remove_const_impl_typeof<false,true,true,false> {
template<typename T,typename ID>
struct inner {
BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
template<typename U>
static msvc_register_type<U[value],ID> test(void(*)(U const[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type;
};
};
template<> //CV Array
struct remove_const_impl_typeof<false,true,true,true> {
template<typename T,typename ID>
struct inner {
BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
template<typename U>
static msvc_register_type<U volatile[value],ID> test(void(*)(U const volatile[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type;
};
};
} //namespace detail
template<typename T>
struct remove_const {
typedef boost::detail::remove_const_impl_typeof<
boost::is_pointer<T>::value,
boost::is_array<T>::value,
boost::is_const<T>::value,
boost::is_volatile<T>::value
> remove_const_type;
typedef typename
remove_const_type::template inner<
typename remove_const_type::template transform_type<T>::type,
remove_const<T>
>::type
type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_const,T)
};
}//namespace boost
#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_CONST_HOLT_2004_0828

190
include/boost/type_traits/msvc/remove_cv.hpp
View File

@ -1,190 +0,0 @@
// Copyright (C) 2004 Peder Holt
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_CV_HOLT_2004_0901
#define BOOST_TYPE_TRAITS_MSVC_REMOVE_CV_HOLT_2004_0901
#include <boost/type_traits/msvc/typeof.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_array.hpp>
namespace boost {
namespace detail {
template<bool IsPointer,bool IsArray,bool IsConst,bool IsVolatile>
struct remove_cv_impl_typeof {
template<typename T,typename ID>
struct inner {
typedef T type;
};
template<typename T>
struct transform_type {
typedef T type;
};
};
template<> //Volatile
struct remove_cv_impl_typeof<false,false,false,true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(U volatile&(*)());
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T& type;
};
};
template<> //Const
struct remove_cv_impl_typeof<false,false,true,false> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(U const&(*)());
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T& type;
};
};
template<> //CV
struct remove_cv_impl_typeof<false,false,true,true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(U const volatile&(*)());
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T& type;
};
};
template<> //Volatile Pointer
struct remove_cv_impl_typeof<true,false,false,true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(void(*)(U volatile[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type[];
};
};
template<> //Const Pointer
struct remove_cv_impl_typeof<true,false,true,false> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(void(*)(U const[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type[];
};
};
template<> //CV Pointer
struct remove_cv_impl_typeof<true,false,true,true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(void(*)(U const volatile[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type[];
};
};
template<> //Volatile Array
struct remove_cv_impl_typeof<false,true,false,true> {
template<typename T,typename ID>
struct inner {
BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
template<typename U>
static msvc_register_type<U[value],ID> test(void(*)(U volatile[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type;
};
};
template<> //Const Array
struct remove_cv_impl_typeof<false,true,true,false> {
template<typename T,typename ID>
struct inner {
BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
template<typename U>
static msvc_register_type<U[value],ID> test(void(*)(U const[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type;
};
};
template<> //CV Array
struct remove_cv_impl_typeof<false,true,true,true> {
template<typename T,typename ID>
struct inner {
BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
template<typename U>
static msvc_register_type<U[value],ID> test(void(*)(U const volatile[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type;
};
};
} //namespace detail
template<typename T>
struct remove_cv {
typedef boost::detail::remove_cv_impl_typeof<
boost::is_pointer<T>::value,
boost::is_array<T>::value,
boost::is_const<T>::value,
boost::is_volatile<T>::value
> remove_cv_type;
typedef typename
remove_cv_type::template inner<
typename remove_cv_type::template transform_type<T>::type,
remove_cv<T>
>::type
type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_cv,T)
};
}//namespace boost
#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_CV_HOLT_2004_0901

43
include/boost/type_traits/msvc/remove_extent.hpp
View File

@ -1,43 +0,0 @@
// Copyright (C) 2004 Peder Holt
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_EXTENT_HOLT_2004_0827
#define BOOST_TYPE_TRAITS_MSVC_REMOVE_EXTENT_HOLT_2004_0827
#include <boost/type_traits/msvc/typeof.hpp>
#include <boost/type_traits/is_array.hpp>
namespace boost {
namespace detail {
template<bool IsArray>
struct remove_extent_impl_typeof {
template<typename T,typename ID>
struct inner {
typedef T type;
};
};
template<>
struct remove_extent_impl_typeof<true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(U[]);
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
};
} //namespace detail
template<typename T>
struct remove_extent {
typedef typename boost::detail::remove_extent_impl_typeof<
boost::is_array<T>::value
>::template inner<T,remove_extent<T> >::type type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_extent,T)
};
} //namespace boost
#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_BOUNDS_HOLT_2004_0827

42
include/boost/type_traits/msvc/remove_pointer.hpp
View File

@ -1,42 +0,0 @@
// Copyright (C) 2004 Peder Holt
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_POINTER_HOLT_2004_0827
#define BOOST_TYPE_TRAITS_MSVC_REMOVE_POINTER_HOLT_2004_0827
#include <boost/type_traits/msvc/typeof.hpp>
#include <boost/type_traits/is_pointer.hpp>
namespace boost {
namespace detail {
template<int IsPointer>
struct remove_pointer_impl_typeof {
template<typename T,typename ID>
struct inner {
typedef T type;
};
};
template<>
struct remove_pointer_impl_typeof<true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(U*);
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( *((T*)NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
};
} //namespace detail
template<typename T>
struct remove_pointer {
typedef typename boost::detail::remove_pointer_impl_typeof<
boost::is_pointer<T>::value
>::template inner<T,remove_pointer<T> >::type type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_pointer,T)
};
} //namespace boost
#endif //BOOST_TYPE_TRAITS_REMOVE_POINTER_HOLT_2004_0827

42
include/boost/type_traits/msvc/remove_reference.hpp
View File

@ -1,42 +0,0 @@
// Copyright (C) 2004 Peder Holt
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_REFERENCE_HOLT_2004_0827
#define BOOST_TYPE_TRAITS_MSVC_REMOVE_REFERENCE_HOLT_2004_0827
#include <boost/type_traits/msvc/typeof.hpp>
#include <boost/type_traits/is_reference.hpp>
namespace boost {
namespace detail {
template<bool IsReference>
struct remove_reference_impl_typeof {
template<typename T,typename ID>
struct inner {
typedef T type;
};
};
template<>
struct remove_reference_impl_typeof<true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(U&(*)());
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
};
} //namespace detail
template<typename T>
struct remove_reference {
typedef typename boost::detail::remove_reference_impl_typeof<
boost::is_reference<T>::value
>::template inner<T,remove_reference<T> >::type type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_reference,T)
};
} //namespace boost
#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_REFERENCE_HOLT_2004_0827

143
include/boost/type_traits/msvc/remove_volatile.hpp
View File

@ -1,143 +0,0 @@
// Copyright (C) 2004 Peder Holt
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_TYPE_TRAITS_MSVC_REMOVE_VOLATILE_HOLT_2004_0828
#define BOOST_TYPE_TRAITS_MSVC_REMOVE_VOLATILE_HOLT_2004_0828
#include <boost/type_traits/msvc/typeof.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_array.hpp>
namespace boost {
namespace detail {
template<bool IsPointer,bool IsArray,bool IsConst,bool IsVolatile>
struct remove_volatile_impl_typeof {
template<typename T,typename ID>
struct inner {
typedef T type;
};
template<typename T>
struct transform_type {
typedef T type;
};
};
template<> //Volatile
struct remove_volatile_impl_typeof<false,false,false,true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(U volatile&(*)());
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T& type;
};
};
template<> //CV
struct remove_volatile_impl_typeof<false,false,true,true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U const,ID> test(U const volatile&(*)());
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (T(*)())(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T& type;
};
};
template<> //Volatile Pointer
struct remove_volatile_impl_typeof<true,false,false,true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U,ID> test(void(*)(U volatile[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type[];
};
};
template<> //CV Pointer
struct remove_volatile_impl_typeof<true,false,true,true> {
template<typename T,typename ID>
struct inner {
template<typename U>
static msvc_register_type<U const,ID> test(void(*)(U const volatile[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type[];
};
};
template<> //Volatile Array
struct remove_volatile_impl_typeof<false,true,false,true> {
template<typename T,typename ID>
struct inner {
BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
template<typename U>
static msvc_register_type<U[value],ID> test(void(*)(U volatile[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type;
};
};
template<> //CV Array
struct remove_volatile_impl_typeof<false,true,true,true> {
template<typename T,typename ID>
struct inner {
BOOST_STATIC_CONSTANT(unsigned,value=(sizeof(T)/sizeof((*((T*)NULL))[0])));
template<typename U>
static msvc_register_type<U const[value],ID> test(void(*)(U const volatile[]));
static msvc_register_type<T,ID> test(...);
BOOST_STATIC_CONSTANT(unsigned,register_test=sizeof(test( (void(*)(T))(NULL) ) ));
typedef typename msvc_extract_type<ID>::id2type::type type;
};
template<typename T>
struct transform_type {
typedef T type;
};
};
} //namespace detail
template<typename T>
struct remove_volatile {
typedef boost::detail::remove_volatile_impl_typeof<
boost::is_pointer<T>::value,
boost::is_array<T>::value,
boost::is_const<T>::value,
boost::is_volatile<T>::value
> remove_volatile_type;
typedef typename
remove_volatile_type::template inner<
typename remove_volatile_type::template transform_type<T>::type,
remove_volatile<T>
>::type
type;
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,remove_volatile,T)
};
}//namespace boost
#endif //BOOST_TYPE_TRAITS_MSVC_REMOVE_VOLATILE_HOLT_2004_0828

50
include/boost/type_traits/msvc/typeof.hpp
View File

@ -1,50 +0,0 @@
// Copyright (C) 2004 Peder Holt
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_TYPETRAITS_MSVC_TYPEOF_HPP
#define BOOST_TYPETRAITS_MSVC_TYPEOF_HPP
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
namespace boost { namespace detail {
# if BOOST_WORKAROUND(BOOST_MSVC,==1300)
template<typename ID>
struct msvc_extract_type
{
template<bool>
struct id2type_impl;
typedef id2type_impl<true> id2type;
};
template<typename T, typename ID>
struct msvc_register_type : public msvc_extract_type<ID>
{
template<>
struct id2type_impl<true> //VC7.0 specific bugfeature
{
typedef T type;
};
};
# else
template<typename ID>
struct msvc_extract_type
{
struct id2type;
};
template<typename T, typename ID>
struct msvc_register_type : public msvc_extract_type<ID>
{
typedef msvc_extract_type<ID> base_type;
struct base_type::id2type // This uses nice VC6.5 and VC7.1 bugfeature
{
typedef T type;
};
};
# endif
}}
#endif //BOOST_TYPETRAITS_MSVC_TYPEOF_IMPL_HPP

8
include/boost/type_traits/remove_all_extents.hpp
View File

@ -13,15 +13,9 @@
#include <cstddef>
#include <boost/detail/workaround.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#include <boost/type_traits/msvc/remove_all_extents.hpp>
#endif
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
namespace boost {
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_all_extents,T,T)
@ -41,8 +35,6 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_all_extents,T const vo
} // namespace boost
#endif
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED

8
include/boost/type_traits/remove_bounds.hpp
View File

@ -13,15 +13,9 @@
#include <cstddef>
#include <boost/detail/workaround.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#include <boost/type_traits/msvc/remove_bounds.hpp>
#endif
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
namespace boost {
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_bounds,T,T)
@ -41,8 +35,6 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T const volatil
} // namespace boost
#endif
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED

6
include/boost/type_traits/remove_const.hpp
View File

@ -19,10 +19,6 @@
#include <cstddef>
#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#include <boost/type_traits/msvc/remove_const.hpp>
#endif
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
@ -77,7 +73,7 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_const,T
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_const,T const volatile[N],T volatile type[N])
#endif
#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#else
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_const,T,typename boost::detail::remove_const_impl<T>::type)

6
include/boost/type_traits/remove_cv.hpp
View File

@ -18,10 +18,6 @@
#include <cstddef>
#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#include <boost/type_traits/msvc/remove_cv.hpp>
#endif
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
@ -61,7 +57,7 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T vol
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T const volatile[N],T type[N])
#endif
#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#else
namespace detail {
template <typename T>

8
include/boost/type_traits/remove_extent.hpp
View File

@ -13,15 +13,9 @@
#include <boost/detail/workaround.hpp>
#include <cstddef>
#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#include <boost/type_traits/msvc/remove_extent.hpp>
#endif
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
#if !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
namespace boost {
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_extent,T,T)
@ -41,8 +35,6 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_extent,T const volatil
} // namespace boost
#endif
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED

6
include/boost/type_traits/remove_pointer.hpp
View File

@ -15,9 +15,7 @@
#include <boost/type_traits/broken_compiler_spec.hpp>
#endif
#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#include <boost/type_traits/msvc/remove_pointer.hpp>
#elif defined(BOOST_MSVC)
#if defined(BOOST_MSVC)
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/is_pointer.hpp>
#endif
@ -79,7 +77,7 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* const,T)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* volatile,T)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* const volatile,T)
#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#else
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,typename boost::detail::remove_pointer_impl<T>::type)

6
include/boost/type_traits/remove_reference.hpp
View File

@ -13,10 +13,6 @@
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#include <boost/type_traits/msvc/remove_reference.hpp>
#endif
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
@ -57,7 +53,7 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& volatile,
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& const volatile,T)
#endif
#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#else
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,typename boost::detail::remove_reference_impl<T>::type)

6
include/boost/type_traits/remove_volatile.hpp
View File

@ -19,10 +19,6 @@
#include <cstddef>
#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#include <boost/type_traits/msvc/remove_volatile.hpp>
#endif
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
@ -75,7 +71,7 @@ BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_volatile
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_volatile,T const volatile[N],T const type[N])
#endif
#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#else
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_volatile,T,typename boost::detail::remove_volatile_impl<T>::type)

2
include/boost/type_traits/type_with_alignment.hpp
View File

@ -248,7 +248,7 @@ BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a64,true)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a128,true)
}
#endif
#if (defined(BOOST_MSVC) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && _MSC_VER >= 1300
#if defined(BOOST_MSVC) || (defined(BOOST_INTEL) && defined(_MSC_VER))
//
// MSVC supports types which have alignments greater than the normal
// maximum: these are used for example in the types __m64 and __m128