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

Merge branch 'Version2' into develop

Browse Source
This commit is contained in:
jzmaddock
2015-05-22 13:18:48 +01:00
parent 9f489b0d71 286d08b1ea
commit 55ea6d614c
162 changed files with 2412 additions and 3570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
changes pending.txt Normal file
View File

@@ -0,0 +1,97 @@
* = PR requests not yet applied to 'develop' branch
ANY
~~~
Missing mpl/if.hpp https://github.com/boostorg/any/pull/4 DM
DETAIL
------
Remove unnecessary include for deprecated ice_xxx.hpp header: https://github.com/boostorg/detail/pull/6 D
Remove dependency on deprecated type_trait headers: https://github.com/boostorg/detail/pull/8 D
FOREACH
~~~~~~~
Relies on conversion from integral_constant* to mpl::bool_*
https://github.com/boostorg/foreach/pull/3 D
FUNCTION
--------
Removed dependencies on ice_xxx.hpp headers: https://github.com/boostorg/function/pull/5 D
Use ! operator directly rather than boost::mpl::not with Boost supported compilers:
https://github.com/boostorg/function/pull/8 D
FUSION
------
Deprecated header usage: https://github.com/boostorg/fusion/pull/77 D
FUNCTION_TYPES
--------------
Removed dependency on deprecated template_arity_spec.hpp: https://github.com/boostorg/function_types/pull/2 D
Remove use of deprecated header: https://github.com/boostorg/function_types/pull/4 D
GRAPH
~~~~~
* Needs to remove ice_or usage: https://github.com/boostorg/graph/pull/30
ITERATOR
~~~~~~~~
* is_lvalue_iterator.hpp needs to include mpl/bool.hpp
https://github.com/boostorg/iterator/pull/11 D
* Removed reliance on deprecated type traits headers: https://github.com/boostorg/iterator/pull/14 D
LAMBDA
~~~~~~
Missing includes:
ice.hpp see https://github.com/boostorg/lambda/pull/3 D
Lots of headers: https://github.com/boostorg/lambda/pull/4 D
Changes for type_traits Version2: https://github.com/boostorg/lambda/pull/9 D
LEXICAL_CAST
~~~~~~~~~~~
missing is_float.hpp in converter_numeric.hpp https://github.com/boostorg/lexical_cast/pull/8 D
Use mpl instead of ice_ functionality: https://github.com/boostorg/lexical_cast/pull/11 D
Change to use operators rather than mpl equivalents for constant boolean values, in the replacements
eliminating dependency on deprecated type_traits headers:
https://github.com/boostorg/lexical_cast/pull/15 D
PYTHON
------
deprecated header usage: https://github.com/boostorg/python/pull/23
RANDOM
~~~~~~
Missing #includes: https://github.com/boostorg/random/pull/13 DM
RANGE
-----
Remove dependency on type traits ice_xxx.hpp headers, which are deprecated:
https://github.com/boostorg/range/pull/27 D
Use operator || rather than boost::mpl::or_ for constant boolean expression:
https://github.com/boostorg/range/pull/31 D
TEST
----
Add needed MPL header file:
https://github.com/boostorg/test/pull/58 D
VARIANT
-------
Removed reliance on deprecated type_traits header: https://github.com/boostorg/variant/pull/12 D
Unexplained new failures
~~~~~~~~~~~~~~~~~~~~~~~~

127
include/boost/aligned_storage.hpp
View File

@@ -13,131 +13,6 @@
#ifndef BOOST_ALIGNED_STORAGE_HPP
#define BOOST_ALIGNED_STORAGE_HPP
#include <cstddef> // for std::size_t
#include "boost/config.hpp"
#include "boost/detail/workaround.hpp"
#include "boost/type_traits/alignment_of.hpp"
#include "boost/type_traits/type_with_alignment.hpp"
#include "boost/type_traits/is_pod.hpp"
#include "boost/mpl/eval_if.hpp"
#include "boost/mpl/identity.hpp"
#include "boost/type_traits/detail/bool_trait_def.hpp"
namespace boost {
namespace detail { namespace aligned_storage {
BOOST_STATIC_CONSTANT(
std::size_t
, alignment_of_max_align = ::boost::alignment_of<max_align>::value
);
//
// To be TR1 conforming this must be a POD type:
//
template <
std::size_t size_
, std::size_t alignment_
>
struct aligned_storage_imp
{
union data_t
{
char buf[size_];
typename ::boost::mpl::eval_if_c<
alignment_ == std::size_t(-1)
, ::boost::mpl::identity< ::boost::detail::max_align >
, ::boost::type_with_alignment<alignment_>
>::type align_;
} data_;
void* address() const { return const_cast<aligned_storage_imp*>(this); }
};
template< std::size_t alignment_ >
struct aligned_storage_imp<0u,alignment_>
{
/* intentionally empty */
void* address() const { return 0; }
};
}} // namespace detail::aligned_storage
template <
std::size_t size_
, std::size_t alignment_ = std::size_t(-1)
>
class aligned_storage :
#ifndef __BORLANDC__
private
#else
public
#endif
::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_>
{
public: // constants
typedef ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
BOOST_STATIC_CONSTANT(
std::size_t
, size = size_
);
BOOST_STATIC_CONSTANT(
std::size_t
, alignment = (
alignment_ == std::size_t(-1)
? ::boost::detail::aligned_storage::alignment_of_max_align
: alignment_
)
);
private: // noncopyable
aligned_storage(const aligned_storage&);
aligned_storage& operator=(const aligned_storage&);
public: // structors
aligned_storage()
{
}
~aligned_storage()
{
}
public: // accessors
void* address()
{
return static_cast<type*>(this)->address();
}
const void* address() const
{
return static_cast<const type*>(this)->address();
}
};
//
// Make sure that is_pod recognises aligned_storage<>::type
// as a POD (Note that aligned_storage<> itself is not a POD):
//
template <std::size_t size_, std::size_t alignment_>
struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
BOOST_TT_AUX_BOOL_C_BASE(true)
{
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(true)
};
} // namespace boost
#include "boost/type_traits/detail/bool_trait_undef.hpp"
#include <boost/type_traits/aligned_storage.hpp>
#endif // BOOST_ALIGNED_STORAGE_HPP

2
include/boost/type_traits.hpp
View File

@@ -97,6 +97,4 @@
#include "boost/type_traits/promote.hpp"
#endif
#include "boost/type_traits/ice.hpp"
#endif // BOOST_TYPE_TRAITS_HPP

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

@@ -10,13 +10,12 @@
#ifndef BOOST_TT_ADD_CONST_HPP_INCLUDED
#define BOOST_TT_ADD_CONST_HPP_INCLUDED
#include <boost/config.hpp>
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
#include <boost/type_traits/detail/config.hpp>
namespace boost {
BOOST_TT_INLINE_NS
// * convert a type T to const type - add_const<T>
// this is not required since the result is always
// the same as "T const", but it does suppress warnings
@@ -30,16 +29,21 @@ namespace boost {
# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
#endif
BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_const,T,T const)
template <class T> struct add_const
{
typedef T const type;
};
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_const,T&,T&)
template <class T> struct add_const<T&>
{
typedef T& type;
};
BOOST_TT_INLINE_NS_END
} // namespace boost
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_ADD_CONST_HPP_INCLUDED

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

@@ -13,9 +13,6 @@
#include <boost/config.hpp>
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
// * convert a type T to a const volatile type - add_cv<T>
@@ -31,16 +28,14 @@ namespace boost {
# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
#endif
BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_cv,T,T const volatile)
template <class T> struct add_cv{ typedef T const volatile type; };
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_cv,T&,T&)
template <class T> struct add_cv<T&>{ typedef T& type; };
} // namespace boost
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_ADD_CV_HPP_INCLUDED

15
include/boost/type_traits/add_lvalue_reference.hpp
View File

@@ -8,19 +8,20 @@
#include <boost/type_traits/add_reference.hpp>
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost{
BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_lvalue_reference,T,typename boost::add_reference<T>::type)
template <class T> struct add_lvalue_reference
{
typedef typename boost::add_reference<T>::type type;
};
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_lvalue_reference,T&&,T&)
template <class T> struct add_lvalue_reference<T&&>
{
typedef T& type;
};
#endif
}
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP

23
include/boost/type_traits/add_pointer.hpp
View File

@@ -11,13 +11,8 @@
#include <boost/type_traits/remove_reference.hpp>
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
namespace detail {
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x5A0)
//
// For some reason this implementation stops Borlands compiler
@@ -25,27 +20,27 @@ namespace detail {
// to arrays for some reason though (shrug...) (JM 20021104)
//
template <typename T>
struct add_pointer_impl
struct add_pointer
{
typedef T* type;
};
template <typename T>
struct add_pointer_impl<T&>
struct add_pointer<T&>
{
typedef T* type;
};
template <typename T>
struct add_pointer_impl<T&const>
struct add_pointer<T&const>
{
typedef T* type;
};
template <typename T>
struct add_pointer_impl<T&volatile>
struct add_pointer<T&volatile>
{
typedef T* type;
};
template <typename T>
struct add_pointer_impl<T&const volatile>
struct add_pointer<T&const volatile>
{
typedef T* type;
};
@@ -53,7 +48,7 @@ struct add_pointer_impl<T&const volatile>
#else
template <typename T>
struct add_pointer_impl
struct add_pointer
{
typedef typename remove_reference<T>::type no_ref_type;
typedef no_ref_type* type;
@@ -61,12 +56,6 @@ struct add_pointer_impl
#endif
} // namespace detail
BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_pointer,T,typename boost::detail::add_pointer_impl<T>::type)
} // namespace boost
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_ADD_POINTER_HPP_INCLUDED

45
include/boost/type_traits/add_reference.hpp
View File

@@ -9,13 +9,9 @@
#ifndef BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
#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
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
namespace detail {
@@ -26,47 +22,38 @@ namespace detail {
//
template <typename T>
struct add_reference_rvalue_layer
struct add_reference_impl
{
typedef T& type;
};
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <typename T>
struct add_reference_rvalue_layer<T&&>
struct add_reference_impl<T&&>
{
typedef T&& type;
};
#endif
template <typename T>
struct add_reference_impl
{
typedef typename add_reference_rvalue_layer<T>::type type;
};
BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&)
// these full specialisations are always required:
BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void,void)
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const,void const)
BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void volatile,void volatile)
BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const volatile,void const volatile)
#endif
} // namespace detail
BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_reference,T,typename boost::detail::add_reference_impl<T>::type)
template <class T> struct add_reference
{
typedef typename boost::detail::add_reference_impl<T>::type type;
};
template <class T> struct add_reference<T&>
{
typedef T& type;
};
// agurt, 07/mar/03: workaround Borland's ill-formed sensitivity to an additional
// level of indirection, here
#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&)
// these full specialisations are always required:
template <> struct add_reference<void> { typedef void type; };
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
template <> struct add_reference<const void> { typedef void type; };
template <> struct add_reference<const volatile void> { typedef void type; };
template <> struct add_reference<volatile void> { typedef void type; };
#endif
} // namespace boost
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED

10
include/boost/type_traits/add_rvalue_reference.hpp
View File

@@ -15,9 +15,6 @@
#include <boost/type_traits/is_void.hpp>
#include <boost/type_traits/is_reference.hpp>
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
//----------------------------------------------------------------------------//
// //
// C++03 implementation of //
@@ -56,11 +53,12 @@ namespace type_traits_detail {
}
BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_rvalue_reference,T,typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type)
template <class T> struct add_rvalue_reference
{
typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type;
};
} // namespace boost
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP

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

@@ -12,9 +12,6 @@
#include <boost/config.hpp>
// should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
// * convert a type T to volatile type - add_volatile<T>
@@ -30,16 +27,14 @@ namespace boost {
# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
#endif
BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_volatile,T,T volatile)
template <class T> struct add_volatile{ typedef T volatile type; };
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_volatile,T&,T&)
template <class T> struct add_volatile<T&>{ typedef T& type; };
} // namespace boost
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_ADD_VOLATILE_HPP_INCLUDED

145
include/boost/type_traits/aligned_storage.hpp Executable file → Normal file
View File

@@ -1,13 +1,138 @@
// Copyright (C) John Maddock 2005.
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).
//-----------------------------------------------------------------------------
// boost aligned_storage.hpp header file
// See http://www.boost.org for updates, documentation, and revision history.
//-----------------------------------------------------------------------------
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
// Copyright (c) 2002-2003
// Eric Friedman, Itay Maman
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_TT_ALIGNED_STORAGE_HPP_INCLUDED
# define BOOST_TT_ALIGNED_STORAGE_HPP_INCLUDED
# include <boost/aligned_storage.hpp>
#endif // BOOST_TT_ALIGNED_STORAGE_HPP_INCLUDED
#ifndef BOOST_TT_ALIGNED_STORAGE_HPP
#define BOOST_TT_ALIGNED_STORAGE_HPP
#include <cstddef> // for std::size_t
#include "boost/config.hpp"
#include "boost/detail/workaround.hpp"
#include "boost/type_traits/alignment_of.hpp"
#include "boost/type_traits/type_with_alignment.hpp"
#include "boost/type_traits/is_pod.hpp"
#include "boost/type_traits/conditional.hpp"
namespace boost {
namespace detail { namespace aligned_storage {
BOOST_STATIC_CONSTANT(
std::size_t
, alignment_of_max_align = ::boost::alignment_of<boost::detail::max_align>::value
);
//
// To be TR1 conforming this must be a POD type:
//
template <
std::size_t size_
, std::size_t alignment_
>
struct aligned_storage_imp
{
union data_t
{
char buf[size_];
typename ::boost::type_with_alignment<alignment_>::type align_;
} data_;
void* address() const { return const_cast<aligned_storage_imp*>(this); }
};
template <std::size_t size>
struct aligned_storage_imp<size, std::size_t(-1)>
{
union data_t
{
char buf[size];
::boost::detail::max_align align_;
} data_;
void* address() const { return const_cast<aligned_storage_imp*>(this); }
};
template< std::size_t alignment_ >
struct aligned_storage_imp<0u,alignment_>
{
/* intentionally empty */
void* address() const { return 0; }
};
}} // namespace detail::aligned_storage
template <
std::size_t size_
, std::size_t alignment_ = std::size_t(-1)
>
class aligned_storage :
#ifndef __BORLANDC__
private
#else
public
#endif
::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_>
{
public: // constants
typedef ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
BOOST_STATIC_CONSTANT(
std::size_t
, size = size_
);
BOOST_STATIC_CONSTANT(
std::size_t
, alignment = (
alignment_ == std::size_t(-1)
? ::boost::detail::aligned_storage::alignment_of_max_align
: alignment_
)
);
private: // noncopyable
aligned_storage(const aligned_storage&);
aligned_storage& operator=(const aligned_storage&);
public: // structors
aligned_storage()
{
}
~aligned_storage()
{
}
public: // accessors
void* address()
{
return static_cast<type*>(this)->address();
}
const void* address() const
{
return static_cast<const type*>(this)->address();
}
};
//
// Make sure that is_pod recognises aligned_storage<>::type
// as a POD (Note that aligned_storage<> itself is not a POD):
//
template <std::size_t size_, std::size_t alignment_>
struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> > : public true_type{};
} // namespace boost
#endif // BOOST_ALIGNED_STORAGE_HPP

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

@@ -13,8 +13,7 @@
#include <cstddef>
#include <boost/type_traits/intrinsics.hpp>
// should be the last #include
#include <boost/type_traits/detail/size_t_trait_def.hpp>
#include <boost/type_traits/integral_constant.hpp>
#ifdef BOOST_MSVC
# pragma warning(push)
@@ -86,29 +85,25 @@ struct alignment_of_impl
} // namespace detail
BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(alignment_of,T,::boost::detail::alignment_of_impl<T>::value)
template <class T> struct alignment_of : public integral_constant<std::size_t, ::boost::detail::alignment_of_impl<T>::value>{};
// references have to be treated specially, assume
// that a reference is just a special pointer:
template <typename T>
struct alignment_of<T&>
: public alignment_of<T*>
{
};
template <typename T> struct alignment_of<T&> : public alignment_of<T*>{};
#ifdef __BORLANDC__
// long double gives an incorrect value of 10 (!)
// unless we do this...
struct long_double_wrapper{ long double ld; };
template<> struct alignment_of<long double>
: public alignment_of<long_double_wrapper>{};
template<> struct alignment_of<long double> : public alignment_of<long_double_wrapper>{};
#endif
// void has to be treated specially:
BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void,0)
template<> struct alignment_of<void> : integral_constant<std::size_t, 0>{};
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const,0)
BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void volatile,0)
BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const volatile,0)
template<> struct alignment_of<void const> : integral_constant<std::size_t, 0>{};
template<> struct alignment_of<void const volatile> : integral_constant<std::size_t, 0>{};
template<> struct alignment_of<void volatile> : integral_constant<std::size_t, 0>{};
#endif
} // namespace boost
@@ -120,7 +115,5 @@ BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const volatile,0)
# pragma warning(pop)
#endif
#include <boost/type_traits/detail/size_t_trait_undef.hpp>
#endif // BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED

17
include/boost/type_traits/broken_compiler_spec.hpp
View File

@@ -1,14 +1,21 @@
// Copyright 2001-2003 Aleksey Gurtovoy.
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#ifndef BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
#define BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#ifndef BOOST_TT_BROKEN_SPEC_HPP_INCLUDED
#define BOOST_TT_BROKEN_SPEC_HPP_INCLUDED
//
// This header is deprecated and no longer used by type_traits:
//
#if defined(__GNUC__) || defined(_MSC_VER)
# pragma message("NOTE: Use of this header (boost/type_traits/broken_compiler_spec.hpp) is deprecated")
#endif
#endif // BOOST_TT_CONFIG_HPP_INCLUDED

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

@@ -10,6 +10,7 @@
#define BOOST_TYPE_TRAITS_COMMON_TYPE_HPP
#include <boost/config.hpp>
#include <boost/static_assert.hpp>
#if defined(__SUNPRO_CC) && !defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF)
# define BOOST_COMMON_TYPE_DONT_USE_TYPEOF
@@ -18,40 +19,31 @@
# define BOOST_COMMON_TYPE_DONT_USE_TYPEOF
#endif
#ifdef __GNUC__
// All supported GCC versions (and emulations thereof) support __typeof__
#define BOOST_COMMON_TYPE_USE_TYPEOF
#endif
//----------------------------------------------------------------------------//
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_COMMON_TYPE_ARITY)
#define BOOST_COMMON_TYPE_ARITY 3
#endif
//----------------------------------------------------------------------------//
#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF)
#include <boost/typeof/typeof.hpp> // boost wonders never cease!
#endif
//----------------------------------------------------------------------------//
#ifndef BOOST_NO_CXX11_STATIC_ASSERT
#define BOOST_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
#elif defined(BOOST_COMMON_TYPE_USES_MPL_ASSERT)
#include <boost/mpl/assert.hpp>
#include <boost/mpl/bool.hpp>
#define BOOST_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) \
BOOST_MPL_ASSERT_MSG(boost::mpl::bool_< (CND) >::type::value, MSG, TYPES)
#else
#include <boost/static_assert.hpp>
#define BOOST_COMMON_TYPE_STATIC_ASSERT(CND, MSG, TYPES) BOOST_STATIC_ASSERT(CND)
#endif
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_COMMON_TYPE_USES_MPL_ASSERT)
#define BOOST_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE "must be complete type"
#endif
#if defined(BOOST_NO_CXX11_DECLTYPE) && defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF)
#include <boost/type_traits/detail/common_type_imp.hpp>
#include <boost/type_traits/remove_cv.hpp>
#endif
#include <boost/mpl/if.hpp>
#if !defined(BOOST_NO_CXX11_DECLTYPE)
#include <boost/utility/declval.hpp>
#elif defined(BOOST_COMMON_TYPE_USE_TYPEOF)
#include <boost/type_traits/add_rvalue_reference.hpp>
#elif defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF)
#include <boost/type_traits/remove_cv.hpp>
#else
#include <boost/typeof/typeof.hpp> // boost wonders never cease!
#include <boost/type_traits/detail/common_type_imp.hpp>
#include <boost/type_traits/add_rvalue_reference.hpp>
#endif
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/decay.hpp>
//----------------------------------------------------------------------------//
// //
@@ -64,6 +56,14 @@
namespace boost {
namespace type_traits_detail {
template <class T>
struct std_decay: boost::remove_cv<
typename boost::decay<T>::type> {};
}
// prototype
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<typename... T>
@@ -87,9 +87,9 @@ namespace boost {
#endif
{
BOOST_COMMON_TYPE_STATIC_ASSERT(sizeof(T) > 0, BOOST_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (T));
BOOST_STATIC_ASSERT_MSG(sizeof(T) > 0, "The template arguments to common_type must be complete types");
public:
typedef T type;
typedef typename type_traits_detail::std_decay<T>::type type;
};
// 2 args
@@ -99,16 +99,18 @@ namespace type_traits_detail {
struct common_type_2
{
private:
BOOST_COMMON_TYPE_STATIC_ASSERT(sizeof(T) > 0, BOOST_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (T));
BOOST_COMMON_TYPE_STATIC_ASSERT(sizeof(U) > 0, BOOST_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (U));
static bool declval_bool(); // workaround gcc bug; not required by std
static typename add_rvalue_reference<T>::type declval_T(); // workaround gcc bug; not required by std
static typename add_rvalue_reference<U>::type declval_U(); // workaround gcc bug; not required by std
static typename add_rvalue_reference<bool>::type declval_b();
BOOST_STATIC_ASSERT_MSG(sizeof(T) > 0, "The template arguments to common_type must be complete types");
BOOST_STATIC_ASSERT_MSG(sizeof(U) > 0, "The template arguments to common_type must be complete types");
#if !defined(BOOST_NO_CXX11_DECLTYPE)
public:
typedef decltype(declval<bool>() ? declval<T>() : declval<U>()) type;
typedef typename std_decay<decltype(declval<bool>() ? declval<T>() : declval<U>())>::type type;
#elif defined(BOOST_COMMON_TYPE_USE_TYPEOF)
static typename add_rvalue_reference<T>::type declval_T(); // workaround gcc bug; not required by std
static typename add_rvalue_reference<U>::type declval_U(); // workaround gcc bug; not required by std
static typename add_rvalue_reference<bool>::type declval_b();
public:
typedef typename std_decay<__typeof__(declval_b() ? declval_T() : declval_U())>::type type;
#elif defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF)
public:
typedef typename detail_type_traits_common_type::common_type_impl<
@@ -116,8 +118,11 @@ namespace type_traits_detail {
typename remove_cv<U>::type
>::type type;
#else
static typename add_rvalue_reference<T>::type declval_T(); // workaround gcc bug; not required by std
static typename add_rvalue_reference<U>::type declval_U(); // workaround gcc bug; not required by std
static typename add_rvalue_reference<bool>::type declval_b();
public:
typedef BOOST_TYPEOF_TPL(declval_b() ? declval_T() : declval_U()) type;
typedef typename std_decay<BOOST_TYPEOF_TPL(declval_b() ? declval_T() : declval_U())>::type type;
#endif
#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ == 3
@@ -129,7 +134,7 @@ namespace type_traits_detail {
template <class T>
struct common_type_2<T, T>
{
typedef T type;
typedef typename type_traits_detail::std_decay<T>::type type;
};
}

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

@@ -1,4 +1,3 @@
// (C) Copyright John Maddock 2010.
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,14 +9,10 @@
#ifndef BOOST_TT_CONDITIONAL_HPP_INCLUDED
#define BOOST_TT_CONDITIONAL_HPP_INCLUDED
#include <boost/mpl/if.hpp>
namespace boost {
template <bool b, class T, class U>
struct conditional : public mpl::if_c<b, T, U>
{
};
template <bool b, class T, class U> struct conditional { typedef T type; };
template <class T, class U> struct conditional<false, T, U> { typedef U type; };
} // namespace boost

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

@@ -6,67 +6,16 @@
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#ifndef BOOST_TT_CONFIG_HPP_INCLUDED
#define BOOST_TT_CONFIG_HPP_INCLUDED
#ifndef BOOST_TT_OLD_CONFIG_HPP_INCLUDED
#define BOOST_TT_OLD_CONFIG_HPP_INCLUDED
#ifndef BOOST_CONFIG_HPP
#include <boost/config.hpp>
//
// This header is deprecated and no longer used by type_traits:
//
#if defined(__GNUC__) || defined(_MSC_VER)
# pragma message("NOTE: Use of this header (boost/type_traits/config.hpp) is deprecated")
#endif
#include <boost/detail/workaround.hpp>
//
// whenever we have a conversion function with ellipses
// it needs to be declared __cdecl to suppress compiler
// warnings from MS and Borland compilers (this *must*
// appear before we include is_same.hpp below):
#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32))
# define BOOST_TT_DECL __cdecl
#else
# define BOOST_TT_DECL /**/
#endif
# if (BOOST_WORKAROUND(__MWERKS__, < 0x3000) \
|| BOOST_WORKAROUND(__IBMCPP__, < 600 ) \
|| BOOST_WORKAROUND(__BORLANDC__, < 0x5A0) \
|| defined(__ghs) \
|| BOOST_WORKAROUND(__HP_aCC, < 60700) \
|| BOOST_WORKAROUND(MPW_CPLUS, BOOST_TESTED_AT(0x890)) \
|| BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))) \
&& defined(BOOST_NO_IS_ABSTRACT)
# define BOOST_TT_NO_CONFORMING_IS_CLASS_IMPLEMENTATION 1
#endif
#ifndef BOOST_TT_NO_CONFORMING_IS_CLASS_IMPLEMENTATION
# define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION 1
#endif
//
// define BOOST_TT_TEST_MS_FUNC_SIGS
// when we want to test __stdcall etc function types with is_function etc
// (Note, does not work with Borland, even though it does support __stdcall etc):
//
#if defined(_MSC_EXTENSIONS) && !defined(__BORLANDC__)
# define BOOST_TT_TEST_MS_FUNC_SIGS
#endif
//
// define BOOST_TT_NO_CV_FUNC_TEST
// if tests for cv-qualified member functions don't
// work in is_member_function_pointer
//
#if BOOST_WORKAROUND(__MWERKS__, < 0x3000) || BOOST_WORKAROUND(__IBMCPP__, <= 600)
# define BOOST_TT_NO_CV_FUNC_TEST
#endif
//
// Macros that have been deprecated, defined here for backwards compatibility:
//
#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(x)
#define BOOST_TT_BROKEN_COMPILER_SPEC(x)
#endif // BOOST_TT_CONFIG_HPP_INCLUDED

24
include/boost/type_traits/decay.hpp Executable file → Normal file
View File

@@ -9,33 +9,31 @@
#ifndef BOOST_TT_DECAY_HPP_INCLUDED
#define BOOST_TT_DECAY_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/is_array.hpp>
#include <boost/type_traits/is_function.hpp>
#include <boost/type_traits/remove_bounds.hpp>
#include <boost/type_traits/add_pointer.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
namespace boost
{
namespace detail
{
template <class T, bool Array, bool Function> struct decay_imp { typedef T type; };
template <class T> struct decay_imp<T, true, false> { typedef typename remove_bounds<T>::type* type; };
template <class T> struct decay_imp<T, false, true> { typedef T* type; };
}
template< class T >
struct decay
{
private:
typedef BOOST_DEDUCED_TYPENAME remove_reference<T>::type Ty;
typedef typename remove_reference<T>::type Ty;
public:
typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
is_array<Ty>,
mpl::identity<BOOST_DEDUCED_TYPENAME remove_bounds<Ty>::type*>,
BOOST_DEDUCED_TYPENAME mpl::eval_if<
is_function<Ty>,
add_pointer<Ty>,
mpl::identity<Ty>
>
>::type type;
typedef typename boost::detail::decay_imp<Ty, boost::is_array<Ty>::value, boost::is_function<Ty>::value>::type type;
};
} // namespace boost

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

@@ -11,10 +11,15 @@
// $Date$
// $Revision$
//
// This header is deprecated and no longer used by type_traits:
//
#if defined(__GNUC__) || defined(_MSC_VER)
# pragma message("NOTE: Use of this header (bool_trait_def.hpp) is deprecated")
#endif
#include <boost/type_traits/detail/template_arity_spec.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/config.hpp>
//
@@ -39,14 +44,6 @@
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1
#endif
#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x570)
# define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
typedef ::boost::integral_constant<bool,C> type; \
enum { value = type::value }; \
/**/
# define BOOST_TT_AUX_BOOL_C_BASE(C)
#endif
#ifndef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
# define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) /**/
#endif
@@ -62,7 +59,6 @@ template< typename T > struct trait \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
}; \
\
BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
@@ -75,7 +71,6 @@ template< typename T1, typename T2 > struct trait \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) \
}; \
\
BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait) \
@@ -87,7 +82,6 @@ template< typename T1, typename T2, typename T3 > struct trait \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT(3,trait,(T1,T2,T3)) \
}; \
\
BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(3,trait) \
@@ -99,7 +93,6 @@ template<> struct trait< sp > \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) \
}; \
/**/
@@ -109,7 +102,6 @@ template<> struct trait< sp1,sp2 > \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \
}; \
/**/
@@ -153,7 +145,6 @@ template< param > struct trait< sp1,sp2 > \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \
}; \
/**/

84
include/boost/type_traits/detail/config.hpp Normal file
View File

@@ -0,0 +1,84 @@
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#ifndef BOOST_TT_CONFIG_HPP_INCLUDED
#define BOOST_TT_CONFIG_HPP_INCLUDED
#ifndef BOOST_CONFIG_HPP
#include <boost/config.hpp>
#endif
#include <boost/version.hpp>
#include <boost/detail/workaround.hpp>
//
// whenever we have a conversion function with ellipses
// it needs to be declared __cdecl to suppress compiler
// warnings from MS and Borland compilers (this *must*
// appear before we include is_same.hpp below):
#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32))
# define BOOST_TT_DECL __cdecl
#else
# define BOOST_TT_DECL /**/
#endif
# if (BOOST_WORKAROUND(__MWERKS__, < 0x3000) \
|| BOOST_WORKAROUND(__IBMCPP__, < 600 ) \
|| BOOST_WORKAROUND(__BORLANDC__, < 0x5A0) \
|| defined(__ghs) \
|| BOOST_WORKAROUND(__HP_aCC, < 60700) \
|| BOOST_WORKAROUND(MPW_CPLUS, BOOST_TESTED_AT(0x890)) \
|| BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))) \
&& defined(BOOST_NO_IS_ABSTRACT)
# define BOOST_TT_NO_CONFORMING_IS_CLASS_IMPLEMENTATION 1
#endif
#ifndef BOOST_TT_NO_CONFORMING_IS_CLASS_IMPLEMENTATION
# define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION 1
#endif
//
// define BOOST_TT_TEST_MS_FUNC_SIGS
// when we want to test __stdcall etc function types with is_function etc
// (Note, does not work with Borland, even though it does support __stdcall etc):
//
#if defined(_MSC_EXTENSIONS) && !defined(__BORLANDC__)
# define BOOST_TT_TEST_MS_FUNC_SIGS
#endif
//
// define BOOST_TT_NO_CV_FUNC_TEST
// if tests for cv-qualified member functions don't
// work in is_member_function_pointer
//
#if BOOST_WORKAROUND(__MWERKS__, < 0x3000) || BOOST_WORKAROUND(__IBMCPP__, <= 600)
# define BOOST_TT_NO_CV_FUNC_TEST
#endif
//
// Macros that have been deprecated, defined here for backwards compatibility:
//
#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(x)
#define BOOST_TT_BROKEN_COMPILER_SPEC(x)
#ifdef BOOST_NO_CXX11_INLINE_NAMESPACES
#define BOOST_TT_INLINE_NS
#define BOOST_TT_INLINE_NS_END
#else
#define BOOST_TT_INLINE_NS inline namespace BOOST_JOIN(tt, BOOST_VERSION) {
#define BOOST_TT_INLINE_NS_END }
#endif
#endif // BOOST_TT_CONFIG_HPP_INCLUDED

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

@@ -1,140 +0,0 @@
// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
// Hinnant & John Maddock 2000.
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#ifndef BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED
#define BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED
#include <cstddef>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
// implementation helper:
namespace boost {
namespace detail {
#if BOOST_WORKAROUND(BOOST_MSVC, == 1700)
#define BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(X) X
template <typename T>
struct cv_traits_imp
{
BOOST_STATIC_CONSTANT(bool, is_const = false);
BOOST_STATIC_CONSTANT(bool, is_volatile = false);
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<T[]>
{
BOOST_STATIC_CONSTANT(bool, is_const = false);
BOOST_STATIC_CONSTANT(bool, is_volatile = false);
typedef T unqualified_type[];
};
template <typename T>
struct cv_traits_imp<const T[]>
{
BOOST_STATIC_CONSTANT(bool, is_const = true);
BOOST_STATIC_CONSTANT(bool, is_volatile = false);
typedef T unqualified_type[];
};
template <typename T>
struct cv_traits_imp<volatile T[]>
{
BOOST_STATIC_CONSTANT(bool, is_const = false);
BOOST_STATIC_CONSTANT(bool, is_volatile = true);
typedef T unqualified_type[];
};
template <typename T>
struct cv_traits_imp<const volatile T[]>
{
BOOST_STATIC_CONSTANT(bool, is_const = true);
BOOST_STATIC_CONSTANT(bool, is_volatile = true);
typedef T unqualified_type[];
};
template <typename T, std::size_t N>
struct cv_traits_imp<T[N]>
{
BOOST_STATIC_CONSTANT(bool, is_const = false);
BOOST_STATIC_CONSTANT(bool, is_volatile = false);
typedef T unqualified_type[N];
};
template <typename T, std::size_t N>
struct cv_traits_imp<const T[N]>
{
BOOST_STATIC_CONSTANT(bool, is_const = true);
BOOST_STATIC_CONSTANT(bool, is_volatile = false);
typedef T unqualified_type[N];
};
template <typename T, std::size_t N>
struct cv_traits_imp<volatile T[N]>
{
BOOST_STATIC_CONSTANT(bool, is_const = false);
BOOST_STATIC_CONSTANT(bool, is_volatile = true);
typedef T unqualified_type[N];
};
template <typename T, std::size_t N>
struct cv_traits_imp<const volatile T[N]>
{
BOOST_STATIC_CONSTANT(bool, is_const = true);
BOOST_STATIC_CONSTANT(bool, is_volatile = true);
typedef T unqualified_type[N];
};
#else
#define BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(X) X *
template <typename T> struct cv_traits_imp {};
template <typename T>
struct cv_traits_imp<T*>
{
BOOST_STATIC_CONSTANT(bool, is_const = false);
BOOST_STATIC_CONSTANT(bool, is_volatile = false);
typedef T unqualified_type;
};
#endif
template <typename T>
struct cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(const T)>
{
BOOST_STATIC_CONSTANT(bool, is_const = true);
BOOST_STATIC_CONSTANT(bool, is_volatile = false);
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(volatile T)>
{
BOOST_STATIC_CONSTANT(bool, is_const = false);
BOOST_STATIC_CONSTANT(bool, is_volatile = true);
typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(const volatile T)>
{
BOOST_STATIC_CONSTANT(bool, is_const = true);
BOOST_STATIC_CONSTANT(bool, is_volatile = true);
typedef T unqualified_type;
};
} // namespace detail
} // namespace boost
#endif // BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED

28
include/boost/type_traits/detail/false_result.hpp
View File

@@ -1,28 +0,0 @@
// Copyright David Abrahams 2002.
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#ifndef BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED
#define BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED
#include <boost/config.hpp>
namespace boost {
namespace type_traits {
// Utility class which always "returns" false
struct false_result
{
template <typename T> struct result_
{
BOOST_STATIC_CONSTANT(bool, value = false);
};
};
}} // namespace boost::type_traits
#endif // BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED

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

@@ -7,7 +7,7 @@
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#include <boost/config.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/is_const.hpp>
@@ -21,9 +21,6 @@
#include <boost/type_traits/remove_pointer.hpp>
#include <boost/type_traits/remove_reference.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
// cannot include this header without getting warnings of the kind:
// gcc:
// warning: value computed is not used
@@ -177,13 +174,7 @@ struct trait_impl1 < Lhs, Rhs, Ret, true > {
template < typename Lhs, typename Rhs, typename Ret >
struct trait_impl1 < Lhs, Rhs, Ret, false > {
BOOST_STATIC_CONSTANT(bool,
value = (
::boost::type_traits::ice_and<
operator_exists < Lhs, Rhs >::value,
operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value
>::value
)
);
value = (operator_exists < Lhs, Rhs >::value && operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value));
};
// some specializations needs to be declared for the special void case
@@ -218,12 +209,11 @@ struct trait_impl {
} // namespace detail
// this is the accessible definition of the trait to end user
BOOST_TT_AUX_BOOL_TRAIT_DEF3(BOOST_TT_TRAIT_NAME, Lhs, Rhs=Lhs, Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::trait_impl < Lhs, Rhs, Ret >::value))
template <class Lhs, class Rhs=Lhs, class Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care>
struct BOOST_TT_TRAIT_NAME : public integral_constant<bool, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _impl)::trait_impl < Lhs, Rhs, Ret >::value)>{};
} // namespace boost
#if defined(BOOST_MSVC)
# pragma warning ( pop )
#endif
#include <boost/type_traits/detail/bool_trait_undef.hpp>

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

@@ -7,7 +7,7 @@
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#include <boost/config.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_fundamental.hpp>
@@ -18,9 +18,6 @@
#include <boost/type_traits/remove_pointer.hpp>
#include <boost/type_traits/remove_reference.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
// avoid warnings
#if defined(__GNUC__)
# pragma GCC system_header
@@ -163,13 +160,7 @@ struct trait_impl1 < Lhs, Ret, true > {
template < typename Lhs, typename Ret >
struct trait_impl1 < Lhs, Ret, false > {
BOOST_STATIC_CONSTANT(bool,
value = (
::boost::type_traits::ice_and<
operator_exists < Lhs >::value,
operator_returns_Ret < Lhs, Ret, operator_returns_void < Lhs >::value >::value
>::value
)
);
value = (operator_exists < Lhs >::value && operator_returns_Ret < Lhs, Ret, operator_returns_void < Lhs >::value >::value));
};
// specialization needs to be declared for the special void case
@@ -191,12 +182,11 @@ struct trait_impl {
} // namespace detail
// this is the accessible definition of the trait to end user
BOOST_TT_AUX_BOOL_TRAIT_DEF2(BOOST_TT_TRAIT_NAME, Lhs, Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::trait_impl< Lhs, Ret >::value))
template <class Lhs, class Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care>
struct BOOST_TT_TRAIT_NAME : public integral_constant<bool, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _impl)::trait_impl< Lhs, Ret >::value)>{};
} // namespace boost
#if defined(BOOST_MSVC)
# pragma warning ( pop )
#endif
#include <boost/type_traits/detail/bool_trait_undef.hpp>

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

@@ -7,7 +7,7 @@
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#include <boost/config.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_fundamental.hpp>
@@ -19,9 +19,6 @@
#include <boost/type_traits/remove_pointer.hpp>
#include <boost/type_traits/remove_reference.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
// cannot include this header without getting warnings of the kind:
// gcc:
// warning: value computed is not used
@@ -171,13 +168,7 @@ struct trait_impl1 < Rhs, Ret, true > {
template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, false > {
BOOST_STATIC_CONSTANT(bool,
value = (
::boost::type_traits::ice_and<
operator_exists < Rhs >::value,
operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value
>::value
)
);
value = (operator_exists < Rhs >::value && operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value));
};
// specialization needs to be declared for the special void case
@@ -199,12 +190,11 @@ struct trait_impl {
} // namespace detail
// this is the accessible definition of the trait to end user
BOOST_TT_AUX_BOOL_TRAIT_DEF2(BOOST_TT_TRAIT_NAME, Rhs, Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::trait_impl < Rhs, Ret >::value))
template <class Rhs, class Ret=::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl)::dont_care>
struct BOOST_TT_TRAIT_NAME : public integral_constant<bool, (::boost::detail::BOOST_JOIN(BOOST_TT_TRAIT_NAME, _impl)::trait_impl < Rhs, Ret >::value)>{};
} // namespace boost
#if defined(BOOST_MSVC)
# pragma warning ( pop )
#endif
#include <boost/type_traits/detail/bool_trait_undef.hpp>

7
include/boost/type_traits/detail/ice_and.hpp
View File

@@ -11,6 +11,13 @@
#include <boost/config.hpp>
//
// This header is deprecated and no longer used by type_traits:
//
#if defined(__GNUC__) || defined(_MSC_VER)
# pragma message("NOTE: Use of this header (ice_and.hpp) is deprecated")
#endif
namespace boost {
namespace type_traits {

7
include/boost/type_traits/detail/ice_eq.hpp
View File

@@ -10,6 +10,13 @@
#include <boost/config.hpp>
//
// This header is deprecated and no longer used by type_traits:
//
#if defined(__GNUC__) || defined(_MSC_VER)
# pragma message("NOTE: Use of this header (ice_eq.hpp) is deprecated")
#endif
namespace boost {
namespace type_traits {

7
include/boost/type_traits/detail/ice_not.hpp
View File

@@ -10,6 +10,13 @@
#include <boost/config.hpp>
//
// This header is deprecated and no longer used by type_traits:
//
#if defined(__GNUC__) || defined(_MSC_VER)
# pragma message("NOTE: Use of this header (ice_not.hpp) is deprecated")
#endif
namespace boost {
namespace type_traits {

7
include/boost/type_traits/detail/ice_or.hpp
View File

@@ -10,6 +10,13 @@
#include <boost/config.hpp>
//
// This header is deprecated and no longer used by type_traits:
//
#if defined(__GNUC__) || defined(_MSC_VER)
# pragma message("NOTE: Use of this header (ice_or.hpp) is deprecated")
#endif
namespace boost {
namespace type_traits {

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

@@ -15,12 +15,20 @@
#ifndef BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED
#define BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#if defined(BOOST_TT_PREPROCESSING_MODE)
# include <boost/preprocessor/iterate.hpp>
# include <boost/preprocessor/enum_params.hpp>
# include <boost/preprocessor/comma_if.hpp>
//
// Hide these #include from dependency analysers as
// these are required in maintenance mode only:
//
#define PP1 <boost/preprocessor/iterate.hpp>
#include PP1
#undef PP1
#define PP1 <boost/preprocessor/enum_params.hpp>
#include PP1
#undef PP1
#define PP1 <boost/preprocessor/comma_if.hpp>
#include PP1
#undef PP1
#endif
namespace boost {

17
include/boost/type_traits/detail/is_function_ptr_tester.hpp
View File

@@ -15,12 +15,21 @@
#define BOOST_TT_DETAIL_IS_FUNCTION_PTR_TESTER_HPP_INCLUDED
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/type_traits/config.hpp>
#if defined(BOOST_TT_PREPROCESSING_MODE)
# include <boost/preprocessor/iterate.hpp>
# include <boost/preprocessor/enum_params.hpp>
# include <boost/preprocessor/comma_if.hpp>
//
// Hide include dependencies from analysers since they're
// only require in maintenance mode:
//
#define PP1 <boost/preprocessor/iterate.hpp>
#define PP2 <boost/preprocessor/enum_params.hpp>
#define PP3 <boost/preprocessor/comma_if.hpp>
#include PP1
#include PP2
#include PP3
#undef PP1
#undef PP2
#undef PP3
#endif
namespace boost {

16
include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp
View File

@@ -17,9 +17,19 @@
#include <boost/config.hpp>
#if defined(BOOST_TT_PREPROCESSING_MODE)
# include <boost/preprocessor/iterate.hpp>
# include <boost/preprocessor/enum_params.hpp>
# include <boost/preprocessor/comma_if.hpp>
//
// Maintenance mode, hide include dependencies
// from trackers:
//
#define PPI <boost/preprocessor/iterate.hpp>
#include PPI
#undef PPI
#define PPI <boost/preprocessor/enum_params.hpp>
#include PPI
#undef PPI
#define PPI <boost/preprocessor/comma_if.hpp>
#include PPI
#undef PPI
#endif
namespace boost {

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

@@ -15,12 +15,22 @@
#define BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_TESTER_HPP_INCLUDED
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/detail/config.hpp>
#if defined(BOOST_TT_PREPROCESSING_MODE)
# include <boost/preprocessor/iterate.hpp>
# include <boost/preprocessor/enum_params.hpp>
# include <boost/preprocessor/comma_if.hpp>
//
// Maintentance mode, hide include dependencies
// from dependency trackers:
//
#define PPI <boost/preprocessor/iterate.hpp>
#include PPI
#undef PPI
#define PPI <boost/preprocessor/enum_params.hpp>
#include PPI
#undef PPI
#define <boost/preprocessor/comma_if.hpp>
#include PPI
#undef
#endif
namespace boost {

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

@@ -1,51 +0,0 @@
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
// Copyright Aleksey Gurtovoy 2002-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// $Source$
// $Date$
// $Revision$
#include <boost/type_traits/detail/template_arity_spec.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/mpl/size_t.hpp>
#include <cstddef>
// Obsolete. Remove.
#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) /**/
#define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) \
template< typename T > struct trait \
: public ::boost::integral_constant<std::size_t,C> \
{ \
public:\
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
}; \
\
BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
/**/
#define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) \
template<> struct trait<spec> \
: public ::boost::integral_constant<std::size_t,C> \
{ \
public:\
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
}; \
/**/
#define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) \
template< param > struct trait<spec> \
: public ::boost::integral_constant<std::size_t,C> \
{ \
}; \
/**/

16
include/boost/type_traits/detail/size_t_trait_undef.hpp
View File

@@ -1,16 +0,0 @@
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
// Copyright Aleksey Gurtovoy 2002-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// $Source$
// $Date$
// $Revision$
#undef BOOST_TT_AUX_SIZE_T_TRAIT_DEF1
#undef BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1
#undef BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1

29
include/boost/type_traits/detail/template_arity_spec.hpp
View File

@@ -1,4 +1,3 @@
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
// Copyright Aleksey Gurtovoy 2002-2004
@@ -7,25 +6,11 @@
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <boost/mpl/int.hpp>
#include <boost/mpl/aux_/template_arity_fwd.hpp>
#include <boost/mpl/aux_/preprocessor/params.hpp>
#include <boost/mpl/aux_/config/lambda.hpp>
#include <boost/mpl/aux_/config/overload_resolution.hpp>
#if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \
&& defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION)
# define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) \
namespace mpl { namespace aux { \
template< BOOST_MPL_PP_PARAMS(i, typename T) > \
struct template_arity< \
name< BOOST_MPL_PP_PARAMS(i, T) > \
> \
: int_<i> \
{ \
}; \
}} \
/**/
#else
# define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) /**/
//
// This header is deprecated and no longer used by type_traits:
//
#if defined(__GNUC__) || defined(_MSC_VER)
# pragma message("NOTE: Use of this header (template_arity_spec.hpp) is deprecated")
#endif
# define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) /**/

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

@@ -1,67 +0,0 @@
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
// Copyright Aleksey Gurtovoy 2002-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// $Source$
// $Date$
// $Revision$
#include <boost/type_traits/detail/template_arity_spec.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#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)) \
}; \
\
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)) \
}; \
/**/
#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) \
template<> struct trait##_impl<spec> \
{ \
public:\
typedef result type; \
}; \
/**/
#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) \
template< param > struct trait<spec> \
{ \
public:\
typedef result type; \
}; \
/**/
#define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) \
template< param1, param2 > struct trait<spec> \
{ \
public:\
typedef result; \
}; \
/**/
#define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) \
template< param > struct trait##_impl<spec> \
{ \
public:\
typedef result type; \
}; \
/**/

19
include/boost/type_traits/detail/type_trait_undef.hpp
View File

@@ -1,19 +0,0 @@
// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
// Copyright Aleksey Gurtovoy 2002-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// $Source$
// $Date$
// $Revision$
#undef BOOST_TT_AUX_TYPE_TRAIT_DEF1
#undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1

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

@@ -1,18 +0,0 @@
// (C) Copyright David Abrahams 2002.
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#ifndef BOOST_TT_DETAIL_WRAP_HPP_INCLUDED
#define BOOST_TT_DETAIL_WRAP_HPP_INCLUDED
namespace boost {
namespace type_traits {
template <class T> struct wrap {};
}} // namespace boost::type_traits
#endif // BOOST_TT_DETAIL_WRAP_HPP_INCLUDED

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

@@ -10,8 +10,8 @@
#ifndef BOOST_TT_EXTENT_HPP_INCLUDED
#define BOOST_TT_EXTENT_HPP_INCLUDED
// should be the last #include
#include <boost/type_traits/detail/size_t_trait_def.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/detail/workaround.hpp>
namespace boost {
@@ -131,11 +131,8 @@ template <class T, std::size_t N = 0>
struct extent
: public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
{
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,extent,(T))
};
} // namespace boost
#include <boost/type_traits/detail/size_t_trait_undef.hpp>
#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED

81
include/boost/type_traits/floating_point_promotion.hpp
View File

@@ -6,86 +6,15 @@
#ifndef FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
#define FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
#include <boost/config.hpp>
#ifdef BOOST_NO_CV_SPECIALIZATIONS
#include <boost/mpl/at.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/multiplies.hpp>
#include <boost/mpl/plus.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
#endif
// Should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
namespace type_traits { namespace detail {
template<class T> struct floating_point_promotion { typedef T type; };
template<> struct floating_point_promotion<float> { typedef double type; };
template<> struct floating_point_promotion<float const> { typedef double const type; };
template<> struct floating_point_promotion<float volatile>{ typedef double volatile type; };
template<> struct floating_point_promotion<float const volatile> { typedef double const volatile type; };
#ifndef BOOST_NO_CV_SPECIALIZATIONS
template<class T>
struct floating_point_promotion
{
typedef T type;
};
template<>
struct floating_point_promotion<float>
{
typedef double type;
};
template<>
struct floating_point_promotion<float const>
{
typedef double const type;
};
template<>
struct floating_point_promotion<float volatile>
{
typedef double volatile type;
};
template<>
struct floating_point_promotion<float const volatile>
{
typedef double const volatile type;
};
#else
template<class T>
struct floating_point_promotion
: mpl::at<
mpl::vector< T, double, double const, double volatile,
double const volatile >
, mpl::plus<
is_same<T, float>
, mpl::multiplies< is_same<T, float const> , mpl::int_<2> >
, mpl::multiplies< is_same<T, float volatile> , mpl::int_<3> >
, mpl::multiplies< is_same<T, float const volatile>, mpl::int_<4> >
>
>
{
};
#endif
} }
BOOST_TT_AUX_TYPE_TRAIT_DEF1(
floating_point_promotion
, T
, BOOST_DEDUCED_TYPENAME
boost::type_traits::detail::floating_point_promotion<T>::type
)
}
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // #ifndef FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED

38
include/boost/type_traits/has_bit_and.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_bit_and
#define BOOST_TT_TRAIT_OP &
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
( \
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

46
include/boost/type_traits/has_bit_and_assign.hpp
View File

@@ -12,38 +12,38 @@
#define BOOST_TT_TRAIT_NAME has_bit_and_assign
#define BOOST_TT_TRAIT_OP &=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
(\
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_const< Lhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

38
include/boost/type_traits/has_bit_or.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_bit_or
#define BOOST_TT_TRAIT_OP |
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
( \
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

46
include/boost/type_traits/has_bit_or_assign.hpp
View File

@@ -12,38 +12,38 @@
#define BOOST_TT_TRAIT_NAME has_bit_or_assign
#define BOOST_TT_TRAIT_OP |=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
( \
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_const< Lhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

38
include/boost/type_traits/has_bit_xor.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_bit_xor
#define BOOST_TT_TRAIT_OP ^
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
( \
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

46
include/boost/type_traits/has_bit_xor_assign.hpp
View File

@@ -12,38 +12,38 @@
#define BOOST_TT_TRAIT_NAME has_bit_xor_assign
#define BOOST_TT_TRAIT_OP ^=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
( \
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_const< Lhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

14
include/boost/type_traits/has_complement.hpp
View File

@@ -12,15 +12,15 @@
#define BOOST_TT_TRAIT_NAME has_complement
#define BOOST_TT_TRAIT_OP ~
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* pointer */\
::boost::is_pointer< Rhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value || \
/* fundamental non integral */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_noref >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value
(\
::boost::is_fundamental< Rhs_noref >::value && \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)
#include <boost/type_traits/detail/has_prefix_operator.hpp>

10
include/boost/type_traits/has_dereference.hpp
View File

@@ -13,13 +13,13 @@
#define BOOST_TT_TRAIT_OP *
#define BOOST_TT_FORBIDDEN_IF\
/* void* or fundamental */\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
(\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_void< Rhs_noptr >::value\
>::value,\
) || \
::boost::is_fundamental< Rhs_nocv >::value\
>::value
)
#include <boost/type_traits/detail/has_prefix_operator.hpp>

28
include/boost/type_traits/has_divides.hpp
View File

@@ -13,22 +13,22 @@
#define BOOST_TT_TRAIT_OP /
#define BOOST_TT_FORBIDDEN_IF\
/* pointer with pointer or fundamental */\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
(\
::boost::is_pointer< Lhs_noref >::value && \
( \
::boost::is_fundamental< Rhs_nocv >::value || \
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value,\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Lhs_nocv >::value,\
)\
)||\
(\
::boost::is_pointer< Rhs_noref >::value && \
( \
::boost::is_fundamental< Lhs_nocv >::value || \
::boost::is_pointer< Lhs_noref >::value\
>::value\
>::value\
>::value
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

36
include/boost/type_traits/has_divides_assign.hpp
View File

@@ -12,30 +12,30 @@
#define BOOST_TT_TRAIT_NAME has_divides_assign
#define BOOST_TT_TRAIT_OP /=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Lhs==const and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_const< Lhs_noref >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_const< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
) || \
/* Lhs==pointer and (Rhs==fundamental or Rhs==pointer) */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
( \
::boost::is_fundamental< Rhs_nocv >::value || \
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value,\
)\
)||\
/* Rhs==pointer and (Lhs==fundamental or Lhs==pointer) */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
( \
::boost::is_fundamental< Lhs_nocv >::value || \
::boost::is_pointer< Lhs_noref >::value\
>::value\
>::value\
>::value
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

40
include/boost/type_traits/has_equal_to.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_equal_to
#define BOOST_TT_TRAIT_OP ==
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==pointer and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
) || \
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
) || \
/* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_not<\
::boost::type_traits::ice_or<\
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_void< Lhs_noptr >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value && \
(! \
(\
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \
::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_void< Lhs_noptr >::value || \
::boost::is_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
)\
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

40
include/boost/type_traits/has_greater.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_greater
#define BOOST_TT_TRAIT_OP >
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==pointer and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
) || \
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
) || \
/* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_not<\
::boost::type_traits::ice_or<\
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_void< Lhs_noptr >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value && \
(! \
( \
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \
::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_void< Lhs_noptr >::value || \
::boost::is_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
)\
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

40
include/boost/type_traits/has_greater_equal.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_greater_equal
#define BOOST_TT_TRAIT_OP >=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==pointer and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
) || \
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
) || \
/* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_not<\
::boost::type_traits::ice_or<\
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_void< Lhs_noptr >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value && \
(! \
( \
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \
::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_void< Lhs_noptr >::value || \
::boost::is_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
)\
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

38
include/boost/type_traits/has_left_shift.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_left_shift
#define BOOST_TT_TRAIT_OP <<
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
( \
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

46
include/boost/type_traits/has_left_shift_assign.hpp
View File

@@ -12,38 +12,38 @@
#define BOOST_TT_TRAIT_NAME has_left_shift_assign
#define BOOST_TT_TRAIT_OP <<=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
( \
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_const< Lhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

40
include/boost/type_traits/has_less.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_less
#define BOOST_TT_TRAIT_OP <
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==pointer and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
) || \
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
) || \
/* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_not<\
::boost::type_traits::ice_or<\
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_void< Lhs_noptr >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value && \
(! \
( \
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \
::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_void< Lhs_noptr >::value || \
::boost::is_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
)\
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

40
include/boost/type_traits/has_less_equal.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_less_equal
#define BOOST_TT_TRAIT_OP <=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==pointer and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
) || \
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
) || \
/* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_not<\
::boost::type_traits::ice_or<\
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_void< Lhs_noptr >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value && \
(! \
( \
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \
::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_void< Lhs_noptr >::value || \
::boost::is_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
)\
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

32
include/boost/type_traits/has_logical_and.hpp
View File

@@ -13,22 +13,22 @@
#define BOOST_TT_TRAIT_OP &&
#define BOOST_TT_FORBIDDEN_IF\
/* pointer with fundamental non convertible to bool */\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_not< ::boost::is_convertible< Rhs_nocv, bool >::value >::value\
>::value\
>::value,\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::type_traits::ice_not< ::boost::is_convertible< Lhs_nocv, bool >::value >::value\
>::value\
>::value\
>::value
(\
(\
::boost::is_pointer< Lhs_noref >::value && \
( \
::boost::is_fundamental< Rhs_nocv >::value && \
(! ::boost::is_convertible< Rhs_nocv, bool >::value )\
)\
)||\
(\
::boost::is_pointer< Rhs_noref >::value && \
( \
::boost::is_fundamental< Lhs_nocv >::value && \
(! ::boost::is_convertible< Lhs_nocv, bool >::value )\
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

32
include/boost/type_traits/has_logical_or.hpp
View File

@@ -13,22 +13,22 @@
#define BOOST_TT_TRAIT_OP ||
#define BOOST_TT_FORBIDDEN_IF\
/* pointer with fundamental non convertible to bool */\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_not< ::boost::is_convertible< Rhs_nocv, bool >::value >::value\
>::value\
>::value,\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::type_traits::ice_not< ::boost::is_convertible< Lhs_nocv, bool >::value >::value\
>::value\
>::value\
>::value
(\
(\
::boost::is_pointer< Lhs_noref >::value && \
(\
::boost::is_fundamental< Rhs_nocv >::value && \
(! ::boost::is_convertible< Rhs_nocv, bool >::value )\
)\
)||\
(\
::boost::is_pointer< Rhs_noref >::value && \
(\
::boost::is_fundamental< Lhs_nocv >::value && \
(! ::boost::is_convertible< Lhs_nocv, bool >::value )\
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

58
include/boost/type_traits/has_minus.hpp
View File

@@ -12,43 +12,43 @@
#define BOOST_TT_TRAIT_NAME has_minus
#define BOOST_TT_TRAIT_OP -
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
(! ::boost::is_integral< Rhs_noref >::value )\
) || \
/* Lhs==void* and (Rhs==fundamental or Rhs==pointer) */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_void< Lhs_noptr >::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_void< Lhs_noptr >::value && \
( \
::boost::is_fundamental< Rhs_nocv >::value || \
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value,\
)\
) || \
/* Rhs==void* and (Lhs==fundamental or Lhs==pointer) */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::is_void< Rhs_noptr >::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_void< Rhs_noptr >::value && \
(\
::boost::is_fundamental< Lhs_nocv >::value || \
::boost::is_pointer< Lhs_noref >::value\
>::value\
>::value,\
)\
) ||\
/* Lhs=fundamental and Rhs=pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
) ||\
/* two different pointers */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_not< ::boost::is_same< Lhs_nocv, Rhs_nocv >::value >::value\
>::value\
>::value
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value && \
(! ::boost::is_same< Lhs_nocv, Rhs_nocv >::value )\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

58
include/boost/type_traits/has_minus_assign.hpp
View File

@@ -12,48 +12,48 @@
#define BOOST_TT_TRAIT_NAME has_minus_assign
#define BOOST_TT_TRAIT_OP -=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
(! ::boost::is_integral< Rhs_noref >::value )\
) || \
/* Lhs==void* and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_void< Lhs_noptr >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_void< Lhs_noptr >::value && \
::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
) || \
/* Rhs==void* and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::is_void< Rhs_noptr >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_void< Rhs_noptr >::value && \
::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
) || \
/* Lhs=fundamental and Rhs=pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
) || \
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
) || \
/* (Lhs==fundamental or Lhs==pointer) and (Rhs==fundamental or Rhs==pointer) and (Lhs==const) */\
::boost::type_traits::ice_and<\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
(\
::boost::is_fundamental< Lhs_nocv >::value || \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Rhs_nocv >::value,\
) && \
(\
::boost::is_fundamental< Rhs_nocv >::value || \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
) && \
::boost::is_const< Lhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

38
include/boost/type_traits/has_modulus.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_modulus
#define BOOST_TT_TRAIT_OP %
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
(\
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

46
include/boost/type_traits/has_modulus_assign.hpp
View File

@@ -12,38 +12,38 @@
#define BOOST_TT_TRAIT_NAME has_modulus_assign
#define BOOST_TT_TRAIT_OP %=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
( \
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_const< Lhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

28
include/boost/type_traits/has_multiplies.hpp
View File

@@ -13,22 +13,22 @@
#define BOOST_TT_TRAIT_OP *
#define BOOST_TT_FORBIDDEN_IF\
/* pointer with pointer or fundamental */\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
(\
::boost::is_pointer< Lhs_noref >::value && \
(\
::boost::is_fundamental< Rhs_nocv >::value || \
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value,\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Lhs_nocv >::value,\
)\
)||\
(\
::boost::is_pointer< Rhs_noref >::value && \
(\
::boost::is_fundamental< Lhs_nocv >::value || \
::boost::is_pointer< Lhs_noref >::value\
>::value\
>::value\
>::value
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

36
include/boost/type_traits/has_multiplies_assign.hpp
View File

@@ -12,30 +12,30 @@
#define BOOST_TT_TRAIT_NAME has_multiplies_assign
#define BOOST_TT_TRAIT_OP *=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Lhs==const and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_const< Lhs_noref >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_const< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
) || \
/* Lhs==pointer and (Rhs==fundamental or Rhs==pointer) */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
( \
::boost::is_fundamental< Rhs_nocv >::value || \
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value,\
)\
)||\
/* Rhs==pointer and (Lhs==fundamental or Lhs==pointer) */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
( \
::boost::is_fundamental< Lhs_nocv >::value || \
::boost::is_pointer< Lhs_noref >::value\
>::value\
>::value\
>::value
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

23
include/boost/type_traits/has_new_operator.hpp
View File

@@ -11,12 +11,9 @@
#include <new> // std::nothrow_t
#include <cstddef> // std::size_t
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#include <boost/detail/workaround.hpp>
#if defined(new)
# if BOOST_WORKAROUND(BOOST_MSVC, >= 1310)
@@ -129,19 +126,17 @@ namespace detail {
#endif
#endif
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_or<
(s1 == sizeof(type_traits::yes_type)),
(s2 == sizeof(type_traits::yes_type)),
(s3 == sizeof(type_traits::yes_type)),
(s4 == sizeof(type_traits::yes_type)),
(s5 == sizeof(type_traits::yes_type)),
(s1 == sizeof(type_traits::yes_type)) ||
(s2 == sizeof(type_traits::yes_type)) ||
(s3 == sizeof(type_traits::yes_type)) ||
(s4 == sizeof(type_traits::yes_type)) ||
(s5 == sizeof(type_traits::yes_type)) ||
(s6 == sizeof(type_traits::yes_type))
>::value)
);
};
} // namespace detail
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_new_operator,T,::boost::detail::has_new_operator_impl<T>::value)
template <class T> struct has_new_operator : public integral_constant<bool, ::boost::detail::has_new_operator_impl<T>::value>{};
} // namespace boost
@@ -149,6 +144,4 @@ BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_new_operator,T,::boost::detail::has_new_operato
# pragma pop_macro("new")
#endif
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED

40
include/boost/type_traits/has_not_equal_to.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_not_equal_to
#define BOOST_TT_TRAIT_OP !=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==pointer and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
) || \
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
) || \
/* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value,\
::boost::type_traits::ice_not<\
::boost::type_traits::ice_or<\
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value,\
::boost::is_same< Lhs_noptr, Rhs_noptr >::value,\
::boost::is_void< Lhs_noptr >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value && \
(! \
(\
::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value || \
::boost::is_same< Lhs_noptr, Rhs_noptr >::value || \
::boost::is_void< Lhs_noptr >::value || \
::boost::is_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
)\
)\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

38
include/boost/type_traits/has_nothrow_assign.hpp
View File

@@ -9,36 +9,38 @@
#ifndef BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED
#include <boost/type_traits/has_trivial_assign.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/intrinsics.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#if !defined(BOOST_HAS_NOTHROW_ASSIGN) || defined(BOOST_MSVC) || defined(BOOST_INTEL)
#include <boost/type_traits/has_trivial_assign.hpp>
#endif
#if defined(__GNUC__)
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_volatile.hpp>
#ifdef BOOST_INTEL
#include <boost/type_traits/is_pod.hpp>
#endif
#endif
namespace boost {
namespace detail{
template <class T>
struct has_nothrow_assign_imp{
struct has_nothrow_assign : public integral_constant<bool,
#ifndef BOOST_HAS_NOTHROW_ASSIGN
BOOST_STATIC_CONSTANT(bool, value = ::boost::has_trivial_assign<T>::value);
::boost::has_trivial_assign<T>::value
#else
BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_NOTHROW_ASSIGN(T));
BOOST_HAS_NOTHROW_ASSIGN(T)
#endif
};
>{};
}
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_assign,T,::boost::detail::has_nothrow_assign_imp<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_assign,void,false)
template <> struct has_nothrow_assign<void> : public false_type{};
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_assign,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_assign,void const volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_assign,void volatile,false)
template <> struct has_nothrow_assign<void const> : public false_type{};
template <> struct has_nothrow_assign<void const volatile> : public false_type{};
template <> struct has_nothrow_assign<void volatile> : public false_type{};
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED

47
include/boost/type_traits/has_nothrow_constructor.hpp
View File

@@ -9,45 +9,38 @@
#ifndef BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
#define BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
#include <boost/type_traits/has_trivial_constructor.hpp>
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#ifdef BOOST_HAS_NOTHROW_CONSTRUCTOR
#if defined(BOOST_MSVC) || defined(BOOST_INTEL)
#include <boost/type_traits/has_trivial_constructor.hpp>
#endif
namespace boost {
namespace detail{
template <class T> struct has_nothrow_constructor : public integral_constant<bool, BOOST_HAS_NOTHROW_CONSTRUCTOR(T)>{};
template <class T>
struct has_nothrow_constructor_imp{
#ifdef BOOST_HAS_NOTHROW_CONSTRUCTOR
BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_NOTHROW_CONSTRUCTOR(T));
#else
BOOST_STATIC_CONSTANT(bool, value = ::boost::has_trivial_constructor<T>::value);
#include <boost/type_traits/has_trivial_constructor.hpp>
namespace boost {
template <class T> struct has_nothrow_constructor : public ::boost::has_trivial_constructor<T> {};
#endif
};
}
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_constructor,T,::boost::detail::has_nothrow_constructor_imp<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_default_constructor,T,::boost::detail::has_nothrow_constructor_imp<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_constructor,void,false)
template<> struct has_nothrow_constructor<void> : public false_type {};
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_constructor,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_constructor,void const volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_constructor,void volatile,false)
template<> struct has_nothrow_constructor<void const> : public false_type{};
template<> struct has_nothrow_constructor<void const volatile> : public false_type{};
template<> struct has_nothrow_constructor<void volatile> : public false_type{};
#endif
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_default_constructor,void,false)
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_default_constructor,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_default_constructor,void const volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_default_constructor,void volatile,false)
#endif
template <class T> struct has_nothrow_default_constructor : public has_nothrow_constructor<T>{};
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED

53
include/boost/type_traits/has_nothrow_copy.hpp
View File

@@ -9,45 +9,44 @@
#ifndef BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED
#define BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED
#include <boost/type_traits/has_trivial_copy.hpp>
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#ifdef BOOST_HAS_NOTHROW_COPY
#if defined(BOOST_CLANG) || defined(__GNUC__) || defined(__ghs__) || defined(__CODEGEARC__)
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/is_reference.hpp>
#ifdef BOOST_INTEL
#include <boost/type_traits/is_pod.hpp>
#endif
#elif defined(BOOST_MSVC) || defined(BOOST_INTEL)
#include <boost/type_traits/has_trivial_copy.hpp>
#endif
namespace boost {
namespace detail{
template <class T> struct has_nothrow_copy_constructor : public integral_constant<bool, BOOST_HAS_NOTHROW_COPY(T)>{};
template <class T>
struct has_nothrow_copy_imp{
#ifdef BOOST_HAS_NOTHROW_COPY
BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_NOTHROW_COPY(T));
#else
BOOST_STATIC_CONSTANT(bool, value = ::boost::has_trivial_copy<T>::value);
#include <boost/type_traits/has_trivial_copy.hpp>
namespace boost{
template <class T> struct has_nothrow_copy_constructor : public integral_constant<bool, ::boost::has_trivial_copy<T>::value>{};
#endif
};
}
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_copy,T,::boost::detail::has_nothrow_copy_imp<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_copy_constructor,T,::boost::detail::has_nothrow_copy_imp<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy,void,false)
template <> struct has_nothrow_copy_constructor<void> : public false_type{};
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy,void const volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy,void volatile,false)
template <> struct has_nothrow_copy_constructor<void const> : public false_type{};
template <> struct has_nothrow_copy_constructor<void volatile> : public false_type{};
template <> struct has_nothrow_copy_constructor<void const volatile> : public false_type{};
#endif
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy_constructor,void,false)
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy_constructor,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy_constructor,void const volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_nothrow_copy_constructor,void volatile,false)
#endif
template <class T> struct has_nothrow_copy : public has_nothrow_copy_constructor<T>{};
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED

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

@@ -11,15 +11,10 @@
#include <boost/type_traits/has_trivial_destructor.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_destructor,T,::boost::has_trivial_destructor<T>::value)
template <class T> struct has_nothrow_destructor : public ::boost::has_trivial_destructor<T> {};
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED

46
include/boost/type_traits/has_plus.hpp
View File

@@ -12,37 +12,37 @@
#define BOOST_TT_TRAIT_NAME has_plus
#define BOOST_TT_TRAIT_OP +
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
) || \
/* Lhs==void* and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_void< Lhs_noptr >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_void< Lhs_noptr >::value && \
::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
) || \
/* Rhs==void* and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::is_void< Rhs_noptr >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_void< Rhs_noptr >::value && \
::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
) || \
/* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
(! ::boost::is_integral< Rhs_noref >::value )\
) || \
/* Rhs==pointer and Lhs==fundamental and Lhs!=integral */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value\
>::value\
>::value
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_fundamental< Lhs_nocv >::value && \
(! ::boost::is_integral< Lhs_noref >::value )\
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

62
include/boost/type_traits/has_plus_assign.hpp
View File

@@ -12,49 +12,49 @@
#define BOOST_TT_TRAIT_NAME has_plus_assign
#define BOOST_TT_TRAIT_OP +=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
) || \
/* Lhs==void* and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_void< Lhs_noptr >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_void< Lhs_noptr >::value && \
::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
) || \
/* Rhs==void* and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::is_void< Rhs_noptr >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_void< Rhs_noptr >::value && \
::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
) || \
/* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
(! ::boost::is_integral< Rhs_noref >::value )\
) || \
/* Rhs==pointer and Lhs==fundamental and Lhs!=bool */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::type_traits::ice_not< ::boost::is_same< Lhs_nocv, bool >::value >::value\
>::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_fundamental< Lhs_nocv >::value && \
(! ::boost::is_same< Lhs_nocv, bool >::value )\
) || \
/* (Lhs==fundamental or Lhs==pointer) and (Rhs==fundamental or Rhs==pointer) and (Lhs==const) */\
::boost::type_traits::ice_and<\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
(\
::boost::is_fundamental< Lhs_nocv >::value || \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Rhs_nocv >::value,\
) && \
( \
::boost::is_fundamental< Rhs_nocv >::value || \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
) && \
::boost::is_const< Lhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

22
include/boost/type_traits/has_post_decrement.hpp
View File

@@ -14,25 +14,25 @@
#define BOOST_TT_TRAIT_NAME has_post_decrement
#define BOOST_TT_TRAIT_OP --
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* bool */\
::boost::is_same< bool, Lhs_nocv >::value,\
::boost::is_same< bool, Lhs_nocv >::value || \
/* void* */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_void< Lhs_noptr >::value\
>::value,\
) || \
/* (fundamental or pointer) and const */\
::boost::type_traits::ice_and<\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
( \
::boost::is_fundamental< Lhs_nocv >::value || \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
) && \
::boost::is_const< Lhs_noref >::value\
>::value,\
)||\
/* Arrays */ \
::boost::is_array<Lhs_noref>::value\
>::value
)
#include <boost/type_traits/detail/has_postfix_operator.hpp>

22
include/boost/type_traits/has_post_increment.hpp
View File

@@ -14,25 +14,25 @@
#define BOOST_TT_TRAIT_NAME has_post_increment
#define BOOST_TT_TRAIT_OP ++
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* bool */\
::boost::is_same< bool, Lhs_nocv >::value,\
::boost::is_same< bool, Lhs_nocv >::value || \
/* void* */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_void< Lhs_noptr >::value\
>::value,\
) || \
/* (fundamental or pointer) and const */\
::boost::type_traits::ice_and<\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
( \
::boost::is_fundamental< Lhs_nocv >::value || \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
) && \
::boost::is_const< Lhs_noref >::value\
>::value,\
)||\
/* Arrays */ \
::boost::is_array<Lhs_noref>::value\
>::value
)
#include <boost/type_traits/detail/has_postfix_operator.hpp>

22
include/boost/type_traits/has_pre_decrement.hpp
View File

@@ -14,25 +14,25 @@
#define BOOST_TT_TRAIT_NAME has_pre_decrement
#define BOOST_TT_TRAIT_OP --
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* bool */\
::boost::is_same< bool, Rhs_nocv >::value,\
::boost::is_same< bool, Rhs_nocv >::value || \
/* void* */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_void< Rhs_noptr >::value\
>::value,\
) || \
/* (fundamental or pointer) and const */\
::boost::type_traits::ice_and<\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
( \
::boost::is_fundamental< Rhs_nocv >::value || \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
) && \
::boost::is_const< Rhs_noref >::value\
>::value,\
)||\
/* Arrays */ \
::boost::is_array<Rhs_noref>::value\
>::value
)
#include <boost/type_traits/detail/has_prefix_operator.hpp>

22
include/boost/type_traits/has_pre_increment.hpp
View File

@@ -14,25 +14,25 @@
#define BOOST_TT_TRAIT_NAME has_pre_increment
#define BOOST_TT_TRAIT_OP ++
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* bool */\
::boost::is_same< bool, Rhs_nocv >::value,\
::boost::is_same< bool, Rhs_nocv >::value || \
/* void* */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Rhs_noref >::value,\
(\
::boost::is_pointer< Rhs_noref >::value && \
::boost::is_void< Rhs_noptr >::value\
>::value,\
) || \
/* (fundamental or pointer) and const */\
::boost::type_traits::ice_and<\
::boost::type_traits::ice_or<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
( \
::boost::is_fundamental< Rhs_nocv >::value || \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
) && \
::boost::is_const< Rhs_noref >::value\
>::value,\
)||\
/* Arrays */ \
::boost::is_array<Rhs_noref>::value\
>::value
)
#include <boost/type_traits/detail/has_prefix_operator.hpp>

38
include/boost/type_traits/has_right_shift.hpp
View File

@@ -12,32 +12,32 @@
#define BOOST_TT_TRAIT_NAME has_right_shift
#define BOOST_TT_TRAIT_OP >>
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
( \
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

46
include/boost/type_traits/has_right_shift_assign.hpp
View File

@@ -12,38 +12,38 @@
#define BOOST_TT_TRAIT_NAME has_right_shift_assign
#define BOOST_TT_TRAIT_OP >>=
#define BOOST_TT_FORBIDDEN_IF\
::boost::type_traits::ice_or<\
(\
/* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
::boost::type_traits::ice_or<\
::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
( \
(! ::boost::is_integral< Lhs_noref >::value ) || \
(! ::boost::is_integral< Rhs_noref >::value )\
)\
)||\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Rhs==fundamental and Lhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_pointer< Lhs_noref >::value\
>::value,\
)||\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
(\
::boost::is_pointer< Lhs_noref >::value && \
::boost::is_pointer< Rhs_noref >::value\
>::value,\
)||\
/* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
::boost::type_traits::ice_and<\
::boost::is_fundamental< Lhs_nocv >::value,\
::boost::is_fundamental< Rhs_nocv >::value,\
(\
::boost::is_fundamental< Lhs_nocv >::value && \
::boost::is_fundamental< Rhs_nocv >::value && \
::boost::is_const< Lhs_noref >::value\
>::value\
>::value
)\
)
#include <boost/type_traits/detail/has_binary_operator.hpp>

41
include/boost/type_traits/has_trivial_assign.hpp
View File

@@ -9,49 +9,34 @@
#ifndef BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/detail/config.hpp>
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#if !defined(BOOST_HAS_TRIVIAL_ASSIGN) || defined(BOOST_MSVC) || defined(__GNUC__) || defined(BOOST_INTEL)
#include <boost/type_traits/is_pod.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/detail/ice_and.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/type_traits/detail/ice_not.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#endif
namespace boost {
namespace detail {
template <typename T>
struct has_trivial_assign_impl
{
struct has_trivial_assign : public integral_constant<bool,
#ifdef BOOST_HAS_TRIVIAL_ASSIGN
BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_TRIVIAL_ASSIGN(T));
BOOST_HAS_TRIVIAL_ASSIGN(T)
#else
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::is_pod<T>::value,
::boost::type_traits::ice_not< ::boost::is_const<T>::value >::value,
::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value
>::value));
::boost::is_pod<T>::value && !::boost::is_const<T>::value && !::boost::is_volatile<T>::value
#endif
};
> {};
} // namespace detail
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_assign,T,::boost::detail::has_trivial_assign_impl<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_assign,void,false)
template<> struct has_trivial_assign<void> : public false_type{};
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_assign,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_assign,void const volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_assign,void volatile,false)
template<> struct has_trivial_assign<void const> : public false_type{};
template<> struct has_trivial_assign<void const volatile> : public false_type{};
template<> struct has_trivial_assign<void volatile> : public false_type{};
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED

40
include/boost/type_traits/has_trivial_constructor.hpp
View File

@@ -9,43 +9,31 @@
#ifndef BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED
#define BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/is_pod.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#ifdef BOOST_HAS_TRIVIAL_CONSTRUCTOR
#ifdef BOOST_HAS_SGI_TYPE_TRAITS
#include <boost/type_traits/is_same.hpp>
#elif defined(__GNUC__)
#include <boost/type_traits/is_volatile.hpp>
#ifdef BOOST_INTEL
#include <boost/type_traits/is_pod.hpp>
#endif
#endif
#endif
namespace boost {
namespace detail {
template <typename T>
struct has_trivial_ctor_impl
{
template <typename T> struct has_trivial_constructor
#ifdef BOOST_HAS_TRIVIAL_CONSTRUCTOR
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_or<
::boost::is_pod<T>::value,
BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)
>::value));
: public integral_constant <bool, (::boost::is_pod<T>::value || BOOST_HAS_TRIVIAL_CONSTRUCTOR(T))>{};
#else
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_or<
::boost::is_pod<T>::value,
false
>::value));
: public integral_constant <bool, ::boost::is_pod<T>::value>{};
#endif
};
} // namespace detail
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_constructor,T,::boost::detail::has_trivial_ctor_impl<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_default_constructor,T,::boost::detail::has_trivial_ctor_impl<T>::value)
template <class T> struct has_trivial_default_constructor : public has_trivial_constructor<T> {};
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED

54
include/boost/type_traits/has_trivial_copy.hpp
View File

@@ -9,74 +9,46 @@
#ifndef BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
#define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/is_pod.hpp>
#include <boost/type_traits/detail/ice_and.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/type_traits/detail/ice_not.hpp>
#include <boost/type_traits/is_reference.hpp>
#ifdef __clang__
#include <boost/type_traits/is_copy_constructible.hpp>
#endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
namespace detail {
template <typename T>
struct has_trivial_copy_impl
{
template <typename T> struct has_trivial_copy
: public integral_constant<bool,
#ifdef BOOST_HAS_TRIVIAL_COPY
# ifdef __clang__
BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_TRIVIAL_COPY(T) && boost::is_copy_constructible<T>::value);
BOOST_HAS_TRIVIAL_COPY(T) && boost::is_copy_constructible<T>::value
# else
BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_TRIVIAL_COPY(T));
BOOST_HAS_TRIVIAL_COPY(T)
# endif
#else
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::is_pod<T>::value,
::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value
>::value));
::boost::is_pod<T>::value && ! ::boost::is_volatile<T>::value
#endif
};
>{};
#ifdef __clang__
template <typename T, std::size_t N>
struct has_trivial_copy_impl<T[N]>
{
static const bool value = has_trivial_copy_impl<T>::value;
};
struct has_trivial_copy<T[N]> : public has_trivial_copy<T>{};
#endif
} // namespace detail
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_copy,T,::boost::detail::has_trivial_copy_impl<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_copy_constructor,T,::boost::detail::has_trivial_copy_impl<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy,void,false)
template <> struct has_trivial_copy<void> : public false_type{};
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy,void const volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy,void volatile,false)
template <> struct has_trivial_copy<void const> : public false_type{};
template <> struct has_trivial_copy<void volatile> : public false_type{};
template <> struct has_trivial_copy<void const volatile> : public false_type{};
#endif
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy_constructor,void,false)
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy_constructor,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy_constructor,void const volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_copy_constructor,void volatile,false)
#endif
template <class T> struct has_trivial_copy_constructor : public has_trivial_copy<T>{};
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED

43
include/boost/type_traits/has_trivial_destructor.hpp
View File

@@ -9,41 +9,36 @@
#ifndef BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED
#define BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/is_pod.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/type_traits/integral_constant.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#ifdef BOOST_HAS_TRIVIAL_DESTRUCTOR
#if defined(BOOST_INTEL) || defined(BOOST_MSVC)
#include <boost/type_traits/is_pod.hpp>
#endif
#ifdef BOOST_HAS_SGI_TYPE_TRAITS
#include <boost/type_traits/is_same.hpp>
#endif
namespace boost {
namespace detail {
template <typename T>
struct has_trivial_dtor_impl
{
#ifdef BOOST_HAS_TRIVIAL_DESTRUCTOR
BOOST_STATIC_CONSTANT(bool, value = BOOST_HAS_TRIVIAL_DESTRUCTOR(T));
template <typename T> struct has_trivial_destructor : public integral_constant<bool, BOOST_HAS_TRIVIAL_DESTRUCTOR(T)>{};
#else
BOOST_STATIC_CONSTANT(bool, value = ::boost::is_pod<T>::value);
#include <boost/type_traits/is_pod.hpp>
namespace boost{
template <typename T> struct has_trivial_destructor : public integral_constant<bool, ::boost::is_pod<T>::value>{};
#endif
};
} // namespace detail
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_destructor,T,::boost::detail::has_trivial_dtor_impl<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_destructor,void,false)
template <> struct has_trivial_destructor<void> : public false_type{};
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_destructor,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_destructor,void const volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_destructor,void volatile,false)
template <> struct has_trivial_destructor<void const> : public false_type{};
template <> struct has_trivial_destructor<void const volatile> : public false_type{};
template <> struct has_trivial_destructor<void volatile> : public false_type{};
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED

43
include/boost/type_traits/has_trivial_move_assign.hpp
View File

@@ -11,47 +11,36 @@
#ifndef BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#if !defined(BOOST_HAS_TRIVIAL_MOVE_ASSIGN) || defined(BOOST_MSVC) || defined(BOOST_INTEL)
#include <boost/type_traits/is_pod.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/detail/ice_and.hpp>
#include <boost/type_traits/detail/ice_not.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#ifdef BOOST_MSVC
#include <boost/type_traits/is_reference.hpp>
#endif
#endif
namespace boost {
namespace detail {
template <typename T>
struct has_trivial_move_assign_impl
{
struct has_trivial_move_assign : public integral_constant<bool,
#ifdef BOOST_HAS_TRIVIAL_MOVE_ASSIGN
BOOST_STATIC_CONSTANT(bool, value = (BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T)));
BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T)
#else
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::is_pod<T>::value,
::boost::type_traits::ice_not< ::boost::is_const<T>::value >::value,
::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value
>::value));
::boost::is_pod<T>::value && !::boost::is_const<T>::value && !::boost::is_volatile<T>::value
#endif
};
> {};
} // namespace detail
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_move_assign,T,::boost::detail::has_trivial_move_assign_impl<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_assign,void,false)
template <> struct has_trivial_move_assign<void> : public false_type{};
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_assign,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_assign,void const volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_assign,void volatile,false)
template <> struct has_trivial_move_assign<void const> : public false_type{};
template <> struct has_trivial_move_assign<void const volatile> : public false_type{};
template <> struct has_trivial_move_assign<void volatile> : public false_type{};
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_TRIVIAL_MOVE_ASSIGN_HPP_INCLUDED

47
include/boost/type_traits/has_trivial_move_constructor.hpp
View File

@@ -11,47 +11,38 @@
#ifndef BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED
#define BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#ifdef BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR
#if defined(BOOST_MSVC) || defined(BOOST_INTEL)
#include <boost/type_traits/is_pod.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/detail/ice_and.hpp>
#include <boost/type_traits/detail/ice_not.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#endif
namespace boost {
namespace detail {
template <typename T> struct has_trivial_move_constructor : public integral_constant<bool, BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)>{};
template <typename T>
struct has_trivial_move_ctor_impl
{
#ifdef BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR
BOOST_STATIC_CONSTANT(bool, value = (BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T)));
#else
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::is_pod<T>::value,
::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value
>::value));
#include <boost/type_traits/is_pod.hpp>
#include <boost/type_traits/is_volatile.hpp>
namespace boost {
template <typename T> struct has_trivial_move_constructor
: public integral_constant<bool, ::boost::is_pod<T>::value && !::boost::is_volatile<T>::value>{};
#endif
};
} // namespace detail
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_move_constructor,T,::boost::detail::has_trivial_move_ctor_impl<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_constructor,void,false)
template <> struct has_trivial_move_constructor<void> : public false_type{};
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_constructor,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_constructor,void const volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(has_trivial_move_constructor,void volatile,false)
template <> struct has_trivial_move_constructor<void const> : public false_type{};
template <> struct has_trivial_move_constructor<void volatile> : public false_type{};
template <> struct has_trivial_move_constructor<void const volatile> : public false_type{};
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_TRIVIAL_MOVE_CONSTRUCTOR_HPP_INCLUDED

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

@@ -11,19 +11,16 @@
#define BOOST_TT_HAS_VIRTUAL_DESTRUCTOR_HPP_INCLUDED
#include <boost/type_traits/intrinsics.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#include <boost/type_traits/integral_constant.hpp>
namespace boost {
#ifdef BOOST_HAS_VIRTUAL_DESTRUCTOR
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_virtual_destructor,T,BOOST_HAS_VIRTUAL_DESTRUCTOR(T))
template <class T> struct has_virtual_destructor : public integral_constant<bool, BOOST_HAS_VIRTUAL_DESTRUCTOR(T)>{};
#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_virtual_destructor,T,false)
template <class T> struct has_virtual_destructor : public integral_constant<bool, false>{};
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED

110
include/boost/type_traits/integral_constant.hpp
View File

@@ -1,4 +1,4 @@
// (C) Copyright John Maddock 2005.
// (C) Copyright John Maddock 2015.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -7,32 +7,98 @@
#define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP
#include <boost/config.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/integral_c.hpp>
#include <boost/detail/workaround.hpp>
#if (BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \
|| BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
|| BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \
|| BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \
|| BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(810)) )
namespace boost{
namespace mpl
{
template <bool B> struct bool_;
template <class I, I val> struct integral_c;
struct integral_c_tag;
}
}
#else
namespace mpl_{
template <bool B> struct bool_;
template <class I, I val> struct integral_c;
struct integral_c_tag;
}
namespace boost
{
namespace mpl
{
using ::mpl_::bool_;
using ::mpl_::integral_c;
using ::mpl_::integral_c_tag;
}
}
#endif
namespace boost{
#if defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS) || defined(__BORLANDC__)
template <class T, int val>
#else
template <class T, T val>
#endif
struct integral_constant : public mpl::integral_c<T, val>
{
typedef integral_constant<T,val> type;
};
template <class T, T val>
struct integral_constant
{
typedef mpl::integral_c_tag tag;
typedef T value_type;
typedef integral_constant<T, val> type;
static const T value = val;
//
// This helper function is just to disable type-punning
// warnings from GCC:
//
template <class U>
static U& dereference(U* p) { return *p; }
template<> struct integral_constant<bool,true> : public mpl::true_
{
typedef integral_constant<bool,true> type;
};
template<> struct integral_constant<bool,false> : public mpl::false_
{
typedef integral_constant<bool,false> type;
};
operator const mpl::integral_c<T, val>& ()const
{
static const char data[sizeof(long)] = { 0 };
return dereference(reinterpret_cast<const mpl::integral_c<T, val>*>(&data));
}
BOOST_CONSTEXPR operator T()const { return val; }
};
typedef integral_constant<bool,true> true_type;
typedef integral_constant<bool,false> false_type;
template <class T, T val>
T const integral_constant<T, val>::value;
template <bool val>
struct integral_constant<bool, val>
{
typedef mpl::integral_c_tag tag;
typedef integral_constant<bool, val> type;
static const bool value = val;
//
// This helper function is just to disable type-punning
// warnings from GCC:
//
template <class T>
static T& dereference(T* p) { return *p; }
operator const mpl::bool_<val>& ()const
{
static const char data = 0;
return dereference(reinterpret_cast<const mpl::bool_<val>*>(&data));
}
BOOST_CONSTEXPR operator bool()const { return val; }
};
template <bool val>
bool const integral_constant<bool, val>::value;
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
}

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

@@ -7,18 +7,12 @@
#define FILE_boost_type_traits_integral_promotion_hpp_INCLUDED
#include <boost/config.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/remove_cv.hpp>
// Should be the last #include
#include <boost/type_traits/detail/type_trait_def.hpp>
namespace boost {
namespace type_traits { namespace detail {
@@ -168,27 +162,20 @@ struct integral_promotion_impl
>::type type;
};
template<class T>
struct integral_promotion
: public boost::mpl::eval_if<
need_promotion<BOOST_DEDUCED_TYPENAME remove_cv<T>::type>
, integral_promotion_impl<T>
, boost::mpl::identity<T>
>
{
};
template<class T, bool b> struct integral_promotion { typedef T type; };
template<class T> struct integral_promotion<T, true> : public integral_promotion_impl<T>{};
} }
BOOST_TT_AUX_TYPE_TRAIT_DEF1(
integral_promotion
, T
, BOOST_DEDUCED_TYPENAME
boost::type_traits::detail::integral_promotion<T>::type
)
}
template <class T> struct integral_promotion
{
private:
typedef boost::type_traits::detail::need_promotion<typename remove_cv<T>::type> tag_type;
public:
typedef typename boost::type_traits::detail::integral_promotion<T, tag_type::value>::type type;
};
#include <boost/type_traits/detail/type_trait_undef.hpp>
}
#endif // #ifndef FILE_boost_type_traits_integral_promotion_hpp_INCLUDED

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

@@ -8,8 +8,10 @@
#ifndef BOOST_TT_INTRINSICS_HPP_INCLUDED
#define BOOST_TT_INTRINSICS_HPP_INCLUDED
#ifndef BOOST_TT_DISABLE_INTRINSICS
#ifndef BOOST_TT_CONFIG_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/detail/config.hpp>
#endif
//
@@ -44,6 +46,9 @@
// BOOST_IS_ENUM(T) true is T is an enum
// BOOST_IS_POLYMORPHIC(T) true if T is a polymorphic type
// BOOST_ALIGNMENT_OF(T) should evaluate to the alignment requirements of type T.
//
// define BOOST_TT_DISABLE_INTRINSICS to prevent any intrinsics being used (mostly used when testing)
//
#ifdef BOOST_HAS_SGI_TYPE_TRAITS
// Hook into SGI's __type_traits class, this will pick up user supplied
@@ -85,9 +90,11 @@
#if (defined(BOOST_MSVC) && defined(BOOST_MSVC_FULL_VER) && (BOOST_MSVC_FULL_VER >=140050215))\
|| (defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1500))
# include <boost/type_traits/is_same.hpp>
# include <boost/type_traits/is_function.hpp>
//
// Note that even though these intrinsics rely on other type traits classes
// we do not #include those here as it produces cyclic dependencies and
// can cause the intrinsics to not even be used at all!
//
# define BOOST_IS_UNION(T) __is_union(T)
# define BOOST_IS_POD(T) (__is_pod(T) && __has_trivial_constructor(T))
# define BOOST_IS_EMPTY(T) __is_empty(T)
@@ -111,8 +118,8 @@
// # define BOOST_ALIGNMENT_OF(T) __alignof(T)
# if defined(_MSC_VER) && (_MSC_VER >= 1700)
# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || __is_pod(T)) && !::boost::is_volatile<T>::value && !::boost::is_reference<T>::value)
# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || __is_pod(T)) && ! ::boost::is_const<T>::value && !::boost::is_volatile<T>::value && !::boost::is_reference<T>::value)
# define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) ((__has_trivial_move_constructor(T) || boost::is_pod<T>::value) && ! ::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value)
# define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) ((__has_trivial_move_assign(T) || boost::is_pod<T>::value) && ! ::boost::is_const<T>::value && !::boost::is_volatile<T>::value && ! ::boost::is_reference<T>::value)
# endif
#if _MSC_FULL_VER >= 180020827
# define BOOST_IS_NOTHROW_MOVE_ASSIGN(T) (__is_nothrow_assignable(T&, T&&))
@@ -144,10 +151,12 @@
// This is a rubbish fix as it basically stops type traits from working correctly,
// but maybe the best we can do for now. See https://svn.boost.org/trac/boost/ticket/10694
//
//
// Note that even though these intrinsics rely on other type traits classes
// we do not #include those here as it produces cyclic dependencies and
// can cause the intrinsics to not even be used at all!
//
# include <cstddef>
# include <boost/type_traits/is_same.hpp>
# include <boost/type_traits/is_reference.hpp>
# include <boost/type_traits/is_volatile.hpp>
# if __has_feature(is_union)
# define BOOST_IS_UNION(T) __is_union(T)
@@ -215,9 +224,11 @@
#endif
#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) && !defined(__GCCXML__))) && !defined(BOOST_CLANG)
# include <boost/type_traits/is_same.hpp>
# include <boost/type_traits/is_reference.hpp>
# include <boost/type_traits/is_volatile.hpp>
//
// Note that even though these intrinsics rely on other type traits classes
// we do not #include those here as it produces cyclic dependencies and
// can cause the intrinsics to not even be used at all!
//
#ifdef BOOST_INTEL
# define BOOST_INTEL_TT_OPTS || is_pod<T>::value
@@ -338,11 +349,7 @@
# define BOOST_HAS_TYPE_TRAITS_INTRINSICS
#endif
#endif // BOOST_TT_DISABLE_INTRINSICS
#endif // BOOST_TT_INTRINSICS_HPP_INCLUDED

12
include/boost/type_traits/is_abstract.hpp
View File

@@ -49,20 +49,18 @@
//
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#ifndef BOOST_IS_ABSTRACT
#include <boost/static_assert.hpp>
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/type_traits/is_class.hpp>
#include <boost/type_traits/detail/ice_and.hpp>
#ifdef BOOST_NO_IS_ABSTRACT
#include <boost/type_traits/is_polymorphic.hpp>
#endif
#endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
namespace detail{
#ifdef BOOST_IS_ABSTRACT
@@ -141,13 +139,11 @@ struct is_abstract_imp
}
#ifndef BOOST_NO_IS_ABSTRACT
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_abstract,T,::boost::detail::is_abstract_imp<T>::value)
template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_abstract_imp<T>::value> {};
#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_abstract,T,::boost::detail::is_polymorphic_imp<T>::value)
template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_polymorphic_imp<T>::value> {};
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif //BOOST_TT_IS_ABSTRACT_CLASS_HPP

35
include/boost/type_traits/is_arithmetic.hpp
View File

@@ -9,43 +9,14 @@
#ifndef BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED
#define BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED
#if !defined( __CODEGEARC__ )
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_float.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/config.hpp>
#endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#include <boost/type_traits/is_floating_point.hpp>
namespace boost {
#if !defined(__CODEGEARC__)
namespace detail {
template< typename T >
struct is_arithmetic_impl
{
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_or<
::boost::is_integral<T>::value,
::boost::is_float<T>::value
>::value));
};
} // namespace detail
#endif
//* is a type T an arithmetic type described in the standard (3.9.1p8)
#if defined(__CODEGEARC__)
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_arithmetic,T,__is_arithmetic(T))
#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_arithmetic,T,::boost::detail::is_arithmetic_impl<T>::value)
#endif
template <class T>
struct is_arithmetic : public integral_constant<bool, is_integral<T>::value || is_floating_point<T>::value> {};
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED

29
include/boost/type_traits/is_array.hpp
View File

@@ -14,30 +14,25 @@
#ifndef BOOST_TT_IS_ARRAY_HPP_INCLUDED
#define BOOST_TT_IS_ARRAY_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <cstddef>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
#if defined( __CODEGEARC__ )
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,__is_array(T))
template <class T> struct is_array : public integral_constant<bool, __is_array(T)> {};
#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,false)
template <class T> struct is_array : public false_type {};
#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T[N],true)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T const[N],true)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T volatile[N],true)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T const volatile[N],true)
template <class T, std::size_t N> struct is_array<T[N]> : public true_type {};
template <class T, std::size_t N> struct is_array<T const[N]> : public true_type{};
template <class T, std::size_t N> struct is_array<T volatile[N]> : public true_type{};
template <class T, std::size_t N> struct is_array<T const volatile[N]> : public true_type{};
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T[],true)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T const[],true)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T volatile[],true)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T const volatile[],true)
template <class T> struct is_array<T[]> : public true_type{};
template <class T> struct is_array<T const[]> : public true_type{};
template <class T> struct is_array<T const volatile[]> : public true_type{};
template <class T> struct is_array<T volatile[]> : public true_type{};
#endif
#endif
@@ -45,6 +40,4 @@ BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T const volatile[],t
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_IS_ARRAY_HPP_INCLUDED

24
include/boost/type_traits/is_base_and_derived.hpp
View File

@@ -10,18 +10,16 @@
#define BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#ifndef BOOST_IS_BASE_OF
#include <boost/type_traits/is_class.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/detail/ice_and.hpp>
#include <boost/config.hpp>
#include <boost/static_assert.hpp>
#endif
#include <boost/type_traits/remove_cv.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#include <boost/type_traits/is_same.hpp>
namespace boost {
@@ -230,23 +228,17 @@ struct is_base_and_derived_impl
#endif
} // namespace detail
BOOST_TT_AUX_BOOL_TRAIT_DEF2(
is_base_and_derived
, Base
, Derived
, (::boost::detail::is_base_and_derived_impl<Base,Derived>::value)
)
template <class Base, class Derived> struct is_base_and_derived
: public integral_constant<bool, (::boost::detail::is_base_and_derived_impl<Base, Derived>::value)> {};
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base,Derived&,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived&,false)
template <class Base, class Derived> struct is_base_and_derived<Base&, Derived> : public false_type{};
template <class Base, class Derived> struct is_base_and_derived<Base, Derived&> : public false_type{};
template <class Base, class Derived> struct is_base_and_derived<Base&, Derived&> : public false_type{};
#if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x610))
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename Base,is_base_and_derived,Base,Base,false)
template <class Base> struct is_base_and_derived<Base, Base> : public true_type{};
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED

26
include/boost/type_traits/is_base_of.hpp
View File

@@ -12,11 +12,6 @@
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_class.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/type_traits/detail/ice_and.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
@@ -26,24 +21,19 @@ namespace boost {
{
typedef typename remove_cv<B>::type ncvB;
typedef typename remove_cv<D>::type ncvD;
BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_or<
(::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value),
(::boost::type_traits::ice_and< ::boost::is_same<ncvB,ncvD>::value, ::boost::is_class<ncvB>::value>::value)>::value));
BOOST_STATIC_CONSTANT(bool, value = (
(::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value) ||
(::boost::is_same<ncvB,ncvD>::value && ::boost::is_class<ncvB>::value)));
};
}
BOOST_TT_AUX_BOOL_TRAIT_DEF2(
is_base_of
, Base
, Derived
, (::boost::detail::is_base_of_imp<Base, Derived>::value))
template <class Base, class Derived> struct is_base_of
: public integral_constant<bool, (::boost::detail::is_base_of_imp<Base, Derived>::value)> {};
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base,Derived&,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived&,false)
template <class Base, class Derived> struct is_base_of<Base, Derived&> : false_type{};
template <class Base, class Derived> struct is_base_of<Base&, Derived&> : false_type{};
template <class Base, class Derived> struct is_base_of<Base&, Derived> : false_type{};
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED

23
include/boost/type_traits/is_base_of_tr1.hpp
View File

@@ -12,10 +12,6 @@
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_class.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost { namespace tr1{
@@ -25,24 +21,17 @@ namespace boost { namespace tr1{
{
typedef typename remove_cv<B>::type ncvB;
typedef typename remove_cv<D>::type ncvD;
BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_or<
(::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value),
(::boost::is_same<ncvB,ncvD>::value)>::value));
BOOST_STATIC_CONSTANT(bool, value = ((::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value) || (::boost::is_same<ncvB,ncvD>::value)));
};
}
BOOST_TT_AUX_BOOL_TRAIT_DEF2(
is_base_of
, Base
, Derived
, (::boost::tr1::detail::is_base_of_imp<Base, Derived>::value))
template <class Base, class Derived> struct is_base_of
: public integral_constant<bool, (::boost::tr1::detail::is_base_of_imp<Base, Derived>::value)>{};
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base,Derived&,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_of,Base&,Derived&,false)
template <class Base, class Derived> struct is_base_of<Base, Derived&> : public false_type{};
template <class Base, class Derived> struct is_base_of<Base&, Derived&> : public false_type{};
template <class Base, class Derived> struct is_base_of<Base&, Derived> : public false_type{};
} } // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_IS_BASE_OF_TR1_HPP_INCLUDED

49
include/boost/type_traits/is_class.hpp
View File

@@ -10,12 +10,11 @@
#ifndef BOOST_TT_IS_CLASS_HPP_INCLUDED
#define BOOST_TT_IS_CLASS_HPP_INCLUDED
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/detail/config.hpp>
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#ifndef BOOST_IS_CLASS
# include <boost/type_traits/is_union.hpp>
# include <boost/type_traits/detail/ice_and.hpp>
# include <boost/type_traits/detail/ice_not.hpp>
#ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION
# include <boost/type_traits/detail/yes_no_type.hpp>
@@ -29,13 +28,6 @@
#endif // BOOST_IS_CLASS
#ifdef __EDG_VERSION__
# include <boost/type_traits/remove_cv.hpp>
#endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
namespace detail {
@@ -63,10 +55,8 @@ struct is_class_impl
{
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
sizeof(is_class_tester<T>(0)) == sizeof(::boost::type_traits::yes_type),
::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value
>::value)
sizeof(is_class_tester<T>(0)) == sizeof(::boost::type_traits::yes_type)
&& ! ::boost::is_union<T>::value
);
};
@@ -79,10 +69,8 @@ struct is_class_impl
template <class U> static ::boost::type_traits::no_type is_class_tester(...);
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
sizeof(is_class_tester<T>(0)) == sizeof(::boost::type_traits::yes_type),
::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value
>::value)
sizeof(is_class_tester<T>(0)) == sizeof(::boost::type_traits::yes_type)
&& ! ::boost::is_union<T>::value
);
};
@@ -94,14 +82,13 @@ template <typename T>
struct is_class_impl
{
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value,
::boost::type_traits::ice_not< ::boost::is_scalar<T>::value >::value,
::boost::type_traits::ice_not< ::boost::is_array<T>::value >::value,
::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value,
::boost::type_traits::ice_not< ::boost::is_void<T>::value >::value,
::boost::type_traits::ice_not< ::boost::is_function<T>::value >::value
>::value));
! ::boost::is_union<T>::value >::value
&& ! ::boost::is_scalar<T>::value
&& ! ::boost::is_array<T>::value
&& ! ::boost::is_reference<T>::value
&& ! ::boost::is_void<T>::value
&& ! ::boost::is_function<T>::value
);
};
# endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION
@@ -115,15 +102,13 @@ struct is_class_impl
} // namespace detail
template <class T> struct is_class : public integral_constant<bool, ::boost::detail::is_class_impl<T>::value> {};
# ifdef __EDG_VERSION__
BOOST_TT_AUX_BOOL_TRAIT_DEF1(
is_class,T, boost::detail::is_class_impl<typename boost::remove_cv<T>::type>::value)
# else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_class,T,::boost::detail::is_class_impl<T>::value)
template <class T> struct is_class<const T> : public is_class<T>{};
template <class T> struct is_class<const volatile T> : public is_class<T>{};
template <class T> struct is_class<volatile T> : public is_class<T>{};
# endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_IS_CLASS_HPP_INCLUDED

19
include/boost/type_traits/is_complex.hpp
View File

@@ -8,27 +8,14 @@
#ifndef BOOST_TT_IS_COMPLEX_HPP
#define BOOST_TT_IS_COMPLEX_HPP
#include <boost/type_traits/is_convertible.hpp>
#include <complex>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#include <boost/type_traits/integral_constant.hpp>
namespace boost {
namespace detail{
struct is_convertible_from_tester
{
template <class T>
is_convertible_from_tester(const std::complex<T>&);
};
}
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_complex,T,(::boost::is_convertible<T, boost::detail::is_convertible_from_tester>::value))
template <class T> struct is_complex : public false_type {};
template <class T> struct is_complex<std::complex<T> > : public true_type{};
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif //BOOST_TT_IS_COMPLEX_HPP

26
include/boost/type_traits/is_compound.hpp
View File

@@ -9,38 +9,16 @@
#ifndef BOOST_TT_IS_COMPOUND_HPP_INCLUDED
#define BOOST_TT_IS_COMPOUND_HPP_INCLUDED
#include <boost/config.hpp>
#include <boost/type_traits/is_fundamental.hpp>
#include <boost/type_traits/detail/ice_not.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
#if !defined( __CODEGEARC__ )
namespace detail {
template <typename T>
struct is_compound_impl
{
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_not<
::boost::is_fundamental<T>::value
>::value));
};
} // namespace detail
#endif // !defined( __CODEGEARC__ )
#if defined( __CODEGEARC__ )
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_compound,T,__is_compound(T))
template <class T> struct is_compound : public integral_constant<bool, __is_compound(T)> {};
#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_compound,T,::boost::detail::is_compound_impl<T>::value)
template <class T> struct is_compound : public integral_constant<bool, ! ::boost::is_fundamental<T>::value> {};
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_IS_COMPOUND_HPP_INCLUDED

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

@@ -21,70 +21,26 @@
#ifndef BOOST_TT_IS_CONST_HPP_INCLUDED
#define BOOST_TT_IS_CONST_HPP_INCLUDED
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
# include <boost/type_traits/detail/cv_traits_impl.hpp>
# ifdef __GNUC__
# include <boost/type_traits/is_reference.hpp>
# endif
# if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
# include <boost/type_traits/remove_bounds.hpp>
# endif
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
#include <boost/type_traits/integral_constant.hpp>
namespace boost {
#if defined( __CODEGEARC__ )
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,__is_const(T))
template <class T>
struct is_const : public integral_constant<bool, __is_const(T)> {};
#else
namespace detail{
//
// We can't filter out rvalue_references at the same level as
// references or we get ambiguities from msvc:
//
template <class T>
struct is_const_rvalue_filter
{
#if BOOST_WORKAROUND(BOOST_MSVC, < 1400)
BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<typename boost::remove_bounds<T>::type*>::is_const);
#else
BOOST_STATIC_CONSTANT(bool, value = ::boost::detail::cv_traits_imp<BOOST_TT_AUX_CV_TRAITS_IMPL_PARAM(T)>::is_const);
#endif
};
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class T>
struct is_const_rvalue_filter<T&&>
{
BOOST_STATIC_CONSTANT(bool, value = false);
};
#endif
}
//* is a type T declared const - is_const<T>
BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::is_const_rvalue_filter<T>::value)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T&,false)
#if defined(BOOST_ILLEGAL_CV_REFERENCES)
// 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...
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const volatile,false)
#endif
template <class T>
struct is_const : public false_type {};
template <class T> struct is_const<T const> : public true_type{};
template <class T, size_t N> struct is_const<T const[N]> : public true_type{};
template <class T> struct is_const<T const[]> : public true_type{};
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_IS_CONST_HPP_INCLUDED

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

@@ -13,14 +13,14 @@
#define BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED
#include <boost/type_traits/intrinsics.hpp>
#include <boost/type_traits/integral_constant.hpp>
#ifndef BOOST_IS_CONVERTIBLE
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/type_traits/config.hpp>
#include <boost/type_traits/detail/config.hpp>
#include <boost/type_traits/is_array.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/type_traits/is_void.hpp>
#ifndef BOOST_NO_IS_ABSTRACT
#if !defined(BOOST_NO_IS_ABSTRACT)
#include <boost/type_traits/is_abstract.hpp>
#endif
#include <boost/type_traits/add_lvalue_reference.hpp>
@@ -33,11 +33,11 @@
#if !defined(BOOST_NO_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
# include <boost/utility/declval.hpp>
#endif
#elif defined(BOOST_MSVC) || defined(BOOST_INTEL)
#include <boost/type_traits/is_function.hpp>
#include <boost/type_traits/is_same.hpp>
#endif // BOOST_IS_CONVERTIBLE
// should be always the last #include directive
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
#ifndef BOOST_IS_CONVERTIBLE
@@ -336,38 +336,15 @@ struct is_convertible_basic_impl
template <typename From, typename To>
struct is_convertible_impl
{
enum { value =
(::boost::type_traits::ice_and<
::boost::type_traits::ice_or<
::boost::detail::is_convertible_basic_impl<From,To>::value,
::boost::is_void<To>::value
>::value,
::boost::type_traits::ice_not<
::boost::is_array<To>::value
>::value,
::boost::type_traits::ice_not<
::boost::is_function<To>::value
>::value
>::value) };
enum {
value = ( ::boost::detail::is_convertible_basic_impl<From,To>::value && ! ::boost::is_array<To>::value && ! ::boost::is_function<To>::value)
};
};
#elif !defined(__BORLANDC__) || __BORLANDC__ > 0x551
template <typename From, typename To>
struct is_convertible_impl
{
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_and<
::boost::type_traits::ice_or<
::boost::detail::is_convertible_basic_impl<From,To>::value,
::boost::is_void<To>::value
>::value,
::boost::type_traits::ice_not<
::boost::is_array<To>::value
>::value,
::boost::type_traits::ice_not<
::boost::is_function<To>::value
>::value
>::value)
);
BOOST_STATIC_CONSTANT(bool, value = ( ::boost::detail::is_convertible_basic_impl<From, To>::value && !::boost::is_array<To>::value && !::boost::is_function<To>::value));
};
#endif
@@ -443,52 +420,55 @@ struct is_convertible_impl_dispatch
// implementation above:
//
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
# define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) \
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2,value) \
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const,value) \
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 volatile,value) \
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const volatile,value) \
/**/
# define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2(trait,spec1,spec2,value) \
TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) \
TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const,spec2,value) \
TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 volatile,spec2,value) \
TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const volatile,spec2,value) \
/**/
template <> struct is_convertible_impl_dispatch<void, void> : public true_type{};
template <> struct is_convertible_impl_dispatch<void, void const> : public true_type{};
template <> struct is_convertible_impl_dispatch<void, void const volatile> : public true_type{};
template <> struct is_convertible_impl_dispatch<void, void volatile> : public true_type{};
TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2(is_convertible,void,void,true)
template <> struct is_convertible_impl_dispatch<void const, void> : public true_type{};
template <> struct is_convertible_impl_dispatch<void const, void const> : public true_type{};
template <> struct is_convertible_impl_dispatch<void const, void const volatile> : public true_type{};
template <> struct is_convertible_impl_dispatch<void const, void volatile> : public true_type{};
# undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2
# undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1
template <> struct is_convertible_impl_dispatch<void const volatile, void> : public true_type{};
template <> struct is_convertible_impl_dispatch<void const volatile, void const> : public true_type{};
template <> struct is_convertible_impl_dispatch<void const volatile, void const volatile> : public true_type{};
template <> struct is_convertible_impl_dispatch<void const volatile, void volatile> : public true_type{};
template <> struct is_convertible_impl_dispatch<void volatile, void> : public true_type{};
template <> struct is_convertible_impl_dispatch<void volatile, void const> : public true_type{};
template <> struct is_convertible_impl_dispatch<void volatile, void const volatile> : public true_type{};
template <> struct is_convertible_impl_dispatch<void volatile, void volatile> : public true_type{};
#else
BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(is_convertible,void,void,true)
template <> struct is_convertible_impl_dispatch<void, void> : public true_type{};
#endif // BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void,To,false)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void,false)
template <class To> struct is_convertible_impl_dispatch<void, To> : public false_type{};
template <class From> struct is_convertible_impl_dispatch<From, void> : public false_type{};
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void const,To,false)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void volatile,To,false)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void const volatile,To,false)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const,false)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void volatile,false)
BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const volatile,false)
template <class To> struct is_convertible_impl_dispatch<void const, To> : public false_type{};
template <class From> struct is_convertible_impl_dispatch<From, void const> : public false_type{};
template <class To> struct is_convertible_impl_dispatch<void const volatile, To> : public false_type{};
template <class From> struct is_convertible_impl_dispatch<From, void const volatile> : public false_type{};
template <class To> struct is_convertible_impl_dispatch<void volatile, To> : public false_type{};
template <class From> struct is_convertible_impl_dispatch<From, void volatile> : public false_type{};
#endif
} // namespace detail
BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_convertible,From,To,(::boost::detail::is_convertible_impl_dispatch<From,To>::value))
template <class From, class To>
struct is_convertible : public integral_constant<bool, ::boost::detail::is_convertible_impl_dispatch<From, To>::value> {};
#else
BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_convertible,From,To,BOOST_IS_CONVERTIBLE(From,To))
template <class From, class To>
struct is_convertible : public integral_constant<bool, BOOST_IS_CONVERTIBLE(From, To)> {};
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED

Some files were not shown because too many files have changed in this diff Show More