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

Merge pull request #142 from glenfe/develop

Browse Source 
Implement multiple type traits
This commit is contained in:
jzmaddock
2020-06-02 19:07:36 +01:00
committed by GitHub
parent bd5bede326 f7f7dbf16e
commit 18962d99a4
20 changed files with 829 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
doc/conjunction.qbk Normal file
View File

@ -0,0 +1,36 @@
[/
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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).
]
[section:conjunction conjunction]
template<class... T>
struct conjunction;
__inherit Inherits from the first type `U` in the list for which
`bool(U::value)` is `false`, or the last type in the list if there is no such
type. If `sizeof...(T)` is `0` then inherits from `__true_type`.
__header `#include <boost/type_traits/conjunction.hpp>`
[all_compilers] In the absence of variadic-template support, `conjunction` has
only 2 parameters.
__examples
[:Given: `template<int N> struct Int { static const int value = N };` ]
[:`conjunction<>` inherits from `__true_type`.]
[:`conjunction<Int<1> >` inherits from `Int<1>`.]
[:`conjunction<Int<1>, Int<2>, Int<3> >` inherits from `Int<3>`.]
[:`conjunction<Int<1>, Int<0>, Int<3> >` inherits from `Int<0>`.]
[endsect]

36
doc/disjunction.qbk Normal file
View File

@ -0,0 +1,36 @@
[/
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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).
]
[section:disjunction disjunction]
template<class... T>
struct disjunction;
__inherit Inherits from the first type `U` in the list for which
`bool(U::value)` is `true`, or the last type in the list if there is no such
type. If `sizeof...(T)` is `0` then inherits from `__false_type`.
__header `#include <boost/type_traits/disjunction.hpp>`
[all_compilers] In the absence of variadic-template support, `disjunction` has
only 2 parameters.
__examples
[:Given: `template<int N> struct Int { static const int value = N };` ]
[:`disjunction<>` inherits from `__false_type`.]
[:`disjunction<Int<1> >` inherits from `Int<1>`.]
[:`disjunction<Int<1>, Int<2>, Int<3> >` inherits from `Int<1>`.]
[:`disjunction<Int<0>, Int<2>, Int<3> >` inherits from `Int<2>`.]
[endsect]

45
doc/is_scoped_enum.qbk Normal file
View File

@ -0,0 +1,45 @@
[/
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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).
]
[section:is_scoped_enum is_scoped_enum]
template<class T>
struct is_scoped_enum
: __tof { };
__inherit If T is a (possibly cv-qualified) scoped enumeration type
(`enum class` but not `enum`), then inherits from __true_type, otherwise
inherits from __false_type.
__header `#include <boost/type_traits/is_scoped_enum.hpp>`
[all_compilers]
__examples
[:Given: `enum class color { red, blue };` and `enum fruit { apple, orange };`]
[:`is_scoped_enum<color>` inherits from `__true_type`.]
[:`is_scoped_enum<fruit>` inherits from `__false_type`.]
[:`is_scoped_enum<color const>::type` is the type `__true_type`.]
[:`is_scoped_enum<color>::value` is an integral constant expression that
evaluates to /true/.]
[:`is_scoped_enum<color&>::value` is an integral constant expression that
evaluates to /false/.]
[:`is_scoped_enum<color*>::value` is an integral constant expression that
evaluates to /false/.]
[:`is_scoped_enum<T>::value_type` is the type `bool`.]
[endsect]

40
doc/is_trivially_copyable.qbk Normal file
View File

@ -0,0 +1,40 @@
[/
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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).
]
[section:is_trivially_copyable is_trivially_copyable]
template<class T>
struct is_trivially_copyable
: __tof { };
__inherit If T is a (possibly cv-qualified) type that is trivially copyable
then inherits from __true_type, otherwise inherits from __false_type.
__compat This trait is implemented as the conjunction of `has_trivial_copy`,
`has_trivial_assign`, and `has_trivial_destructor`.
__header `#include <boost/type_traits/is_trivially_copyable.hpp>`
__examples
[:`is_trivially_copyable<int>` inherits from `__true_type`.]
[:`is_trivially_copyable<const int>` inherits from `__false_type`.]
[:`is_trivially_copyable<char*>::type` is the type `__true_type`.]
[:`is_trivially_copyable<int(*)(long)>::value` is an integral constant
expression that evaluates to /true/.]
[:`is_trivially_copyable<MyClass>::value` is an integral constant expression
that evaluates to /false/.]
[:`is_trivially_copyable<T>::value_type` is the type `bool`.]
[endsect]

45
doc/is_unscoped_enum.qbk Normal file
View File

@ -0,0 +1,45 @@
[/
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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).
]
[section:is_unscoped_enum is_unscoped_enum]
template<class T>
struct is_unscoped_enum
: __tof { };
__inherit If T is a (possibly cv-qualified) unscoped enumeration type
(`enum` but not `enum class`), then inherits from __true_type, otherwise
inherits from __false_type.
__header `#include <boost/type_traits/is_unscoped_enum.hpp>`
[all_compilers]
__examples
[:Given: `enum color { red, blue };` and `enum class fruit { apple, orange };`]
[:`is_unscoped_enum<color>` inherits from `__true_type`.]
[:`is_unscoped_enum<fruit>` inherits from `__false_type`.]
[:`is_unscoped_enum<color const>::type` is the type `__true_type`.]
[:`is_unscoped_enum<color>::value` is an integral constant expression that
evaluates to /true/.]
[:`is_unscoped_enum<color&>::value` is an integral constant expression that
evaluates to /false/.]
[:`is_unscoped_enum<color*>::value` is an integral constant expression that
evaluates to /false/.]
[:`is_unscoped_enum<T>::value_type` is the type `bool`.]
[endsect]

35
doc/negation.qbk Normal file
View File

@ -0,0 +1,35 @@
[/
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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).
]
[section:negation negation]
template<class T>
struct negation
: public __integral_constant<bool, !bool(T::value)> { };
__inherit Inherits from `__integral_constant<bool, !bool(T::value)>`.
__header `#include <boost/type_traits/negation.hpp>`
[all_compilers]
__examples
[:`negation<__true_type>` inherits from `__false_type`.]
[:`negation<__false_type>` inherits from `__true_type`.]
[:`negation<__integral_constant<int, 4> >::type` is the type `__false_type`.]
[:`negation<__integral_constant<int, 0> >::value` is an integral constant
expression that evaluates to /true/.]
[:`negation<T>::value_type` is the type `bool`.]
[endsect]

14
doc/type_traits.qbk
View File

@ -8,7 +8,7 @@
[library Boost.TypeTraits
[quickbook 1.5]
[copyright 2000 2011 Adobe Systems Inc, David Abrahams, Frederic Bron,
Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones,
Steve Cleary, Beman Dawes, Glen Fernandes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones,
Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen,
Roman Perepelitsa, Robert Ramey, Jeremy Siek, Robert Stewart and Steven Watanabe]
[purpose Meta-programming support library]
@ -55,6 +55,8 @@
[def __is_unbounded_array [link boost_typetraits.reference.is_unbounded_array is_unbounded_array]]
[def __is_union [link boost_typetraits.reference.is_union is_union]]
[def __is_class [link boost_typetraits.reference.is_class is_class]]
[def __is_scoped_enum [link boost_typetraits.reference.is_scoped_enum is_scoped_enum]]
[def __is_unscoped_enum [link boost_typetraits.reference.is_unscoped_enum is_unscoped_enum]]
[def __is_enum [link boost_typetraits.reference.is_enum is_enum]]
[def __is_enum [link boost_typetraits.reference.is_enum is_enum]]
[def __is_function [link boost_typetraits.reference.is_function is_function]]
@ -85,6 +87,7 @@
[def __is_signed [link boost_typetraits.reference.is_signed is_signed]]
[def __is_unsigned [link boost_typetraits.reference.is_unsigned is_unsigned]]
[def __has_virtual_destructor [link boost_typetraits.reference.has_virtual_destructor has_virtual_destructor]]
[def __is_trivially_copyable [link boost_typetraits.reference.is_trivially_copyable is_trivially_copyable]]
[def __is_pod [link boost_typetraits.reference.is_pod is_pod]]
[def __is_final [link boost_typetraits.reference.is_final is_final]]
[def __has_trivial_constructor [link boost_typetraits.reference.has_trivial_constructor has_trivial_constructor]]
@ -129,6 +132,9 @@
[def __add_cv [link boost_typetraits.reference.add_cv add_cv]]
[def __common_type [link boost_typetraits.reference.common_type common_type]]
[def __conditional [link boost_typetraits.reference.conditional conditional]]
[def __conjunction [link boost_typetraits.reference.conjunction conjunction]]
[def __disjunction [link boost_typetraits.reference.disjunction disjunction]]
[def __negation [link boost_typetraits.reference.negation negation]]
[def __type_with_alignment [link boost_typetraits.reference.type_with_alignment type_with_alignment]]
[def __aligned_storage [link boost_typetraits.reference.aligned_storage aligned_storage]]
@ -307,6 +313,7 @@ that is the result of the transformation.
[include aligned_storage.qbk]
[include alignment_of.qbk]
[include conditional.qbk]
[include conjunction.qbk]
[include common_type.qbk]
[include copy_cv.qbk]
[include copy_cv_ref.qbk]
@ -315,6 +322,7 @@ that is the result of the transformation.
[include declval.qbk]
[include detected.qbk]
[include detected_or.qbk]
[include disjunction.qbk]
[include enable_if.qbk]
[include extent.qbk]
[include floating_point_promotion.qbk]
@ -429,10 +437,13 @@ See __has_trivial_constructor.
[include is_rvalue_reference.qbk]
[include is_same.qbk]
[include is_scalar.qbk]
[include is_scoped_enum.qbk]
[include is_signed.qbk]
[include is_stateless.qbk]
[include is_trivially_copyable.qbk]
[include is_unbounded_array.qbk]
[include is_union.qbk]
[include is_unscoped_enum.qbk]
[include is_unsigned.qbk]
[include is_virtual_base_of.qbk]
[include is_void.qbk]
@ -441,6 +452,7 @@ See __has_trivial_constructor.
[include make_signed.qbk]
[include make_unsigned.qbk]
[include make_void.qbk]
[include negation.qbk]
[include nonesuch.qbk]
[include promote.qbk]

6
include/boost/type_traits.hpp
View File

@ -21,11 +21,13 @@
#include <boost/type_traits/alignment_of.hpp>
#include <boost/type_traits/common_type.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/conjunction.hpp>
#include <boost/type_traits/copy_cv.hpp>
#include <boost/type_traits/copy_cv_ref.hpp>
#include <boost/type_traits/copy_reference.hpp>
#include <boost/type_traits/decay.hpp>
#include <boost/type_traits/declval.hpp>
#include <boost/type_traits/disjunction.hpp>
#include <boost/type_traits/enable_if.hpp>
#include <boost/type_traits/extent.hpp>
#include <boost/type_traits/floating_point_promotion.hpp>
@ -126,9 +128,12 @@
#include <boost/type_traits/is_rvalue_reference.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_scalar.hpp>
#include <boost/type_traits/is_scoped_enum.hpp>
#include <boost/type_traits/is_signed.hpp>
#include <boost/type_traits/is_stateless.hpp>
#include <boost/type_traits/is_trivially_copyable.hpp>
#include <boost/type_traits/is_union.hpp>
#include <boost/type_traits/is_unscoped_enum.hpp>
#include <boost/type_traits/is_unsigned.hpp>
#include <boost/type_traits/is_virtual_base_of.hpp>
#include <boost/type_traits/is_void.hpp>
@ -136,6 +141,7 @@
#include <boost/type_traits/make_signed.hpp>
#include <boost/type_traits/make_unsigned.hpp>
#include <boost/type_traits/make_void.hpp>
#include <boost/type_traits/negation.hpp>
#include <boost/type_traits/rank.hpp>
#include <boost/type_traits/remove_all_extents.hpp>
#include <boost/type_traits/remove_bounds.hpp>

40
include/boost/type_traits/conjunction.hpp Normal file
View File

@ -0,0 +1,40 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt
or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_TT_CONJUNCTION_HPP_INCLUDED
#define BOOST_TT_CONJUNCTION_HPP_INCLUDED
#include <boost/type_traits/conditional.hpp>
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#include <boost/type_traits/integral_constant.hpp>
#endif
namespace boost {
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<class...>
struct conjunction
: true_type { };
template<class T>
struct conjunction<T>
: T { };
template<class T, class... U>
struct conjunction<T, U...>
: conditional<bool(T::value), conjunction<U...>, T>::type { };
#else
template<class T, class U>
struct conjunction
: conditional<bool(T::value), U, T>::type { };
#endif
} /* boost */
#endif

40
include/boost/type_traits/disjunction.hpp Normal file
View File

@ -0,0 +1,40 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt
or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_TT_DISJUNCTION_HPP_INCLUDED
#define BOOST_TT_DISJUNCTION_HPP_INCLUDED
#include <boost/type_traits/conditional.hpp>
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#include <boost/type_traits/integral_constant.hpp>
#endif
namespace boost {
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<class...>
struct disjunction
: false_type { };
template<class T>
struct disjunction<T>
: T { };
template<class T, class... U>
struct disjunction<T, U...>
: conditional<bool(T::value), T, disjunction<U...> >::type { };
#else
template<class T, class U>
struct disjunction
: conditional<bool(T::value), T, U>::type { };
#endif
} /* boost */
#endif

26
include/boost/type_traits/is_scoped_enum.hpp Normal file
View File

@ -0,0 +1,26 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt
or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_TT_IS_SCOPED_ENUM_HPP_INCLUDED
#define BOOST_TT_IS_SCOPED_ENUM_HPP_INCLUDED
#include <boost/type_traits/conjunction.hpp>
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/negation.hpp>
namespace boost {
template<class T>
struct is_scoped_enum
: conjunction<is_enum<T>, negation<is_convertible<T, int> > >::type { };
} /* boost */
#endif

27
include/boost/type_traits/is_trivially_copyable.hpp Normal file
View File

@ -0,0 +1,27 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt
or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_TT_IS_TRIVIALLY_COPYABLE_HPP_INCLUDED
#define BOOST_TT_IS_TRIVIALLY_COPYABLE_HPP_INCLUDED
#include <boost/type_traits/has_trivial_assign.hpp>
#include <boost/type_traits/has_trivial_copy.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
namespace boost {
template<class T>
struct is_trivially_copyable
: integral_constant<bool, has_trivial_copy<T>::value &&
has_trivial_assign<T>::value &&
has_trivial_destructor<T>::value> { };
} /* boost */
#endif

25
include/boost/type_traits/is_unscoped_enum.hpp Normal file
View File

@ -0,0 +1,25 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt
or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_TT_IS_UNSCOPED_ENUM_HPP_INCLUDED
#define BOOST_TT_IS_UNSCOPED_ENUM_HPP_INCLUDED
#include <boost/type_traits/conjunction.hpp>
#include <boost/type_traits/is_enum.hpp>
#include <boost/type_traits/is_convertible.hpp>
namespace boost {
template<class T>
struct is_unscoped_enum
: conjunction<is_enum<T>, is_convertible<T, int> >::type { };
} /* boost */
#endif

23
include/boost/type_traits/negation.hpp Normal file
View File

@ -0,0 +1,23 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt
or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_TT_NEGATION_HPP_INCLUDED
#define BOOST_TT_NEGATION_HPP_INCLUDED
#include <boost/type_traits/integral_constant.hpp>
namespace boost {
template<class T>
struct negation
: integral_constant<bool, !bool(T::value)> { };
} /* boost */
#endif

35
test/conjunction_test.cpp Normal file
View File

@ -0,0 +1,35 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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)
*/
#ifdef TEST_STD
#include <type_traits>
#else
#include <boost/type_traits/conjunction.hpp>
#endif
#include "check_integral_constant.hpp"
template<int V>
struct Int {
static const int value = V;
};
TT_TEST_BEGIN(conjunction)
BOOST_CHECK_INTEGRAL_CONSTANT((::tt::conjunction<Int<2>, Int<4> >::value), 4);
BOOST_CHECK_INTEGRAL_CONSTANT((::tt::conjunction<Int<0>, Int<4> >::value), 0);
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
BOOST_CHECK_INTEGRAL_CONSTANT((::tt::conjunction<Int<2>, Int<4>, Int<6>,
Int<8>, Int<10> >::value), 10);
BOOST_CHECK_INTEGRAL_CONSTANT((::tt::conjunction<Int<2>, Int<0>, Int<4>,
Int<6>, Int<8> >::value), 0);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::conjunction<Int<4> >::value, 4);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::conjunction<>::value, true);
#endif
TT_TEST_END

35
test/disjunction_test.cpp Normal file
View File

@ -0,0 +1,35 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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)
*/
#ifdef TEST_STD
#include <type_traits>
#else
#include <boost/type_traits/disjunction.hpp>
#endif
#include "check_integral_constant.hpp"
template<int V>
struct Int {
static const int value = V;
};
TT_TEST_BEGIN(disjunction)
BOOST_CHECK_INTEGRAL_CONSTANT((::tt::disjunction<Int<2>, Int<4> >::value), 2);
BOOST_CHECK_INTEGRAL_CONSTANT((::tt::disjunction<Int<0>, Int<4> >::value), 4);
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
BOOST_CHECK_INTEGRAL_CONSTANT((::tt::disjunction<Int<2>, Int<4>, Int<6>,
Int<8>, Int<10> >::value), 2);
BOOST_CHECK_INTEGRAL_CONSTANT((::tt::disjunction<Int<0>, Int<0>, Int<6>,
Int<0>, Int<0> >::value), 6);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::disjunction<Int<4> >::value, 4);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::disjunction<>::value, false);
#endif
TT_TEST_END

36
test/is_scoped_enum_test.cpp Normal file
View File

@ -0,0 +1,36 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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)
*/
#ifdef TEST_STD
#include <type_traits>
#else
#include <boost/type_traits/is_scoped_enum.hpp>
#endif
#include "check_integral_constant.hpp"
enum Unscoped {
Constant = 1
};
#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
enum class Scoped {
Constant = 2
};
#endif
TT_TEST_BEGIN(is_scoped_enum)
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scoped_enum<void>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scoped_enum<int>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scoped_enum<Unscoped>::value, false);
#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_scoped_enum<Scoped>::value, true);
#endif
TT_TEST_END

224
test/is_trivially_copyable_test.cpp Normal file
View File

@ -0,0 +1,224 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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)
*/
#ifdef TEST_STD
#include <type_traits>
#else
#include <boost/type_traits/is_trivially_copyable.hpp>
#endif
#include "test.hpp"
#include "check_integral_constant.hpp"
class private_copy {
public:
private_copy();
private:
private_copy(const private_copy&);
};
class private_assign {
public:
private_assign();
private:
private_assign& operator=(const private_assign&);
};
class private_destruct {
public:
private_destruct();
private:
~private_destruct();
};
#ifndef BOOST_NO_CXX11_DELETED_FUNCTIONS
struct deleted_assign {
deleted_assign();
deleted_assign& operator=(const deleted_assign&) = delete;
};
struct deleted_copy {
deleted_copy() { }
deleted_copy(const deleted_copy&) = delete;
deleted_copy(deleted_copy&&) { }
};
struct deleted_destruct {
deleted_destruct();
~deleted_destruct() = delete;
};
#endif
TT_TEST_BEGIN(is_trivially_copyable)
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<bool>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<bool const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<bool volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<bool const volatile>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<signed char>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<signed char const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<signed char volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<signed char const volatile>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned char>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<char>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned char const>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<char const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned char volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<char volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned char const volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<char const volatile>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned short>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<short>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned short const>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<short const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned short volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<short volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned short const volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<short const volatile>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned int>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<int>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned int const>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<int const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned int volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<int volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned int const volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<int const volatile>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned long>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<long>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned long const>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<long const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned long volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<long volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned long const volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<long const volatile>::value, false);
#endif
#ifdef BOOST_HAS_LONG_LONG
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable< ::boost::ulong_long_type>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable< ::boost::long_long_type>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable< ::boost::ulong_long_type const>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable< ::boost::long_long_type const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable< ::boost::ulong_long_type volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable< ::boost::long_long_type volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable< ::boost::ulong_long_type const volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable< ::boost::long_long_type const volatile>::value, false);
#endif
#endif
#ifdef BOOST_HAS_MS_INT64
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int8>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int8>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int8 const>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int8 const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int8 volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int8 volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int8 const volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int8 const volatile>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int16>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int16>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int16 const>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int16 const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int16 volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int16 volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int16 const volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int16 const volatile>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int32>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int32>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int32 const>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int32 const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int32 volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int32 volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int32 const volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int32 const volatile>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int64>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int64>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int64 const>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int64 const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int64 volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int64 volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<unsigned __int64 const volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<__int64 const volatile>::value, false);
#endif
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<float>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<float const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<float volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<float const volatile>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<double>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<double const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<double volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<double const volatile>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<long double>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<long double const>::value, false);
#ifndef TEST_STD
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<long double volatile>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<long double const volatile>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<int>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<void*>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<int*const>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<f1>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<f2>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<f3>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<mf1>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<mf2>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<mf3>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<mp>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<cmf>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<enum_UDT>::value, true);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<int&>::value, false);
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<int&&>::value, false);
#endif
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<const int&>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<int[2]>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<int[3][2]>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<int[2][4][5][6][3]>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<UDT>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<void>::value, false);
BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<empty_POD_UDT>::value, true, false);
BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<POD_UDT>::value, true, false);
BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<POD_union_UDT>::value, true, false);
BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<empty_POD_union_UDT>::value, true, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<trivial_except_copy>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<trivial_except_destroy>::value, false);
BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<trivial_except_construct>::value, true, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<trivial_except_assign>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<wrap<trivial_except_copy> >::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<wrap<trivial_except_destroy> >::value, false);
BOOST_CHECK_SOFT_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<wrap<trivial_except_construct> >::value, true, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<wrap<trivial_except_assign> >::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<test_abc1>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<private_copy>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<private_assign>::value, false);
#ifndef BOOST_NO_CXX11_DELETED_FUNCTIONS
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_trivially_copyable<deleted_copy>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::has_trivial_assign<deleted_assign>::value, false);
#endif
TT_TEST_END

36
test/is_unscoped_enum_test.cpp Normal file
View File

@ -0,0 +1,36 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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)
*/
#ifdef TEST_STD
#include <type_traits>
#else
#include <boost/type_traits/is_unscoped_enum.hpp>
#endif
#include "check_integral_constant.hpp"
enum Unscoped {
Constant = 1
};
#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
enum class Scoped {
Constant = 2
};
#endif
TT_TEST_BEGIN(is_unscoped_enum)
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unscoped_enum<void>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unscoped_enum<int>::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unscoped_enum<Unscoped>::value, true);
#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::is_unscoped_enum<Scoped>::value, false);
#endif
TT_TEST_END

26
test/negation_test.cpp Normal file
View File

@ -0,0 +1,26 @@
/*
Copyright 2020 Glen Joseph Fernandes
(glenjofe@gmail.com)
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)
*/
#ifdef TEST_STD
#include <type_traits>
#else
#include <boost/type_traits/negation.hpp>
#endif
#include "check_integral_constant.hpp"
template<int V>
struct Int {
static const int value = V;
};
TT_TEST_BEGIN(negation)
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::negation<Int<5> >::value, false);
BOOST_CHECK_INTEGRAL_CONSTANT(::tt::negation<Int<0> >::value, true);
TT_TEST_END