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

Merged remove_xxx implementation for VC6.5 and VC7.0 using typeof trick from HEAD

Browse Source 
[SVN r33524]
This commit is contained in:
Peder Holt
2006-03-29 17:35:11 +00:00
parent e675469610
commit 62132b3ad4
17 changed files with 800 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -0,0 +1,47 @@
// 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 {
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 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 Normal file
View File

@ -0,0 +1,43 @@
// 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 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 Normal file
View File

@ -0,0 +1,143 @@
// 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 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 Normal file
View File

@ -0,0 +1,190 @@
// 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 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 Normal file
View File

@ -0,0 +1,43 @@
// 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 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 Normal file
View File

@ -0,0 +1,42 @@
// 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 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 Normal file
View File

@ -0,0 +1,42 @@
// 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 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 Normal file
View File

@ -0,0 +1,143 @@
// 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 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 Normal file
View File

@ -0,0 +1,50 @@
// 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 : 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 : 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

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

@ -11,10 +11,17 @@
#include <boost/config.hpp>
#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)
@ -34,6 +41,8 @@ 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

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

@ -11,10 +11,17 @@
#include <boost/config.hpp>
#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)
@ -34,6 +41,8 @@ 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

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

@ -15,9 +15,14 @@
#include <boost/type_traits/broken_compiler_spec.hpp>
#include <boost/type_traits/detail/cv_traits_impl.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#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>
@ -60,7 +65,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
#else
#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_const,T,typename detail::remove_const_impl<T>::type)

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

@ -14,9 +14,14 @@
#include <boost/type_traits/broken_compiler_spec.hpp>
#include <boost/type_traits/detail/cv_traits_impl.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#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>
@ -33,7 +38,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
#else
#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
namespace detail {
template <typename T>

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

@ -10,11 +10,18 @@
#define BOOST_TT_REMOVE_EXTENT_HPP_INCLUDED
#include <boost/config.hpp>
#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)
@ -34,6 +41,8 @@ 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

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

@ -11,6 +11,11 @@
#include <boost/type_traits/broken_compiler_spec.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC,<=1300)
#include <boost/type_traits/msvc/remove_pointer.hpp>
#endif
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
@ -25,7 +30,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)
#else
#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,typename detail::remove_pointer_impl<T>::type)

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

@ -11,6 +11,11 @@
#include <boost/type_traits/broken_compiler_spec.hpp>
#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>
@ -32,7 +37,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
#else
#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,typename detail::remove_reference_impl<T>::type)

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

@ -15,9 +15,14 @@
#include <boost/type_traits/broken_compiler_spec.hpp>
#include <boost/type_traits/detail/cv_traits_impl.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#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>
@ -59,7 +64,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
#else
#elif !BOOST_WORKAROUND(BOOST_MSVC,<=1300)
BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_volatile,T,typename detail::remove_volatile_impl<T>::type)