boostorg/type_traits
1
0
Fork 1
mirror of https://github.com/boostorg/type_traits.git synced 2025-08-02 22:14:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

Initial commit of new version of type_traits which has zero dependencies (other than Boost.Config), plus reduced template instantiations, and cleaner easier to read code.

Browse Source
This commit is contained in:
jzmaddock
2015-01-14 18:34:11 +00:00
parent 5f0de298dc
commit f0da159e1f
271 changed files with 952 additions and 24897 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
include/boost/aligned_storage.hpp
View File

@@ -1,143 +0,0 @@
//-----------------------------------------------------------------------------
// boost aligned_storage.hpp header file
// See http://www.boost.org for updates, documentation, and revision history.
//-----------------------------------------------------------------------------
//
// 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_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"
#endif // BOOST_ALIGNED_STORAGE_HPP

102
include/boost/type_traits.hpp
View File

@@ -1,102 +0,0 @@
// (C) Copyright 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.
// See boost/type_traits/*.hpp for full copyright notices.
#ifndef BOOST_TYPE_TRAITS_HPP
#define BOOST_TYPE_TRAITS_HPP
#include "boost/type_traits/add_const.hpp"
#include "boost/type_traits/add_cv.hpp"
#include "boost/type_traits/add_lvalue_reference.hpp"
#include "boost/type_traits/add_pointer.hpp"
#include "boost/type_traits/add_reference.hpp"
#include "boost/type_traits/add_rvalue_reference.hpp"
#include "boost/type_traits/add_volatile.hpp"
#include "boost/type_traits/aligned_storage.hpp"
#include "boost/type_traits/alignment_of.hpp"
#include "boost/type_traits/common_type.hpp"
#include "boost/type_traits/conditional.hpp"
#include "boost/type_traits/decay.hpp"
#include "boost/type_traits/extent.hpp"
#include "boost/type_traits/floating_point_promotion.hpp"
#include "boost/type_traits/function_traits.hpp"
#if !defined(__BORLANDC__) && !defined(__CUDACC__)
#include "boost/type_traits/has_new_operator.hpp"
#endif
#include "boost/type_traits/has_nothrow_assign.hpp"
#include "boost/type_traits/has_nothrow_constructor.hpp"
#include "boost/type_traits/has_nothrow_copy.hpp"
#include "boost/type_traits/has_nothrow_destructor.hpp"
#include <boost/type_traits/has_operator.hpp>
#include "boost/type_traits/has_trivial_assign.hpp"
#include "boost/type_traits/has_trivial_constructor.hpp"
#include "boost/type_traits/has_trivial_copy.hpp"
#include "boost/type_traits/has_trivial_destructor.hpp"
#include "boost/type_traits/has_trivial_move_assign.hpp"
#include "boost/type_traits/has_trivial_move_constructor.hpp"
#include "boost/type_traits/has_virtual_destructor.hpp"
#include "boost/type_traits/is_abstract.hpp"
#include "boost/type_traits/is_arithmetic.hpp"
#include "boost/type_traits/is_array.hpp"
#include "boost/type_traits/is_base_and_derived.hpp"
#include "boost/type_traits/is_base_of.hpp"
#include "boost/type_traits/is_class.hpp"
#include <boost/type_traits/is_complex.hpp>
#include "boost/type_traits/is_compound.hpp"
#include "boost/type_traits/is_const.hpp"
#include "boost/type_traits/is_convertible.hpp"
#include "boost/type_traits/is_copy_constructible.hpp"
#include "boost/type_traits/is_copy_assignable.hpp"
#include "boost/type_traits/is_empty.hpp"
#include "boost/type_traits/is_enum.hpp"
#include "boost/type_traits/is_float.hpp"
#include "boost/type_traits/is_floating_point.hpp"
#include "boost/type_traits/is_function.hpp"
#include "boost/type_traits/is_fundamental.hpp"
#include "boost/type_traits/is_integral.hpp"
#include "boost/type_traits/is_lvalue_reference.hpp"
#include "boost/type_traits/is_member_function_pointer.hpp"
#include "boost/type_traits/is_member_object_pointer.hpp"
#include "boost/type_traits/is_member_pointer.hpp"
#include "boost/type_traits/is_nothrow_move_assignable.hpp"
#include "boost/type_traits/is_nothrow_move_constructible.hpp"
#include "boost/type_traits/is_object.hpp"
#include "boost/type_traits/is_pod.hpp"
#include "boost/type_traits/is_polymorphic.hpp"
#include "boost/type_traits/is_pointer.hpp"
#include "boost/type_traits/is_reference.hpp"
#include "boost/type_traits/is_rvalue_reference.hpp"
#include "boost/type_traits/is_signed.hpp"
#include "boost/type_traits/is_same.hpp"
#include "boost/type_traits/is_scalar.hpp"
#include "boost/type_traits/is_stateless.hpp"
#include "boost/type_traits/is_union.hpp"
#include "boost/type_traits/is_unsigned.hpp"
#include "boost/type_traits/is_void.hpp"
#include "boost/type_traits/is_virtual_base_of.hpp"
#include "boost/type_traits/is_volatile.hpp"
#include <boost/type_traits/make_unsigned.hpp>
#include <boost/type_traits/make_signed.hpp>
#include "boost/type_traits/rank.hpp"
#include "boost/type_traits/remove_bounds.hpp"
#include "boost/type_traits/remove_extent.hpp"
#include "boost/type_traits/remove_all_extents.hpp"
#include "boost/type_traits/remove_const.hpp"
#include "boost/type_traits/remove_cv.hpp"
#include "boost/type_traits/remove_pointer.hpp"
#include "boost/type_traits/remove_reference.hpp"
#include "boost/type_traits/remove_volatile.hpp"
#include "boost/type_traits/type_with_alignment.hpp"
#if !(defined(__sgi) && defined(__EDG_VERSION__) && (__EDG_VERSION__ == 238))
#include "boost/type_traits/integral_promotion.hpp"
#include "boost/type_traits/promote.hpp"
#endif
#include "boost/type_traits/ice.hpp"
#endif // BOOST_TYPE_TRAITS_HPP

15
include/boost/type_traits/add_const.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 const type - add_const<T>
@@ -30,16 +27,20 @@ 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;
};
} // namespace boost
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_ADD_CONST_HPP_INCLUDED

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

@@ -1,46 +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_ADD_CV_HPP_INCLUDED
#define BOOST_TT_ADD_CV_HPP_INCLUDED
#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>
// this is not required since the result is always
// the same as "T const volatile", but it does suppress warnings
// from some compilers:
#if defined(BOOST_MSVC)
// This bogus warning will appear when add_volatile is applied to a
// const volatile reference because we can't detect const volatile
// references with MSVC6.
# pragma warning(push)
# 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)
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_cv,T&,T&)
} // 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

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

@@ -1,72 +0,0 @@
// (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_ADD_POINTER_HPP_INCLUDED
#define BOOST_TT_ADD_POINTER_HPP_INCLUDED
#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
// from dropping cv-qualifiers, it still fails with references
// to arrays for some reason though (shrug...) (JM 20021104)
//
template <typename T>
struct add_pointer_impl
{
typedef T* type;
};
template <typename T>
struct add_pointer_impl<T&>
{
typedef T* type;
};
template <typename T>
struct add_pointer_impl<T&const>
{
typedef T* type;
};
template <typename T>
struct add_pointer_impl<T&volatile>
{
typedef T* type;
};
template <typename T>
struct add_pointer_impl<T&const volatile>
{
typedef T* type;
};
#else
template <typename T>
struct add_pointer_impl
{
typedef typename remove_reference<T>::type no_ref_type;
typedef no_ref_type* type;
};
#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

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

@@ -1,45 +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_ADD_VOLATILE_HPP_INCLUDED
#define BOOST_TT_ADD_VOLATILE_HPP_INCLUDED
#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>
// this is not required since the result is always
// the same as "T volatile", but it does suppress warnings
// from some compilers:
#if defined(BOOST_MSVC)
// This bogus warning will appear when add_volatile is applied to a
// const volatile reference because we can't detect const volatile
// references with MSVC6.
# pragma warning(push)
# pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
#endif
BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_volatile,T,T volatile)
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_volatile,T&,T&)
} // namespace boost
#include <boost/type_traits/detail/type_trait_undef.hpp>
#endif // BOOST_TT_ADD_VOLATILE_HPP_INCLUDED

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

@@ -1,13 +0,0 @@
// 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).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#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

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

@@ -1,126 +0,0 @@
// (C) Copyright 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_ALIGNMENT_OF_HPP_INCLUDED
#define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
#include <boost/config.hpp>
#include <cstddef>
#include <boost/type_traits/intrinsics.hpp>
// should be the last #include
#include <boost/type_traits/detail/size_t_trait_def.hpp>
#ifdef BOOST_MSVC
# pragma warning(push)
# pragma warning(disable: 4121 4512) // alignment is sensitive to packing
#endif
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
#pragma option push -Vx- -Ve-
#endif
namespace boost {
template <typename T> struct alignment_of;
// get the alignment of some arbitrary type:
namespace detail {
#ifdef BOOST_MSVC
#pragma warning(push)
#pragma warning(disable:4324) // structure was padded due to __declspec(align())
#endif
template <typename T>
struct alignment_of_hack
{
char c;
T t;
alignment_of_hack();
};
#ifdef BOOST_MSVC
#pragma warning(pop)
#endif
template <unsigned A, unsigned S>
struct alignment_logic
{
BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S);
};
template< typename T >
struct alignment_of_impl
{
#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400)
//
// With MSVC both the native __alignof operator
// and our own logic gets things wrong from time to time :-(
// Using a combination of the two seems to make the most of a bad job:
//
BOOST_STATIC_CONSTANT(std::size_t, value =
(::boost::detail::alignment_logic<
sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
__alignof(T)
>::value));
#elif !defined(BOOST_ALIGNMENT_OF)
BOOST_STATIC_CONSTANT(std::size_t, value =
(::boost::detail::alignment_logic<
sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
sizeof(T)
>::value));
#else
//
// We put this here, rather than in the definition of
// alignment_of below, because MSVC's __alignof doesn't
// always work in that context for some unexplained reason.
// (See type_with_alignment tests for test cases).
//
BOOST_STATIC_CONSTANT(std::size_t, value = BOOST_ALIGNMENT_OF(T));
#endif
};
} // namespace detail
BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(alignment_of,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*>
{
};
#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>{};
#endif
// void has to be treated specially:
BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void,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)
#endif
} // namespace boost
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
#pragma option pop
#endif
#ifdef BOOST_MSVC
# pragma warning(pop)
#endif
#include <boost/type_traits/detail/size_t_trait_undef.hpp>
#endif // BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED

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

@@ -1,15 +0,0 @@
// (C) Copyright 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_ALIGNMENT_TRAITS_HPP_INCLUDED
#define BOOST_TT_ALIGNMENT_TRAITS_HPP_INCLUDED
#include <boost/type_traits/alignment_of.hpp>
#include <boost/type_traits/type_with_alignment.hpp>
#endif // BOOST_TT_ALIGNMENT_TRAITS_HPP_INCLUDED

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

@@ -1,20 +0,0 @@
// (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.
//
// defines traits classes for arithmetic types:
// is_void, is_integral, is_float, is_arithmetic, is_fundamental.
#ifndef BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED
#define BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED
#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/type_traits/is_float.hpp>
#include <boost/type_traits/is_fundamental.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_void.hpp>
#endif // BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED

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

@@ -1,15 +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_ARRAY_TRAITS_HPP_INCLUDED
#define BOOST_TT_ARRAY_TRAITS_HPP_INCLUDED
#include <boost/type_traits/is_array.hpp>
#endif // BOOST_TT_ARRAY_TRAITS_HPP_INCLUDED

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

@@ -1,14 +0,0 @@
// Copyright 2001-2003 Aleksey Gurtovoy.
// 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>
#endif

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

@@ -1,157 +0,0 @@
// common_type.hpp ---------------------------------------------------------//
// Copyright 2008 Howard Hinnant
// Copyright 2008 Beman Dawes
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_TYPE_TRAITS_COMMON_TYPE_HPP
#define BOOST_TYPE_TRAITS_COMMON_TYPE_HPP
#include <boost/config.hpp>
#if defined(__SUNPRO_CC) && !defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF)
# define BOOST_COMMON_TYPE_DONT_USE_TYPEOF
#endif
#if defined(__IBMCPP__) && !defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF)
# define BOOST_COMMON_TYPE_DONT_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>
#include <boost/utility/declval.hpp>
#include <boost/type_traits/add_rvalue_reference.hpp>
//----------------------------------------------------------------------------//
// //
// C++03 implementation of //
// 20.9.7.6 Other transformations [meta.trans.other] //
// Written by Howard Hinnant //
// Adapted for Boost by Beman Dawes, Vicente Botet and Jeffrey Hellrung //
// //
//----------------------------------------------------------------------------//
namespace boost {
// prototype
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<typename... T>
struct common_type;
#else // or no specialization
template <class T, class U = void, class V = void>
struct common_type
{
public:
typedef typename common_type<typename common_type<T, U>::type, V>::type type;
};
#endif
// 1 arg
template<typename T>
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
struct common_type<T>
#else
struct common_type<T, void, void>
#endif
{
BOOST_COMMON_TYPE_STATIC_ASSERT(sizeof(T) > 0, BOOST_COMMON_TYPE_MUST_BE_A_COMPLE_TYPE, (T));
public:
typedef T type;
};
// 2 args
namespace type_traits_detail {
template <class T, class U>
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();
#if !defined(BOOST_NO_CXX11_DECLTYPE)
public:
typedef decltype(declval<bool>() ? declval<T>() : declval<U>()) type;
#elif defined(BOOST_COMMON_TYPE_DONT_USE_TYPEOF)
public:
typedef typename detail_type_traits_common_type::common_type_impl<
typename remove_cv<T>::type,
typename remove_cv<U>::type
>::type type;
#else
public:
typedef BOOST_TYPEOF_TPL(declval_b() ? declval_T() : declval_U()) type;
#endif
#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ == 3
public:
void public_dummy_function_just_to_silence_warning();
#endif
};
template <class T>
struct common_type_2<T, T>
{
typedef T type;
};
}
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template <class T, class U>
struct common_type<T, U>
#else
template <class T, class U>
struct common_type<T, U, void>
#endif
: public type_traits_detail::common_type_2<T,U>
{ };
// 3 or more args
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<typename T, typename U, typename... V>
struct common_type<T, U, V...> {
public:
typedef typename common_type<typename common_type<T, U>::type, V...>::type type;
};
#endif
} // namespace boost
#endif // BOOST_TYPE_TRAITS_COMMON_TYPE_HPP

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

@@ -1,29 +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.
//
// defines traits classes for composite types:
// is_array, is_pointer, is_reference, is_member_pointer, is_enum, is_union.
//
#ifndef BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED
#define BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED
#include <boost/type_traits/is_array.hpp>
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_member_pointer.hpp>
#include <boost/type_traits/is_member_function_pointer.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/is_union.hpp>
#endif // BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED

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

@@ -1,25 +0,0 @@
// (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
// 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_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>
{
};
} // namespace boost
#endif // BOOST_TT_CONDITIONAL_HPP_INCLUDED

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

@@ -1,17 +0,0 @@
// Copyright 2000 John Maddock (john@johnmaddock.co.uk)
// Copyright 2000 Jeremy Siek (jsiek@lsc.nd.edu)
// Copyright 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
//
// 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_CONVERSION_TRAITS_HPP_INCLUDED
#define BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED
#include <boost/type_traits/is_convertible.hpp>
#endif // BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED

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

@@ -1,24 +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.
//
// defines traits classes for cv-qualified types:
// is_const, is_volatile, remove_const, remove_volatile, remove_cv.
#ifndef BOOST_TT_CV_TRAITS_HPP_INCLUDED
#define BOOST_TT_CV_TRAITS_HPP_INCLUDED
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_volatile.hpp>
#include <boost/type_traits/add_cv.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_volatile.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_volatile.hpp>
#include <boost/type_traits/remove_cv.hpp>
#endif // BOOST_TT_CV_TRAITS_HPP_INCLUDED

44
include/boost/type_traits/decay.hpp
View File

@@ -1,44 +0,0 @@
// (C) Copyright John Maddock & Thorsten Ottosen 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).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#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
{
template< class T >
struct decay
{
private:
typedef BOOST_DEDUCED_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;
};
} // namespace boost
#endif // BOOST_TT_DECAY_HPP_INCLUDED

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

@@ -1,188 +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/bool.hpp>
#include <boost/mpl/aux_/lambda_support.hpp>
#include <boost/config.hpp>
//
// Unfortunately some libraries have started using this header without
// cleaning up afterwards: so we'd better undef the macros just in case
// they've been defined already....
//
#ifdef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#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
#ifndef BOOST_TT_AUX_BOOL_C_BASE
# define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
#endif
#define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) \
template< typename T > struct trait \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
}; \
\
BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
/**/
#define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) \
template< typename T1, typename T2 > struct trait \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) \
}; \
\
BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait) \
/**/
#define BOOST_TT_AUX_BOOL_TRAIT_DEF3(trait,T1,T2,T3,C) \
template< typename T1, typename T2, typename T3 > struct trait \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
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) \
/**/
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) \
template<> struct trait< sp > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) \
}; \
/**/
#define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) \
template<> struct trait< sp1,sp2 > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \
}; \
/**/
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) \
template<> struct trait##_impl< sp > \
{ \
public:\
BOOST_STATIC_CONSTANT(bool, value = (C)); \
}; \
/**/
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) \
template<> struct trait##_impl< sp1,sp2 > \
{ \
public:\
BOOST_STATIC_CONSTANT(bool, value = (C)); \
}; \
/**/
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) \
template< param > struct trait< sp > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
}; \
/**/
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) \
template< param1, param2 > struct trait< sp > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
}; \
/**/
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \
template< param > struct trait< sp1,sp2 > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \
}; \
/**/
#define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) \
template< param1, param2 > struct trait< sp1,sp2 > \
BOOST_TT_AUX_BOOL_C_BASE(C) \
{ \
public:\
BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
}; \
/**/
#define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \
template< param > struct trait##_impl< sp1,sp2 > \
{ \
public:\
BOOST_STATIC_CONSTANT(bool, value = (C)); \
}; \
/**/
#ifndef BOOST_NO_CV_SPECIALIZATIONS
# define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) \
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) \
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) \
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) \
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value) \
/**/
#else
# define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) \
BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) \
/**/
#endif

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

@@ -1,28 +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_BOOL_TRAIT_VALUE_DECL
#undef BOOST_TT_AUX_BOOL_C_BASE
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF1
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF2
#undef BOOST_TT_AUX_BOOL_TRAIT_DEF3
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2
#undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1
#undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1

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

@@ -1,333 +0,0 @@
/*******************************************************************************
* boost/type_traits/detail/common_type_imp.hpp
*
* Copyright 2010, Jeffrey Hellrung.
* 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)
*
* struct boost::common_type<T,U>
*
* common_type<T,U>::type is the type of the expression
* b() ? x() : y()
* where b() returns a bool, x() has return type T, and y() has return type U.
* See
* http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm#common_type
*
* Note that this evaluates to void if one or both of T and U is void.
******************************************************************************/
#ifndef BOOST_TYPE_TRAITS_DETAIL_COMMON_TYPE_IMP_HPP
#define BOOST_TYPE_TRAITS_DETAIL_COMMON_TYPE_IMP_HPP
#include <cstddef>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/begin_end.hpp>
#include <boost/mpl/contains.hpp>
#include <boost/mpl/copy.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/inserter.hpp>
#include <boost/mpl/next.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/placeholders.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/vector/vector0.hpp>
#include <boost/mpl/vector/vector10.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/make_signed.hpp>
#include <boost/type_traits/make_unsigned.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/utility/declval.hpp>
namespace boost
{
namespace detail_type_traits_common_type
{
/*******************************************************************************
* struct propagate_cv< From, To >
*
* This metafunction propagates cv-qualifiers on type From to type To.
******************************************************************************/
template< class From, class To >
struct propagate_cv
{ typedef To type; };
template< class From, class To >
struct propagate_cv< const From, To >
{ typedef To const type; };
template< class From, class To >
struct propagate_cv< volatile From, To >
{ typedef To volatile type; };
template< class From, class To >
struct propagate_cv< const volatile From, To >
{ typedef To const volatile type; };
/*******************************************************************************
* struct is_integral_or_enum<T>
*
* This metafunction determines if T is an integral type which can be made
* signed or unsigned.
******************************************************************************/
template< class T >
struct is_integral_or_enum
: public mpl::or_< is_integral<T>, is_enum<T> >
{ };
template<>
struct is_integral_or_enum< bool >
: public false_type
{ };
/*******************************************************************************
* struct make_unsigned_soft<T>
* struct make_signed_soft<T>
*
* These metafunction are identical to make_unsigned and make_signed,
* respectively, except for special-casing bool.
******************************************************************************/
template< class T >
struct make_unsigned_soft
: public make_unsigned<T>
{ };
template<>
struct make_unsigned_soft< bool >
{ typedef bool type; };
template< class T >
struct make_signed_soft
: public make_signed<T>
{ };
template<>
struct make_signed_soft< bool >
{ typedef bool type; };
/*******************************************************************************
* struct sizeof_t<N>
* typedef ... yes_type
* typedef ... no_type
*
* These types are integral players in the use of the "sizeof trick", i.e., we
* can distinguish overload selection by inspecting the size of the return type
* of the overload.
******************************************************************************/
template< std::size_t N > struct sizeof_t { char _dummy[N]; };
typedef sizeof_t<1> yes_type;
typedef sizeof_t<2> no_type;
BOOST_MPL_ASSERT_RELATION( sizeof( yes_type ), ==, 1 );
BOOST_MPL_ASSERT_RELATION( sizeof( no_type ), ==, 2 );
/*******************************************************************************
* rvalue_test(T&) -> no_type
* rvalue_test(...) -> yes_type
*
* These overloads are used to determine the rvalue-ness of an expression.
******************************************************************************/
template< class T > no_type rvalue_test(T&);
yes_type rvalue_test(...);
/*******************************************************************************
* struct conversion_test_overloads< Sequence >
*
* This struct has multiple overloads of the static member function apply, each
* one taking a single parameter of a type within the Boost.MPL sequence
* Sequence. Each such apply overload has a return type with sizeof equal to
* one plus the index of the parameter type within Sequence. Thus, we can
* deduce the type T of an expression as long as we can generate a finite set of
* candidate types containing T via these apply overloads and the "sizeof
* trick".
******************************************************************************/
template< class First, class Last, std::size_t Index >
struct conversion_test_overloads_iterate
: public conversion_test_overloads_iterate<
typename mpl::next< First >::type, Last, Index + 1
>
{
using conversion_test_overloads_iterate<
typename mpl::next< First >::type, Last, Index + 1
>::apply;
static sizeof_t< Index + 1 >
apply(typename mpl::deref< First >::type);
};
template< class Last, std::size_t Index >
struct conversion_test_overloads_iterate< Last, Last, Index >
{ static sizeof_t< Index + 1 > apply(...); };
template< class Sequence >
struct conversion_test_overloads
: public conversion_test_overloads_iterate<
typename mpl::begin< Sequence >::type,
typename mpl::end< Sequence >::type,
0
>
{ };
/*******************************************************************************
* struct select< Sequence, Index >
*
* select is synonymous with mpl::at_c unless Index equals the size of the
* Boost.MPL Sequence, in which case this evaluates to void.
******************************************************************************/
template<
class Sequence, int Index,
int N = mpl::size< Sequence >::value
>
struct select
: public mpl::at_c< Sequence, Index >
{ };
template< class Sequence, int N >
struct select< Sequence, N, N >
{ typedef void type; };
/*******************************************************************************
* class deduce_common_type< T, U, NominalCandidates >
* struct nominal_candidates<T,U>
* struct common_type_dispatch_on_rvalueness<T,U>
* struct common_type_impl<T,U>
*
* These classes and structs implement the logic behind common_type, which goes
* roughly as follows. Let C be the type of the conditional expression
* declval< bool >() ? declval<T>() : declval<U>()
* if C is an rvalue, then:
* let T' and U' be T and U stripped of reference- and cv-qualifiers
* if T' and U' are pointer types, say, T' = V* and U' = W*, then:
* define the set of NominalCandidates to be
* { V*, W*, V'*, W'* }
* where V' is V with whatever cv-qualifiers are on W, and W' is W
* with whatever cv-qualifiers are on V
* else if T' and U' are both integral or enum types, then:
* define the set of NominalCandidates to be
* {
* unsigned_soft(T'),
* unsigned_soft(U'),
* signed_soft(T'),
* signed_soft(U'),
* T',
* U',
* unsigned int,
* int
* }
* where unsigned_soft(X) is make_unsigned_soft<X>::type and
* signed_soft(X) is make_signed_soft<X>::type (these are all
* generally necessary to cover the various integral promotion cases)
* else
* define the set of NominalCandidates to be
* { T', U' }
* else
* let V and W be T and U stripped of reference-qualifiers
* define the set of NominalCandidates to be
* { V&, W&, V'&, W'& }
* where V' is V with whatever cv-qualifiers are on W, and W' is W with
* whatever cv-qualifiers are on V
* define the set of Candidates to be equal to the set of NominalCandidates with
* duplicates removed, and use this set of Candidates to determine C using the
* conversion_test_overloads struct
******************************************************************************/
template< class T, class U, class NominalCandidates >
class deduce_common_type
{
typedef typename mpl::copy<
NominalCandidates,
mpl::inserter<
mpl::vector0<>,
mpl::if_<
mpl::contains< mpl::_1, mpl::_2 >,
mpl::_1,
mpl::push_back< mpl::_1, mpl::_2 >
>
>
>::type candidate_types;
static const int best_candidate_index =
sizeof( conversion_test_overloads< candidate_types >::apply(
declval< bool >() ? declval<T>() : declval<U>()
) ) - 1;
public:
typedef typename select< candidate_types, best_candidate_index >::type type;
};
template<
class T, class U,
class V = typename remove_cv< typename remove_reference<T>::type >::type,
class W = typename remove_cv< typename remove_reference<U>::type >::type,
bool = is_integral_or_enum<V>::value && is_integral_or_enum<W>::value
>
struct nominal_candidates
{ typedef mpl::vector2<V,W> type; };
template< class T, class U, class V, class W >
struct nominal_candidates< T, U, V, W, true >
{
typedef boost::mpl::vector8<
typename make_unsigned_soft<V>::type,
typename make_unsigned_soft<W>::type,
typename make_signed_soft<V>::type,
typename make_signed_soft<W>::type,
V, W, unsigned int, int
> type;
};
template< class T, class U, class V, class W >
struct nominal_candidates< T, U, V*, W*, false >
{
typedef mpl::vector4<
V*, W*,
typename propagate_cv<W,V>::type *,
typename propagate_cv<V,W>::type *
> type;
};
template<class T, class U, bool b>
struct common_type_dispatch_on_rvalueness
: public deduce_common_type< T, U, typename nominal_candidates<T,U>::type >
{ };
template< class T, class U >
struct common_type_dispatch_on_rvalueness< T, U, false >
{
private:
typedef typename remove_reference<T>::type unrefed_T_type;
typedef typename remove_reference<U>::type unrefed_U_type;
public:
typedef typename deduce_common_type<
T, U,
mpl::vector4<
unrefed_T_type &,
unrefed_U_type &,
typename propagate_cv< unrefed_U_type, unrefed_T_type >::type &,
typename propagate_cv< unrefed_T_type, unrefed_U_type >::type &
>
>::type type;
};
template< class T, class U >
struct common_type_impl
: public common_type_dispatch_on_rvalueness<T,U, sizeof( ::boost::detail_type_traits_common_type::rvalue_test(
declval< bool >() ? declval<T>() : declval<U>() ) ) == sizeof( yes_type ) >
{ };
template< class T > struct common_type_impl< T, void > { typedef void type; };
template< class T > struct common_type_impl< void, T > { typedef void type; };
template<> struct common_type_impl< void, void > { typedef void type; };
} // namespace detail_type_traits_common_type
} // namespace boost
#endif // BOOST_TYPE_TRAITS_DETAIL_COMMON_TYPE_HPP

0
include/boost/type_traits/config.hpp → include/boost/type_traits/detail/config.hpp
View File

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

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

@@ -1,229 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa.
//
// 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.
#include <boost/config.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_fundamental.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_void.hpp>
#include <boost/type_traits/remove_cv.hpp>
#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
// warning: comparison between signed and unsigned integer expressions
// msvc:
// warning C4018: '<' : signed/unsigned mismatch
// warning C4244: '+=' : conversion from 'double' to 'char', possible loss of data
// warning C4547: '*' : operator before comma has no effect; expected operator with side-effect
// warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning)
// warning C4804: '<' : unsafe use of type 'bool' in operation
// warning C4805: '==' : unsafe mix of type 'bool' and type 'char' in operation
// cannot find another implementation -> declared as system header to suppress these warnings.
#if defined(__GNUC__)
# pragma GCC system_header
#elif defined(BOOST_MSVC)
# pragma warning ( push )
# pragma warning ( disable : 4018 4244 4547 4800 4804 4805 4913 )
#endif
namespace boost {
namespace detail {
// This namespace ensures that argument-dependent name lookup does not mess things up.
namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
// 1. a function to have an instance of type T without requiring T to be default
// constructible
template <typename T> T &make();
// 2. we provide our operator definition for types that do not have one already
// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
// found in the type's own namespace (our own operator is used) so that we have
// a means to know that our operator was used
struct no_operator { };
// this class allows implicit conversions and makes the following operator
// definition less-preferred than any other such operators that might be found
// via argument-dependent name lookup
struct any { template <class T> any(T const&); };
// when operator BOOST_TT_TRAIT_OP is not available, this one is used
no_operator operator BOOST_TT_TRAIT_OP (const any&, const any&);
// 3. checks if the operator returns void or not
// conditions: Lhs!=void and Rhs!=void
// we first redefine "operator," so that we have no compilation error if
// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
// (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if
// operator BOOST_TT_TRAIT_OP returns void or not:
// - operator BOOST_TT_TRAIT_OP returns void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
// - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
struct returns_void_t { };
template <typename T> int operator,(const T&, returns_void_t);
template <typename T> int operator,(const volatile T&, returns_void_t);
// this intermediate trait has member value of type bool:
// - value==true -> operator BOOST_TT_TRAIT_OP returns void
// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
template < typename Lhs, typename Rhs >
struct operator_returns_void {
// overloads of function returns_void make the difference
// yes_type and no_type have different size by construction
static ::boost::type_traits::yes_type returns_void(returns_void_t);
static ::boost::type_traits::no_type returns_void(int);
BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>(),returns_void_t())))));
};
// 4. checks if the return type is Ret or Ret==dont_care
// conditions: Lhs!=void and Rhs!=void
struct dont_care { };
template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;
template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, void, true > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, void, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
template < typename Lhs, typename Rhs, typename Ret >
struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
// otherwise checks if it is convertible to Ret using the sizeof trick
// based on overload resolution
// condition: Ret!=void and Ret!=dont_care and the operator does not return void
template < typename Lhs, typename Rhs, typename Ret >
struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise
BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_Ret(make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>()))==sizeof(::boost::type_traits::yes_type)));
};
// 5. checks for operator existence
// condition: Lhs!=void and Rhs!=void
// checks if our definition of operator BOOST_TT_TRAIT_OP is used or an other
// existing one;
// this is done with redefinition of "operator," that returns no_operator or has_operator
struct has_operator { };
no_operator operator,(no_operator, has_operator);
template < typename Lhs, typename Rhs >
struct operator_exists {
static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists
static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise
BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((make<Lhs>() BOOST_TT_TRAIT_OP make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
};
// 6. main trait: to avoid any compilation error, this class behaves
// differently when operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the
// standard.
// Forbidden_if is a bool that is:
// - true when the operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the standard
// (would yield compilation error if used)
// - false otherwise
template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;
template < typename Lhs, typename Rhs, typename Ret >
struct trait_impl1 < Lhs, Rhs, Ret, true > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
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
)
);
};
// some specializations needs to be declared for the special void case
template < typename Rhs, typename Ret >
struct trait_impl1 < void, Rhs, Ret, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
template < typename Lhs, typename Ret >
struct trait_impl1 < Lhs, void, Ret, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
template < typename Ret >
struct trait_impl1 < void, void, Ret, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
// defines some typedef for convenience
template < typename Lhs, typename Rhs, typename Ret >
struct trait_impl {
typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
BOOST_STATIC_CONSTANT(bool, value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, BOOST_TT_FORBIDDEN_IF >::value));
};
} // namespace 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))
} // namespace boost
#if defined(BOOST_MSVC)
# pragma warning ( pop )
#endif
#include <boost/type_traits/detail/bool_trait_undef.hpp>

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

@@ -1,202 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa.
//
// 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.
#include <boost/config.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_fundamental.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_void.hpp>
#include <boost/type_traits/remove_cv.hpp>
#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
#elif defined(BOOST_MSVC)
# pragma warning ( push )
# pragma warning ( disable : 4244 4913 )
#endif
namespace boost {
namespace detail {
// This namespace ensures that argument-dependent name lookup does not mess things up.
namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
// 1. a function to have an instance of type T without requiring T to be default
// constructible
template <typename T> T &make();
// 2. we provide our operator definition for types that do not have one already
// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
// found in the type's own namespace (our own operator is used) so that we have
// a means to know that our operator was used
struct no_operator { };
// this class allows implicit conversions and makes the following operator
// definition less-preferred than any other such operators that might be found
// via argument-dependent name lookup
struct any { template <class T> any(T const&); };
// when operator BOOST_TT_TRAIT_OP is not available, this one is used
no_operator operator BOOST_TT_TRAIT_OP (const any&, int);
// 3. checks if the operator returns void or not
// conditions: Lhs!=void
// we first redefine "operator," so that we have no compilation error if
// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
// (lhs BOOST_TT_TRAIT_OP, returns_void_t()) to deduce if
// operator BOOST_TT_TRAIT_OP returns void or not:
// - operator BOOST_TT_TRAIT_OP returns void -> (lhs BOOST_TT_TRAIT_OP, returns_void_t()) returns returns_void_t
// - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP, returns_void_t()) returns int
struct returns_void_t { };
template <typename T> int operator,(const T&, returns_void_t);
template <typename T> int operator,(const volatile T&, returns_void_t);
// this intermediate trait has member value of type bool:
// - value==true -> operator BOOST_TT_TRAIT_OP returns void
// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
template < typename Lhs >
struct operator_returns_void {
// overloads of function returns_void make the difference
// yes_type and no_type have different size by construction
static ::boost::type_traits::yes_type returns_void(returns_void_t);
static ::boost::type_traits::no_type returns_void(int);
BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() BOOST_TT_TRAIT_OP,returns_void_t())))));
};
// 4. checks if the return type is Ret or Ret==dont_care
// conditions: Lhs!=void
struct dont_care { };
template < typename Lhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;
template < typename Lhs >
struct operator_returns_Ret < Lhs, dont_care, true > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Lhs >
struct operator_returns_Ret < Lhs, dont_care, false > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Lhs >
struct operator_returns_Ret < Lhs, void, true > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Lhs >
struct operator_returns_Ret < Lhs, void, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
template < typename Lhs, typename Ret >
struct operator_returns_Ret < Lhs, Ret, true > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
// otherwise checks if it is convertible to Ret using the sizeof trick
// based on overload resolution
// condition: Ret!=void and Ret!=dont_care and the operator does not return void
template < typename Lhs, typename Ret >
struct operator_returns_Ret < Lhs, Ret, false > {
static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise
BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_Ret(make<Lhs>() BOOST_TT_TRAIT_OP))==sizeof(::boost::type_traits::yes_type)));
};
// 5. checks for operator existence
// condition: Lhs!=void
// checks if our definition of operator BOOST_TT_TRAIT_OP is used or an other
// existing one;
// this is done with redefinition of "operator," that returns no_operator or has_operator
struct has_operator { };
no_operator operator,(no_operator, has_operator);
template < typename Lhs >
struct operator_exists {
static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists
static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise
BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((make<Lhs>() BOOST_TT_TRAIT_OP),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
};
// 6. main trait: to avoid any compilation error, this class behaves
// differently when operator BOOST_TT_TRAIT_OP(Lhs) is forbidden by the
// standard.
// Forbidden_if is a bool that is:
// - true when the operator BOOST_TT_TRAIT_OP(Lhs) is forbidden by the standard
// (would yield compilation error if used)
// - false otherwise
template < typename Lhs, typename Ret, bool Forbidden_if >
struct trait_impl1;
template < typename Lhs, typename Ret >
struct trait_impl1 < Lhs, Ret, true > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
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
)
);
};
// specialization needs to be declared for the special void case
template < typename Ret >
struct trait_impl1 < void, Ret, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
// defines some typedef for convenience
template < typename Lhs, typename Ret >
struct trait_impl {
typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
BOOST_STATIC_CONSTANT(bool, value = (trait_impl1 < Lhs_noref, Ret, BOOST_TT_FORBIDDEN_IF >::value));
};
} // namespace 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))
} // namespace boost
#if defined(BOOST_MSVC)
# pragma warning ( pop )
#endif
#include <boost/type_traits/detail/bool_trait_undef.hpp>

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

@@ -1,210 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron, Robert Stewart, Steven Watanabe & Roman Perepelitsa.
//
// 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.
#include <boost/config.hpp>
#include <boost/type_traits/ice.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_fundamental.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_void.hpp>
#include <boost/type_traits/remove_cv.hpp>
#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
// warning: comparison between signed and unsigned integer expressions
// msvc:
// warning C4146: unary minus operator applied to unsigned type, result still unsigned
// warning C4804: '-' : unsafe use of type 'bool' in operation
// cannot find another implementation -> declared as system header to suppress these warnings.
#if defined(__GNUC__)
# pragma GCC system_header
#elif defined(BOOST_MSVC)
# pragma warning ( push )
# pragma warning ( disable : 4146 4804 4913 4244 )
#endif
namespace boost {
namespace detail {
// This namespace ensures that argument-dependent name lookup does not mess things up.
namespace BOOST_JOIN(BOOST_TT_TRAIT_NAME,_impl) {
// 1. a function to have an instance of type T without requiring T to be default
// constructible
template <typename T> T &make();
// 2. we provide our operator definition for types that do not have one already
// a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
// found in the type's own namespace (our own operator is used) so that we have
// a means to know that our operator was used
struct no_operator { };
// this class allows implicit conversions and makes the following operator
// definition less-preferred than any other such operators that might be found
// via argument-dependent name lookup
struct any { template <class T> any(T const&); };
// when operator BOOST_TT_TRAIT_OP is not available, this one is used
no_operator operator BOOST_TT_TRAIT_OP (const any&);
// 3. checks if the operator returns void or not
// conditions: Rhs!=void
// we first redefine "operator," so that we have no compilation error if
// operator BOOST_TT_TRAIT_OP returns void and we can use the return type of
// (BOOST_TT_TRAIT_OP rhs, returns_void_t()) to deduce if
// operator BOOST_TT_TRAIT_OP returns void or not:
// - operator BOOST_TT_TRAIT_OP returns void -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
// - operator BOOST_TT_TRAIT_OP returns !=void -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
struct returns_void_t { };
template <typename T> int operator,(const T&, returns_void_t);
template <typename T> int operator,(const volatile T&, returns_void_t);
// this intermediate trait has member value of type bool:
// - value==true -> operator BOOST_TT_TRAIT_OP returns void
// - value==false -> operator BOOST_TT_TRAIT_OP does not return void
template < typename Rhs >
struct operator_returns_void {
// overloads of function returns_void make the difference
// yes_type and no_type have different size by construction
static ::boost::type_traits::yes_type returns_void(returns_void_t);
static ::boost::type_traits::no_type returns_void(int);
BOOST_STATIC_CONSTANT(bool, value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((BOOST_TT_TRAIT_OP make<Rhs>(),returns_void_t())))));
};
// 4. checks if the return type is Ret or Ret==dont_care
// conditions: Rhs!=void
struct dont_care { };
template < typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;
template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, true > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, false > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Rhs >
struct operator_returns_Ret < Rhs, void, true > {
BOOST_STATIC_CONSTANT(bool, value = true);
};
template < typename Rhs >
struct operator_returns_Ret < Rhs, void, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, true > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
// otherwise checks if it is convertible to Ret using the sizeof trick
// based on overload resolution
// condition: Ret!=void and Ret!=dont_care and the operator does not return void
template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, false > {
static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
static ::boost::type_traits::no_type is_convertible_to_Ret(...); // this version is used otherwise
BOOST_STATIC_CONSTANT(bool, value = (sizeof(is_convertible_to_Ret(BOOST_TT_TRAIT_OP make<Rhs>()))==sizeof(::boost::type_traits::yes_type)));
};
// 5. checks for operator existence
// condition: Rhs!=void
// checks if our definition of operator BOOST_TT_TRAIT_OP is used or an other
// existing one;
// this is done with redefinition of "operator," that returns no_operator or has_operator
struct has_operator { };
no_operator operator,(no_operator, has_operator);
template < typename Rhs >
struct operator_exists {
static ::boost::type_traits::yes_type s_check(has_operator); // this version is preferred when operator exists
static ::boost::type_traits::no_type s_check(no_operator); // this version is used otherwise
BOOST_STATIC_CONSTANT(bool, value = (sizeof(s_check(((BOOST_TT_TRAIT_OP make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type)));
};
// 6. main trait: to avoid any compilation error, this class behaves
// differently when operator BOOST_TT_TRAIT_OP(Rhs) is forbidden by the
// standard.
// Forbidden_if is a bool that is:
// - true when the operator BOOST_TT_TRAIT_OP(Rhs) is forbidden by the standard
// (would yield compilation error if used)
// - false otherwise
template < typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;
template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, true > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
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
)
);
};
// specialization needs to be declared for the special void case
template < typename Ret >
struct trait_impl1 < void, Ret, false > {
BOOST_STATIC_CONSTANT(bool, value = false);
};
// defines some typedef for convenience
template < typename Rhs, typename Ret >
struct trait_impl {
typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
BOOST_STATIC_CONSTANT(bool, value = (trait_impl1 < Rhs_noref, Ret, BOOST_TT_FORBIDDEN_IF >::value));
};
} // namespace 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))
} // namespace boost
#if defined(BOOST_MSVC)
# pragma warning ( pop )
#endif
#include <boost/type_traits/detail/bool_trait_undef.hpp>

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

@@ -1,35 +0,0 @@
// (C) Copyright John Maddock and Steve Cleary 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_ICE_AND_HPP_INCLUDED
#define BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED
#include <boost/config.hpp>
namespace boost {
namespace type_traits {
template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
struct ice_and;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_and
{
BOOST_STATIC_CONSTANT(bool, value = false);
};
template <>
struct ice_and<true, true, true, true, true, true, true>
{
BOOST_STATIC_CONSTANT(bool, value = true);
};
} // namespace type_traits
} // namespace boost
#endif // BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED

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

@@ -1,36 +0,0 @@
// (C) Copyright John Maddock and Steve Cleary 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_ICE_EQ_HPP_INCLUDED
#define BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED
#include <boost/config.hpp>
namespace boost {
namespace type_traits {
template <int b1, int b2>
struct ice_eq
{
BOOST_STATIC_CONSTANT(bool, value = (b1 == b2));
};
template <int b1, int b2>
struct ice_ne
{
BOOST_STATIC_CONSTANT(bool, value = (b1 != b2));
};
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
template <int b1, int b2> bool const ice_eq<b1,b2>::value;
template <int b1, int b2> bool const ice_ne<b1,b2>::value;
#endif
} // namespace type_traits
} // namespace boost
#endif // BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED

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

@@ -1,31 +0,0 @@
// (C) Copyright John Maddock and Steve Cleary 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_ICE_NOT_HPP_INCLUDED
#define BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED
#include <boost/config.hpp>
namespace boost {
namespace type_traits {
template <bool b>
struct ice_not
{
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <>
struct ice_not<true>
{
BOOST_STATIC_CONSTANT(bool, value = false);
};
} // namespace type_traits
} // namespace boost
#endif // BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED

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

@@ -1,34 +0,0 @@
// (C) Copyright John Maddock and Steve Cleary 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_ICE_OR_HPP_INCLUDED
#define BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED
#include <boost/config.hpp>
namespace boost {
namespace type_traits {
template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
struct ice_or;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_or
{
BOOST_STATIC_CONSTANT(bool, value = true);
};
template <>
struct ice_or<false, false, false, false, false, false, false>
{
BOOST_STATIC_CONSTANT(bool, value = false);
};
} // namespace type_traits
} // namespace boost
#endif // BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED

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

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

@@ -1,31 +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)
#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) /**/
#endif

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

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

@@ -1,141 +0,0 @@
// (C) Copyright 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).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#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>
namespace boost {
namespace detail{
#if defined( __CODEGEARC__ )
// wrap the impl as main trait provides additional MPL lambda support
template < typename T, std::size_t N >
struct extent_imp {
static const std::size_t value = __array_extent(T, N);
};
#else
template <class T, std::size_t N>
struct extent_imp
{
BOOST_STATIC_CONSTANT(std::size_t, value = 0);
};
#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
template <class T, std::size_t R, std::size_t N>
struct extent_imp<T[R], N>
{
BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
};
template <class T, std::size_t R, std::size_t N>
struct extent_imp<T const[R], N>
{
BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
};
template <class T, std::size_t R, std::size_t N>
struct extent_imp<T volatile[R], N>
{
BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
};
template <class T, std::size_t R, std::size_t N>
struct extent_imp<T const volatile[R], N>
{
BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
};
template <class T, std::size_t R>
struct extent_imp<T[R],0>
{
BOOST_STATIC_CONSTANT(std::size_t, value = R);
};
template <class T, std::size_t R>
struct extent_imp<T const[R], 0>
{
BOOST_STATIC_CONSTANT(std::size_t, value = R);
};
template <class T, std::size_t R>
struct extent_imp<T volatile[R], 0>
{
BOOST_STATIC_CONSTANT(std::size_t, value = R);
};
template <class T, std::size_t R>
struct extent_imp<T const volatile[R], 0>
{
BOOST_STATIC_CONSTANT(std::size_t, value = R);
};
#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) && !defined(__MWERKS__)
template <class T, std::size_t N>
struct extent_imp<T[], N>
{
BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
};
template <class T, std::size_t N>
struct extent_imp<T const[], N>
{
BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
};
template <class T, std::size_t N>
struct extent_imp<T volatile[], N>
{
BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
};
template <class T, std::size_t N>
struct extent_imp<T const volatile[], N>
{
BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::extent_imp<T, N-1>::value));
};
template <class T>
struct extent_imp<T[], 0>
{
BOOST_STATIC_CONSTANT(std::size_t, value = 0);
};
template <class T>
struct extent_imp<T const[], 0>
{
BOOST_STATIC_CONSTANT(std::size_t, value = 0);
};
template <class T>
struct extent_imp<T volatile[], 0>
{
BOOST_STATIC_CONSTANT(std::size_t, value = 0);
};
template <class T>
struct extent_imp<T const volatile[], 0>
{
BOOST_STATIC_CONSTANT(std::size_t, value = 0);
};
#endif
#endif
#endif // non-CodeGear implementation
} // ::boost::detail
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

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

@@ -1,91 +0,0 @@
// Copyright 2005 Alexander Nasonov.
// 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 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 {
#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

174
include/boost/type_traits/function_traits.hpp
View File

@@ -1,174 +0,0 @@
// Copyright 2000 John Maddock (john@johnmaddock.co.uk)
// 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_FUNCTION_TRAITS_HPP_INCLUDED
#define BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED
#include <boost/config.hpp>
#include <boost/type_traits/is_function.hpp>
#include <boost/type_traits/add_pointer.hpp>
namespace boost {
namespace detail {
template<typename Function> struct function_traits_helper;
template<typename R>
struct function_traits_helper<R (*)(void)>
{
BOOST_STATIC_CONSTANT(unsigned, arity = 0);
typedef R result_type;
};
template<typename R, typename T1>
struct function_traits_helper<R (*)(T1)>
{
BOOST_STATIC_CONSTANT(unsigned, arity = 1);
typedef R result_type;
typedef T1 arg1_type;
typedef T1 argument_type;
};
template<typename R, typename T1, typename T2>
struct function_traits_helper<R (*)(T1, T2)>
{
BOOST_STATIC_CONSTANT(unsigned, arity = 2);
typedef R result_type;
typedef T1 arg1_type;
typedef T2 arg2_type;
typedef T1 first_argument_type;
typedef T2 second_argument_type;
};
template<typename R, typename T1, typename T2, typename T3>
struct function_traits_helper<R (*)(T1, T2, T3)>
{
BOOST_STATIC_CONSTANT(unsigned, arity = 3);
typedef R result_type;
typedef T1 arg1_type;
typedef T2 arg2_type;
typedef T3 arg3_type;
};
template<typename R, typename T1, typename T2, typename T3, typename T4>
struct function_traits_helper<R (*)(T1, T2, T3, T4)>
{
BOOST_STATIC_CONSTANT(unsigned, arity = 4);
typedef R result_type;
typedef T1 arg1_type;
typedef T2 arg2_type;
typedef T3 arg3_type;
typedef T4 arg4_type;
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
{
BOOST_STATIC_CONSTANT(unsigned, arity = 5);
typedef R result_type;
typedef T1 arg1_type;
typedef T2 arg2_type;
typedef T3 arg3_type;
typedef T4 arg4_type;
typedef T5 arg5_type;
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
{
BOOST_STATIC_CONSTANT(unsigned, arity = 6);
typedef R result_type;
typedef T1 arg1_type;
typedef T2 arg2_type;
typedef T3 arg3_type;
typedef T4 arg4_type;
typedef T5 arg5_type;
typedef T6 arg6_type;
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
{
BOOST_STATIC_CONSTANT(unsigned, arity = 7);
typedef R result_type;
typedef T1 arg1_type;
typedef T2 arg2_type;
typedef T3 arg3_type;
typedef T4 arg4_type;
typedef T5 arg5_type;
typedef T6 arg6_type;
typedef T7 arg7_type;
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
{
BOOST_STATIC_CONSTANT(unsigned, arity = 8);
typedef R result_type;
typedef T1 arg1_type;
typedef T2 arg2_type;
typedef T3 arg3_type;
typedef T4 arg4_type;
typedef T5 arg5_type;
typedef T6 arg6_type;
typedef T7 arg7_type;
typedef T8 arg8_type;
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8, typename T9>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
{
BOOST_STATIC_CONSTANT(unsigned, arity = 9);
typedef R result_type;
typedef T1 arg1_type;
typedef T2 arg2_type;
typedef T3 arg3_type;
typedef T4 arg4_type;
typedef T5 arg5_type;
typedef T6 arg6_type;
typedef T7 arg7_type;
typedef T8 arg8_type;
typedef T9 arg9_type;
};
template<typename R, typename T1, typename T2, typename T3, typename T4,
typename T5, typename T6, typename T7, typename T8, typename T9,
typename T10>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
{
BOOST_STATIC_CONSTANT(unsigned, arity = 10);
typedef R result_type;
typedef T1 arg1_type;
typedef T2 arg2_type;
typedef T3 arg3_type;
typedef T4 arg4_type;
typedef T5 arg5_type;
typedef T6 arg6_type;
typedef T7 arg7_type;
typedef T8 arg8_type;
typedef T9 arg9_type;
typedef T10 arg10_type;
};
} // end namespace detail
template<typename Function>
struct function_traits :
public boost::detail::function_traits_helper<typename boost::add_pointer<Function>::type>
{
};
}
#endif // BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_BIT_AND_HPP_INCLUDED
#define BOOST_TT_HAS_BIT_AND_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,55 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_BIT_AND_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_BIT_AND_ASSIGN_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_const< Lhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_BIT_OR_HPP_INCLUDED
#define BOOST_TT_HAS_BIT_OR_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,55 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_BIT_OR_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_BIT_OR_ASSIGN_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_const< Lhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_BIT_XOR_HPP_INCLUDED
#define BOOST_TT_HAS_BIT_XOR_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,55 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_BIT_XOR_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_BIT_XOR_ASSIGN_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_const< Lhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,32 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_COMPLEMENT_HPP_INCLUDED
#define BOOST_TT_HAS_COMPLEMENT_HPP_INCLUDED
#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,\
/* 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
#include <boost/type_traits/detail/has_prefix_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,31 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_DEREFERENCE_HPP_INCLUDED
#define BOOST_TT_HAS_DEREFERENCE_HPP_INCLUDED
#define BOOST_TT_TRAIT_NAME has_dereference
#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_void< Rhs_noptr >::value\
>::value,\
::boost::is_fundamental< Rhs_nocv >::value\
>::value
#include <boost/type_traits/detail/has_prefix_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,40 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_DIVIDES_HPP_INCLUDED
#define BOOST_TT_HAS_DIVIDES_HPP_INCLUDED
#define BOOST_TT_TRAIT_NAME has_divides
#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< 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< Lhs_noref >::value\
>::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,47 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_DIVIDES_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_DIVIDES_ASSIGN_HPP_INCLUDED
#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< 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< 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< Lhs_noref >::value\
>::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_EQUAL_TO_HPP_INCLUDED
#define BOOST_TT_HAS_EQUAL_TO_HPP_INCLUDED
#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_fundamental< Rhs_nocv >::value\
>::value,\
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::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_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_GREATER_HPP_INCLUDED
#define BOOST_TT_HAS_GREATER_HPP_INCLUDED
#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_fundamental< Rhs_nocv >::value\
>::value,\
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::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_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_GREATER_EQUAL_HPP_INCLUDED
#define BOOST_TT_HAS_GREATER_EQUAL_HPP_INCLUDED
#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_fundamental< Rhs_nocv >::value\
>::value,\
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::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_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_LEFT_SHIFT_HPP_INCLUDED
#define BOOST_TT_HAS_LEFT_SHIFT_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,55 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_LEFT_SHIFT_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_LEFT_SHIFT_ASSIGN_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_const< Lhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_LESS_HPP_INCLUDED
#define BOOST_TT_HAS_LESS_HPP_INCLUDED
#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_fundamental< Rhs_nocv >::value\
>::value,\
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::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_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_LESS_EQUAL_HPP_INCLUDED
#define BOOST_TT_HAS_LESS_EQUAL_HPP_INCLUDED
#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_fundamental< Rhs_nocv >::value\
>::value,\
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::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_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,40 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_LOGICAL_AND_HPP_INCLUDED
#define BOOST_TT_HAS_LOGICAL_AND_HPP_INCLUDED
#define BOOST_TT_TRAIT_NAME has_logical_and
#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
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,32 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_LOGICAL_NOT_HPP_INCLUDED
#define BOOST_TT_HAS_LOGICAL_NOT_HPP_INCLUDED
#if defined(__GNUC__) && (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ > 40800)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-value"
#endif
#define BOOST_TT_TRAIT_NAME has_logical_not
#define BOOST_TT_TRAIT_OP !
#define BOOST_TT_FORBIDDEN_IF\
false
#include <boost/type_traits/detail/has_prefix_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#if defined(__GNUC__) && (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ > 40800)
#pragma GCC diagnostic pop
#endif
#endif

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

@@ -1,40 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_LOGICAL_OR_HPP_INCLUDED
#define BOOST_TT_HAS_LOGICAL_OR_HPP_INCLUDED
#define BOOST_TT_TRAIT_NAME has_logical_or
#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
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,60 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_MINUS_HPP_INCLUDED
#define BOOST_TT_HAS_MINUS_HPP_INCLUDED
#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,\
/* 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< 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< Lhs_noref >::value\
>::value\
>::value,\
/* Lhs=fundamental and Rhs=pointer */\
::boost::type_traits::ice_and<\
::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
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,65 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_MINUS_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_MINUS_ASSIGN_HPP_INCLUDED
#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,\
/* Lhs==void* and Rhs==fundamental */\
::boost::type_traits::ice_and<\
::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_fundamental< Lhs_nocv >::value\
>::value,\
/* Lhs=fundamental and Rhs=pointer */\
::boost::type_traits::ice_and<\
::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< 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_pointer< Lhs_noref >::value\
>::value,\
::boost::type_traits::ice_or<\
::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>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_MODULUS_HPP_INCLUDED
#define BOOST_TT_HAS_MODULUS_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,55 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_MODULUS_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_MODULUS_ASSIGN_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_const< Lhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,40 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_MULTIPLIES_HPP_INCLUDED
#define BOOST_TT_HAS_MULTIPLIES_HPP_INCLUDED
#define BOOST_TT_TRAIT_NAME has_multiplies
#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< 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< Lhs_noref >::value\
>::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,47 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_MULTIPLIES_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_MULTIPLIES_ASSIGN_HPP_INCLUDED
#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< 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< 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< Lhs_noref >::value\
>::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,25 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_NEGATE_HPP_INCLUDED
#define BOOST_TT_HAS_NEGATE_HPP_INCLUDED
#define BOOST_TT_TRAIT_NAME has_negate
#define BOOST_TT_TRAIT_OP -
#define BOOST_TT_FORBIDDEN_IF\
/* pointer */\
::boost::is_pointer< Rhs_noref >::value
#include <boost/type_traits/detail/has_prefix_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,154 +0,0 @@
// (C) Copyright Runar Undheim, Robert Ramey & John Maddock 2008.
// 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_HAS_NEW_OPERATOR_HPP_INCLUDED
#define BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED
#include <new> // std::nothrow_t
#include <cstddef> // std::size_t
#include <boost/type_traits/config.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>
#if defined(new)
# if BOOST_WORKAROUND(BOOST_MSVC, >= 1310)
# define BOOST_TT_AUX_MACRO_NEW_DEFINED
# pragma push_macro("new")
# undef new
# else
# error "Sorry but you can't include this header if 'new' is defined as a macro."
# endif
#endif
namespace boost {
namespace detail {
template <class U, U x>
struct test;
template <typename T>
struct has_new_operator_impl {
template<class U>
static type_traits::yes_type check_sig1(
U*,
test<
void *(*)(std::size_t),
&U::operator new
>* = NULL
);
template<class U>
static type_traits::no_type check_sig1(...);
template<class U>
static type_traits::yes_type check_sig2(
U*,
test<
void *(*)(std::size_t, const std::nothrow_t&),
&U::operator new
>* = NULL
);
template<class U>
static type_traits::no_type check_sig2(...);
template<class U>
static type_traits::yes_type check_sig3(
U*,
test<
void *(*)(std::size_t, void*),
&U::operator new
>* = NULL
);
template<class U>
static type_traits::no_type check_sig3(...);
template<class U>
static type_traits::yes_type check_sig4(
U*,
test<
void *(*)(std::size_t),
&U::operator new[]
>* = NULL
);
template<class U>
static type_traits::no_type check_sig4(...);
template<class U>
static type_traits::yes_type check_sig5(
U*,
test<
void *(*)(std::size_t, const std::nothrow_t&),
&U::operator new[]
>* = NULL
);
template<class U>
static type_traits::no_type check_sig5(...);
template<class U>
static type_traits::yes_type check_sig6(
U*,
test<
void *(*)(std::size_t, void*),
&U::operator new[]
>* = NULL
);
template<class U>
static type_traits::no_type check_sig6(...);
// GCC2 won't even parse this template if we embed the computation
// of s1 in the computation of value.
#ifdef __GNUC__
BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(has_new_operator_impl<T>::template check_sig1<T>(0)));
BOOST_STATIC_CONSTANT(unsigned, s2 = sizeof(has_new_operator_impl<T>::template check_sig2<T>(0)));
BOOST_STATIC_CONSTANT(unsigned, s3 = sizeof(has_new_operator_impl<T>::template check_sig3<T>(0)));
BOOST_STATIC_CONSTANT(unsigned, s4 = sizeof(has_new_operator_impl<T>::template check_sig4<T>(0)));
BOOST_STATIC_CONSTANT(unsigned, s5 = sizeof(has_new_operator_impl<T>::template check_sig5<T>(0)));
BOOST_STATIC_CONSTANT(unsigned, s6 = sizeof(has_new_operator_impl<T>::template check_sig6<T>(0)));
#else
#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
#pragma warning(push)
#pragma warning(disable:6334)
#endif
BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(check_sig1<T>(0)));
BOOST_STATIC_CONSTANT(unsigned, s2 = sizeof(check_sig2<T>(0)));
BOOST_STATIC_CONSTANT(unsigned, s3 = sizeof(check_sig3<T>(0)));
BOOST_STATIC_CONSTANT(unsigned, s4 = sizeof(check_sig4<T>(0)));
BOOST_STATIC_CONSTANT(unsigned, s5 = sizeof(check_sig5<T>(0)));
BOOST_STATIC_CONSTANT(unsigned, s6 = sizeof(check_sig6<T>(0)));
#if BOOST_WORKAROUND(BOOST_MSVC_FULL_VER, >= 140050000)
#pragma warning(pop)
#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)),
(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)
} // namespace boost
#if defined(BOOST_TT_AUX_MACRO_NEW_DEFINED)
# pragma pop_macro("new")
#endif
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_NOT_EQUAL_TO_HPP_INCLUDED
#define BOOST_TT_HAS_NOT_EQUAL_TO_HPP_INCLUDED
#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_fundamental< Rhs_nocv >::value\
>::value,\
/* Rhs==pointer and Lhs==fundamental */\
::boost::type_traits::ice_and<\
::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_void< Rhs_noptr >::value\
>::value\
>::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -9,36 +9,35 @@
#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>
#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

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

@@ -1,53 +0,0 @@
// (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_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
#define BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED
#include <boost/type_traits/has_trivial_constructor.hpp>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
namespace boost {
namespace detail{
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);
#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)
#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)
#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
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED

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

@@ -9,45 +9,41 @@
#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>
#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

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

@@ -1,25 +0,0 @@
// (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_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED
#define BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED
#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)
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED

51
include/boost/type_traits/has_operator.hpp
View File

@@ -1,51 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_OPERATOR_HPP_INCLUDED
#define BOOST_TT_HAS_OPERATOR_HPP_INCLUDED
#include <boost/type_traits/has_bit_and.hpp>
#include <boost/type_traits/has_bit_and_assign.hpp>
#include <boost/type_traits/has_bit_or.hpp>
#include <boost/type_traits/has_bit_or_assign.hpp>
#include <boost/type_traits/has_bit_xor.hpp>
#include <boost/type_traits/has_bit_xor_assign.hpp>
#include <boost/type_traits/has_complement.hpp>
#include <boost/type_traits/has_dereference.hpp>
#include <boost/type_traits/has_divides.hpp>
#include <boost/type_traits/has_divides_assign.hpp>
#include <boost/type_traits/has_equal_to.hpp>
#include <boost/type_traits/has_greater.hpp>
#include <boost/type_traits/has_greater_equal.hpp>
#include <boost/type_traits/has_left_shift.hpp>
#include <boost/type_traits/has_left_shift_assign.hpp>
#include <boost/type_traits/has_less.hpp>
#include <boost/type_traits/has_less_equal.hpp>
#include <boost/type_traits/has_logical_and.hpp>
#include <boost/type_traits/has_logical_not.hpp>
#include <boost/type_traits/has_logical_or.hpp>
#include <boost/type_traits/has_minus.hpp>
#include <boost/type_traits/has_minus_assign.hpp>
#include <boost/type_traits/has_modulus.hpp>
#include <boost/type_traits/has_modulus_assign.hpp>
#include <boost/type_traits/has_multiplies.hpp>
#include <boost/type_traits/has_multiplies_assign.hpp>
#include <boost/type_traits/has_negate.hpp>
#include <boost/type_traits/has_not_equal_to.hpp>
#include <boost/type_traits/has_plus.hpp>
#include <boost/type_traits/has_plus_assign.hpp>
#include <boost/type_traits/has_post_decrement.hpp>
#include <boost/type_traits/has_post_increment.hpp>
#include <boost/type_traits/has_pre_decrement.hpp>
#include <boost/type_traits/has_pre_increment.hpp>
#include <boost/type_traits/has_right_shift.hpp>
#include <boost/type_traits/has_right_shift_assign.hpp>
#include <boost/type_traits/has_unary_minus.hpp>
#include <boost/type_traits/has_unary_plus.hpp>
#endif

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

@@ -1,54 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_PLUS_HPP_INCLUDED
#define BOOST_TT_HAS_PLUS_HPP_INCLUDED
#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< 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_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_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,\
/* 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
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,66 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_PLUS_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_PLUS_ASSIGN_HPP_INCLUDED
#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< 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_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_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,\
/* 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,\
/* (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_pointer< Lhs_noref >::value\
>::value,\
::boost::type_traits::ice_or<\
::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>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,44 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_POST_DECREMENT_HPP_INCLUDED
#define BOOST_TT_HAS_POST_DECREMENT_HPP_INCLUDED
#include <boost/type_traits/is_array.hpp>
#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,\
/* void* */\
::boost::type_traits::ice_and<\
::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_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>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,44 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_POST_INCREMENT_HPP_INCLUDED
#define BOOST_TT_HAS_POST_INCREMENT_HPP_INCLUDED
#include <boost/type_traits/is_array.hpp>
#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,\
/* void* */\
::boost::type_traits::ice_and<\
::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_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>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,44 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_PRE_DECREMENT_HPP_INCLUDED
#define BOOST_TT_HAS_PRE_DECREMENT_HPP_INCLUDED
#include <boost/type_traits/is_array.hpp>
#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,\
/* void* */\
::boost::type_traits::ice_and<\
::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_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>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,44 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_PRE_INCREMENT_HPP_INCLUDED
#define BOOST_TT_HAS_PRE_INCREMENT_HPP_INCLUDED
#include <boost/type_traits/is_array.hpp>
#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,\
/* void* */\
::boost::type_traits::ice_and<\
::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_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>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,49 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_RIGHT_SHIFT_HPP_INCLUDED
#define BOOST_TT_HAS_RIGHT_SHIFT_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::boost::is_pointer< Lhs_noref >::value,\
::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,55 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_RIGHT_SHIFT_ASSIGN_HPP_INCLUDED
#define BOOST_TT_HAS_RIGHT_SHIFT_ASSIGN_HPP_INCLUDED
#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,\
/* Lhs==fundamental and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_pointer< Lhs_noref >::value\
>::value,\
/* Lhs==pointer and Rhs==pointer */\
::boost::type_traits::ice_and<\
::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_const< Lhs_noref >::value\
>::value\
>::value
#include <boost/type_traits/detail/has_binary_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

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

@@ -1,51 +0,0 @@
// (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_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>
namespace boost {
namespace detail {
template <typename T>
struct has_trivial_ctor_impl
{
#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));
#else
BOOST_STATIC_CONSTANT(bool, value =
(::boost::type_traits::ice_or<
::boost::is_pod<T>::value,
false
>::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)
} // 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

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

@@ -1,49 +0,0 @@
// (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_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>
// should be the last #include
#include <boost/type_traits/detail/bool_trait_def.hpp>
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));
#else
BOOST_STATIC_CONSTANT(bool, value = ::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)
#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)
#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

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

@@ -1,25 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_UNARY_MINUS_HPP_INCLUDED
#define BOOST_TT_HAS_UNARY_MINUS_HPP_INCLUDED
#define BOOST_TT_TRAIT_NAME has_unary_minus
#define BOOST_TT_TRAIT_OP -
#define BOOST_TT_FORBIDDEN_IF\
/* pointer */\
::boost::is_pointer< Rhs_noref >::value
#include <boost/type_traits/detail/has_prefix_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,23 +0,0 @@
// (C) Copyright 2009-2011 Frederic Bron.
//
// 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_HAS_UNARY_PLUS_HPP_INCLUDED
#define BOOST_TT_HAS_UNARY_PLUS_HPP_INCLUDED
#define BOOST_TT_TRAIT_NAME has_unary_plus
#define BOOST_TT_TRAIT_OP +
#define BOOST_TT_FORBIDDEN_IF\
false
#include <boost/type_traits/detail/has_prefix_operator.hpp>
#undef BOOST_TT_TRAIT_NAME
#undef BOOST_TT_TRAIT_OP
#undef BOOST_TT_FORBIDDEN_IF
#endif

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

@@ -1,29 +0,0 @@
// (C) Copyright 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).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
#ifndef BOOST_TT_HAS_VIRTUAL_DESTRUCTOR_HPP_INCLUDED
#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>
namespace boost {
#ifdef BOOST_HAS_VIRTUAL_DESTRUCTOR
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_virtual_destructor,T,BOOST_HAS_VIRTUAL_DESTRUCTOR(T))
#else
BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_virtual_destructor,T,false)
#endif
} // namespace boost
#include <boost/type_traits/detail/bool_trait_undef.hpp>
#endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED

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

@@ -1,20 +0,0 @@
// (C) Copyright John Maddock and Steve Cleary 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.
//
// macros and helpers for working with integral-constant-expressions.
#ifndef BOOST_TT_ICE_HPP_INCLUDED
#define BOOST_TT_ICE_HPP_INCLUDED
#include <boost/type_traits/detail/yes_no_type.hpp>
#include <boost/type_traits/detail/ice_or.hpp>
#include <boost/type_traits/detail/ice_and.hpp>
#include <boost/type_traits/detail/ice_not.hpp>
#include <boost/type_traits/detail/ice_eq.hpp>
#endif // BOOST_TT_ICE_HPP_INCLUDED

85
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,73 @@
#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;
}
}
#else
namespace mpl_{
template <bool B> struct bool_;
template <class I, I val> struct integral_c;
}
namespace boost
{
namespace mpl
{
using ::mpl_::bool_;
using ::mpl_::integral_c;
}
}
#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 integral_constant<T, val> type;
static const T value = val;
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 = 0;
return *reinterpret_cast<const mpl::integral_c<T, val>*>(&data);
}
};
typedef integral_constant<bool,true> true_type;
typedef integral_constant<bool,false> false_type;
template <bool val>
struct integral_constant<bool, val>
{
typedef integral_constant<bool, val> type;
static const bool value = val;
operator const mpl::bool_<val>& ()const
{
static const char data = 0;
return *reinterpret_cast<const mpl::bool_<val>*>(&data);
}
};
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
}

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