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

Fix up type_traits intrinsic support when using the Intel compiler.

Browse Source 
Suppress quite a few Intel-12.0 warnings.

[SVN r70221]
This commit is contained in:
John Maddock
2011-03-20 12:18:59 +00:00
parent 4f873ea632
commit 28631034ca
24 changed files with 86 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -93,7 +93,7 @@ BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(alignment_of,T,::boost::detail::alignment_of_impl
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <typename T>
struct alignment_of<T&>
: alignment_of<T*>
: public alignment_of<T*>
{
};
#endif

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

@ -141,7 +141,7 @@ namespace type_traits_detail {
template <class T, class U>
struct common_type<T, U, void>
#endif
: type_traits_detail::common_type_2<T,U>
: public type_traits_detail::common_type_2<T,U>
{ };

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

@ -60,7 +60,7 @@
#endif
#ifndef BOOST_TT_AUX_BOOL_C_BASE
# define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>
# define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#endif
@ -68,6 +68,7 @@
template< typename T > struct trait \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
}; \
@ -80,6 +81,7 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
template< typename T1, typename T2 > struct trait \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) \
}; \
@ -91,6 +93,7 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait) \
template<> struct trait< sp > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) \
}; \
@ -100,6 +103,7 @@ template<> struct trait< sp > \
template<> struct trait< sp1,sp2 > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \
}; \
@ -108,6 +112,7 @@ template<> struct trait< sp1,sp2 > \
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) \
template<> struct trait##_impl< sp > \
{ \
public:\
BOOST_STATIC_CONSTANT(bool, value = (C)); \
}; \
/**/
@ -115,6 +120,7 @@ template<> struct trait##_impl< sp > \
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) \
template<> struct trait##_impl< sp1,sp2 > \
{ \
public:\
BOOST_STATIC_CONSTANT(bool, value = (C)); \
}; \
/**/
@ -123,6 +129,7 @@ template<> struct trait##_impl< sp1,sp2 > \
template< param > struct trait< sp > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
}; \
/**/
@ -131,6 +138,7 @@ template< param > struct trait< sp > \
template< param1, param2 > struct trait< sp > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
}; \
/**/
@ -139,6 +147,7 @@ template< param1, param2 > struct trait< sp > \
template< param > struct trait< sp1,sp2 > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \
}; \
@ -148,6 +157,7 @@ template< param > struct trait< sp1,sp2 > \
template< param1, param2 > struct trait< sp1,sp2 > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
}; \
/**/
@ -155,6 +165,7 @@ template< param1, param2 > struct trait< sp1,sp2 > \
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \
template< param > struct trait##_impl< sp1,sp2 > \
{ \
public:\
BOOST_STATIC_CONSTANT(bool, value = (C)); \
}; \
/**/

18
include/boost/type_traits/detail/common_type_imp.hpp
View File

@ -80,11 +80,11 @@ struct propagate_cv< const volatile From, To >
template< class T >
struct is_integral_or_enum
: mpl::or_< is_integral<T>, is_enum<T> >
: public mpl::or_< is_integral<T>, is_enum<T> >
{ };
template<>
struct is_integral_or_enum< bool >
: false_type
: public false_type
{ };
/*******************************************************************************
@ -97,7 +97,7 @@ struct is_integral_or_enum< bool >
template< class T >
struct make_unsigned_soft
: make_unsigned<T>
: public make_unsigned<T>
{ };
template<>
struct make_unsigned_soft< bool >
@ -105,7 +105,7 @@ struct make_unsigned_soft< bool >
template< class T >
struct make_signed_soft
: make_signed<T>
: public make_signed<T>
{ };
template<>
struct make_signed_soft< bool >
@ -151,7 +151,7 @@ yes_type rvalue_test(...);
template< class First, class Last, std::size_t Index >
struct conversion_test_overloads_iterate
: conversion_test_overloads_iterate<
: public conversion_test_overloads_iterate<
typename mpl::next< First >::type, Last, Index + 1
>
{
@ -168,7 +168,7 @@ struct conversion_test_overloads_iterate< Last, Last, Index >
template< class Sequence >
struct conversion_test_overloads
: conversion_test_overloads_iterate<
: public conversion_test_overloads_iterate<
typename mpl::begin< Sequence >::type,
typename mpl::end< Sequence >::type,
0
@ -187,7 +187,7 @@ template<
int N = mpl::size< Sequence >::value
>
struct select
: mpl::at_c< Sequence, Index >
: public mpl::at_c< Sequence, Index >
{ };
template< class Sequence, int N >
struct select< Sequence, N, N >
@ -293,7 +293,7 @@ struct nominal_candidates< T, U, V*, W*, false >
template<class T, class U, bool b>
struct common_type_dispatch_on_rvalueness
: deduce_common_type< T, U, typename nominal_candidates<T,U>::type >
: public deduce_common_type< T, U, typename nominal_candidates<T,U>::type >
{ };
template< class T, class U >
@ -316,7 +316,7 @@ public:
template< class T, class U >
struct common_type_impl
: common_type_dispatch_on_rvalueness<T,U, sizeof( ::boost::detail_type_traits_common_type::rvalue_test(
: public common_type_dispatch_on_rvalueness<T,U, sizeof( ::boost::detail_type_traits_common_type::rvalue_test(
declval< bool >() ? declval<T>() : declval<U>() ) ) == sizeof( yes_type ) >
{ };

2
include/boost/type_traits/detail/cv_traits_impl.hpp
View File

@ -77,7 +77,7 @@ namespace detail {
// Use the implementation above for non function pointers
template <typename T, unsigned Select
= (unsigned)sizeof(::boost::type_traits::gcc8503::mini_funcptr_tester((T)0)) >
struct cv_traits_imp : ::boost::type_traits::gcc8503::cv_traits_imp<T> { };
struct cv_traits_imp : public ::boost::type_traits::gcc8503::cv_traits_imp<T> { };
// Functions are never cv-qualified
template <typename T> struct cv_traits_imp<T*,1>

6
include/boost/type_traits/detail/size_t_trait_def.hpp
View File

@ -19,10 +19,10 @@
#include <cstddef>
#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300
# define BOOST_TT_AUX_SIZE_T_BASE(C) ::boost::integral_constant<std::size_t,C>
# define BOOST_TT_AUX_SIZE_T_BASE(C) public ::boost::integral_constant<std::size_t,C>
# define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/
#else
# define BOOST_TT_AUX_SIZE_T_BASE(C) ::boost::mpl::size_t<C>
# define BOOST_TT_AUX_SIZE_T_BASE(C) public ::boost::mpl::size_t<C>
# define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
typedef ::boost::mpl::size_t<C> base_; \
using base_::value; \
@ -34,6 +34,7 @@
template< typename T > struct trait \
: BOOST_TT_AUX_SIZE_T_BASE(C) \
{ \
public:\
BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
}; \
@ -45,6 +46,7 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
template<> struct trait<spec> \
: BOOST_TT_AUX_SIZE_T_BASE(C) \
{ \
public:\
BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
}; \

6
include/boost/type_traits/detail/type_trait_def.hpp
View File

@ -17,6 +17,7 @@
#define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) \
template< typename T > struct trait \
{ \
public:\
typedef result type; \
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
}; \
@ -27,6 +28,7 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
#define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) \
template<> struct trait<spec> \
{ \
public:\
typedef result type; \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
}; \
@ -35,6 +37,7 @@ template<> struct trait<spec> \
#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) \
template<> struct trait##_impl<spec> \
{ \
public:\
typedef result type; \
}; \
/**/
@ -42,6 +45,7 @@ template<> struct trait##_impl<spec> \
#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) \
template< param > struct trait<spec> \
{ \
public:\
typedef result type; \
}; \
/**/
@ -49,6 +53,7 @@ template< param > struct trait<spec> \
#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) \
template< param1, param2 > struct trait<spec> \
{ \
public:\
typedef result; \
}; \
/**/
@ -56,6 +61,7 @@ template< param1, param2 > struct trait<spec> \
#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) \
template< param > struct trait##_impl<spec> \
{ \
public:\
typedef result type; \
}; \
/**/

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

@ -24,14 +24,14 @@ namespace boost {
namespace type_traits { namespace detail {
// 4.5/2
template <class T> struct need_promotion : boost::is_enum<T> {};
template <class T> struct need_promotion : public boost::is_enum<T> {};
// 4.5/1
template<> struct need_promotion<char > : true_type {};
template<> struct need_promotion<signed char > : true_type {};
template<> struct need_promotion<unsigned char > : true_type {};
template<> struct need_promotion<signed short int > : true_type {};
template<> struct need_promotion<unsigned short int> : true_type {};
template<> struct need_promotion<char > : public true_type {};
template<> struct need_promotion<signed char > : public true_type {};
template<> struct need_promotion<unsigned char > : public true_type {};
template<> struct need_promotion<signed short int > : public true_type {};
template<> struct need_promotion<unsigned short int> : public true_type {};
// Specializations for non-standard types.
@ -39,7 +39,7 @@ template<> struct need_promotion<unsigned short int> : true_type {};
#define BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(T) \
template<> struct need_promotion<T> \
: integral_constant<bool, (sizeof(T) < sizeof(int))> {};
: public integral_constant<bool, (sizeof(T) < sizeof(int))> {};
// Same set of integral types as in boost/type_traits/is_integral.hpp.
// Please, keep in sync.
@ -72,13 +72,13 @@ BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE( __int64)
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
// 4.5/2
template<> struct need_promotion<wchar_t> : true_type {};
template<> struct need_promotion<wchar_t> : public true_type {};
#endif
// 4.5/3 (integral bit-field) is not supported.
// 4.5/4
template<> struct need_promotion<bool> : true_type {};
template<> struct need_promotion<bool> : public true_type {};
// Get promoted type by index and cv qualifiers.
@ -171,7 +171,7 @@ struct integral_promotion_impl
template<class T>
struct integral_promotion
: boost::mpl::eval_if<
: public boost::mpl::eval_if<
need_promotion<BOOST_DEDUCED_TYPENAME remove_cv<T>::type>
, integral_promotion_impl<T>
, boost::mpl::identity<T>

20
include/boost/type_traits/intrinsics.hpp
View File

@ -129,16 +129,22 @@
# include <boost/type_traits/is_reference.hpp>
# include <boost/type_traits/is_volatile.hpp>
#ifdef BOOST_INTEL
# define BOOST_INTEL_TT_OPTS || is_pod<T>::value
#else
# define BOOST_INTEL_TT_OPTS
#endif
# define BOOST_IS_UNION(T) __is_union(T)
# define BOOST_IS_POD(T) __is_pod(T)
# define BOOST_IS_EMPTY(T) __is_empty(T)
# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_constructor(T) && ! ::boost::is_volatile<T>::value)
# define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference<T>::value && ! ::boost::is_volatile<T>::value)
# define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && ! ::boost::is_volatile<T>::value)
# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
# define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value)
# define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile<T>::value)
# define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value)
# define BOOST_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_INTEL_TT_OPTS) && !is_reference<T>::value && ! ::boost::is_volatile<T>::value)
# define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value)
# define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS)
# define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_INTEL_TT_OPTS)
# define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_reference<T>::value)
# define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_const<T>::value)
# define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
# define BOOST_IS_ABSTRACT(T) __is_abstract(T)

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

@ -106,7 +106,7 @@ no_type is_const_tester(volatile void *);
template <bool is_ref, bool array>
struct is_const_helper
: ::boost::type_traits::false_result
: public ::boost::type_traits::false_result
{
};
@ -136,7 +136,7 @@ struct is_const_helper<false,true>
template <typename T>
struct is_const_impl
: is_const_helper<
: public is_const_helper<
is_reference<T>::value
, is_array<T>::value
>::template result_<T>

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

@ -85,7 +85,7 @@ struct does_conversion_exist<void>
template <typename From, typename To>
struct is_convertible_basic_impl
: does_conversion_exist<From>::template result_<To>
: public does_conversion_exist<From>::template result_<To>
{
};

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

@ -95,7 +95,7 @@ template <>
struct is_enum_helper<false>
{
template <typename T> struct type
: ::boost::is_convertible<typename boost::add_reference<T>::type,::boost::detail::int_convertible>
: public ::boost::is_convertible<typename boost::add_reference<T>::type,::boost::detail::int_convertible>
{
};
};

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

@ -40,7 +40,7 @@ namespace detail {
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
template<bool is_ref = true>
struct is_function_chooser
: ::boost::type_traits::false_result
: public ::boost::type_traits::false_result
{
};
@ -48,14 +48,14 @@ template <>
struct is_function_chooser<false>
{
template< typename T > struct result_
: ::boost::type_traits::is_function_ptr_helper<T*>
: public ::boost::type_traits::is_function_ptr_helper<T*>
{
};
};
template <typename T>
struct is_function_impl
: is_function_chooser< ::boost::is_reference<T>::value >
: public is_function_chooser< ::boost::is_reference<T>::value >
::BOOST_NESTED_TEMPLATE result_<T>
{
};

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

@ -22,7 +22,7 @@ namespace detail {
template <typename T>
struct is_fundamental_impl
: ::boost::type_traits::ice_or<
: public ::boost::type_traits::ice_or<
::boost::is_arithmetic<T>::value
, ::boost::is_void<T>::value
>

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

@ -55,7 +55,7 @@ namespace detail {
template <bool>
struct is_mem_fun_pointer_select
: ::boost::type_traits::false_result
: public ::boost::type_traits::false_result
{
};
@ -83,7 +83,7 @@ struct is_mem_fun_pointer_select<false>
template <typename T>
struct is_member_function_pointer_impl
: is_mem_fun_pointer_select<
: public is_mem_fun_pointer_select<
::boost::type_traits::ice_or<
::boost::is_reference<T>::value
, ::boost::is_array<T>::value

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

@ -66,7 +66,7 @@ template <typename R, typename T>
template <bool>
struct is_member_pointer_select
: ::boost::type_traits::false_result
: public ::boost::type_traits::false_result
{
};
@ -87,7 +87,7 @@ struct is_member_pointer_select<false>
template <typename T>
struct is_member_pointer_impl
: is_member_pointer_select<
: public is_member_pointer_select<
::boost::type_traits::ice_or<
::boost::is_reference<T>::value
, ::boost::is_array<T>::value

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

@ -49,7 +49,7 @@ template <typename T> struct is_pod_impl
#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
template <typename T, std::size_t sz>
struct is_pod_impl<T[sz]>
: is_pod_impl<T>
: public is_pod_impl<T>
{
};
#endif

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

@ -113,7 +113,7 @@ no_type BOOST_TT_DECL is_pointer_tester(...);
template <bool>
struct is_pointer_select
: ::boost::type_traits::false_result
: public ::boost::type_traits::false_result
{
};
@ -133,7 +133,7 @@ struct is_pointer_select<false>
template <typename T>
struct is_pointer_impl
: is_pointer_select<
: public is_pointer_select<
::boost::type_traits::ice_or<
::boost::is_reference<T>::value
, ::boost::is_array<T>::value

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

@ -52,14 +52,14 @@ struct is_virtual_base_of_impl<Base, Derived, mpl::true_>
~boost_type_traits_internal_struct_Y()throw();
};
#else
struct boost_type_traits_internal_struct_X : Derived, virtual Base
struct boost_type_traits_internal_struct_X : public Derived, virtual Base
{
boost_type_traits_internal_struct_X();
boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
~boost_type_traits_internal_struct_X()throw();
};
struct boost_type_traits_internal_struct_Y : Derived
struct boost_type_traits_internal_struct_Y : public Derived
{
boost_type_traits_internal_struct_Y();
boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);

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

@ -94,7 +94,7 @@ no_type is_volatile_tester(void const*);
template <bool is_ref, bool array>
struct is_volatile_helper
: ::boost::type_traits::false_result
: public ::boost::type_traits::false_result
{
};
@ -124,7 +124,7 @@ struct is_volatile_helper<false,true>
template <typename T>
struct is_volatile_impl
: is_volatile_helper<
: public is_volatile_helper<
is_reference<T>::value
, is_array<T>::value
>::template result_<T>

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

@ -20,7 +20,7 @@ namespace boost { namespace detail {
};
template<typename T, typename ID>
struct msvc_register_type : msvc_extract_type<ID>
struct msvc_register_type : public msvc_extract_type<ID>
{
template<>
struct id2type_impl<true> //VC7.0 specific bugfeature
@ -36,7 +36,7 @@ namespace boost { namespace detail {
};
template<typename T, typename ID>
struct msvc_register_type : msvc_extract_type<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

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

@ -19,7 +19,7 @@ namespace detail {
template<class T>
struct promote_impl
: integral_promotion<
: public integral_promotion<
BOOST_DEDUCED_TYPENAME floating_point_promotion<T>::type
>
{

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

@ -86,7 +86,7 @@ struct lower_alignment_helper_impl<false>
{
template <std::size_t target, class TestType>
struct apply
: mpl::if_c<(alignment_of<TestType>::value == target), TestType, char>
: public mpl::if_c<(alignment_of<TestType>::value == target), TestType, char>
{
enum { value = (alignment_of<TestType>::value == target) };
};
@ -94,7 +94,7 @@ struct lower_alignment_helper_impl<false>
template <bool found, std::size_t target, class TestType>
struct lower_alignment_helper
: lower_alignment_helper_impl<found>::template apply<target,TestType>
: public lower_alignment_helper_impl<found>::template apply<target,TestType>
{
};
#else

5
test/test.hpp
View File

@ -206,7 +206,12 @@ typedef int (UDT::*cmf)(int) const;
// on some compilers):
//
typedef int& r_type;
#ifndef BOOST_INTEL
typedef const r_type cr_type;
#else
// recent Intel compilers generate a hard error on the above:
typedef r_type cr_type;
#endif
# ifdef BOOST_MSVC
# pragma warning(pop)
# elif defined(BOOST_INTEL)