darlinghq/darling-libcxx
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-libcxx.git synced 2024-11-27 05:40:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

N3142. Many of these traits are just placeholders with medium quality emulation; waiting on compiler intrinsics to do it right.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@119854 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant 2010-11-19 22:17:28 +00:00
parent 01feecb789
commit 1468b668aa
46 changed files with 1900 additions and 933 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/__config
View File

@ -86,6 +86,8 @@
#if defined(__clang__)
#undef __STRICT_ANSI__
#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES

8
include/__split_buffer
View File

@ -118,12 +118,12 @@ public:
__construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
_LIBCPP_INLINE_VISIBILITY void __destruct_at_begin(pointer __new_begin)
{__destruct_at_begin(__new_begin, has_trivial_destructor<value_type>());}
{__destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());}
void __destruct_at_begin(pointer __new_begin, false_type);
void __destruct_at_begin(pointer __new_begin, true_type);
_LIBCPP_INLINE_VISIBILITY void __destruct_at_end(pointer __new_last)
{__destruct_at_end(__new_last, has_trivial_destructor<value_type>());}
{__destruct_at_end(__new_last, is_trivially_destructible<value_type>());}
void __destruct_at_end(pointer __new_last, false_type);
void __destruct_at_end(pointer __new_last, true_type);
@ -230,8 +230,8 @@ _LIBCPP_INLINE_VISIBILITY inline
void
__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
{
__construct_at_end(__n, __x, integral_constant<bool, has_trivial_copy_constructor<value_type>::value &&
has_trivial_copy_assign<value_type>::value>());
__construct_at_end(__n, __x, integral_constant<bool, is_trivially_copy_constructible<value_type>::value &&
is_trivially_copy_assignable<value_type>::value>());
}
template <class _Tp, class _Allocator>

24
include/algorithm
View File

@ -1438,7 +1438,7 @@ template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
typename enable_if
<
has_trivial_copy_assign<_Tp>::value,
is_trivially_copy_assignable<_Tp>::value,
_Tp*
>::type
__unwrap_iter(move_iterator<_Tp*> __i)
@ -1450,7 +1450,7 @@ template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
typename enable_if
<
has_trivial_copy_assign<_Tp>::value,
is_trivially_copy_assignable<_Tp>::value,
_Tp*
>::type
__unwrap_iter(__wrap_iter<_Tp*> __i)
@ -1473,7 +1473,7 @@ inline _LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_same<typename remove_const<_Tp>::type, _Up>::value &&
has_trivial_copy_assign<_Up>::value,
is_trivially_copy_assignable<_Up>::value,
_Up*
>::type
__copy(_Tp* __first, _Tp* __last, _Up* __result)
@ -1508,7 +1508,7 @@ inline _LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_same<typename remove_const<_Tp>::type, _Up>::value &&
has_trivial_copy_assign<_Up>::value,
is_trivially_copy_assignable<_Up>::value,
_Up*
>::type
__copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
@ -1593,7 +1593,7 @@ inline _LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_same<typename remove_const<_Tp>::type, _Up>::value &&
has_trivial_copy_assign<_Up>::value,
is_trivially_copy_assignable<_Up>::value,
_Up*
>::type
__move(_Tp* __first, _Tp* __last, _Up* __result)
@ -1628,7 +1628,7 @@ inline _LIBCPP_INLINE_VISIBILITY
typename enable_if
<
is_same<typename remove_const<_Tp>::type, _Up>::value &&
has_trivial_copy_assign<_Up>::value,
is_trivially_copy_assignable<_Up>::value,
_Up*
>::type
__move_backward(_Tp* __first, _Tp* __last, _Up* __result)
@ -1766,7 +1766,7 @@ fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
{
return _STD::__fill_n(__first, __n, __value, integral_constant<bool,
is_pointer<_OutputIterator>::value &&
has_trivial_copy_assign<_Tp>::value &&
is_trivially_copy_assignable<_Tp>::value &&
sizeof(_Tp) == 1>());
}
@ -2169,7 +2169,7 @@ rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __l
typename iterator_traits<_ForwardIterator>::iterator_category,
random_access_iterator_tag
>::value &&
has_trivial_copy_assign
is_trivially_copy_assignable
<
typename iterator_traits<_ForwardIterator>::value_type
>::value
@ -3434,8 +3434,8 @@ __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __c
// _Compare is known to be a reference type
typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
const difference_type __limit = has_trivial_copy_constructor<value_type>::value &&
has_trivial_copy_assign<value_type>::value ? 30 : 6;
const difference_type __limit = is_trivially_copy_constructible<value_type>::value &&
is_trivially_copy_assignable<value_type>::value ? 30 : 6;
while (true)
{
__restart:
@ -4069,7 +4069,7 @@ __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle,
template <class _Tp>
struct __inplace_merge_switch
{
static const unsigned value = has_trivial_copy_assign<_Tp>::value;
static const unsigned value = is_trivially_copy_assignable<_Tp>::value;
};
template <class _BidirectionalIterator, class _Compare>
@ -4237,7 +4237,7 @@ __stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1
template <class _Tp>
struct __stable_sort_switch
{
static const unsigned value = 128*has_trivial_copy_assign<_Tp>::value;
static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value;
};
template <class _Compare, class _RandomAccessIterator>

4
include/iterator
View File

@ -1038,7 +1038,7 @@ template <class _B1, class _B2> _B2 move_backward(_B1, _B1, _B2);
template <class _Tp>
typename enable_if
<
has_trivial_copy_assign<_Tp>::value,
is_trivially_copy_assignable<_Tp>::value,
_Tp*
>::type
__unwrap_iter(__wrap_iter<_Tp*>);
@ -1137,7 +1137,7 @@ private:
friend
typename enable_if
<
has_trivial_copy_assign<_Tp>::value,
is_trivially_copy_assignable<_Tp>::value,
_Tp*
>::type
__unwrap_iter(__wrap_iter<_Tp*>);

6
include/memory
View File

@ -2446,15 +2446,15 @@ public:
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY void __incr(_Tp*)
{__incr(integral_constant<bool, has_trivial_destructor<_Tp>::value>());}
{__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*)
{__set(__s, integral_constant<bool, has_trivial_destructor<_Tp>::value>());}
{__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p)
{__process(__p, integral_constant<bool, has_trivial_destructor<_Tp>::value>());}
{__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
};
template <class _Alloc>

821
include/type_traits
View File

@ -92,29 +92,32 @@ namespace std
template <class T> struct is_abstract;
template <class T, class... Args> struct is_constructible;
template <class T> struct is_default_constructible;
template <class T> struct is_copy_constructible;
template <class T> struct is_move_constructible;
template <class T, class U> struct is_assignable;
template <class T> struct is_copy_assignable;
template <class T> struct is_move_assignable;
template <class T> struct is_destructible;
template <class T, class... Args> struct is_trivially_constructible;
template <class T> struct is_trivially_default_constructible;
template <class T> struct is_trivially_copy_constructible;
template <class T> struct is_trivially_move_constructible;
template <class T, class U> struct is_trivially_assignable;
template <class T> struct is_trivially_copy_assignable;
template <class T> struct is_trivially_move_assignable;
template <class T> struct is_trivially_destructible;
template <class T, class... Args> struct is_nothrow_constructible;
template <class T> struct is_nothrow_default_constructible;
template <class T> struct is_nothrow_copy_constructible;
template <class T> struct is_nothrow_move_constructible;
template <class T, class U> struct is_nothrow_assignable;
template <class T> struct is_nothrow_copy_assignable;
template <class T> struct is_nothrow_move_assignable;
template <class T> struct is_nothrow_destructible;
template <class T> struct has_trivial_default_constructor
template <class T> struct has_nothrow_default_constructor;
template <class T> struct has_default_constructor;
template <class T> struct has_trivial_copy_constructor;
template <class T> struct has_nothrow_copy_constructor;
template <class T> struct has_copy_constructor;
template <class T> struct has_trivial_move_constructor;
template <class T> struct has_nothrow_move_constructor;
template <class T> struct has_move_constructor;
template <class T> struct has_trivial_copy_assign;
template <class T> struct has_nothrow_copy_assign;
template <class T> struct has_copy_assign;
template <class T> struct has_trivial_move_assign;
template <class T> struct has_nothrow_move_assign;
template <class T> struct has_move_assign;
template <class T> struct has_trivial_destructor;
template <class T> struct has_virtual_destructor;
// Relationships between types:
@ -777,118 +780,6 @@ template <class _Tp> struct __libcpp_polymorphic<_Tp, false> : public false_type
template <class _Tp> struct _LIBCPP_VISIBLE is_polymorphic
: public __libcpp_polymorphic<_Tp> {};
// has_trivial_default_constructor
#ifdef _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_default_constructor
: public integral_constant<bool, __has_trivial_constructor(_Tp)> {};
#else // _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct __has_trivial_default_constructor
: public integral_constant<bool, is_scalar<_Tp>::value> {};
template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_default_constructor
: public __has_trivial_default_constructor<typename remove_all_extents<_Tp>::type> {};
#endif // _LIBCPP_HAS_TYPE_TRAITS
// has_nothrow_default_constructor
#ifdef _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_default_constructor
: public integral_constant<bool, __has_nothrow_constructor(_Tp)> {};
#else // _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_default_constructor
: public has_trivial_default_constructor<_Tp> {};
#endif // _LIBCPP_HAS_TYPE_TRAITS
// has_trivial_copy_constructor
#ifdef _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_constructor
: public integral_constant<bool, __has_trivial_copy(_Tp)> {};
#else // _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_constructor
: public integral_constant<bool, is_scalar<_Tp>::value ||
is_reference<_Tp>::value> {};
#endif // _LIBCPP_HAS_TYPE_TRAITS
// has_nothrow_copy_constructor
#ifdef _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_constructor
: public integral_constant<bool, __has_nothrow_copy(_Tp)> {};
#else // _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_constructor
: public has_trivial_copy_constructor<_Tp> {};
#endif // _LIBCPP_HAS_TYPE_TRAITS
// has_nothrow_move_constructor
template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_move_constructor
: public has_nothrow_copy_constructor<_Tp> {};
// has_trivial_copy_assign
#ifdef _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_assign
: public integral_constant<bool, __has_trivial_assign(_Tp)> {};
#else // _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_assign
: public integral_constant<bool, is_scalar<_Tp>::value &&
!is_const<_Tp>::value> {};
#endif // _LIBCPP_HAS_TYPE_TRAITS
// has_nothrow_copy_assign
#ifdef _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_assign
: public integral_constant<bool, __has_nothrow_assign(_Tp)> {};
#else // _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_assign
: public has_trivial_copy_assign<_Tp> {};
#endif // _LIBCPP_HAS_TYPE_TRAITS
// has_trivial_destructor
#ifdef _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_destructor
: public integral_constant<bool, __has_trivial_destructor(_Tp)> {};
#else // _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct __libcpp_trivial_destructor
: public integral_constant<bool, is_scalar<_Tp>::value ||
is_reference<_Tp>::value> {};
template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_destructor
: public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {};
#endif // _LIBCPP_HAS_TYPE_TRAITS
// has_virtual_destructor
#ifdef _LIBCPP_HAS_TYPE_TRAITS
@ -903,23 +794,6 @@ template <class _Tp> struct _LIBCPP_VISIBLE has_virtual_destructor
#endif // _LIBCPP_HAS_TYPE_TRAITS
// is_pod
#ifdef _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE is_pod
: public integral_constant<bool, __is_pod(_Tp)> {};
#else // _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE is_pod
: public integral_constant<bool, has_trivial_default_constructor<_Tp>::value &&
has_trivial_copy_constructor<_Tp>::value &&
has_trivial_copy_assign<_Tp>::value &&
has_trivial_destructor<_Tp>::value> {};
#endif // _LIBCPP_HAS_TYPE_TRAITS
// alignment_of
template <class _Tp> struct __alignment_of {_Tp _;};
@ -1287,6 +1161,8 @@ struct _LIBCPP_VISIBLE common_type<_Tp, _Up, _Vp...>
#endif // _LIBCPP_HAS_NO_VARIADICS
// is_assignable
template <class _Tp, class _Arg>
decltype((_STD::declval<_Tp>() = _STD::declval<_Arg>(), true_type()))
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@ -1311,19 +1187,56 @@ struct __is_assignable_imp
>::type {};
template <class _Tp, class _Arg>
struct __is_assignable
struct is_assignable
: public __is_assignable_imp<_Tp, _Arg> {};
// has_copy_assign
// is_copy_assignable
template <class _Tp> struct _LIBCPP_VISIBLE has_copy_assign
: public __is_assignable<_Tp&, const _Tp&> {};
template <class _Tp> struct _LIBCPP_VISIBLE is_copy_assignable
: public is_assignable<_Tp&, const _Tp&> {};
template <class _Tp> struct _LIBCPP_VISIBLE has_copy_assign<_Tp[]>
// is_move_assignable
template <class _Tp> struct _LIBCPP_VISIBLE is_move_assignable
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
: public is_assignable<_Tp&, _Tp&&> {};
#else
: public is_copy_assignable<_Tp> {};
#endif
// is_destructible
template <class _Tp>
struct __destructible_test
{
_Tp __t;
};
template <class _Tp>
decltype((_STD::declval<__destructible_test<_Tp> >().~__destructible_test<_Tp>(), true_type()))
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
__is_destructible_test(_Tp&&);
#else
__is_destructible_test(_Tp&);
#endif
false_type
__is_destructible_test(__any);
template <class _Tp, bool = is_void<_Tp>::value || is_abstract<_Tp>::value>
struct __destructible_imp
: public common_type
<
decltype(__is_destructible_test(declval<_Tp>()))
>::type {};
template <class _Tp>
struct __destructible_imp<_Tp, true>
: public false_type {};
template <class _Tp> struct _LIBCPP_VISIBLE has_copy_assign<_Tp&>
: public false_type {};
template <class _Tp>
struct is_destructible
: public __destructible_imp<_Tp> {};
// move
@ -1638,7 +1551,7 @@ class _LIBCPP_VISIBLE result_of<_Fn(_A0, _A1, _A2)>
#endif // _LIBCPP_HAS_NO_VARIADICS
#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
#ifndef _LIBCPP_HAS_NO_VARIADICS
// template <class T, class... Args> struct is_constructible;
@ -1758,24 +1671,35 @@ struct __is_constructible<false, _A[], _Args...>
: public false_type
{};
template <class _Tp>
struct _LIBCPP_VISIBLE has_default_constructor
: public is_constructible<_Tp>
{};
#else // _LIBCPP_HAS_NO_ADVANCED_SFINAE
#else // _LIBCPP_HAS_NO_VARIADICS
// template <class T> struct is_constructible0;
// main is_constructible0 test
template <class _Tp>
decltype((_STD::move(_Tp()), true_type()))
decltype((_Tp(), true_type()))
__is_constructible0_test(_Tp&);
false_type
__is_constructible0_test(__any);
template <class _Tp, class _A0>
decltype((_Tp(_STD::declval<_A0>()), true_type()))
__is_constructible1_test(_Tp&, _A0&);
template <class _A0>
false_type
__is_constructible1_test(__any, _A0&);
template <class _Tp, class _A0, class _A1>
decltype((_Tp(_STD::declval<_A0>(), _STD::declval<_A1>()), true_type()))
__is_constructible2_test(_Tp&, _A0&, _A1&);
template <class _A0, class _A1>
false_type
__is_constructible2_test(__any, _A0&, _A1&);
template <bool, class _Tp>
struct __is_constructible0_imp // false, _Tp is not a scalar
: public common_type
@ -1784,6 +1708,22 @@ struct __is_constructible0_imp // false, _Tp is not a scalar
>::type
{};
template <bool, class _Tp, class _A0>
struct __is_constructible1_imp // false, _Tp is not a scalar
: public common_type
<
decltype(__is_constructible1_test(declval<_Tp&>(), declval<_A0&>()))
>::type
{};
template <bool, class _Tp, class _A0, class _A1>
struct __is_constructible2_imp // false, _Tp is not a scalar
: public common_type
<
decltype(__is_constructible2_test(declval<_Tp&>(), declval<_A0>(), declval<_A1>()))
>::type
{};
// handle scalars and reference types
// Scalars are default constructible, references are not
@ -1793,6 +1733,16 @@ struct __is_constructible0_imp<true, _Tp>
: public is_scalar<_Tp>
{};
template <class _Tp, class _A0>
struct __is_constructible1_imp<true, _Tp, _A0>
: public is_convertible<_A0, _Tp>
{};
template <class _Tp, class _A0, class _A1>
struct __is_constructible2_imp<true, _Tp, _A0, _A1>
: public false_type
{};
// Treat scalars and reference types separately
template <bool, class _Tp>
@ -1801,6 +1751,18 @@ struct __is_constructible0_void_check
_Tp>
{};
template <bool, class _Tp, class _A0>
struct __is_constructible1_void_check
: public __is_constructible1_imp<is_scalar<_Tp>::value || is_reference<_Tp>::value,
_Tp, _A0>
{};
template <bool, class _Tp, class _A0, class _A1>
struct __is_constructible2_void_check
: public __is_constructible2_imp<is_scalar<_Tp>::value || is_reference<_Tp>::value,
_Tp, _A0, _A1>
{};
// If any of T or Args is void, is_constructible should be false
template <class _Tp>
@ -1808,21 +1770,69 @@ struct __is_constructible0_void_check<true, _Tp>
: public false_type
{};
// has_default_constructor entry point
template <class _Tp, class _A0>
struct __is_constructible1_void_check<true, _Tp, _A0>
: public false_type
{};
template <class _Tp, class _A0, class _A1>
struct __is_constructible2_void_check<true, _Tp, _A0, _A1>
: public false_type
{};
// is_constructible entry point
namespace __is_construct
{
struct __nat {};
}
template <class _Tp, class _A0 = __is_construct::__nat,
class _A1 = __is_construct::__nat>
struct _LIBCPP_VISIBLE is_constructible
: public __is_constructible2_void_check<is_void<_Tp>::value
|| is_abstract<_Tp>::value
|| is_function<_Tp>::value
|| is_void<_A0>::value
|| is_void<_A1>::value,
_Tp, _A0, _A1>
{};
template <class _Tp>
struct _LIBCPP_VISIBLE has_default_constructor
struct _LIBCPP_VISIBLE is_constructible<_Tp, __is_construct::__nat, __is_construct::__nat>
: public __is_constructible0_void_check<is_void<_Tp>::value
|| is_abstract<_Tp>::value,
|| is_abstract<_Tp>::value
|| is_function<_Tp>::value,
_Tp>
{};
template <class _Tp, class _A0>
struct _LIBCPP_VISIBLE is_constructible<_Tp, _A0, __is_construct::__nat>
: public __is_constructible1_void_check<is_void<_Tp>::value
|| is_abstract<_Tp>::value
|| is_function<_Tp>::value
|| is_void<_A0>::value,
_Tp, _A0>
{};
// Array types are default constructible if their element type
// is default constructible
template <class _A, size_t _N>
struct __is_constructible0_imp<false, _A[_N]>
: public has_default_constructor<typename remove_all_extents<_A>::type>
: public is_constructible<typename remove_all_extents<_A>::type>
{};
template <class _A, size_t _N, class _A0>
struct __is_constructible1_imp<false, _A[_N], _A0>
: public false_type
{};
template <class _A, size_t _N, class _A0, class _A1>
struct __is_constructible2_imp<false, _A[_N], _A0, _A1>
: public false_type
{};
// Incomplete array types are not constructible
@ -1832,25 +1842,468 @@ struct __is_constructible0_imp<false, _A[]>
: public false_type
{};
#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE
// has_copy_constructor
#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
template <class _Tp>
struct _LIBCPP_VISIBLE has_copy_constructor
: public is_constructible<_Tp, typename add_lvalue_reference<const _Tp>::type>
template <class _A, class _A0>
struct __is_constructible1_imp<false, _A[], _A0>
: public false_type
{};
#else // _LIBCPP_HAS_NO_ADVANCED_SFINAE
template <class _Tp>
struct _LIBCPP_VISIBLE has_copy_constructor
: public has_nothrow_copy_constructor<_Tp>
template <class _A, class _A0, class _A1>
struct __is_constructible2_imp<false, _A[], _A0, _A1>
: public false_type
{};
#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE
#endif // _LIBCPP_HAS_NO_VARIADICS
// is_default_constructible
template <class _Tp>
struct _LIBCPP_VISIBLE is_default_constructible
: public is_constructible<_Tp>
{};
// is_copy_constructible
template <class _Tp>
struct _LIBCPP_VISIBLE is_copy_constructible
: public is_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
{};
// is_move_constructible
template <class _Tp>
struct _LIBCPP_VISIBLE is_move_constructible
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
: public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
#else
: public is_copy_constructible<_Tp>
#endif
{};
// is_trivially_constructible
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class... _Args>
struct _LIBCPP_VISIBLE is_trivially_constructible
: false_type
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_constructor(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&&>
#else
struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp>
#endif
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
#else // _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _A0 = __is_construct::__nat,
class _A1 = __is_construct::__nat>
struct _LIBCPP_VISIBLE is_trivially_constructible
: false_type
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, __is_construct::__nat,
__is_construct::__nat>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_constructor(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp,
__is_construct::__nat>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&,
__is_construct::__nat>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&,
__is_construct::__nat>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
#endif // _LIBCPP_HAS_NO_VARIADICS
// is_trivially_default_constructible
template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_default_constructible
: public is_trivially_constructible<_Tp>
{};
// is_trivially_copy_constructible
template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_copy_constructible
: public is_trivially_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
{};
// is_trivially_move_constructible
template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_move_constructible
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
: public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
#else
: public is_trivially_copy_constructible<_Tp>
#endif
{};
// is_trivially_assignable
template <class _Tp, class _Arg>
struct is_trivially_assignable
: public false_type {};
template <class _Tp>
struct is_trivially_assignable<_Tp&, _Tp>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_assign(_Tp)> {};
#else
: integral_constant<bool, is_scalar<_Tp>::value> {};
#endif
template <class _Tp>
struct is_trivially_assignable<_Tp&, _Tp&>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_assign(_Tp)> {};
#else
: integral_constant<bool, is_scalar<_Tp>::value> {};
#endif
template <class _Tp>
struct is_trivially_assignable<_Tp&, const _Tp&>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_assign(_Tp)> {};
#else
: integral_constant<bool, is_scalar<_Tp>::value> {};
#endif
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp>
struct is_trivially_assignable<_Tp&, _Tp&&>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_trivial_assign(_Tp)> {};
#else
: integral_constant<bool, is_scalar<_Tp>::value> {};
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
// is_trivially_copy_assignable
template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_copy_assignable
: public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
const typename add_lvalue_reference<_Tp>::type>
{};
// is_trivially_move_assignable
template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_move_assignable
: public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
typename add_rvalue_reference<_Tp>::type>
#else
typename add_lvalue_reference<_Tp>::type>
#endif
{};
// is_trivially_destructible
#ifdef _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_destructible
: public integral_constant<bool, __has_trivial_destructor(_Tp)> {};
#else // _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct __libcpp_trivial_destructor
: public integral_constant<bool, is_scalar<_Tp>::value ||
is_reference<_Tp>::value> {};
template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_destructible
: public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {};
#endif // _LIBCPP_HAS_TYPE_TRAITS
// is_nothrow_constructible
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class... _Args>
struct _LIBCPP_VISIBLE is_nothrow_constructible
: false_type
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_constructor(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&&>
#else
struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp>
#endif
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
#else // _LIBCPP_HAS_NO_VARIADICS
template <class _Tp, class _A0 = __is_construct::__nat,
class _A1 = __is_construct::__nat>
struct _LIBCPP_VISIBLE is_nothrow_constructible
: false_type
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, __is_construct::__nat,
__is_construct::__nat>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_constructor(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp,
__is_construct::__nat>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&,
__is_construct::__nat>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
template <class _Tp>
struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&,
__is_construct::__nat>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_copy(_Tp)>
#else
: integral_constant<bool, is_scalar<_Tp>::value>
#endif
{
};
#endif // _LIBCPP_HAS_NO_VARIADICS
// is_nothrow_default_constructible
template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_default_constructible
: public is_nothrow_constructible<_Tp>
{};
// is_nothrow_copy_constructible
template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_copy_constructible
: public is_nothrow_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type>
{};
// is_nothrow_move_constructible
template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_move_constructible
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
: public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
#else
: public is_nothrow_copy_constructible<_Tp>
#endif
{};
// is_nothrow_assignable
template <class _Tp, class _Arg>
struct is_nothrow_assignable
: public false_type {};
template <class _Tp>
struct is_nothrow_assignable<_Tp&, _Tp>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
#else
: integral_constant<bool, is_scalar<_Tp>::value> {};
#endif
template <class _Tp>
struct is_nothrow_assignable<_Tp&, _Tp&>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
#else
: integral_constant<bool, is_scalar<_Tp>::value> {};
#endif
template <class _Tp>
struct is_nothrow_assignable<_Tp&, const _Tp&>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
#else
: integral_constant<bool, is_scalar<_Tp>::value> {};
#endif
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp>
struct is_nothrow_assignable<_Tp&, _Tp&&>
#ifdef _LIBCPP_HAS_TYPE_TRAITS
: integral_constant<bool, __has_nothrow_assign(_Tp)> {};
#else
: integral_constant<bool, is_scalar<_Tp>::value> {};
#endif
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
// is_nothrow_copy_assignable
template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_copy_assignable
: public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
const typename add_lvalue_reference<_Tp>::type>
{};
// is_nothrow_move_assignable
template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_move_assignable
: public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
typename add_rvalue_reference<_Tp>::type>
#else
typename add_lvalue_reference<_Tp>::type>
#endif
{};
// is_nothrow_destructible
template <class _Tp> struct __libcpp_nothrow_destructor
: public integral_constant<bool, is_scalar<_Tp>::value ||
is_reference<_Tp>::value> {};
template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_destructible
: public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {};
// is_pod
#ifdef _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE is_pod
: public integral_constant<bool, __is_pod(_Tp)> {};
#else // _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct _LIBCPP_VISIBLE is_pod
: public integral_constant<bool, is_trivially_default_constructible<_Tp>::value &&
is_trivially_copy_constructible<_Tp>::value &&
is_trivially_copy_assignable<_Tp>::value &&
is_trivially_destructible<_Tp>::value> {};
#endif // _LIBCPP_HAS_TYPE_TRAITS
template <class _Tp> struct __is_zero_default_constructible
: public integral_constant<bool, is_scalar<_Tp>::value || is_empty<_Tp>::value> {};

4
include/utility
View File

@ -38,7 +38,7 @@ template <class T> typename remove_reference<T>::type&& move(T&&);
template <class T>
typename conditional
<
!has_nothrow_move_constructor<T>::value && has_copy_constructor<T>::value,
!is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
const T&,
T&&
>::type
@ -178,7 +178,7 @@ inline _LIBCPP_INLINE_VISIBILITY
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
typename conditional
<
!has_nothrow_move_constructor<_Tp>::value && has_copy_constructor<_Tp>::value,
!is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value,
const _Tp&,
_Tp&&
>::type

6
include/vector
View File

@ -326,7 +326,7 @@ protected:
_LIBCPP_INLINE_VISIBILITY size_type capacity() const {return static_cast<size_type>(__end_cap() - __begin_);}
_LIBCPP_INLINE_VISIBILITY void __destruct_at_end(const_pointer __new_last)
{__destruct_at_end(__new_last, has_trivial_destructor<value_type>());}
{__destruct_at_end(__new_last, is_trivially_destructible<value_type>());}
void __destruct_at_end(const_pointer __new_last, false_type);
void __destruct_at_end(const_pointer __new_last, true_type);
@ -771,8 +771,8 @@ _LIBCPP_INLINE_VISIBILITY inline
void
vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
{
__construct_at_end(__n, __x, integral_constant<bool, has_trivial_copy_constructor<value_type>::value &&
has_trivial_copy_assign<value_type>::value>());
__construct_at_end(__n, __x, integral_constant<bool, is_trivially_copy_constructible<value_type>::value &&
is_trivially_copy_assignable<value_type>::value>());
}
template <class _Tp, class _Allocator>

50
test/utilities/meta/meta.unary/meta.unary.prop/has_copy_assign.pass.cpp
View File

@ -1,50 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_copy_assign
#include <type_traits>
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
struct A
{
A();
};
int main()
{
static_assert(( std::has_copy_assign<int>::value), "");
static_assert((!std::has_copy_assign<const int>::value), "");
static_assert((!std::has_copy_assign<int[]>::value), "");
static_assert((!std::has_copy_assign<int[3]>::value), "");
static_assert((!std::has_copy_assign<int&>::value), "");
static_assert(( std::has_copy_assign<A>::value), "");
static_assert(( std::has_copy_assign<bit_zero>::value), "");
static_assert(( std::has_copy_assign<Union>::value), "");
static_assert(( std::has_copy_assign<NotEmpty>::value), "");
static_assert(( std::has_copy_assign<Empty>::value), "");
}

67
test/utilities/meta/meta.unary/meta.unary.prop/has_copy_constructor.pass.cpp
View File

@ -1,67 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_copy_constructor
#include <type_traits>
template <class T, bool Result>
void test_has_copy_constructor()
{
static_assert(std::has_copy_constructor<T>::value == Result, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
public:
virtual ~Abstract() = 0;
};
struct A
{
A(const A&);
};
int main()
{
test_has_copy_constructor<char[3], false>();
test_has_copy_constructor<char[], false>();
test_has_copy_constructor<void, false>();
test_has_copy_constructor<Abstract, false>();
test_has_copy_constructor<A, true>();
test_has_copy_constructor<int&, true>();
test_has_copy_constructor<Union, true>();
test_has_copy_constructor<Empty, true>();
test_has_copy_constructor<int, true>();
test_has_copy_constructor<double, true>();
test_has_copy_constructor<int*, true>();
test_has_copy_constructor<const int*, true>();
test_has_copy_constructor<NotEmpty, true>();
test_has_copy_constructor<bit_zero, true>();
}

70
test/utilities/meta/meta.unary/meta.unary.prop/has_default_constructor.pass.cpp
View File

@ -1,70 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_default_constructor
#include <type_traits>
template <class T, bool Result>
void test_has_default_constructor()
{
static_assert(std::has_default_constructor<T>::value == Result, "");
static_assert(std::has_default_constructor<const T>::value == Result, "");
static_assert(std::has_default_constructor<volatile T>::value == Result, "");
static_assert(std::has_default_constructor<const volatile T>::value == Result, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
public:
virtual ~Abstract() = 0;
};
struct A
{
A();
};
int main()
{
test_has_default_constructor<void, false>();
test_has_default_constructor<int&, false>();
test_has_default_constructor<char[], false>();
test_has_default_constructor<Abstract, false>();
test_has_default_constructor<A, true>();
test_has_default_constructor<Union, true>();
test_has_default_constructor<Empty, true>();
test_has_default_constructor<int, true>();
test_has_default_constructor<double, true>();
test_has_default_constructor<int*, true>();
test_has_default_constructor<const int*, true>();
test_has_default_constructor<char[3], true>();
test_has_default_constructor<NotEmpty, true>();
test_has_default_constructor<bit_zero, true>();
}

19
test/utilities/meta/meta.unary/meta.unary.prop/has_move_assign.pass.cpp
View File

@ -1,19 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_move_assign
#include <type_traits>
int main()
{
#error has_move_assign not implemented
}

19
test/utilities/meta/meta.unary/meta.unary.prop/has_move_constructor.pass.cpp
View File

@ -1,19 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_move_constructor
#include <type_traits>
int main()
{
#error has_move_constructor not implemented
}

79
test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_constructor.pass.cpp
View File

@ -1,79 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_nothrow_copy_constructor
#include <type_traits>
template <class T>
void test_has_nothrow_copy_constructor()
{
static_assert( std::has_nothrow_copy_constructor<T>::value, "");
static_assert( std::has_nothrow_copy_constructor<const T>::value, "");
static_assert( std::has_nothrow_copy_constructor<volatile T>::value, "");
static_assert( std::has_nothrow_copy_constructor<const volatile T>::value, "");
}
template <class T>
void test_has_not_nothrow_copy_constructor()
{
static_assert(!std::has_nothrow_copy_constructor<T>::value, "");
static_assert(!std::has_nothrow_copy_constructor<const T>::value, "");
static_assert(!std::has_nothrow_copy_constructor<volatile T>::value, "");
static_assert(!std::has_nothrow_copy_constructor<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
public:
virtual ~Abstract() = 0;
};
struct A
{
A(const A&);
};
int main()
{
test_has_not_nothrow_copy_constructor<void>();
test_has_not_nothrow_copy_constructor<A>();
test_has_not_nothrow_copy_constructor<Abstract>();
test_has_not_nothrow_copy_constructor<char[3]>();
test_has_not_nothrow_copy_constructor<char[]>();
test_has_nothrow_copy_constructor<int&>();
test_has_nothrow_copy_constructor<Union>();
test_has_nothrow_copy_constructor<Empty>();
test_has_nothrow_copy_constructor<int>();
test_has_nothrow_copy_constructor<double>();
test_has_nothrow_copy_constructor<int*>();
test_has_nothrow_copy_constructor<const int*>();
test_has_nothrow_copy_constructor<NotEmpty>();
test_has_nothrow_copy_constructor<bit_zero>();
}

79
test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_default_constructor.pass.cpp
View File

@ -1,79 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_nothrow_default_constructor
#include <type_traits>
template <class T>
void test_has_nothrow_default_constructor()
{
static_assert( std::has_nothrow_default_constructor<T>::value, "");
static_assert( std::has_nothrow_default_constructor<const T>::value, "");
static_assert( std::has_nothrow_default_constructor<volatile T>::value, "");
static_assert( std::has_nothrow_default_constructor<const volatile T>::value, "");
}
template <class T>
void test_has_not_nothrow_default_constructor()
{
static_assert(!std::has_nothrow_default_constructor<T>::value, "");
static_assert(!std::has_nothrow_default_constructor<const T>::value, "");
static_assert(!std::has_nothrow_default_constructor<volatile T>::value, "");
static_assert(!std::has_nothrow_default_constructor<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
public:
virtual ~Abstract() = 0;
};
struct A
{
A();
};
int main()
{
test_has_not_nothrow_default_constructor<void>();
test_has_not_nothrow_default_constructor<int&>();
test_has_not_nothrow_default_constructor<A>();
test_has_not_nothrow_default_constructor<char[]>();
test_has_not_nothrow_default_constructor<Abstract>();
test_has_nothrow_default_constructor<Union>();
test_has_nothrow_default_constructor<Empty>();
test_has_nothrow_default_constructor<int>();
test_has_nothrow_default_constructor<double>();
test_has_nothrow_default_constructor<int*>();
test_has_nothrow_default_constructor<const int*>();
test_has_nothrow_default_constructor<char[3]>();
test_has_nothrow_default_constructor<NotEmpty>();
test_has_nothrow_default_constructor<bit_zero>();
}

19
test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_assign.pass.cpp
View File

@ -1,19 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_nothrow_move_assign
#include <type_traits>
int main()
{
#error has_nothrow_move_assign not implemented
}

19
test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_constructor.pass.cpp
View File

@ -1,19 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_nothrow_move_constructor
#include <type_traits>
int main()
{
#error has_nothrow_move_constructor not implemented
}

79
test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_constructor.pass.cpp
View File

@ -1,79 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_trivial_copy_constructor
#include <type_traits>
template <class T>
void test_has_trivial_copy_constructor()
{
static_assert( std::has_trivial_copy_constructor<T>::value, "");
static_assert( std::has_trivial_copy_constructor<const T>::value, "");
static_assert( std::has_trivial_copy_constructor<volatile T>::value, "");
static_assert( std::has_trivial_copy_constructor<const volatile T>::value, "");
}
template <class T>
void test_has_not_trivial_copy_constructor()
{
static_assert(!std::has_trivial_copy_constructor<T>::value, "");
static_assert(!std::has_trivial_copy_constructor<const T>::value, "");
static_assert(!std::has_trivial_copy_constructor<volatile T>::value, "");
static_assert(!std::has_trivial_copy_constructor<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
public:
virtual ~Abstract() = 0;
};
struct A
{
A(const A&);
};
int main()
{
test_has_not_trivial_copy_constructor<void>();
test_has_not_trivial_copy_constructor<A>();
test_has_not_trivial_copy_constructor<char[3]>();
test_has_not_trivial_copy_constructor<char[]>();
test_has_not_trivial_copy_constructor<Abstract>();
test_has_not_trivial_copy_constructor<NotEmpty>();
test_has_trivial_copy_constructor<int&>();
test_has_trivial_copy_constructor<Union>();
test_has_trivial_copy_constructor<Empty>();
test_has_trivial_copy_constructor<int>();
test_has_trivial_copy_constructor<double>();
test_has_trivial_copy_constructor<int*>();
test_has_trivial_copy_constructor<const int*>();
test_has_trivial_copy_constructor<bit_zero>();
}

77
test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_default_constructor.pass.cpp
View File

@ -1,77 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_trivial_default_constructor
#include <type_traits>
template <class T>
void test_has_trivial_default_constructor()
{
static_assert( std::has_trivial_default_constructor<T>::value, "");
static_assert( std::has_trivial_default_constructor<const T>::value, "");
static_assert( std::has_trivial_default_constructor<volatile T>::value, "");
static_assert( std::has_trivial_default_constructor<const volatile T>::value, "");
}
template <class T>
void test_has_not_trivial_default_constructor()
{
static_assert(!std::has_trivial_default_constructor<T>::value, "");
static_assert(!std::has_trivial_default_constructor<const T>::value, "");
static_assert(!std::has_trivial_default_constructor<volatile T>::value, "");
static_assert(!std::has_trivial_default_constructor<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
virtual ~Abstract() = 0;
};
struct A
{
A();
};
int main()
{
test_has_not_trivial_default_constructor<void>();
test_has_not_trivial_default_constructor<int&>();
test_has_not_trivial_default_constructor<A>();
test_has_not_trivial_default_constructor<Abstract>();
test_has_not_trivial_default_constructor<NotEmpty>();
test_has_not_trivial_default_constructor<char[]>();
test_has_trivial_default_constructor<Union>();
test_has_trivial_default_constructor<Empty>();
test_has_trivial_default_constructor<int>();
test_has_trivial_default_constructor<double>();
test_has_trivial_default_constructor<int*>();
test_has_trivial_default_constructor<const int*>();
test_has_trivial_default_constructor<char[3]>();
test_has_trivial_default_constructor<bit_zero>();
}

77
test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_destructor.pass.cpp
View File

@ -1,77 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_trivial_destructor
#include <type_traits>
template <class T>
void test_has_trivial_destructor()
{
static_assert( std::has_trivial_destructor<T>::value, "");
static_assert( std::has_trivial_destructor<const T>::value, "");
static_assert( std::has_trivial_destructor<volatile T>::value, "");
static_assert( std::has_trivial_destructor<const volatile T>::value, "");
}
template <class T>
void test_has_not_trivial_destructor()
{
static_assert(!std::has_trivial_destructor<T>::value, "");
static_assert(!std::has_trivial_destructor<const T>::value, "");
static_assert(!std::has_trivial_destructor<volatile T>::value, "");
static_assert(!std::has_trivial_destructor<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
virtual ~Abstract() = 0;
};
struct A
{
~A();
};
int main()
{
test_has_not_trivial_destructor<void>();
test_has_not_trivial_destructor<A>();
test_has_not_trivial_destructor<Abstract>();
test_has_not_trivial_destructor<NotEmpty>();
test_has_trivial_destructor<int&>();
test_has_trivial_destructor<Union>();
test_has_trivial_destructor<Empty>();
test_has_trivial_destructor<int>();
test_has_trivial_destructor<double>();
test_has_trivial_destructor<int*>();
test_has_trivial_destructor<const int*>();
test_has_trivial_destructor<char[3]>();
test_has_trivial_destructor<char[3]>();
test_has_trivial_destructor<bit_zero>();
}

19
test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_assign.pass.cpp
View File

@ -1,19 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_trivial_move_assign
#include <type_traits>
int main()
{
#error has_trivial_move_assign not implemented
}

19
test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_constructor.pass.cpp
View File

@ -1,19 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_trivial_move_constructor
#include <type_traits>
int main()
{
#error has_trivial_move_constructor not implemented
}

34
test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp Normal file
View File

@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_assignable
#include <type_traits>
struct A
{
};
struct B
{
void operator=(A);
};
int main()
{
static_assert(( std::is_assignable<int&, int&>::value), "");
static_assert(( std::is_assignable<int&, int>::value), "");
static_assert((!std::is_assignable<int, int&>::value), "");
static_assert((!std::is_assignable<int, int>::value), "");
static_assert(( std::is_assignable<int&, double>::value), "");
static_assert(( std::is_assignable<B, A>::value), "");
static_assert((!std::is_assignable<A, B>::value), "");
}

8
test/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp
View File

@ -14,25 +14,17 @@
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
struct A
{
explicit A(int);
A(int, double);
};
#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE
int main()
{
#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
static_assert((std::is_constructible<int>::value), "");
static_assert((std::is_constructible<int, const int>::value), "");
static_assert((std::is_constructible<A, int>::value), "");
static_assert((std::is_constructible<A, int, double>::value), "");
static_assert((!std::is_constructible<A>::value), "");
#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE
}

50
test/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp Normal file
View File

@ -0,0 +1,50 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_copy_assignable
#include <type_traits>
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
struct A
{
A();
};
int main()
{
static_assert(( std::is_copy_assignable<int>::value), "");
static_assert((!std::is_copy_assignable<const int>::value), "");
static_assert((!std::is_copy_assignable<int[]>::value), "");
static_assert((!std::is_copy_assignable<int[3]>::value), "");
static_assert(( std::is_copy_assignable<int&>::value), "");
static_assert(( std::is_copy_assignable<A>::value), "");
static_assert(( std::is_copy_assignable<bit_zero>::value), "");
static_assert(( std::is_copy_assignable<Union>::value), "");
static_assert(( std::is_copy_assignable<NotEmpty>::value), "");
static_assert(( std::is_copy_assignable<Empty>::value), "");
}

67
test/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp Normal file
View File

@ -0,0 +1,67 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_copy_constructible
#include <type_traits>
template <class T, bool Result>
void test_is_copy_constructible()
{
static_assert(std::is_copy_constructible<T>::value == Result, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
public:
virtual ~Abstract() = 0;
};
struct A
{
A(const A&);
};
int main()
{
test_is_copy_constructible<char[3], false>();
test_is_copy_constructible<char[], false>();
test_is_copy_constructible<void, false>();
test_is_copy_constructible<Abstract, false>();
test_is_copy_constructible<A, true>();
test_is_copy_constructible<int&, true>();
test_is_copy_constructible<Union, true>();
test_is_copy_constructible<Empty, true>();
test_is_copy_constructible<int, true>();
test_is_copy_constructible<double, true>();
test_is_copy_constructible<int*, true>();
test_is_copy_constructible<const int*, true>();
test_is_copy_constructible<NotEmpty, true>();
test_is_copy_constructible<bit_zero, true>();
}

70
test/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp Normal file
View File

@ -0,0 +1,70 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_default_constructible
#include <type_traits>
template <class T, bool Result>
void test_is_default_constructible()
{
static_assert(std::is_default_constructible<T>::value == Result, "");
static_assert(std::is_default_constructible<const T>::value == Result, "");
static_assert(std::is_default_constructible<volatile T>::value == Result, "");
static_assert(std::is_default_constructible<const volatile T>::value == Result, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
public:
virtual ~Abstract() = 0;
};
struct A
{
A();
};
int main()
{
test_is_default_constructible<void, false>();
test_is_default_constructible<int&, false>();
test_is_default_constructible<char[], false>();
test_is_default_constructible<Abstract, false>();
test_is_default_constructible<A, true>();
test_is_default_constructible<Union, true>();
test_is_default_constructible<Empty, true>();
test_is_default_constructible<int, true>();
test_is_default_constructible<double, true>();
test_is_default_constructible<int*, true>();
test_is_default_constructible<const int*, true>();
test_is_default_constructible<char[3], true>();
test_is_default_constructible<NotEmpty, true>();
test_is_default_constructible<bit_zero, true>();
}

66
test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp Normal file
View File

@ -0,0 +1,66 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_destructible
#include <type_traits>
template <class T, bool Result>
void test_is_destructible()
{
static_assert( std::is_destructible<T>::value == Result, "");
static_assert( std::is_destructible<const T>::value == Result, "");
static_assert( std::is_destructible<volatile T>::value == Result, "");
static_assert( std::is_destructible<const volatile T>::value == Result, "");
}
class Empty
{
};
class NotEmpty
{
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
virtual ~Abstract() = 0;
};
struct A
{
~A();
};
int main()
{
test_is_destructible<void, false>();
test_is_destructible<A, true>();
test_is_destructible<Abstract, false>();
test_is_destructible<NotEmpty, false>();
test_is_destructible<int&, true>();
test_is_destructible<Union, true>();
test_is_destructible<Empty, true>();
test_is_destructible<int, true>();
test_is_destructible<double, true>();
test_is_destructible<int*, true>();
test_is_destructible<const int*, true>();
test_is_destructible<char[3], true>();
test_is_destructible<bit_zero, true>();
}

50
test/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp Normal file
View File

@ -0,0 +1,50 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_move_assignable
#include <type_traits>
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
struct A
{
A();
};
int main()
{
static_assert(( std::is_move_assignable<int>::value), "");
static_assert((!std::is_move_assignable<const int>::value), "");
static_assert((!std::is_move_assignable<int[]>::value), "");
static_assert((!std::is_move_assignable<int[3]>::value), "");
static_assert(( std::is_move_assignable<int&>::value), "");
static_assert(( std::is_move_assignable<A>::value), "");
static_assert(( std::is_move_assignable<bit_zero>::value), "");
static_assert(( std::is_move_assignable<Union>::value), "");
static_assert(( std::is_move_assignable<NotEmpty>::value), "");
static_assert(( std::is_move_assignable<Empty>::value), "");
}

73
test/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp Normal file
View File

@ -0,0 +1,73 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_move_constructible
#include <type_traits>
template <class T, bool Result>
void test_is_move_constructible()
{
static_assert(std::is_move_constructible<T>::value == Result, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
public:
virtual ~Abstract() = 0;
};
struct A
{
A(const A&);
};
struct B
{
B(B&&);
};
int main()
{
test_is_move_constructible<char[3], false>();
test_is_move_constructible<char[], false>();
test_is_move_constructible<void, false>();
test_is_move_constructible<Abstract, false>();
test_is_move_constructible<A, true>();
test_is_move_constructible<int&, true>();
test_is_move_constructible<Union, true>();
test_is_move_constructible<Empty, true>();
test_is_move_constructible<int, true>();
test_is_move_constructible<double, true>();
test_is_move_constructible<int*, true>();
test_is_move_constructible<const int*, true>();
test_is_move_constructible<NotEmpty, true>();
test_is_move_constructible<bit_zero, true>();
test_is_move_constructible<B, true>();
}

34
test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp Normal file
View File

@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_nothrow_assignable
#include <type_traits>
struct A
{
};
struct B
{
void operator=(A);
};
int main()
{
static_assert(( std::is_nothrow_assignable<int&, int&>::value), "");
static_assert(( std::is_nothrow_assignable<int&, int>::value), "");
static_assert((!std::is_nothrow_assignable<int, int&>::value), "");
static_assert((!std::is_nothrow_assignable<int, int>::value), "");
static_assert(( std::is_nothrow_assignable<int&, double>::value), "");
static_assert((!std::is_nothrow_assignable<B, A>::value), "");
static_assert((!std::is_nothrow_assignable<A, B>::value), "");
}

12
test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp
View File

@ -14,8 +14,6 @@
#include <type_traits>
#ifndef _LIBCPP_HAS_NO_VARIADICS
class Empty
{
};
@ -42,11 +40,11 @@ struct A
A(const A&);
};
#endif // _LIBCPP_HAS_NO_VARIADICS
int main()
{
#ifndef _LIBCPP_HAS_NO_VARIADICS
static_assert((std::is_nothrow_constructible<int, const int>::value), "");
#endif
static_assert(( std::is_nothrow_constructible<int>::value), "");
static_assert(( std::is_nothrow_constructible<int, const int&>::value), "");
static_assert((!std::is_nothrow_constructible<A, int>::value), "");
static_assert((!std::is_nothrow_constructible<A, int, double>::value), "");
static_assert((!std::is_nothrow_constructible<A>::value), "");
}

14
test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_assign.pass.cpp → test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp
View File

@ -9,14 +9,14 @@
// type_traits
// has_nothrow_copy_assign
// is_nothrow_copy_assignable
#include <type_traits>
template <class T, bool Result>
void test_has_nothrow_assign()
{
static_assert(std::has_nothrow_copy_assign<T>::value == Result, "");
static_assert(std::is_nothrow_copy_assignable<T>::value == Result, "");
}
class Empty
@ -35,11 +35,6 @@ struct bit_zero
int : 0;
};
struct Abstract
{
virtual ~Abstract() = 0;
};
struct A
{
A& operator=(const A&);
@ -49,10 +44,7 @@ int main()
{
test_has_nothrow_assign<void, false>();
test_has_nothrow_assign<A, false>();
test_has_nothrow_assign<int&, false>();
test_has_nothrow_assign<Abstract, false>();
test_has_nothrow_assign<char[3], false>();
test_has_nothrow_assign<char[], false>();
test_has_nothrow_assign<int&, true>();
test_has_nothrow_assign<Union, true>();
test_has_nothrow_assign<Empty, true>();

70
test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp Normal file
View File

@ -0,0 +1,70 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_nothrow_copy_constructible
#include <type_traits>
template <class T>
void test_is_nothrow_copy_constructible()
{
static_assert( std::is_nothrow_copy_constructible<T>::value, "");
static_assert( std::is_nothrow_copy_constructible<const T>::value, "");
static_assert( std::is_nothrow_copy_constructible<volatile T>::value, "");
static_assert( std::is_nothrow_copy_constructible<const volatile T>::value, "");
}
template <class T>
void test_has_not_nothrow_copy_constructor()
{
static_assert(!std::is_nothrow_copy_constructible<T>::value, "");
static_assert(!std::is_nothrow_copy_constructible<const T>::value, "");
static_assert(!std::is_nothrow_copy_constructible<volatile T>::value, "");
static_assert(!std::is_nothrow_copy_constructible<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
struct A
{
A(const A&);
};
int main()
{
test_has_not_nothrow_copy_constructor<void>();
test_has_not_nothrow_copy_constructor<A>();
test_is_nothrow_copy_constructible<int&>();
test_is_nothrow_copy_constructible<Union>();
test_is_nothrow_copy_constructible<Empty>();
test_is_nothrow_copy_constructible<int>();
test_is_nothrow_copy_constructible<double>();
test_is_nothrow_copy_constructible<int*>();
test_is_nothrow_copy_constructible<const int*>();
test_is_nothrow_copy_constructible<NotEmpty>();
test_is_nothrow_copy_constructible<bit_zero>();
}

71
test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp Normal file
View File

@ -0,0 +1,71 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_nothrow_default_constructible
#include <type_traits>
template <class T>
void test_is_nothrow_default_constructible()
{
static_assert( std::is_nothrow_default_constructible<T>::value, "");
static_assert( std::is_nothrow_default_constructible<const T>::value, "");
static_assert( std::is_nothrow_default_constructible<volatile T>::value, "");
static_assert( std::is_nothrow_default_constructible<const volatile T>::value, "");
}
template <class T>
void test_has_not_nothrow_default_constructor()
{
static_assert(!std::is_nothrow_default_constructible<T>::value, "");
static_assert(!std::is_nothrow_default_constructible<const T>::value, "");
static_assert(!std::is_nothrow_default_constructible<volatile T>::value, "");
static_assert(!std::is_nothrow_default_constructible<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
struct A
{
A();
};
int main()
{
test_has_not_nothrow_default_constructor<void>();
test_has_not_nothrow_default_constructor<int&>();
test_has_not_nothrow_default_constructor<A>();
test_is_nothrow_default_constructible<Union>();
test_is_nothrow_default_constructible<Empty>();
test_is_nothrow_default_constructible<int>();
test_is_nothrow_default_constructible<double>();
test_is_nothrow_default_constructible<int*>();
test_is_nothrow_default_constructible<const int*>();
test_is_nothrow_default_constructible<char[3]>();
test_is_nothrow_default_constructible<NotEmpty>();
test_is_nothrow_default_constructible<bit_zero>();
}

77
test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp Normal file
View File

@ -0,0 +1,77 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_nothrow_destructible
#include <type_traits>
template <class T>
void test_is_nothrow_destructible()
{
static_assert( std::is_nothrow_destructible<T>::value, "");
static_assert( std::is_nothrow_destructible<const T>::value, "");
static_assert( std::is_nothrow_destructible<volatile T>::value, "");
static_assert( std::is_nothrow_destructible<const volatile T>::value, "");
}
template <class T>
void test_has_not_nothrow_destructor()
{
static_assert(!std::is_nothrow_destructible<T>::value, "");
static_assert(!std::is_nothrow_destructible<const T>::value, "");
static_assert(!std::is_nothrow_destructible<volatile T>::value, "");
static_assert(!std::is_nothrow_destructible<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
virtual ~Abstract() = 0;
};
struct A
{
~A();
};
int main()
{
test_has_not_nothrow_destructor<void>();
test_has_not_nothrow_destructor<A>();
test_has_not_nothrow_destructor<Abstract>();
test_has_not_nothrow_destructor<NotEmpty>();
test_is_nothrow_destructible<int&>();
test_is_nothrow_destructible<Union>();
test_is_nothrow_destructible<Empty>();
test_is_nothrow_destructible<int>();
test_is_nothrow_destructible<double>();
test_is_nothrow_destructible<int*>();
test_is_nothrow_destructible<const int*>();
test_is_nothrow_destructible<char[3]>();
test_is_nothrow_destructible<char[3]>();
test_is_nothrow_destructible<bit_zero>();
}

57
test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp Normal file
View File

@ -0,0 +1,57 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_nothrow_move_assign
#include <type_traits>
template <class T, bool Result>
void test_has_nothrow_assign()
{
static_assert(std::is_nothrow_move_assignable<T>::value == Result, "");
}
class Empty
{
};
struct NotEmpty
{
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
struct A
{
A& operator=(const A&);
};
int main()
{
test_has_nothrow_assign<void, false>();
test_has_nothrow_assign<A, false>();
test_has_nothrow_assign<int&, true>();
test_has_nothrow_assign<Union, true>();
test_has_nothrow_assign<Empty, true>();
test_has_nothrow_assign<int, true>();
test_has_nothrow_assign<double, true>();
test_has_nothrow_assign<int*, true>();
test_has_nothrow_assign<const int*, true>();
test_has_nothrow_assign<NotEmpty, true>();
test_has_nothrow_assign<bit_zero, true>();
}

70
test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp Normal file
View File

@ -0,0 +1,70 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// has_nothrow_move_constructor
#include <type_traits>
template <class T>
void test_is_nothrow_move_constructible()
{
static_assert( std::is_nothrow_move_constructible<T>::value, "");
static_assert( std::is_nothrow_move_constructible<const T>::value, "");
static_assert( std::is_nothrow_move_constructible<volatile T>::value, "");
static_assert( std::is_nothrow_move_constructible<const volatile T>::value, "");
}
template <class T>
void test_has_not_nothrow_move_constructor()
{
static_assert(!std::is_nothrow_move_constructible<T>::value, "");
static_assert(!std::is_nothrow_move_constructible<const T>::value, "");
static_assert(!std::is_nothrow_move_constructible<volatile T>::value, "");
static_assert(!std::is_nothrow_move_constructible<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
struct A
{
A(const A&);
};
int main()
{
test_has_not_nothrow_move_constructor<void>();
test_has_not_nothrow_move_constructor<A>();
test_has_not_nothrow_move_constructor<int&>();
test_is_nothrow_move_constructible<Union>();
test_is_nothrow_move_constructible<Empty>();
test_is_nothrow_move_constructible<int>();
test_is_nothrow_move_constructible<double>();
test_is_nothrow_move_constructible<int*>();
test_is_nothrow_move_constructible<const int*>();
test_is_nothrow_move_constructible<NotEmpty>();
test_is_nothrow_move_constructible<bit_zero>();
}

34
test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp Normal file
View File

@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_trivially_assignable
#include <type_traits>
struct A
{
};
struct B
{
void operator=(A);
};
int main()
{
static_assert(( std::is_trivially_assignable<int&, int&>::value), "");
static_assert(( std::is_trivially_assignable<int&, int>::value), "");
static_assert((!std::is_trivially_assignable<int, int&>::value), "");
static_assert((!std::is_trivially_assignable<int, int>::value), "");
static_assert(( std::is_trivially_assignable<int&, double>::value), "");
static_assert((!std::is_trivially_assignable<B, A>::value), "");
static_assert((!std::is_trivially_assignable<A, B>::value), "");
}

30
test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp Normal file
View File

@ -0,0 +1,30 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// template <class T, class... Args>
// struct is_trivially_constructible;
#include <type_traits>
struct A
{
explicit A(int);
A(int, double);
};
int main()
{
static_assert(( std::is_trivially_constructible<int>::value), "");
static_assert(( std::is_trivially_constructible<int, const int&>::value), "");
static_assert((!std::is_trivially_constructible<A, int>::value), "");
static_assert((!std::is_trivially_constructible<A, int, double>::value), "");
static_assert((!std::is_trivially_constructible<A>::value), "");
}

8
test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_assign.pass.cpp → test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp
View File

@ -9,14 +9,14 @@
// type_traits
// has_trivial_copy_assign
// is_trivially_copy_assignable
#include <type_traits>
template <class T, bool Result>
void test_has_trivial_assign()
{
static_assert(std::has_trivial_copy_assign<T>::value == Result, "");
static_assert(std::is_trivially_copy_assignable<T>::value == Result, "");
}
class Empty
@ -49,12 +49,10 @@ int main()
{
test_has_trivial_assign<void, false>();
test_has_trivial_assign<A, false>();
test_has_trivial_assign<int&, false>();
test_has_trivial_assign<int&, true>();
test_has_trivial_assign<NotEmpty, false>();
test_has_trivial_assign<Abstract, false>();
test_has_trivial_assign<const Empty, false>();
test_has_trivial_assign<char[3], false>();
test_has_trivial_assign<char[], false>();
test_has_trivial_assign<Union, true>();
test_has_trivial_assign<Empty, true>();

77
test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp Normal file
View File

@ -0,0 +1,77 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_trivially_copy_constructible
#include <type_traits>
template <class T>
void test_is_trivially_copy_constructible()
{
static_assert( std::is_trivially_copy_constructible<T>::value, "");
static_assert( std::is_trivially_copy_constructible<const T>::value, "");
static_assert( std::is_trivially_copy_constructible<volatile T>::value, "");
static_assert( std::is_trivially_copy_constructible<const volatile T>::value, "");
}
template <class T>
void test_has_not_trivial_copy_constructor()
{
static_assert(!std::is_trivially_copy_constructible<T>::value, "");
static_assert(!std::is_trivially_copy_constructible<const T>::value, "");
static_assert(!std::is_trivially_copy_constructible<volatile T>::value, "");
static_assert(!std::is_trivially_copy_constructible<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
public:
virtual ~Abstract() = 0;
};
struct A
{
A(const A&);
};
int main()
{
test_has_not_trivial_copy_constructor<void>();
test_has_not_trivial_copy_constructor<A>();
test_has_not_trivial_copy_constructor<Abstract>();
test_has_not_trivial_copy_constructor<NotEmpty>();
test_is_trivially_copy_constructible<int&>();
test_is_trivially_copy_constructible<Union>();
test_is_trivially_copy_constructible<Empty>();
test_is_trivially_copy_constructible<int>();
test_is_trivially_copy_constructible<double>();
test_is_trivially_copy_constructible<int*>();
test_is_trivially_copy_constructible<const int*>();
test_is_trivially_copy_constructible<bit_zero>();
}

76
test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp Normal file
View File

@ -0,0 +1,76 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_trivially_default_constructible
#include <type_traits>
template <class T>
void test_is_trivially_default_constructible()
{
static_assert( std::is_trivially_default_constructible<T>::value, "");
static_assert( std::is_trivially_default_constructible<const T>::value, "");
static_assert( std::is_trivially_default_constructible<volatile T>::value, "");
static_assert( std::is_trivially_default_constructible<const volatile T>::value, "");
}
template <class T>
void test_has_not_trivial_default_constructor()
{
static_assert(!std::is_trivially_default_constructible<T>::value, "");
static_assert(!std::is_trivially_default_constructible<const T>::value, "");
static_assert(!std::is_trivially_default_constructible<volatile T>::value, "");
static_assert(!std::is_trivially_default_constructible<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
virtual ~Abstract() = 0;
};
struct A
{
A();
};
int main()
{
test_has_not_trivial_default_constructor<void>();
test_has_not_trivial_default_constructor<int&>();
test_has_not_trivial_default_constructor<A>();
test_has_not_trivial_default_constructor<Abstract>();
test_has_not_trivial_default_constructor<NotEmpty>();
test_is_trivially_default_constructible<Union>();
test_is_trivially_default_constructible<Empty>();
test_is_trivially_default_constructible<int>();
test_is_trivially_default_constructible<double>();
test_is_trivially_default_constructible<int*>();
test_is_trivially_default_constructible<const int*>();
test_is_trivially_default_constructible<char[3]>();
test_is_trivially_default_constructible<bit_zero>();
}

77
test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp Normal file
View File

@ -0,0 +1,77 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_trivially_destructible
#include <type_traits>
template <class T>
void test_is_trivially_destructible()
{
static_assert( std::is_trivially_destructible<T>::value, "");
static_assert( std::is_trivially_destructible<const T>::value, "");
static_assert( std::is_trivially_destructible<volatile T>::value, "");
static_assert( std::is_trivially_destructible<const volatile T>::value, "");
}
template <class T>
void test_has_not_trivial_destructor()
{
static_assert(!std::is_trivially_destructible<T>::value, "");
static_assert(!std::is_trivially_destructible<const T>::value, "");
static_assert(!std::is_trivially_destructible<volatile T>::value, "");
static_assert(!std::is_trivially_destructible<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
virtual ~Abstract() = 0;
};
struct A
{
~A();
};
int main()
{
test_has_not_trivial_destructor<void>();
test_has_not_trivial_destructor<A>();
test_has_not_trivial_destructor<Abstract>();
test_has_not_trivial_destructor<NotEmpty>();
test_is_trivially_destructible<int&>();
test_is_trivially_destructible<Union>();
test_is_trivially_destructible<Empty>();
test_is_trivially_destructible<int>();
test_is_trivially_destructible<double>();
test_is_trivially_destructible<int*>();
test_is_trivially_destructible<const int*>();
test_is_trivially_destructible<char[3]>();
test_is_trivially_destructible<char[3]>();
test_is_trivially_destructible<bit_zero>();
}

64
test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp Normal file
View File

@ -0,0 +1,64 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_trivially_move_assignable
#include <type_traits>
template <class T, bool Result>
void test_has_trivial_assign()
{
static_assert(std::is_trivially_move_assignable<T>::value == Result, "");
}
class Empty
{
};
class NotEmpty
{
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
virtual ~Abstract() = 0;
};
struct A
{
A& operator=(const A&);
};
int main()
{
test_has_trivial_assign<void, false>();
test_has_trivial_assign<A, false>();
test_has_trivial_assign<int&, true>();
test_has_trivial_assign<NotEmpty, false>();
test_has_trivial_assign<Abstract, false>();
test_has_trivial_assign<const Empty, false>();
test_has_trivial_assign<Union, true>();
test_has_trivial_assign<Empty, true>();
test_has_trivial_assign<int, true>();
test_has_trivial_assign<double, true>();
test_has_trivial_assign<int*, true>();
test_has_trivial_assign<const int*, true>();
test_has_trivial_assign<bit_zero, true>();
}

77
test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp Normal file
View File

@ -0,0 +1,77 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// type_traits
// is_trivially_move_constructible
#include <type_traits>
template <class T>
void test_is_trivially_move_constructible()
{
static_assert( std::is_trivially_move_constructible<T>::value, "");
static_assert( std::is_trivially_move_constructible<const T>::value, "");
static_assert( std::is_trivially_move_constructible<volatile T>::value, "");
static_assert( std::is_trivially_move_constructible<const volatile T>::value, "");
}
template <class T>
void test_has_not_trivial_move_constructor()
{
static_assert(!std::is_trivially_move_constructible<T>::value, "");
static_assert(!std::is_trivially_move_constructible<const T>::value, "");
static_assert(!std::is_trivially_move_constructible<volatile T>::value, "");
static_assert(!std::is_trivially_move_constructible<const volatile T>::value, "");
}
class Empty
{
};
class NotEmpty
{
public:
virtual ~NotEmpty();
};
union Union {};
struct bit_zero
{
int : 0;
};
class Abstract
{
public:
virtual ~Abstract() = 0;
};
struct A
{
A(const A&);
};
int main()
{
test_has_not_trivial_move_constructor<void>();
test_has_not_trivial_move_constructor<A>();
test_has_not_trivial_move_constructor<Abstract>();
test_has_not_trivial_move_constructor<NotEmpty>();
test_is_trivially_move_constructible<int&>();
test_is_trivially_move_constructible<Union>();
test_is_trivially_move_constructible<Empty>();
test_is_trivially_move_constructible<int>();
test_is_trivially_move_constructible<double>();
test_is_trivially_move_constructible<int*>();
test_is_trivially_move_constructible<const int*>();
test_is_trivially_move_constructible<bit_zero>();
}