Skip to content

R
riscv-gcc-1
Commit 123c516a by Paolo Carlini
Options

[multiple changes] 

2011-04-13  Daniel Krugler  <daniel.kruegler@googlemail.com>
	    Paolo Carlini  <paolo.carlini@oracle.com>

	PR libstdc++/48526
	* include/std/type_traits (struct is_constructible): Re-implement,
	according to n3290.
	(struct is_default_constructible): Add.
	(struct is_destructible): Likewise.
	(struct __and_, __or_, __not_): Add and use throughout; reorder some
	facilities, other minor tweaks.
	* testsuite/util/testsuite_tr1.h: Add test types.
	* testsuite/20_util/is_constructible/value-2.cc: New.
	* testsuite/20_util/is_default_constructible/value.cc: Likewise.
	* testsuite/20_util/is_default_constructible/requirements/typedefs.cc:
	Likewise.
	* testsuite/20_util/is_default_constructible/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_destructible/value.cc: Likewise.
	* testsuite/20_util/is_destructible/requirements/typedefs.cc:
	Likewise.
	* testsuite/20_util/is_destructible/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/make_signed/requirements/typedefs_neg.cc: Adjust
	dg-error line numbers.
	* testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc:
	Likewise.
	* testsuite/20_util/declval/requirements/1_neg.cc: Likewise.
	* testsuite/20_util/ratio/cons/cons_overflow_neg.cc: Likewise.

2011-04-13  Paolo Carlini  <paolo.carlini@oracle.com>

	* testsuite/20_util/is_function/value.cc: Add, adapted from the tr
	testsuite. 
	* testsuite/20_util/is_function/requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_function/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_function/24808.cc: Likewise.
	* testsuite/20_util/is_function/35637.cc: Likewise.
	* testsuite/20_util/is_object/value.cc: Likewise.
	* testsuite/20_util/is_object/requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_object/requirements/explicit_instantiation.cc:
	: Likewise.
	* testsuite/20_util/is_object/24808.cc: Likewise.
	* testsuite/20_util/is_compound/value.cc: Likewise.
	* testsuite/20_util/is_compound/requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_compound/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_member_object_pointer/value.cc: Likewise.
	* testsuite/20_util/is_member_object_pointer/requirements/
	typedefs.cc: Likewise.
	* testsuite/20_util/is_member_object_pointer/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_fundamental/value.cc: Likewise.
	* testsuite/20_util/is_fundamental/requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_fundamental/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_member_pointer/value.cc: Likewise.
	* testsuite/20_util/is_member_pointer/requirements/typedefs.cc: 
	Likewise.
	* testsuite/20_util/is_member_pointer/requirements/
	explicit_instantiation.cc: Likewise.
	* testsuite/20_util/is_member_function_pointer/value.cc: Likewise.
	* testsuite/20_util/is_member_function_pointer/
	requirements/typedefs.cc: Likewise.
	* testsuite/20_util/is_member_function_pointer/requirements/
	explicit_instantiation.cc: Likewise.

	* testsuite/20_util/is_convertible/value.cc: Minor tweak, adjust
	Copyright years.

From-SVN: r172401
parent 12e05824
Showing with 3122 additions and 440 deletions
libstdc++-v3/ChangeLog
2011-04-13 Daniel Krugler <daniel.kruegler@googlemail.com>
Paolo Carlini <paolo.carlini@oracle.com>
PR libstdc++/48526
* include/std/type_traits (struct is_constructible): Re-implement,
according to n3290.
(struct is_default_constructible): Add.
(struct is_destructible): Likewise.
(struct __and_, __or_, __not_): Add and use throughout; reorder some
facilities, other minor tweaks.
* testsuite/util/testsuite_tr1.h: Add test types.
* testsuite/20_util/is_constructible/value-2.cc: New.
* testsuite/20_util/is_default_constructible/value.cc: Likewise.
* testsuite/20_util/is_default_constructible/requirements/typedefs.cc:
Likewise.
* testsuite/20_util/is_default_constructible/requirements/
explicit_instantiation.cc: Likewise.
* testsuite/20_util/is_destructible/value.cc: Likewise.
* testsuite/20_util/is_destructible/requirements/typedefs.cc:
Likewise.
* testsuite/20_util/is_destructible/requirements/
explicit_instantiation.cc: Likewise.
* testsuite/20_util/make_signed/requirements/typedefs_neg.cc: Adjust
dg-error line numbers.
* testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc:
Likewise.
* testsuite/20_util/declval/requirements/1_neg.cc: Likewise.
* testsuite/20_util/ratio/cons/cons_overflow_neg.cc: Likewise.
2011-04-13 Paolo Carlini <paolo.carlini@oracle.com>
* testsuite/20_util/is_function/value.cc: Add, adapted from the tr
testsuite.
* testsuite/20_util/is_function/requirements/typedefs.cc: Likewise.
* testsuite/20_util/is_function/requirements/
explicit_instantiation.cc: Likewise.
* testsuite/20_util/is_function/24808.cc: Likewise.
* testsuite/20_util/is_function/35637.cc: Likewise.
* testsuite/20_util/is_object/value.cc: Likewise.
* testsuite/20_util/is_object/requirements/typedefs.cc: Likewise.
* testsuite/20_util/is_object/requirements/explicit_instantiation.cc:
: Likewise.
* testsuite/20_util/is_object/24808.cc: Likewise.
* testsuite/20_util/is_compound/value.cc: Likewise.
* testsuite/20_util/is_compound/requirements/typedefs.cc: Likewise.
* testsuite/20_util/is_compound/requirements/
explicit_instantiation.cc: Likewise.
* testsuite/20_util/is_member_object_pointer/value.cc: Likewise.
* testsuite/20_util/is_member_object_pointer/requirements/
typedefs.cc: Likewise.
* testsuite/20_util/is_member_object_pointer/requirements/
explicit_instantiation.cc: Likewise.
* testsuite/20_util/is_fundamental/value.cc: Likewise.
* testsuite/20_util/is_fundamental/requirements/typedefs.cc: Likewise.
* testsuite/20_util/is_fundamental/requirements/
explicit_instantiation.cc: Likewise.
* testsuite/20_util/is_member_pointer/value.cc: Likewise.
* testsuite/20_util/is_member_pointer/requirements/typedefs.cc:
Likewise.
* testsuite/20_util/is_member_pointer/requirements/
explicit_instantiation.cc: Likewise.
* testsuite/20_util/is_member_function_pointer/value.cc: Likewise.
* testsuite/20_util/is_member_function_pointer/
requirements/typedefs.cc: Likewise.
* testsuite/20_util/is_member_function_pointer/requirements/
explicit_instantiation.cc: Likewise.
* testsuite/20_util/is_convertible/value.cc: Minor tweak, adjust
Copyright years.
2011-04-12 Takaya Saito <gintensubaru@gmail.com> 2011-04-12 Takaya Saito <gintensubaru@gmail.com>
PR libstdc++/48476 PR libstdc++/48476
......
libstdc++-v3/include/std/type_traits
// C++0x type_traits -*- C++ -*- // C++0x type_traits -*- C++ -*-
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. // Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
// //
// This file is part of the GNU ISO C++ Library. This library is free // This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the // software; you can redistribute it and/or modify it under the
...@@ -51,21 +51,46 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -51,21 +51,46 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef struct { char __arr[2]; } __two; typedef struct { char __arr[2]; } __two;
}; };
#define _DEFINE_SPEC_0_HELPER \ // Meta programming helper types.
template<>
#define _DEFINE_SPEC_1_HELPER \ template<bool, typename, typename>
template<typename _Tp> struct conditional;
#define _DEFINE_SPEC_2_HELPER \ template<typename _Tp, _Tp>
template<typename _Tp, typename _Cp> struct integral_constant;
template<typename, typename, typename...>
struct __or_;
template<typename _B1, typename _B2>
struct __or_<_B1, _B2>
: public conditional<_B1::value, _B1, _B2>::type
{ };
template<typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __or_<_B1, _B2, _B3, _Bn...>
: public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
{ };
#define _DEFINE_SPEC(_Order, _Trait, _Type, _Value) \ template<typename, typename, typename...>
_DEFINE_SPEC_##_Order##_HELPER \ struct __and_;
struct _Trait<_Type> \
: public integral_constant<bool, _Value> { };
// helper classes. template<typename _B1, typename _B2>
struct __and_<_B1, _B2>
: public conditional<_B1::value, _B2, _B1>::type
{ };
template<typename _B1, typename _B2, typename _B3, typename... _Bn>
struct __and_<_B1, _B2, _B3, _Bn...>
: public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
{ };
template<typename _Pp>
struct __not_
: public integral_constant<bool, !_Pp::value>
{ };
// helper class.
/// integral_constant /// integral_constant
template<typename _Tp, _Tp __v> template<typename _Tp, _Tp __v>
...@@ -86,16 +111,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -86,16 +111,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, _Tp __v> template<typename _Tp, _Tp __v>
constexpr _Tp integral_constant<_Tp, __v>::value; constexpr _Tp integral_constant<_Tp, __v>::value;
/// remove_cv // primary type categories.
template<typename> template<typename>
struct remove_cv; struct remove_cv;
template<typename> template<typename>
struct __is_void_helper struct __is_void_helper
: public false_type { }; : public false_type { };
_DEFINE_SPEC(0, __is_void_helper, void, true)
// primary type categories. template<>
struct __is_void_helper<void>
: public true_type { };
/// is_void /// is_void
template<typename _Tp> template<typename _Tp>
...@@ -107,23 +134,68 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -107,23 +134,68 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename> template<typename>
struct __is_integral_helper struct __is_integral_helper
: public false_type { }; : public false_type { };
_DEFINE_SPEC(0, __is_integral_helper, bool, true)
_DEFINE_SPEC(0, __is_integral_helper, char, true) template<>
_DEFINE_SPEC(0, __is_integral_helper, signed char, true) struct __is_integral_helper<bool>
_DEFINE_SPEC(0, __is_integral_helper, unsigned char, true) : public true_type { };
template<>
struct __is_integral_helper<char>
: public true_type { };
template<>
struct __is_integral_helper<signed char>
: public true_type { };
template<>
struct __is_integral_helper<unsigned char>
: public true_type { };
#ifdef _GLIBCXX_USE_WCHAR_T #ifdef _GLIBCXX_USE_WCHAR_T
_DEFINE_SPEC(0, __is_integral_helper, wchar_t, true) template<>
struct __is_integral_helper<wchar_t>
: public true_type { };
#endif #endif
_DEFINE_SPEC(0, __is_integral_helper, char16_t, true)
_DEFINE_SPEC(0, __is_integral_helper, char32_t, true) template<>
_DEFINE_SPEC(0, __is_integral_helper, short, true) struct __is_integral_helper<char16_t>
_DEFINE_SPEC(0, __is_integral_helper, unsigned short, true) : public true_type { };
_DEFINE_SPEC(0, __is_integral_helper, int, true)
_DEFINE_SPEC(0, __is_integral_helper, unsigned int, true) template<>
_DEFINE_SPEC(0, __is_integral_helper, long, true) struct __is_integral_helper<char32_t>
_DEFINE_SPEC(0, __is_integral_helper, unsigned long, true) : public true_type { };
_DEFINE_SPEC(0, __is_integral_helper, long long, true)
_DEFINE_SPEC(0, __is_integral_helper, unsigned long long, true) template<>
struct __is_integral_helper<short>
: public true_type { };
template<>
struct __is_integral_helper<unsigned short>
: public true_type { };
template<>
struct __is_integral_helper<int>
: public true_type { };
template<>
struct __is_integral_helper<unsigned int>
: public true_type { };
template<>
struct __is_integral_helper<long>
: public true_type { };
template<>
struct __is_integral_helper<unsigned long>
: public true_type { };
template<>
struct __is_integral_helper<long long>
: public true_type { };
template<>
struct __is_integral_helper<unsigned long long>
: public true_type { };
/// is_integral /// is_integral
template<typename _Tp> template<typename _Tp>
...@@ -135,9 +207,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -135,9 +207,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename> template<typename>
struct __is_floating_point_helper struct __is_floating_point_helper
: public false_type { }; : public false_type { };
_DEFINE_SPEC(0, __is_floating_point_helper, float, true)
_DEFINE_SPEC(0, __is_floating_point_helper, double, true) template<>
_DEFINE_SPEC(0, __is_floating_point_helper, long double, true) struct __is_floating_point_helper<float>
: public true_type { };
template<>
struct __is_floating_point_helper<double>
: public true_type { };
template<>
struct __is_floating_point_helper<long double>
: public true_type { };
/// is_floating_point /// is_floating_point
template<typename _Tp> template<typename _Tp>
...@@ -162,7 +243,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -162,7 +243,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename> template<typename>
struct __is_pointer_helper struct __is_pointer_helper
: public false_type { }; : public false_type { };
_DEFINE_SPEC(1, __is_pointer_helper, _Tp*, true)
template<typename _Tp>
struct __is_pointer_helper<_Tp*>
: public true_type { };
/// is_pointer /// is_pointer
template<typename _Tp> template<typename _Tp>
...@@ -171,19 +255,34 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -171,19 +255,34 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
remove_cv<_Tp>::type>::value)> remove_cv<_Tp>::type>::value)>
{ }; { };
/// is_reference /// is_lvalue_reference
template<typename>
struct is_lvalue_reference
: public false_type { };
template<typename _Tp> template<typename _Tp>
struct is_reference; struct is_lvalue_reference<_Tp&>
: public true_type { };
/// is_rvalue_reference
template<typename>
struct is_rvalue_reference
: public false_type { };
/// is_function
template<typename _Tp> template<typename _Tp>
struct is_rvalue_reference<_Tp&&>
: public true_type { };
template<typename>
struct is_function; struct is_function;
template<typename> template<typename>
struct __is_member_object_pointer_helper struct __is_member_object_pointer_helper
: public false_type { }; : public false_type { };
_DEFINE_SPEC(2, __is_member_object_pointer_helper, _Tp _Cp::*,
!is_function<_Tp>::value) template<typename _Tp, typename _Cp>
struct __is_member_object_pointer_helper<_Tp _Cp::*>
: public integral_constant<bool, !is_function<_Tp>::value> { };
/// is_member_object_pointer /// is_member_object_pointer
template<typename _Tp> template<typename _Tp>
...@@ -195,8 +294,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -195,8 +294,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename> template<typename>
struct __is_member_function_pointer_helper struct __is_member_function_pointer_helper
: public false_type { }; : public false_type { };
_DEFINE_SPEC(2, __is_member_function_pointer_helper, _Tp _Cp::*,
is_function<_Tp>::value) template<typename _Tp, typename _Cp>
struct __is_member_function_pointer_helper<_Tp _Cp::*>
: public integral_constant<bool, is_function<_Tp>::value> { };
/// is_member_function_pointer /// is_member_function_pointer
template<typename _Tp> template<typename _Tp>
...@@ -227,27 +328,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -227,27 +328,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename> template<typename>
struct is_function struct is_function
: public false_type { }; : public false_type { };
template<typename _Res, typename... _ArgTypes> template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...)> struct is_function<_Res(_ArgTypes...)>
: public true_type { }; : public true_type { };
template<typename _Res, typename... _ArgTypes> template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......)> struct is_function<_Res(_ArgTypes......)>
: public true_type { }; : public true_type { };
template<typename _Res, typename... _ArgTypes> template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const> struct is_function<_Res(_ArgTypes...) const>
: public true_type { }; : public true_type { };
template<typename _Res, typename... _ArgTypes> template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const> struct is_function<_Res(_ArgTypes......) const>
: public true_type { }; : public true_type { };
template<typename _Res, typename... _ArgTypes> template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) volatile> struct is_function<_Res(_ArgTypes...) volatile>
: public true_type { }; : public true_type { };
template<typename _Res, typename... _ArgTypes> template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) volatile> struct is_function<_Res(_ArgTypes......) volatile>
: public true_type { }; : public true_type { };
template<typename _Res, typename... _ArgTypes> template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes...) const volatile> struct is_function<_Res(_ArgTypes...) const volatile>
: public true_type { }; : public true_type { };
template<typename _Res, typename... _ArgTypes> template<typename _Res, typename... _ArgTypes>
struct is_function<_Res(_ArgTypes......) const volatile> struct is_function<_Res(_ArgTypes......) const volatile>
: public true_type { }; : public true_type { };
...@@ -255,7 +364,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -255,7 +364,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename> template<typename>
struct __is_nullptr_t_helper struct __is_nullptr_t_helper
: public false_type { }; : public false_type { };
_DEFINE_SPEC(0, __is_nullptr_t_helper, std::nullptr_t, true)
template<>
struct __is_nullptr_t_helper<std::nullptr_t>
: public true_type { };
// __is_nullptr_t (extension). // __is_nullptr_t (extension).
template<typename _Tp> template<typename _Tp>
...@@ -264,42 +376,42 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -264,42 +376,42 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
remove_cv<_Tp>::type>::value)> remove_cv<_Tp>::type>::value)>
{ }; { };
// composite type traits. // composite type categories.
/// is_reference
template<typename _Tp>
struct is_reference
: public __or_<is_lvalue_reference<_Tp>,
is_rvalue_reference<_Tp>>::type
{ };
/// is_arithmetic /// is_arithmetic
template<typename _Tp> template<typename _Tp>
struct is_arithmetic struct is_arithmetic
: public integral_constant<bool, (is_integral<_Tp>::value : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
|| is_floating_point<_Tp>::value)>
{ }; { };
/// is_fundamental /// is_fundamental
template<typename _Tp> template<typename _Tp>
struct is_fundamental struct is_fundamental
: public integral_constant<bool, (is_arithmetic<_Tp>::value : public __or_<is_arithmetic<_Tp>, is_void<_Tp>>::type
|| is_void<_Tp>::value)>
{ }; { };
/// is_object /// is_object
template<typename _Tp> template<typename _Tp>
struct is_object struct is_object
: public integral_constant<bool, !(is_function<_Tp>::value : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
|| is_reference<_Tp>::value is_void<_Tp>>>::type
|| is_void<_Tp>::value)>
{ }; { };
/// is_member_pointer template<typename>
template<typename _Tp>
struct is_member_pointer; struct is_member_pointer;
/// is_scalar /// is_scalar
template<typename _Tp> template<typename _Tp>
struct is_scalar struct is_scalar
: public integral_constant<bool, (is_arithmetic<_Tp>::value : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
|| is_enum<_Tp>::value is_member_pointer<_Tp>, __is_nullptr_t<_Tp>>::type
|| is_pointer<_Tp>::value
|| is_member_pointer<_Tp>::value
|| __is_nullptr_t<_Tp>::value)>
{ }; { };
/// is_compound /// is_compound
...@@ -311,15 +423,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -311,15 +423,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp> template<typename _Tp>
struct __is_member_pointer_helper struct __is_member_pointer_helper
: public false_type { }; : public false_type { };
_DEFINE_SPEC(2, __is_member_pointer_helper, _Tp _Cp::*, true)
template<typename _Tp, typename _Cp>
struct __is_member_pointer_helper<_Tp _Cp::*>
: public true_type { };
template<typename _Tp> template<typename _Tp>
struct is_member_pointer struct is_member_pointer
: public integral_constant<bool, (__is_member_pointer_helper< : public integral_constant<bool, (__is_member_pointer_helper<
typename remove_cv<_Tp>::type>::value)> typename remove_cv<_Tp>::type>::value)>
{ }; { };
// type properties. // type properties.
/// is_const /// is_const
template<typename> template<typename>
struct is_const struct is_const
...@@ -338,6 +454,33 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -338,6 +454,33 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct is_volatile<_Tp volatile> struct is_volatile<_Tp volatile>
: public true_type { }; : public true_type { };
/// is_trivial
template<typename _Tp>
struct is_trivial
: public integral_constant<bool, __is_trivial(_Tp)>
{ };
/// is_trivially_copyable (still unimplemented)
/// is_standard_layout
template<typename _Tp>
struct is_standard_layout
: public integral_constant<bool, __is_standard_layout(_Tp)>
{ };
/// is_pod
// Could use is_standard_layout && is_trivial instead of the builtin.
template<typename _Tp>
struct is_pod
: public integral_constant<bool, __is_pod(_Tp)>
{ };
/// is_literal_type
template<typename _Tp>
struct is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)>
{ };
/// is_empty /// is_empty
template<typename _Tp> template<typename _Tp>
struct is_empty struct is_empty
...@@ -356,336 +499,362 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -356,336 +499,362 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: public integral_constant<bool, __is_abstract(_Tp)> : public integral_constant<bool, __is_abstract(_Tp)>
{ }; { };
/// has_virtual_destructor template<typename _Tp,
bool = is_integral<_Tp>::value,
bool = is_floating_point<_Tp>::value>
struct __is_signed_helper
: public false_type { };
template<typename _Tp> template<typename _Tp>
struct has_virtual_destructor struct __is_signed_helper<_Tp, false, true>
: public integral_constant<bool, __has_virtual_destructor(_Tp)> : public true_type { };
template<typename _Tp>
struct __is_signed_helper<_Tp, true, false>
: public integral_constant<bool, static_cast<bool>(_Tp(-1) < _Tp(0))>
{ }; { };
/// alignment_of /// is_signed
template<typename _Tp> template<typename _Tp>
struct alignment_of struct is_signed
: public integral_constant<std::size_t, __alignof__(_Tp)> { }; : public integral_constant<bool, __is_signed_helper<_Tp>::value>
{ };
/// rank
/// is_unsigned
template<typename _Tp>
struct is_unsigned
: public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type
{ };
// destructible and constructible type properties
template<typename> template<typename>
struct rank struct add_rvalue_reference;
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename _Tp> template<typename _Tp>
struct rank<_Tp[]> typename add_rvalue_reference<_Tp>::type declval() noexcept;
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
/// extent template<typename, unsigned = 0>
template<typename, unsigned _Uint = 0> struct extent;
struct extent
: public integral_constant<std::size_t, 0> { }; template<typename>
struct remove_all_extents;
template<typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint> template<typename _Tp>
: public integral_constant<std::size_t, struct __is_array_known_bounds
_Uint == 0 ? _Size : extent<_Tp, : public integral_constant<bool, (extent<_Tp>::value > 0)>
_Uint - 1>::value>
{ }; { };
template<typename _Tp, unsigned _Uint> template<typename _Tp>
struct extent<_Tp[], _Uint> struct __is_array_unknown_bounds
: public integral_constant<std::size_t, : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>::type
_Uint == 0 ? 0 : extent<_Tp,
_Uint - 1>::value>
{ }; { };
// relationships between types [4.6]. struct __do_is_destructible_impl_1
{
template<typename _Up>
struct __w { _Up __u; };
/// is_same template<typename _Tp, typename
template<typename, typename> = decltype(declval<__w<_Tp>&>().~__w<_Tp>())>
struct is_same static true_type __test(int);
: public false_type { };
template<typename>
static false_type __test(...);
};
template<typename _Tp> template<typename _Tp>
struct is_same<_Tp, _Tp> struct __is_destructible_impl_1
: public true_type { }; : public __do_is_destructible_impl_1
{
typedef decltype(__test<_Tp>(0)) type;
};
// const-volatile modifications [4.7.1]. struct __do_is_destructible_impl_2
{
template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
static true_type __test(int);
template<typename>
static false_type __test(...);
};
/// remove_const
template<typename _Tp> template<typename _Tp>
struct remove_const struct __is_destructible_impl_2
{ typedef _Tp type; }; : public __do_is_destructible_impl_2
{
typedef decltype(__test<_Tp>(0)) type;
};
template<typename _Tp,
bool = __or_<is_void<_Tp>,
__is_array_unknown_bounds<_Tp>>::value,
bool = __or_<is_reference<_Tp>, is_function<_Tp>>::value>
struct __is_destructible_safe;
template<typename _Tp> template<typename _Tp>
struct remove_const<_Tp const> struct __is_destructible_safe<_Tp, false, false>
{ typedef _Tp type; }; : public conditional<is_abstract<_Tp>::value,
__is_destructible_impl_2<_Tp>,
/// remove_volatile __is_destructible_impl_1<_Tp>>::type::type
{ };
template<typename _Tp> template<typename _Tp>
struct remove_volatile struct __is_destructible_safe<_Tp, true, false>
{ typedef _Tp type; }; : public false_type { };
template<typename _Tp> template<typename _Tp>
struct remove_volatile<_Tp volatile> struct __is_destructible_safe<_Tp, false, true>
{ typedef _Tp type; }; : public true_type { };
/// remove_cv /// is_destructible
template<typename _Tp> template<typename _Tp>
struct remove_cv struct is_destructible
: public integral_constant<bool, (__is_destructible_safe<_Tp>::value)>
{ };
struct __do_is_default_constructible_impl
{
template<typename _Tp, typename = decltype(_Tp())>
static true_type __test(int);
template<typename>
static false_type __test(...);
};
template<typename _Tp>
struct __is_default_constructible_impl
: public __do_is_default_constructible_impl
{ {
typedef typename typedef decltype(__test<_Tp>(0)) type;
remove_const<typename remove_volatile<_Tp>::type>::type type;
}; };
/// add_const
template<typename _Tp>
struct add_const
{ typedef _Tp const type; };
/// add_volatile
template<typename _Tp>
struct add_volatile
{ typedef _Tp volatile type; };
/// add_cv
template<typename _Tp>
struct add_cv
{
typedef typename
add_const<typename add_volatile<_Tp>::type>::type type;
};
// array modifications.
/// remove_extent
template<typename _Tp>
struct remove_extent
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_extent<_Tp[_Size]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_extent<_Tp[]>
{ typedef _Tp type; };
/// remove_all_extents
template<typename _Tp>
struct remove_all_extents
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp> template<typename _Tp>
struct remove_all_extents<_Tp[]> struct __is_default_constructible_atom
{ typedef typename remove_all_extents<_Tp>::type type; }; : public __and_<is_destructible<_Tp>,
__is_default_constructible_impl<_Tp>>::type::type
// pointer modifications. { };
template<typename _Tp, typename> template<typename _Tp, bool = is_array<_Tp>::value>
struct __remove_pointer_helper struct __is_default_constructible_safe;
{ typedef _Tp type; };
template<typename _Tp, typename _Up> // The following technique is a workaround for a gcc defect, which does
struct __remove_pointer_helper<_Tp, _Up*> // not sfinae away attempts to default-construct arrays of unknown bounds.
{ typedef _Up type; }; // Complete arrays can be default-constructed, if the element type is
// default-constructible, but arrays with unknown bounds are not:
/// remove_pointer
template<typename _Tp> template<typename _Tp>
struct remove_pointer struct __is_default_constructible_safe<_Tp, true>
: public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type> : public __and_<__is_array_known_bounds<_Tp>,
__is_default_constructible_atom<typename
remove_all_extents<_Tp>::type>>::type::type
{ }; { };
template<typename>
struct remove_reference;
/// add_pointer
template<typename _Tp> template<typename _Tp>
struct add_pointer struct __is_default_constructible_safe<_Tp, false>
{ typedef typename remove_reference<_Tp>::type* type; }; : public __is_default_constructible_atom<_Tp>::type
{ };
// Primary classification traits.
/// is_lvalue_reference
template<typename>
struct is_lvalue_reference
: public false_type { };
/// is_default_constructible
template<typename _Tp> template<typename _Tp>
struct is_lvalue_reference<_Tp&> struct is_default_constructible
: public true_type { }; : public integral_constant<bool, (__is_default_constructible_safe<
_Tp>::value)>
{ };
/// is_rvalue_reference struct __do_is_static_castable_impl
template<typename> {
struct is_rvalue_reference template<typename _From, typename _To, typename
: public false_type { }; = decltype(static_cast<_To>(declval<_From>()))>
static true_type __test(int);
template<typename _Tp> template<typename, typename>
struct is_rvalue_reference<_Tp&&> static false_type __test(...);
: public true_type { }; };
// Secondary classification traits. template<typename _From, typename _To>
struct __is_static_castable_impl
: public __do_is_static_castable_impl
{
typedef decltype(__test<_From, _To>(0)) type;
};
/// is_reference template<typename _From, typename _To>
template<typename _Tp> struct __is_static_castable_safe
struct is_reference : public __and_<__or_<is_void<_To>, is_destructible<_To>>,
: public integral_constant<bool, (is_lvalue_reference<_Tp>::value __is_static_castable_impl<_From, _To>>::type::type
|| is_rvalue_reference<_Tp>::value)>
{ }; { };
// Reference transformations. // __is_static_castable
template<typename _From, typename _To>
struct __is_static_castable
: public integral_constant<bool, (__is_static_castable_safe<
_From, _To>::value)>
{ };
/// remove_reference struct __do_is_direct_constructible_impl
template<typename _Tp> {
struct remove_reference template<typename _Tp, typename _Arg, typename
{ typedef _Tp type; }; = decltype(::new _Tp(declval<_Arg>()))>
static true_type __test(int);
template<typename _Tp> template<typename, typename>
struct remove_reference<_Tp&> static false_type __test(...);
{ typedef _Tp type; }; };
template<typename _Tp> template<typename _Tp, typename _Arg>
struct remove_reference<_Tp&&> struct __is_direct_constructible_impl
{ typedef _Tp type; }; : public __do_is_direct_constructible_impl
{
typedef decltype(__test<_Tp, _Arg>(0)) type;
};
template<typename _Tp, template<typename _Tp, typename _Arg>
bool = !is_reference<_Tp>::value && !is_void<_Tp>::value, struct __is_direct_constructible_new_safe
bool = is_rvalue_reference<_Tp>::value> : public __and_<is_destructible<_Tp>,
struct __add_lvalue_reference_helper __is_direct_constructible_impl<_Tp, _Arg>>::type::type
{ typedef _Tp type; }; { };
template<typename _Tp> template<typename, typename>
struct __add_lvalue_reference_helper<_Tp, true, false> struct is_same;
{ typedef _Tp& type; };
template<typename _Tp> template<typename, typename>
struct __add_lvalue_reference_helper<_Tp, false, true> struct is_base_of;
{ typedef typename remove_reference<_Tp>::type& type; };
/// add_lvalue_reference template<typename>
template<typename _Tp> struct remove_reference;
struct add_lvalue_reference
: public __add_lvalue_reference_helper<_Tp>
{ };
template<typename _Tp, template<typename _From, typename _To, bool
bool = !is_reference<_Tp>::value && !is_void<_Tp>::value> = is_reference<_From>::value>
struct __add_rvalue_reference_helper struct __is_base_to_derived_ref;
{ typedef _Tp type; };
template<typename _Tp> template<typename _From, typename _To>
struct __add_rvalue_reference_helper<_Tp, true> struct __is_base_to_derived_ref<_From, _To, true>
{ typedef _Tp&& type; }; {
typedef typename remove_cv<typename remove_reference<_From
>::type>::type __src_t;
typedef typename remove_cv<typename remove_reference<_To
>::type>::type __dst_t;
typedef typename __and_<
__not_<is_same<__src_t, __dst_t>>,
is_base_of<__src_t, __dst_t>
>::type type;
static constexpr bool value = type::value;
};
/// add_rvalue_reference template<typename _From, typename _To>
template<typename _Tp> struct __is_base_to_derived_ref<_From, _To, false>
struct add_rvalue_reference : public false_type
: public __add_rvalue_reference_helper<_Tp>
{ }; { };
// Scalar properties and transformations. template<typename _From, typename _To, bool
= __and_<is_lvalue_reference<_From>,
template<typename _Tp, is_rvalue_reference<_To>>::value>
bool = is_integral<_Tp>::value, struct __is_lvalue_to_rvalue_ref;
bool = is_floating_point<_Tp>::value>
struct __is_signed_helper
: public false_type { };
template<typename _Tp> template<typename _From, typename _To>
struct __is_signed_helper<_Tp, false, true> struct __is_lvalue_to_rvalue_ref<_From, _To, true>
: public true_type { }; {
typedef typename remove_cv<typename remove_reference<
_From>::type>::type __src_t;
typedef typename remove_cv<typename remove_reference<
_To>::type>::type __dst_t;
typedef typename __or_<
is_same<__src_t, __dst_t>,
is_base_of<__dst_t, __src_t>
>::type type;
static constexpr bool value = type::value;
};
template<typename _Tp> template<typename _From, typename _To>
struct __is_signed_helper<_Tp, true, false> struct __is_lvalue_to_rvalue_ref<_From, _To, false>
: public integral_constant<bool, static_cast<bool>(_Tp(-1) < _Tp(0))> : public false_type
{ }; { };
/// is_signed // Here we handle direct-initialization to a reference type
template<typename _Tp> // as equivalent to a static_cast modulo overshooting conversions.
struct is_signed // These are restricted to the following conversion:
: public integral_constant<bool, __is_signed_helper<_Tp>::value> // a) A base class to a derived class reference
{ }; // b) An lvalue-reference to an rvalue-reference
/// is_unsigned template<typename _Tp, typename _Arg>
template<typename _Tp> struct __is_direct_constructible_ref_cast
struct is_unsigned : public __and_<__is_static_castable<_Arg, _Tp>,
: public integral_constant<bool, (is_arithmetic<_Tp>::value __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
&& !is_signed<_Tp>::value)> __is_lvalue_to_rvalue_ref<_Arg, _Tp>
>>>::type::type
{ }; { };
// Member introspection. // Direct-initialization is tricky, because of functional
// casts: For a conversion to reference we fall back to a
/// is_trivial // static_cast modulo extra cases, otherwise we use a
template<typename _Tp> // new expression:
struct is_trivial
: public integral_constant<bool, __is_trivial(_Tp)>
{ };
/// is_standard_layout template<typename _Tp, typename _Arg>
template<typename _Tp> struct __is_direct_constructible_new
struct is_standard_layout : public conditional<is_reference<_Tp>::value,
: public integral_constant<bool, __is_standard_layout(_Tp)> __is_direct_constructible_ref_cast<_Tp, _Arg>,
__is_direct_constructible_new_safe<_Tp, _Arg>
>::type
{ }; { };
/// is_pod template<typename _Tp, typename _Arg>
// Could use is_standard_layout && is_trivial instead of the builtin. struct __is_direct_constructible
template<typename _Tp> : public integral_constant<bool, (__is_direct_constructible_new<
struct is_pod _Tp, _Arg>::type::value)>
: public integral_constant<bool, __is_pod(_Tp)>
{ }; { };
/// is_literal_type struct __do_is_nary_constructible_impl
template<typename _Tp> {
struct is_literal_type template<typename _Tp, typename... _Args, typename
: public integral_constant<bool, __is_literal_type(_Tp)> = decltype(_Tp(declval<_Args>()...))>
{ }; static true_type __test(int);
template<typename _Tp> template<typename, typename...>
typename add_rvalue_reference<_Tp>::type declval() noexcept; static false_type __test(...);
};
template<typename _Tp, typename... _Args> template<typename _Tp, typename... _Args>
class __is_constructible_helper struct __is_nary_constructible_impl
: public __sfinae_types : public __do_is_nary_constructible_impl
{ {
template<typename _Tp1, typename... _Args1> typedef decltype(__test<_Tp, _Args...>(0)) type;
static decltype(_Tp1(declval<_Args1>()...), __one()) __test(int);
template<typename, typename...>
static __two __test(...);
public:
static const bool __value = sizeof(__test<_Tp, _Args...>(0)) == 1;
}; };
template<typename _Tp, typename _Arg> template<typename _Tp, typename... _Args>
class __is_constructible_helper<_Tp, _Arg> struct __is_nary_constructible
: public __sfinae_types : public __and_<is_destructible<_Tp>,
__is_nary_constructible_impl<_Tp, _Args...>
>::type::type
{ {
template<typename _Tp1, typename _Arg1> static_assert(sizeof...(_Args) > 1,
static decltype(static_cast<_Tp1>(declval<_Arg1>()), __one()) "Only useful for > 1 arguments");
__test(int); };
template<typename, typename> template<typename _Tp, typename... _Args>
static __two __test(...); struct __is_constructible_impl
: public __is_nary_constructible<_Tp, _Args...>
{ };
public: template<typename _Tp, typename _Arg>
static const bool __value = sizeof(__test<_Tp, _Arg>(0)) == 1; struct __is_constructible_impl<_Tp, _Arg>
}; : public __is_direct_constructible<_Tp, _Arg>
{ };
template<typename _Tp>
struct __is_constructible_impl<_Tp>
: public is_default_constructible<_Tp>
{ };
/// is_constructible /// is_constructible
// XXX FIXME
// The C++0x specifications require front-end support, see N2255.
template<typename _Tp, typename... _Args> template<typename _Tp, typename... _Args>
struct is_constructible struct is_constructible
: public integral_constant<bool, : public integral_constant<bool, (__is_constructible_impl<_Tp,
__is_constructible_helper<_Tp, _Args...>::value)>
_Args...>::__value>
{ }; { };
template<bool, typename _Tp, typename... _Args> template<bool, typename _Tp, typename... _Args>
struct __is_nt_constructible_helper struct __is_nt_constructible_helper
{ static const bool __value = false; }; { static const bool __value = false; };
...@@ -750,7 +919,63 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -750,7 +919,63 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: public integral_constant<bool, __has_nothrow_assign(_Tp)> : public integral_constant<bool, __has_nothrow_assign(_Tp)>
{ }; { };
// Relationships between types. /// has_virtual_destructor
template<typename _Tp>
struct has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)>
{ };
// type property queries.
/// alignment_of
template<typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, __alignof__(_Tp)> { };
/// rank
template<typename>
struct rank
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
template<typename _Tp>
struct rank<_Tp[]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
/// extent
template<typename, unsigned _Uint>
struct extent
: public integral_constant<std::size_t, 0> { };
template<typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? _Size : extent<_Tp,
_Uint - 1>::value>
{ };
template<typename _Tp, unsigned _Uint>
struct extent<_Tp[], _Uint>
: public integral_constant<std::size_t,
_Uint == 0 ? 0 : extent<_Tp,
_Uint - 1>::value>
{ };
// type relations.
/// is_same
template<typename, typename>
struct is_same
: public false_type { };
template<typename _Tp>
struct is_same<_Tp, _Tp>
: public true_type { };
/// is_base_of /// is_base_of
template<typename _Base, typename _Derived> template<typename _Base, typename _Derived>
...@@ -759,8 +984,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -759,8 +984,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ }; { };
template<typename _From, typename _To, template<typename _From, typename _To,
bool = (is_void<_From>::value || is_function<_To>::value bool = __or_<is_void<_From>, is_function<_To>,
|| is_array<_To>::value)> is_array<_To>>::value>
struct __is_convertible_helper struct __is_convertible_helper
{ static const bool __value = is_void<_To>::value; }; { static const bool __value = is_void<_To>::value; };
...@@ -783,8 +1008,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -783,8 +1008,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}; };
/// is_convertible /// is_convertible
// XXX FIXME
// The C++0x specifications require front-end support, see N2255.
template<typename _From, typename _To> template<typename _From, typename _To>
struct is_convertible struct is_convertible
: public integral_constant<bool, : public integral_constant<bool,
...@@ -797,124 +1020,109 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -797,124 +1020,109 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: public is_constructible<_To, _From> : public is_constructible<_To, _From>
{ }; { };
template<std::size_t _Len>
struct __aligned_storage_msa
{
union __type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__)) { } __align;
};
};
/** // const-volatile modifications.
* @brief Alignment type.
*
* The value of _Align is a default-alignment which shall be the
* most stringent alignment requirement for any C++ object type
* whose size is no greater than _Len (3.9). The member typedef
* type shall be a POD type suitable for use as uninitialized
* storage for any object whose size is at most _Len and whose
* alignment is a divisor of _Align.
*/
template<std::size_t _Len, std::size_t _Align =
__alignof__(typename __aligned_storage_msa<_Len>::__type)>
struct aligned_storage
{
union type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__((_Align)))) { } __align;
};
};
// Define a nested type if some predicate holds.
// Primary template.
/// enable_if
template<bool, typename _Tp = void>
struct enable_if
{ };
// Partial specialization for true. /// remove_const
template<typename _Tp> template<typename _Tp>
struct enable_if<true, _Tp> struct remove_const
{ typedef _Tp type; }; { typedef _Tp type; };
// A conditional expression, but for types. If true, first, if false, second.
// Primary template.
/// conditional
template<bool _Cond, typename _Iftrue, typename _Iffalse>
struct conditional
{ typedef _Iftrue type; };
// Partial specialization for false.
template<typename _Iftrue, typename _Iffalse>
struct conditional<false, _Iftrue, _Iffalse>
{ typedef _Iffalse type; };
template<typename _Tp>
struct remove_const<_Tp const>
{ typedef _Tp type; };
/// remove_volatile
template<typename _Tp>
struct remove_volatile
{ typedef _Tp type; };
// Decay trait for arrays and functions, used for perfect forwarding template<typename _Tp>
// in make_pair, make_tuple, etc. struct remove_volatile<_Tp volatile>
template<typename _Up, { typedef _Tp type; };
bool _IsArray = is_array<_Up>::value,
bool _IsFunction = is_function<_Up>::value> /// remove_cv
struct __decay_selector; template<typename _Tp>
struct remove_cv
{
typedef typename
remove_const<typename remove_volatile<_Tp>::type>::type type;
};
/// add_const
template<typename _Tp>
struct add_const
{ typedef _Tp const type; };
/// add_volatile
template<typename _Tp>
struct add_volatile
{ typedef _Tp volatile type; };
/// add_cv
template<typename _Tp>
struct add_cv
{
typedef typename
add_const<typename add_volatile<_Tp>::type>::type type;
};
// NB: DR 705.
template<typename _Up>
struct __decay_selector<_Up, false, false>
{ typedef typename remove_cv<_Up>::type __type; };
template<typename _Up> // Reference transformations.
struct __decay_selector<_Up, true, false>
{ typedef typename remove_extent<_Up>::type* __type; };
template<typename _Up> /// remove_reference
struct __decay_selector<_Up, false, true> template<typename _Tp>
{ typedef typename add_pointer<_Up>::type __type; }; struct remove_reference
{ typedef _Tp type; };
/// decay template<typename _Tp>
template<typename _Tp> struct remove_reference<_Tp&>
class decay { typedef _Tp type; };
{
typedef typename remove_reference<_Tp>::type __remove_type;
public: template<typename _Tp>
typedef typename __decay_selector<__remove_type>::__type type; struct remove_reference<_Tp&&>
}; { typedef _Tp type; };
template<typename _Tp,
bool = __and_<__not_<is_reference<_Tp>>,
__not_<is_void<_Tp>>>::value,
bool = is_rvalue_reference<_Tp>::value>
struct __add_lvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp> template<typename _Tp>
class reference_wrapper; struct __add_lvalue_reference_helper<_Tp, true, false>
{ typedef _Tp& type; };
// Helper which adds a reference to a type when given a reference_wrapper
template<typename _Tp> template<typename _Tp>
struct __strip_reference_wrapper struct __add_lvalue_reference_helper<_Tp, false, true>
{ { typedef typename remove_reference<_Tp>::type& type; };
typedef _Tp __type;
};
/// add_lvalue_reference
template<typename _Tp> template<typename _Tp>
struct __strip_reference_wrapper<reference_wrapper<_Tp> > struct add_lvalue_reference
{ : public __add_lvalue_reference_helper<_Tp>
typedef _Tp& __type; { };
};
template<typename _Tp,
bool = __and_<__not_<is_reference<_Tp>>,
__not_<is_void<_Tp>>>::value>
struct __add_rvalue_reference_helper
{ typedef _Tp type; };
template<typename _Tp> template<typename _Tp>
struct __strip_reference_wrapper<const reference_wrapper<_Tp> > struct __add_rvalue_reference_helper<_Tp, true>
{ { typedef _Tp&& type; };
typedef _Tp& __type;
};
/// add_rvalue_reference
template<typename _Tp> template<typename _Tp>
struct __decay_and_strip struct add_rvalue_reference
{ : public __add_rvalue_reference_helper<_Tp>
typedef typename __strip_reference_wrapper< { };
typename decay<_Tp>::type>::__type __type;
};
// sign modifications.
// Utility for constructing identically cv-qualified types. // Utility for constructing identically cv-qualified types.
template<typename _Unqualified, bool _IsConst, bool _IsVol> template<typename _Unqualified, bool _IsConst, bool _IsVol>
struct __cv_selector; struct __cv_selector;
...@@ -946,7 +1154,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -946,7 +1154,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef typename __match::__type __type; typedef typename __match::__type __type;
}; };
// Utility for finding the unsigned versions of signed integral types. // Utility for finding the unsigned versions of signed integral types.
template<typename _Tp> template<typename _Tp>
struct __make_unsigned struct __make_unsigned
...@@ -976,7 +1183,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -976,7 +1183,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct __make_unsigned<long long> struct __make_unsigned<long long>
{ typedef unsigned long long __type; }; { typedef unsigned long long __type; };
// Select between integral and enum: not possible to be both. // Select between integral and enum: not possible to be both.
template<typename _Tp, template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value, bool _IsInt = is_integral<_Tp>::value,
...@@ -1053,7 +1259,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -1053,7 +1259,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct __make_signed<unsigned long long> struct __make_signed<unsigned long long>
{ typedef signed long long __type; }; { typedef signed long long __type; };
// Select between integral and enum: not possible to be both. // Select between integral and enum: not possible to be both.
template<typename _Tp, template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value, bool _IsInt = is_integral<_Tp>::value,
...@@ -1100,6 +1305,176 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -1100,6 +1305,176 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<> template<>
struct make_signed<bool>; struct make_signed<bool>;
// array modifications.
/// remove_extent
template<typename _Tp>
struct remove_extent
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_extent<_Tp[_Size]>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_extent<_Tp[]>
{ typedef _Tp type; };
/// remove_all_extents
template<typename _Tp>
struct remove_all_extents
{ typedef _Tp type; };
template<typename _Tp, std::size_t _Size>
struct remove_all_extents<_Tp[_Size]>
{ typedef typename remove_all_extents<_Tp>::type type; };
template<typename _Tp>
struct remove_all_extents<_Tp[]>
{ typedef typename remove_all_extents<_Tp>::type type; };
// pointer modifications.
template<typename _Tp, typename>
struct __remove_pointer_helper
{ typedef _Tp type; };
template<typename _Tp, typename _Up>
struct __remove_pointer_helper<_Tp, _Up*>
{ typedef _Up type; };
/// remove_pointer
template<typename _Tp>
struct remove_pointer
: public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
{ };
/// add_pointer
template<typename _Tp>
struct add_pointer
{ typedef typename remove_reference<_Tp>::type* type; };
template<std::size_t _Len>
struct __aligned_storage_msa
{
union __type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__)) { } __align;
};
};
/**
* @brief Alignment type.
*
* The value of _Align is a default-alignment which shall be the
* most stringent alignment requirement for any C++ object type
* whose size is no greater than _Len (3.9). The member typedef
* type shall be a POD type suitable for use as uninitialized
* storage for any object whose size is at most _Len and whose
* alignment is a divisor of _Align.
*/
template<std::size_t _Len, std::size_t _Align =
__alignof__(typename __aligned_storage_msa<_Len>::__type)>
struct aligned_storage
{
union type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__((_Align)))) { } __align;
};
};
// Decay trait for arrays and functions, used for perfect forwarding
// in make_pair, make_tuple, etc.
template<typename _Up,
bool _IsArray = is_array<_Up>::value,
bool _IsFunction = is_function<_Up>::value>
struct __decay_selector;
// NB: DR 705.
template<typename _Up>
struct __decay_selector<_Up, false, false>
{ typedef typename remove_cv<_Up>::type __type; };
template<typename _Up>
struct __decay_selector<_Up, true, false>
{ typedef typename remove_extent<_Up>::type* __type; };
template<typename _Up>
struct __decay_selector<_Up, false, true>
{ typedef typename add_pointer<_Up>::type __type; };
/// decay
template<typename _Tp>
class decay
{
typedef typename remove_reference<_Tp>::type __remove_type;
public:
typedef typename __decay_selector<__remove_type>::__type type;
};
template<typename _Tp>
class reference_wrapper;
// Helper which adds a reference to a type when given a reference_wrapper
template<typename _Tp>
struct __strip_reference_wrapper
{
typedef _Tp __type;
};
template<typename _Tp>
struct __strip_reference_wrapper<reference_wrapper<_Tp> >
{
typedef _Tp& __type;
};
template<typename _Tp>
struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
{
typedef _Tp& __type;
};
template<typename _Tp>
struct __decay_and_strip
{
typedef typename __strip_reference_wrapper<
typename decay<_Tp>::type>::__type __type;
};
// Define a nested type if some predicate holds.
// Primary template.
/// enable_if
template<bool, typename _Tp = void>
struct enable_if
{ };
// Partial specialization for true.
template<typename _Tp>
struct enable_if<true, _Tp>
{ typedef _Tp type; };
// A conditional expression, but for types. If true, first, if false, second.
// Primary template.
/// conditional
template<bool _Cond, typename _Iftrue, typename _Iffalse>
struct conditional
{ typedef _Iftrue type; };
// Partial specialization for false.
template<typename _Iftrue, typename _Iffalse>
struct conditional<false, _Iftrue, _Iffalse>
{ typedef _Iffalse type; };
/// common_type /// common_type
template<typename... _Tp> template<typename... _Tp>
struct common_type; struct common_type;
...@@ -1119,6 +1494,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -1119,6 +1494,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type; common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
}; };
/// underlying_type (still unimplemented)
/// result_of
template<typename _Signature>
class result_of;
template<typename _Functor, typename... _ArgTypes>
struct result_of<_Functor(_ArgTypes...)>
{
typedef
decltype( std::declval<_Functor>()(std::declval<_ArgTypes>()...) )
type;
};
/// declval /// declval
template<typename _Tp> template<typename _Tp>
struct __declval_protector struct __declval_protector
...@@ -1136,18 +1525,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -1136,18 +1525,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __declval_protector<_Tp>::__delegate(); return __declval_protector<_Tp>::__delegate();
} }
/// result_of
template<typename _Signature>
class result_of;
template<typename _Functor, typename... _ArgTypes>
struct result_of<_Functor(_ArgTypes...)>
{
typedef
decltype( std::declval<_Functor>()(std::declval<_ArgTypes>()...) )
type;
};
/** /**
* Use SFINAE to determine if the type _Tp has a publicly-accessible * Use SFINAE to determine if the type _Tp has a publicly-accessible
* member type _NTYPE. * member type _NTYPE.
...@@ -1177,11 +1554,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION ...@@ -1177,11 +1554,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
<typename remove_cv<_Tp>::type>::value> \ <typename remove_cv<_Tp>::type>::value> \
{ }; { };
#undef _DEFINE_SPEC_0_HELPER
#undef _DEFINE_SPEC_1_HELPER
#undef _DEFINE_SPEC_2_HELPER
#undef _DEFINE_SPEC
// @} group metaprogramming // @} group metaprogramming
_GLIBCXX_END_NAMESPACE_VERSION _GLIBCXX_END_NAMESPACE_VERSION
} // namespace } // namespace
......
libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc
...@@ -19,7 +19,7 @@ ...@@ -19,7 +19,7 @@
// with this library; see the file COPYING3. If not see // with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>. // <http://www.gnu.org/licenses/>.
// { dg-error "static assertion failed" "" { target *-*-* } 1134 } // { dg-error "static assertion failed" "" { target *-*-* } 1523 }
#include <utility> #include <utility>
......
libstdc++-v3/testsuite/20_util/is_compound/requirements/explicit_instantiation.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
namespace std
{
typedef short test_type;
template struct is_compound<test_type>;
}
libstdc++-v3/testsuite/20_util/is_compound/requirements/typedefs.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
void test01()
{
// Check for required typedefs
typedef std::is_compound<int> test_type;
typedef test_type::value_type value_type;
typedef test_type::type type;
typedef test_type::type::value_type type_value_type;
typedef test_type::type::type type_type;
}
libstdc++-v3/testsuite/20_util/is_compound/value.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
void test01()
{
bool test __attribute__((unused)) = true;
using std::is_compound;
using namespace __gnu_test;
VERIFY( (test_category<is_compound, void>(false)) );
VERIFY( (test_category<is_compound, char>(false)) );
VERIFY( (test_category<is_compound, signed char>(false)) );
VERIFY( (test_category<is_compound, unsigned char>(false)) );
#ifdef _GLIBCXX_USE_WCHAR_T
VERIFY( (test_category<is_compound, wchar_t>(false)) );
#endif
VERIFY( (test_category<is_compound, short>(false)) );
VERIFY( (test_category<is_compound, unsigned short>(false)) );
VERIFY( (test_category<is_compound, int>(false)) );
VERIFY( (test_category<is_compound, unsigned int>(false)) );
VERIFY( (test_category<is_compound, long>(false)) );
VERIFY( (test_category<is_compound, unsigned long>(false)) );
VERIFY( (test_category<is_compound, long long>(false)) );
VERIFY( (test_category<is_compound, unsigned long long>(false)) );
VERIFY( (test_category<is_compound, float>(false)) );
VERIFY( (test_category<is_compound, double>(false)) );
VERIFY( (test_category<is_compound, long double>(false)) );
// Sanity check.
VERIFY( (test_category<is_compound, ClassType>(true)) );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/20_util/is_constructible/value-2.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <initializer_list>
#include <testsuite_tr1.h>
using namespace __gnu_test::construct_destruct;
static_assert(std::is_constructible<int, int>::value, "Error");
static_assert(std::is_constructible<std::nullptr_t, std::nullptr_t>::value,
"Error");
static_assert(std::is_constructible<E, E>::value, "Error");
static_assert(std::is_constructible<SE, SE>::value, "Error");
static_assert(std::is_constructible<OpE, OpE>::value, "Error");
static_assert(std::is_constructible<OpSE, OpSE>::value, "Error");
static_assert(std::is_constructible<Empty, Empty>::value, "Error");
static_assert(std::is_constructible<B, B>::value, "Error");
static_assert(std::is_constructible<U, U>::value, "Error");
static_assert(std::is_constructible<int B::*, int B::*>::value, "Error");
static_assert(std::is_constructible<Ellipsis, Ellipsis>::value, "Error");
static_assert(std::is_constructible<int*, int*>::value, "Error");
static_assert(std::is_constructible<void*, void*>::value, "Error");
static_assert(std::is_constructible<Any, Any>::value, "Error");
static_assert(std::is_constructible<nAny, nAny>::value, "Error");
static_assert(std::is_constructible<std::initializer_list<int>,
std::initializer_list<int>>::value, "Error");
static_assert(std::is_constructible<DelDef, DelDef>::value, "Error");
static_assert(!std::is_constructible<void, void>::value, "Error");
static_assert(!std::is_constructible<Abstract, Abstract>::value, "Error");
static_assert(!std::is_constructible<int[], int[]>::value, "Error");
static_assert(!std::is_constructible<int[1], int[1]>::value, "Error");
static_assert(!std::is_constructible<DelCopy, const DelCopy&>::value, "Error");
static_assert(!std::is_constructible<DelCopy, DelCopy&&>::value, "Error");
static_assert(!std::is_constructible<DelCopy, DelCopy>::value, "Error");
static_assert(!std::is_constructible<DelDtor, void>::value, "Error");
static_assert(!std::is_constructible<DelDtor, int>::value, "Error");
static_assert(!std::is_constructible<DelDtor, DelDtor>::value, "Error");
static_assert(!std::is_constructible<DelDtor, DelDtor&&>::value, "Error");
static_assert(!std::is_constructible<DelDtor, const DelDtor&>::value, "Error");
static_assert(std::is_constructible<DelEllipsis, const DelEllipsis&>::value,
"Error");
static_assert(std::is_constructible<DelEllipsis, DelEllipsis&&>::value,
"Error");
static_assert(std::is_constructible<DelEllipsis, DelEllipsis>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, void>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, std::nullptr_t>::value,
"Error");
static_assert(!std::is_constructible<DelEllipsis, B>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, Empty>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, E>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, SE>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, OpE>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, OpSE>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, void()>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, void() const>::value,
"Error");
static_assert(!std::is_constructible<DelEllipsis, int[1]>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, int[]>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, int*>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, void*>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, int B::*>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, int D::*>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, Abstract>::value, "Error");
static_assert(!std::is_constructible<int, DelImplicitTo<int>>::value, "Error");
static_assert(!std::is_constructible<std::nullptr_t,
DelImplicitTo<std::nullptr_t>>::value, "Error");
static_assert(!std::is_constructible<int&,
DelImplicitTo<const int&>>::value, "Error");
static_assert(!std::is_constructible<int, void>::value, "Error");
static_assert(!std::is_constructible<void, int>::value, "Error");
static_assert(std::is_constructible<void*, int*>::value, "Error");
static_assert(!std::is_constructible<int*, void*>::value, "Error");
static_assert(std::is_constructible<int*, std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<std::nullptr_t, int*>::value, "Error");
static_assert(!std::is_constructible<Empty, E>::value, "Error");
static_assert(!std::is_constructible<Empty, SE>::value, "Error");
static_assert(!std::is_constructible<Empty, OpE>::value, "Error");
static_assert(!std::is_constructible<Empty, OpSE>::value, "Error");
static_assert(!std::is_constructible<Empty, void>::value, "Error");
static_assert(!std::is_constructible<Empty, void*>::value, "Error");
static_assert(!std::is_constructible<Empty, std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<Empty, int[]>::value, "Error");
static_assert(!std::is_constructible<Empty, int[3]>::value, "Error");
static_assert(!std::is_constructible<Empty, int>::value, "Error");
static_assert(!std::is_constructible<Abstract, int>::value, "Error");
static_assert(!std::is_constructible<Abstract, std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<std::nullptr_t, Abstract>::value, "Error");
static_assert(!std::is_constructible<Abstract, int[]>::value, "Error");
static_assert(std::is_constructible<B, D>::value, "Error");
static_assert(!std::is_constructible<D, B>::value, "Error");
static_assert(!std::is_constructible<int[], int[1]>::value, "Error");
static_assert(!std::is_constructible<int[1], int[]>::value, "Error");
static_assert(!std::is_constructible<int[], Empty>::value, "Error");
static_assert(!std::is_constructible<int[], std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<int[1], Abstract>::value, "Error");
static_assert(std::is_constructible<const int*, int*>::value, "Error");
static_assert(std::is_constructible<const void*, void*>::value, "Error");
static_assert(std::is_constructible<const void*, int*>::value, "Error");
static_assert(!std::is_constructible<int*, const void*>::value, "Error");
static_assert(std::is_constructible<int, E>::value, "Error");
static_assert(!std::is_constructible<E, int>::value, "Error");
static_assert(!std::is_constructible<E, E2>::value, "Error");
static_assert(std::is_constructible<E, E>::value, "Error");
static_assert(std::is_constructible<bool, E>::value, "Error");
static_assert(!std::is_constructible<E, bool>::value, "Error");
static_assert(std::is_constructible<double, E>::value, "Error");
static_assert(!std::is_constructible<E, double>::value, "Error");
static_assert(!std::is_constructible<std::nullptr_t, E>::value, "Error");
static_assert(!std::is_constructible<E, std::nullptr_t>::value, "Error");
static_assert(std::is_constructible<int, OpE>::value, "Error");
static_assert(!std::is_constructible<OpE, int>::value, "Error");
static_assert(!std::is_constructible<OpE, E2>::value, "Error");
static_assert(std::is_constructible<OpE, OpE>::value, "Error");
static_assert(std::is_constructible<bool, OpE>::value, "Error");
static_assert(!std::is_constructible<OpE, bool>::value, "Error");
static_assert(std::is_constructible<double, OpE>::value, "Error");
static_assert(!std::is_constructible<OpE, double>::value, "Error");
static_assert(!std::is_constructible<std::nullptr_t, OpE>::value, "Error");
static_assert(!std::is_constructible<OpE, std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<int, SE>::value, "Error");
static_assert(!std::is_constructible<SE, int>::value, "Error");
static_assert(!std::is_constructible<E, SE>::value, "Error");
static_assert(!std::is_constructible<SE, SE2>::value, "Error");
static_assert(std::is_constructible<SE, SE>::value, "Error");
static_assert(!std::is_constructible<bool, SE>::value, "Error");
static_assert(!std::is_constructible<SE, bool>::value, "Error");
static_assert(!std::is_constructible<double, SE>::value, "Error");
static_assert(!std::is_constructible<SE, double>::value, "Error");
static_assert(!std::is_constructible<std::nullptr_t, SE>::value, "Error");
static_assert(!std::is_constructible<SE, std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<int, OpSE>::value, "Error");
static_assert(!std::is_constructible<OpSE, int>::value, "Error");
static_assert(!std::is_constructible<OpE, OpSE>::value, "Error");
static_assert(!std::is_constructible<OpSE, SE2>::value, "Error");
static_assert(std::is_constructible<OpSE, OpSE>::value, "Error");
static_assert(!std::is_constructible<bool, OpSE>::value, "Error");
static_assert(!std::is_constructible<OpSE, bool>::value, "Error");
static_assert(!std::is_constructible<double, OpSE>::value, "Error");
static_assert(!std::is_constructible<OpSE, double>::value, "Error");
static_assert(!std::is_constructible<std::nullptr_t, OpSE>::value, "Error");
static_assert(!std::is_constructible<OpSE, std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<D*, B*>::value, "Error");
static_assert(!std::is_constructible<const volatile D*, B*>::value, "Error");
static_assert(!std::is_constructible<D*, const volatile B*>::value, "Error");
static_assert(!std::is_constructible<D*, B* const>::value, "Error");
static_assert(!std::is_constructible<const volatile D*, B* const>::value,
"Error");
static_assert(!std::is_constructible<D*, const volatile B* const>::value,
"Error");
static_assert(!std::is_constructible<D*, B*&>::value, "Error");
static_assert(!std::is_constructible<const volatile D*, B*&>::value, "Error");
static_assert(!std::is_constructible<D*, const volatile B*&>::value, "Error");
static_assert(!std::is_constructible<int B::*, int D::*>::value, "Error");
static_assert(!std::is_constructible<const volatile int B::*, int D::*>::value,
"Error");
static_assert(!std::is_constructible<int B::*, const volatile int D::*>::value,
"Error");
static_assert(!std::is_constructible<int B::*, int D::* const>::value, "Error");
static_assert(!std::is_constructible<const volatile int B::*,
int D::* const>::value, "Error");
static_assert(!std::is_constructible<int B::*,
const volatile int D::* const>::value, "Error");
static_assert(!std::is_constructible<int B::*, int D::*&>::value, "Error");
static_assert(!std::is_constructible<const volatile int B::*,
int D::*&>::value, "Error");
static_assert(!std::is_constructible<int B::*,
const volatile int D::*&>::value, "Error");
static_assert(!std::is_constructible<int B::*, int D::* const &>::value,
"Error");
static_assert(!std::is_constructible<const volatile int B::*,
int D::* const &>::value, "Error");
static_assert(!std::is_constructible<int B::*,
const volatile int D::* const &>::value, "Error");
static_assert(!std::is_constructible<int&&, int&>::value, "Error");
static_assert(!std::is_constructible<const int&&, int&>::value, "Error");
static_assert(std::is_constructible<B&, D&>::value, "Error");
static_assert(std::is_constructible<B&&, D&&>::value, "Error");
static_assert(std::is_constructible<const B&, D&>::value, "Error");
static_assert(std::is_constructible<const B&&, D&&>::value, "Error");
static_assert(!std::is_constructible<B&, const D&>::value, "Error");
static_assert(!std::is_constructible<B&&, const D&&>::value, "Error");
static_assert(!std::is_constructible<D&, B&>::value, "Error");
static_assert(!std::is_constructible<D&&, B&&>::value, "Error");
static_assert(!std::is_constructible<D&, const B&>::value, "Error");
static_assert(!std::is_constructible<D&&, const B&&>::value, "Error");
static_assert(!std::is_constructible<const D&, B&>::value, "Error");
static_assert(!std::is_constructible<const D&&, B&&>::value, "Error");
static_assert(!std::is_constructible<B&&, B&>::value, "Error");
static_assert(!std::is_constructible<B&&, D&>::value, "Error");
static_assert(std::is_constructible<B&&, ImplicitTo<D&&>>::value, "Error");
static_assert(std::is_constructible<B&&, ImplicitTo<D&&>&>::value, "Error");
static_assert(std::is_constructible<int&&, double&>::value, "Error");
static_assert(std::is_constructible<const int&,
ImplicitTo<int&>&>::value, "Error");
static_assert(std::is_constructible<const int&,
ImplicitTo<int&>>::value, "Error");
static_assert(std::is_constructible<const int&,
ExplicitTo<int&>&>::value, "Error");
static_assert(std::is_constructible<const int&,
ExplicitTo<int&>>::value, "Error");
static_assert(std::is_constructible<B&&, ExplicitTo<D&&>>::value, "Error");
static_assert(std::is_constructible<B&&, ExplicitTo<D&&>&>::value, "Error");
static_assert(!std::is_constructible<B&, B&&>::value, "Error");
static_assert(!std::is_constructible<D&, B&&>::value, "Error");
static_assert(!std::is_constructible<B&, D&&>::value, "Error");
static_assert(std::is_constructible<void(&)(), void(&)()>::value, "Error");
static_assert(std::is_constructible<void(&&)(), void(&&)()>::value, "Error");
static_assert(std::is_constructible<void(&&)(), void()>::value, "Error");
static_assert(!std::is_constructible<void>::value, "Error" );
static_assert(!std::is_constructible<void, int>::value, "Error" );
static_assert(!std::is_constructible<void, int, double>::value, "Error" );
static_assert(!std::is_constructible<int&>::value, "Error" );
static_assert(!std::is_constructible<const int&>::value, "Error" );
static_assert(!std::is_constructible<int&, int, int>::value, "Error" );
static_assert(!std::is_constructible<const int&, int, int>::value, "Error" );
static_assert(std::is_constructible<void(&)(), void()>::value, "Error");
static_assert(std::is_constructible<void(&)(), void(&&)()>::value, "Error");
static_assert(std::is_constructible<int&, int&>::value, "Error");
static_assert(!std::is_constructible<int&, const int&>::value, "Error");
static_assert(!std::is_constructible<int&, int>::value, "Error");
static_assert(!std::is_constructible<int&, int&&>::value, "Error");
static_assert(!std::is_constructible<int&, const int&&>::value, "Error");
static_assert(std::is_constructible<const int&, int&>::value, "Error");
static_assert(std::is_constructible<const int&, int>::value, "Error");
static_assert(std::is_constructible<const int&, const int>::value, "Error");
static_assert(std::is_constructible<const int&, int&&>::value, "Error");
static_assert(std::is_constructible<const int&, const int&&>::value, "Error");
static_assert(std::is_constructible<volatile int&, int&>::value, "Error");
static_assert(!std::is_constructible<volatile int&, const int&>::value,
"Error");
static_assert(!std::is_constructible<volatile int&, int>::value, "Error");
static_assert(!std::is_constructible<volatile int&, int&&>::value, "Error");
static_assert(!std::is_constructible<volatile int&, const int&&>::value,
"Error");
static_assert(std::is_constructible<const volatile int&, int&>::value, "Error");
static_assert(!std::is_constructible<const volatile int&, int>::value, "Error");
static_assert(!std::is_constructible<const volatile int&, const int>::value,
"Error");
static_assert(!std::is_constructible<const volatile int&, int&&>::value,
"Error");
static_assert(!std::is_constructible<const volatile int&, const int&&>::value,
"Error");
static_assert(std::is_constructible<int&&, int>::value, "Error");
static_assert(std::is_constructible<int&&, int&&>::value, "Error");
static_assert(!std::is_constructible<int&&, const int&&>::value, "Error");
static_assert(!std::is_constructible<int&&, int&>::value, "Error");
static_assert(!std::is_constructible<int&&, const int&>::value, "Error");
static_assert(std::is_constructible<int&&, double&>::value, "Error");
static_assert(std::is_constructible<const int&&, int>::value, "Error");
static_assert(std::is_constructible<const int&&, int&&>::value, "Error");
static_assert(std::is_constructible<const int&&, const int>::value, "Error");
static_assert(std::is_constructible<const int&&, const int&&>::value, "Error");
static_assert(!std::is_constructible<int&&, const int&>::value, "Error");
static_assert(!std::is_constructible<const int&&, int&>::value, "Error");
static_assert(!std::is_constructible<const int&&, const int&>::value, "Error");
static_assert(std::is_constructible<volatile int&&, int>::value, "Error");
static_assert(std::is_constructible<volatile int&&, int&&>::value, "Error");
static_assert(!std::is_constructible<volatile int&&, const int&&>::value,
"Error");
static_assert(!std::is_constructible<volatile int&&, int&>::value, "Error");
static_assert(!std::is_constructible<volatile int&&, const int&>::value,
"Error");
static_assert(std::is_constructible<volatile int&&, double&>::value, "Error");
static_assert(std::is_constructible<volatile const int&&, int>::value, "Error");
static_assert(std::is_constructible<const volatile int&&, int&&>::value,
"Error");
static_assert(std::is_constructible<const volatile int&&, const int>::value,
"Error");
static_assert(std::is_constructible<const volatile int&&, const int&&>::value,
"Error");
static_assert(!std::is_constructible<volatile int&&, const int&>::value,
"Error");
static_assert(!std::is_constructible<const volatile int&&, int&>::value,
"Error");
static_assert(!std::is_constructible<const volatile int&&,
const int&>::value, "Error");
static_assert(std::is_constructible<Empty&, Empty&>::value, "Error");
static_assert(!std::is_constructible<Empty&, const Empty&>::value, "Error");
static_assert(!std::is_constructible<Empty&, Empty>::value, "Error");
static_assert(!std::is_constructible<Empty&, Empty&&>::value, "Error");
static_assert(!std::is_constructible<Empty&, const Empty&&>::value, "Error");
static_assert(std::is_constructible<const Empty&, Empty&>::value, "Error");
static_assert(std::is_constructible<const Empty&, Empty>::value, "Error");
static_assert(std::is_constructible<const Empty&, const Empty>::value, "Error");
static_assert(std::is_constructible<const Empty&, Empty&&>::value, "Error");
static_assert(std::is_constructible<const Empty&, const Empty&&>::value,
"Error");
static_assert(std::is_constructible<volatile Empty&, Empty&>::value, "Error");
static_assert(!std::is_constructible<volatile Empty&, const Empty&>::value,
"Error");
static_assert(!std::is_constructible<volatile Empty&, Empty>::value, "Error");
static_assert(!std::is_constructible<volatile Empty&, Empty&&>::value, "Error");
static_assert(!std::is_constructible<volatile Empty&, const Empty&&>::value,
"Error");
static_assert(std::is_constructible<const volatile Empty&, Empty&>::value,
"Error");
static_assert(!std::is_constructible<const volatile Empty&, Empty>::value,
"Error");
static_assert(!std::is_constructible<const volatile Empty&,
const Empty>::value, "Error");
static_assert(!std::is_constructible<const volatile Empty&,
Empty&&>::value, "Error");
static_assert(!std::is_constructible<const volatile Empty&,
const Empty&&>::value, "Error");
static_assert(std::is_constructible<Empty&&, Empty>::value, "Error");
static_assert(std::is_constructible<Empty&&, Empty&&>::value, "Error");
static_assert(!std::is_constructible<Empty&&, const Empty&&>::value, "Error");
static_assert(!std::is_constructible<Empty&&, Empty&>::value, "Error");
static_assert(!std::is_constructible<Empty&&, const Empty&>::value, "Error");
static_assert(!std::is_constructible<Empty&&, double&>::value, "Error");
static_assert(!std::is_constructible<Empty&&, const double&>::value, "Error");
static_assert(std::is_constructible<const Empty&&, Empty>::value, "Error");
static_assert(std::is_constructible<const Empty&&, Empty&&>::value, "Error");
static_assert(std::is_constructible<const Empty&&, const Empty>::value,
"Error");
static_assert(std::is_constructible<const Empty&&, const Empty&&>::value,
"Error");
static_assert(!std::is_constructible<Empty&&, const Empty&>::value, "Error");
static_assert(!std::is_constructible<const Empty&&, Empty&>::value, "Error");
static_assert(!std::is_constructible<const Empty&&, const Empty&>::value,
"Error");
static_assert(std::is_constructible<volatile Empty&&, Empty>::value, "Error");
static_assert(std::is_constructible<volatile Empty&&, Empty&&>::value, "Error");
static_assert(!std::is_constructible<volatile Empty&&, const Empty&&>::value,
"Error");
static_assert(!std::is_constructible<volatile Empty&&, Empty&>::value, "Error");
static_assert(!std::is_constructible<volatile Empty&&, const Empty&>::value,
"Error");
static_assert(!std::is_constructible<volatile Empty&&, double&>::value,
"Error");
static_assert(!std::is_constructible<volatile Empty&&, const double&>::value,
"Error");
static_assert(std::is_constructible<const volatile Empty&&, Empty>::value,
"Error");
static_assert(std::is_constructible<const volatile Empty&&, Empty&&>::value,
"Error");
static_assert(std::is_constructible<const volatile Empty&&,
const Empty>::value, "Error");
static_assert(std::is_constructible<const volatile Empty&&,
const Empty&&>::value, "Error");
static_assert(!std::is_constructible<volatile Empty&&,
const Empty&>::value, "Error");
static_assert(!std::is_constructible<const volatile Empty&&,
Empty&>::value, "Error");
static_assert(!std::is_constructible<const volatile Empty&&,
const Empty&>::value, "Error");
static_assert(std::is_constructible<Ellipsis, int>::value, "Error");
static_assert(std::is_constructible<Ellipsis, Empty>::value, "Error");
static_assert(std::is_constructible<Ellipsis, std::nullptr_t>::value, "Error");
static_assert(std::is_constructible<Ellipsis, int[]>::value, "Error");
static_assert(std::is_constructible<Ellipsis, int[1]>::value, "Error");
static_assert(!std::is_constructible<Ellipsis, void>::value, "Error");
static_assert(std::is_constructible<int(&)[1], int(&)[1]>::value, "Error");
static_assert(std::is_constructible<const int(&)[1],
int(&)[1]>::value, "Error");
static_assert(std::is_constructible<volatile int(&)[1],
int(&)[1]>::value, "Error");
static_assert(std::is_constructible<const volatile int(&)[1],
int(&)[1]>::value, "Error");
static_assert(!std::is_constructible<int(&)[1],
const int(&)[1]>::value, "Error");
static_assert(!std::is_constructible<const int(&)[1],
volatile int(&)[1]>::value, "Error");
static_assert(std::is_constructible<int(&)[], int(&)[]>::value, "Error");
static_assert(!std::is_constructible<int(&)[1], int(&)[2]>::value, "Error");
static_assert(!std::is_constructible<int(&)[1], int&>::value, "Error");
static_assert(!std::is_constructible<int&, int(&)[1]>::value, "Error");
static_assert(!std::is_constructible<U, int>::value, "Error");
static_assert(!std::is_constructible<U, Empty>::value, "Error");
static_assert(!std::is_constructible<void(), void()>::value, "Error");
static_assert(!std::is_constructible<void(), int>::value, "Error");
static_assert(!std::is_constructible<void(), Abstract>::value, "Error");
static_assert(!std::is_constructible<void(), std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<void(), Empty>::value, "Error");
static_assert(!std::is_constructible<void(), U>::value, "Error");
static_assert(!std::is_constructible<void(), E>::value, "Error");
static_assert(!std::is_constructible<void(), SE>::value, "Error");
static_assert(!std::is_constructible<void(), OpE>::value, "Error");
static_assert(!std::is_constructible<void(), OpSE>::value, "Error");
static_assert(!std::is_constructible<void(), int[]>::value, "Error");
static_assert(!std::is_constructible<void(), int[1]>::value, "Error");
static_assert(!std::is_constructible<void() const,
void() volatile>::value, "Error");
static_assert(!std::is_constructible<void() const, int>::value, "Error");
static_assert(!std::is_constructible<void() const, Abstract>::value, "Error");
static_assert(!std::is_constructible<void() const, std::nullptr_t>::value,
"Error");
static_assert(!std::is_constructible<void() const, Empty>::value, "Error");
static_assert(!std::is_constructible<void() const, U>::value, "Error");
static_assert(!std::is_constructible<void() const, E>::value, "Error");
static_assert(!std::is_constructible<void() const, SE>::value, "Error");
static_assert(!std::is_constructible<void() const, OpE>::value, "Error");
static_assert(!std::is_constructible<void() const, OpSE>::value, "Error");
static_assert(!std::is_constructible<void() const, int[]>::value, "Error");
static_assert(!std::is_constructible<void() const, int[1]>::value, "Error");
static_assert(!std::is_constructible<void(int), void()>::value, "Error");
static_assert(!std::is_constructible<int, void()>::value, "Error");
static_assert(!std::is_constructible<Abstract, void()>::value, "Error");
static_assert(!std::is_constructible<std::nullptr_t, void()>::value, "Error");
static_assert(!std::is_constructible<Empty, void()>::value, "Error");
static_assert(!std::is_constructible<U, void()>::value, "Error");
static_assert(!std::is_constructible<E, void()>::value, "Error");
static_assert(!std::is_constructible<SE, void()>::value, "Error");
static_assert(!std::is_constructible<OpE, void()>::value, "Error");
static_assert(!std::is_constructible<OpSE, void()>::value, "Error");
static_assert(!std::is_constructible<int[], void()>::value, "Error");
static_assert(!std::is_constructible<int[1], void()>::value, "Error");
static_assert(!std::is_constructible<void(int) const,
void() const>::value, "Error");
static_assert(!std::is_constructible<int, void() const>::value, "Error");
static_assert(!std::is_constructible<Abstract, void() const>::value, "Error");
static_assert(!std::is_constructible<std::nullptr_t, void() const>::value,
"Error");
static_assert(!std::is_constructible<Empty, void() const>::value, "Error");
static_assert(!std::is_constructible<U, void() const>::value, "Error");
static_assert(!std::is_constructible<E, void() const>::value, "Error");
static_assert(!std::is_constructible<SE, void() const>::value, "Error");
static_assert(!std::is_constructible<OpE, void() const>::value, "Error");
static_assert(!std::is_constructible<OpSE, void() const>::value, "Error");
static_assert(!std::is_constructible<int[], void() const>::value, "Error");
static_assert(!std::is_constructible<int[1], void() const>::value, "Error");
static_assert(!std::is_constructible<void, int, int>::value, "Error");
static_assert(!std::is_constructible<void, Empty, B>::value, "Error");
static_assert(!std::is_constructible<void, Empty, Empty>::value, "Error");
static_assert(!std::is_constructible<void, U, Empty>::value, "Error");
static_assert(!std::is_constructible<void, U, U>::value, "Error");
static_assert(!std::is_constructible<void, std::nullptr_t,
std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<void, int[1], int[1]>::value, "Error");
static_assert(!std::is_constructible<void, int[], int[]>::value, "Error");
static_assert(!std::is_constructible<void, void, int>::value, "Error");
static_assert(!std::is_constructible<void, void, void>::value, "Error");
static_assert(!std::is_constructible<void, void(), void()>::value, "Error");
static_assert(!std::is_constructible<void, void() const,
void() volatile>::value, "Error");
static_assert(!std::is_constructible<int, int, int>::value, "Error");
static_assert(!std::is_constructible<const int, int, int>::value, "Error");
static_assert(!std::is_constructible<int, void, int>::value, "Error");
static_assert(!std::is_constructible<const int, void, int>::value, "Error");
static_assert(!std::is_constructible<int, void, void>::value, "Error");
static_assert(!std::is_constructible<const int, void, void>::value, "Error");
static_assert(!std::is_constructible<bool, int, int>::value, "Error");
static_assert(!std::is_constructible<const bool, int, int>::value, "Error");
static_assert(!std::is_constructible<std::nullptr_t, int, int>::value, "Error");
static_assert(!std::is_constructible<const std::nullptr_t, int, int>::value,
"Error");
static_assert(!std::is_constructible<std::nullptr_t, void, int>::value,
"Error");
static_assert(!std::is_constructible<const std::nullptr_t, void, int>::value,
"Error");
static_assert(!std::is_constructible<std::nullptr_t, void, void>::value,
"Error");
static_assert(!std::is_constructible<const std::nullptr_t, void, void>::value,
"Error");
static_assert(!std::is_constructible<E, int, int>::value, "Error");
static_assert(!std::is_constructible<const E, int, int>::value, "Error");
static_assert(!std::is_constructible<E, void, int>::value, "Error");
static_assert(!std::is_constructible<const E, void, int>::value, "Error");
static_assert(!std::is_constructible<E, void, void>::value, "Error");
static_assert(!std::is_constructible<const E, void, void>::value, "Error");
static_assert(!std::is_constructible<SE, int, int>::value, "Error");
static_assert(!std::is_constructible<const SE, int, int>::value, "Error");
static_assert(!std::is_constructible<SE, void, int>::value, "Error");
static_assert(!std::is_constructible<const SE, void, int>::value, "Error");
static_assert(!std::is_constructible<SE, void, void>::value, "Error");
static_assert(!std::is_constructible<const SE, void, void>::value, "Error");
static_assert(!std::is_constructible<OpE, int, int>::value, "Error");
static_assert(!std::is_constructible<const OpE, int, int>::value, "Error");
static_assert(!std::is_constructible<OpE, void, int>::value, "Error");
static_assert(!std::is_constructible<const OpE, void, int>::value, "Error");
static_assert(!std::is_constructible<OpE, void, void>::value, "Error");
static_assert(!std::is_constructible<const OpE, void, void>::value, "Error");
static_assert(!std::is_constructible<OpSE, int, int>::value, "Error");
static_assert(!std::is_constructible<const OpSE, int, int>::value, "Error");
static_assert(!std::is_constructible<OpSE, void, int>::value, "Error");
static_assert(!std::is_constructible<const OpSE, void, int>::value, "Error");
static_assert(!std::is_constructible<OpSE, void, void>::value, "Error");
static_assert(!std::is_constructible<const OpSE, void, void>::value, "Error");
static_assert(!std::is_constructible<Empty, int, int>::value, "Error");
static_assert(!std::is_constructible<const Empty, int, int>::value, "Error");
static_assert(!std::is_constructible<Empty, void, int>::value, "Error");
static_assert(!std::is_constructible<const Empty, void, int>::value, "Error");
static_assert(!std::is_constructible<Empty, void, void>::value, "Error");
static_assert(!std::is_constructible<const Empty, void, void>::value, "Error");
static_assert(!std::is_constructible<U, int, int>::value, "Error");
static_assert(!std::is_constructible<const U, int, int>::value, "Error");
static_assert(!std::is_constructible<U, void, int>::value, "Error");
static_assert(!std::is_constructible<const U, void, int>::value, "Error");
static_assert(!std::is_constructible<U, void, void>::value, "Error");
static_assert(!std::is_constructible<const U, void, void>::value, "Error");
static_assert(!std::is_constructible<B, int, int>::value, "Error");
static_assert(!std::is_constructible<const B, int, int>::value, "Error");
static_assert(!std::is_constructible<B, void, int>::value, "Error");
static_assert(!std::is_constructible<const B, void, int>::value, "Error");
static_assert(!std::is_constructible<B, void, void>::value, "Error");
static_assert(!std::is_constructible<const B, void, void>::value, "Error");
static_assert(!std::is_constructible<Any, int, int>::value, "Error");
static_assert(!std::is_constructible<const Any, int, int>::value, "Error");
static_assert(!std::is_constructible<Any, void, int>::value, "Error");
static_assert(!std::is_constructible<const Any, void, int>::value, "Error");
static_assert(!std::is_constructible<Any, void, void>::value, "Error");
static_assert(!std::is_constructible<const Any, void, void>::value, "Error");
static_assert(!std::is_constructible<nAny, void, int>::value, "Error");
static_assert(!std::is_constructible<const nAny, void, int>::value, "Error");
static_assert(!std::is_constructible<nAny, void, void>::value, "Error");
static_assert(!std::is_constructible<const nAny, void, void>::value, "Error");
static_assert(!std::is_constructible<FromArgs<>, int, int>::value, "Error");
static_assert(!std::is_constructible<const FromArgs<>, int, int>::value,
"Error");
static_assert(!std::is_constructible<FromArgs<>, void, int>::value, "Error");
static_assert(!std::is_constructible<const FromArgs<>, void, int>::value,
"Error");
static_assert(!std::is_constructible<FromArgs<>, void, void>::value, "Error");
static_assert(!std::is_constructible<const FromArgs<>, void, void>::value,
"Error");
static_assert(!std::is_constructible<Abstract, int, int>::value, "Error");
static_assert(!std::is_constructible<const Abstract, int, int>::value, "Error");
static_assert(!std::is_constructible<Abstract, void, int>::value, "Error");
static_assert(!std::is_constructible<const Abstract, void, int>::value,
"Error");
static_assert(!std::is_constructible<Abstract, void, void>::value, "Error");
static_assert(!std::is_constructible<const Abstract, void, void>::value,
"Error");
static_assert(!std::is_constructible<AbstractDelDtor, int, int>::value,
"Error");
static_assert(!std::is_constructible<const AbstractDelDtor, int, int>::value,
"Error");
static_assert(!std::is_constructible<AbstractDelDtor, void, int>::value,
"Error");
static_assert(!std::is_constructible<const AbstractDelDtor, void, int>::value,
"Error");
static_assert(!std::is_constructible<AbstractDelDtor, void, void>::value,
"Error");
static_assert(!std::is_constructible<const AbstractDelDtor, void, void>::value,
"Error");
static_assert(!std::is_constructible<int[1], int, int>::value, "Error");
static_assert(!std::is_constructible<const int[1], int, int>::value, "Error");
static_assert(!std::is_constructible<int[1], void, int>::value, "Error");
static_assert(!std::is_constructible<const int[1], void, int>::value, "Error");
static_assert(!std::is_constructible<int[1], void, void>::value, "Error");
static_assert(!std::is_constructible<const int[1], void, void>::value, "Error");
static_assert(!std::is_constructible<int&, int, int>::value, "Error");
static_assert(!std::is_constructible<int&, void, int>::value, "Error");
static_assert(!std::is_constructible<int&, void, void>::value, "Error");
static_assert(!std::is_constructible<int&, int&, int&>::value, "Error");
static_assert(!std::is_constructible<int&, void, int&>::value, "Error");
static_assert(!std::is_constructible<int&, void, void>::value, "Error");
static_assert(!std::is_constructible<std::nullptr_t&, int, int>::value,
"Error");
static_assert(!std::is_constructible<std::nullptr_t&, void, int>::value,
"Error");
static_assert(!std::is_constructible<std::nullptr_t&, void, void>::value,
"Error");
static_assert(!std::is_constructible<E&, int, int>::value, "Error");
static_assert(!std::is_constructible<E&, void, int>::value, "Error");
static_assert(!std::is_constructible<E&, void, void>::value, "Error");
static_assert(!std::is_constructible<SE&, int, int>::value, "Error");
static_assert(!std::is_constructible<SE&, void, int>::value, "Error");
static_assert(!std::is_constructible<SE&, void, void>::value, "Error");
static_assert(!std::is_constructible<OpE&, int, int>::value, "Error");
static_assert(!std::is_constructible<OpE&, void, int>::value, "Error");
static_assert(!std::is_constructible<OpE&, void, void>::value, "Error");
static_assert(!std::is_constructible<OpSE&, int, int>::value, "Error");
static_assert(!std::is_constructible<OpSE&, void, int>::value, "Error");
static_assert(!std::is_constructible<OpSE&, void, void>::value, "Error");
static_assert(!std::is_constructible<Empty&, int, int>::value, "Error");
static_assert(!std::is_constructible<Empty&, void, int>::value, "Error");
static_assert(!std::is_constructible<Empty&, void, void>::value, "Error");
static_assert(!std::is_constructible<U&, int, int>::value, "Error");
static_assert(!std::is_constructible<U&, void, int>::value, "Error");
static_assert(!std::is_constructible<U&, void, void>::value, "Error");
static_assert(!std::is_constructible<B&, int, int>::value, "Error");
static_assert(!std::is_constructible<B&, void, int>::value, "Error");
static_assert(!std::is_constructible<B&, void, void>::value, "Error");
static_assert(!std::is_constructible<Any&, int, int>::value, "Error");
static_assert(!std::is_constructible<Any&, void, int>::value, "Error");
static_assert(!std::is_constructible<Any&, void, void>::value, "Error");
static_assert(!std::is_constructible<nAny&, void, int>::value, "Error");
static_assert(!std::is_constructible<nAny&, void, void>::value, "Error");
static_assert(!std::is_constructible<FromArgs<>&, int, int>::value, "Error");
static_assert(!std::is_constructible<FromArgs<>&, void, int>::value, "Error");
static_assert(!std::is_constructible<FromArgs<>&, void, void>::value, "Error");
static_assert(!std::is_constructible<Abstract&, int, int>::value, "Error");
static_assert(!std::is_constructible<Abstract&, void, int>::value, "Error");
static_assert(!std::is_constructible<Abstract&, void, void>::value, "Error");
static_assert(!std::is_constructible<int(&)[1], int, int>::value, "Error");
static_assert(!std::is_constructible<int(&)[1], void, int>::value, "Error");
static_assert(!std::is_constructible<int(&)[1], void, void>::value, "Error");
static_assert(!std::is_constructible<void(), int, int>::value, "Error");
static_assert(!std::is_constructible<void(), void, int>::value, "Error");
static_assert(!std::is_constructible<void(), void, void>::value, "Error");
static_assert(!std::is_constructible<void(), void(), int>::value, "Error");
static_assert(!std::is_constructible<void(), void(), void()>::value, "Error");
static_assert(!std::is_constructible<void() const, int, int>::value, "Error");
static_assert(!std::is_constructible<void() const, void, int>::value, "Error");
static_assert(!std::is_constructible<void() const, void, void>::value, "Error");
static_assert(!std::is_constructible<void() const, void() volatile,
int>::value, "Error");
static_assert(!std::is_constructible<void() const, void() volatile const,
void() const>::value, "Error");
static_assert(!std::is_constructible<FromArgs<int>, int, int>::value, "Error");
static_assert(!std::is_constructible<const FromArgs<int>, int, int>::value,
"Error");
static_assert(!std::is_constructible<FromArgs<int>, void, int>::value, "Error");
static_assert(!std::is_constructible<const FromArgs<int>, void, int>::value,
"Error");
static_assert(!std::is_constructible<FromArgs<int, int>, void, int>::value,
"Error");
static_assert(!std::is_constructible<const FromArgs<int, int>, void,
int>::value, "Error");
static_assert(!std::is_constructible<DelDtor, int, B, U>::value, "Error");
static_assert(!std::is_constructible<const DelDtor, int, B, U>::value, "Error");
static_assert(!std::is_constructible<DelDtor, int>::value, "Error");
static_assert(!std::is_constructible<const DelDtor, int>::value, "Error");
static_assert(!std::is_constructible<DelDtor>::value, "Error");
static_assert(!std::is_constructible<const DelDtor>::value, "Error");
static_assert(!std::is_constructible<DelDtor, void*, void(&)()>::value,
"Error");
static_assert(!std::is_constructible<const DelDtor, void*, void(&)()>::value,
"Error");
static_assert(!std::is_constructible<AbstractDelDtor>::value, "Error");
static_assert(!std::is_constructible<const AbstractDelDtor>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis>::value, "Error");
static_assert(!std::is_constructible<const DelEllipsis>::value, "Error");
static_assert(!std::is_constructible<DelEllipsis, double>::value, "Error");
static_assert(!std::is_constructible<const DelEllipsis, double>::value,
"Error");
static_assert(!std::is_constructible<DelEllipsis, double, int&>::value,
"Error");
static_assert(!std::is_constructible<const DelEllipsis, double, int&>::value,
"Error");
static_assert(!std::is_constructible<DelnAny>::value, "Error");
static_assert(!std::is_constructible<const DelnAny>::value, "Error");
static_assert(!std::is_constructible<DelnAny, int>::value, "Error");
static_assert(!std::is_constructible<const DelnAny, int>::value, "Error");
static_assert(!std::is_constructible<DelnAny, int, void*>::value, "Error");
static_assert(!std::is_constructible<const DelnAny, int, void*>::value,
"Error");
static_assert(!std::is_constructible<DelnAny, Empty, B, D>::value, "Error");
static_assert(!std::is_constructible<const DelnAny, Empty, B, D>::value,
"Error");
// Deleted members in unions with non-trivial members:
static_assert(!std::is_constructible<NontrivialUnion>::value, "Error");
static_assert(!std::is_constructible<NontrivialUnion,
const NontrivialUnion&>::value, "Error");
// Unusual copy:
static_assert(!std::is_constructible<UnusualCopy>::value, "Error");
static_assert(!std::is_constructible<UnusualCopy, UnusualCopy>::value, "Error");
static_assert(!std::is_constructible<UnusualCopy,
UnusualCopy&&>::value, "Error");
static_assert(!std::is_constructible<UnusualCopy,
const UnusualCopy&>::value, "Error");
static_assert(std::is_constructible<UnusualCopy, UnusualCopy&>::value, "Error");
static_assert(std::is_constructible<FromArgs<int, char>,
int, char>::value, "Error");
static_assert(std::is_constructible<const FromArgs<int, char>,
int, char>::value, "Error");
static_assert(std::is_constructible<FromArgs<int, char>,
int, int>::value, "Error");
static_assert(std::is_constructible<const FromArgs<int, char>,
int, int>::value, "Error");
static_assert(std::is_constructible<nAny, int, int>::value, "Error");
static_assert(std::is_constructible<const nAny, int, int>::value, "Error");
static_assert(std::is_constructible<FromArgs<int, char>,
ImplicitTo<int>, ImplicitTo<char>>::value, "Error");
static_assert(std::is_constructible<const FromArgs<int, char>,
ImplicitTo<int>, ImplicitTo<char>>::value, "Error");
static_assert(std::is_constructible<Ellipsis, int, char>::value, "Error");
static_assert(std::is_constructible<const Ellipsis, int, char>::value, "Error");
static_assert(std::is_constructible<Ellipsis, B, U, int&>::value, "Error");
static_assert(std::is_constructible<const Ellipsis,
B, U, int&>::value, "Error");
static_assert(std::is_constructible<nAny, B, U, int&>::value, "Error");
static_assert(std::is_constructible<const nAny, B, U, int&>::value, "Error");
static_assert(std::is_constructible<FromArgs<std::initializer_list<int>,
std::initializer_list<B>>, std::initializer_list<int>,
std::initializer_list<B>>::value, "Error");
static_assert(std::is_constructible<const FromArgs<std::initializer_list<int>,
std::initializer_list<B>>, std::initializer_list<int>,
std::initializer_list<B>>::value, "Error");
static_assert(std::is_constructible<FromArgs<std::initializer_list<int>,
std::initializer_list<B>>, std::initializer_list<int>&,
std::initializer_list<B>&>::value, "Error");
static_assert(!std::is_constructible<FromArgs<std::initializer_list<int>&,
std::initializer_list<B>&>, std::initializer_list<int>,
std::initializer_list<B>>::value, "Error");
static_assert(!std::is_constructible<FromArgs<std::initializer_list<int>>,
int, int>::value, "Error");
static_assert(!std::is_constructible<const
FromArgs<std::initializer_list<int>>, int, int>::value, "Error");
static_assert(!std::is_constructible<B[2], B, B>::value, "Error");
static_assert(!std::is_constructible<const B[2], B, B>::value, "Error");
static_assert(!std::is_constructible<U[2], U, U>::value, "Error");
static_assert(!std::is_constructible<const U[2], U, U>::value, "Error");
static_assert(!std::is_constructible<E, E, E>::value, "Error");
static_assert(!std::is_constructible<const E, E, E>::value, "Error");
static_assert(!std::is_constructible<SE, SE, SE>::value, "Error");
static_assert(!std::is_constructible<const SE, SE, SE>::value, "Error");
static_assert(!std::is_constructible<E, B, std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<const E, B, std::nullptr_t>::value,
"Error");
static_assert(!std::is_constructible<SE, B, std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<const SE, B, std::nullptr_t>::value,
"Error");
static_assert(!std::is_constructible<E, int[], int[]>::value, "Error");
static_assert(!std::is_constructible<const E, int[], int[]>::value, "Error");
static_assert(!std::is_constructible<SE, int[], int[]>::value, "Error");
static_assert(!std::is_constructible<const SE, int[], int[]>::value, "Error");
static_assert(!std::is_constructible<OpE, OpE, OpE>::value, "Error");
static_assert(!std::is_constructible<const OpE, OpE, OpE>::value, "Error");
static_assert(!std::is_constructible<OpSE, OpSE, OpSE>::value, "Error");
static_assert(!std::is_constructible<const OpSE, OpSE, OpSE>::value, "Error");
static_assert(!std::is_constructible<OpE, B, std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<const OpE, B, std::nullptr_t>::value,
"Error");
static_assert(!std::is_constructible<OpSE, B, std::nullptr_t>::value, "Error");
static_assert(!std::is_constructible<const OpSE, B, std::nullptr_t>::value,
"Error");
static_assert(!std::is_constructible<OpE, int[], int[]>::value, "Error");
static_assert(!std::is_constructible<const OpE, int[], int[]>::value, "Error");
static_assert(!std::is_constructible<OpSE, int[], int[]>::value, "Error");
static_assert(!std::is_constructible<const OpSE, int[], int[]>::value, "Error");
static_assert(!std::is_constructible<int[], int, int>::value, "Error");
static_assert(!std::is_constructible<const int[], int, int>::value, "Error");
static_assert(std::is_constructible<int&, ImplicitTo<int&>>::value, "Error");
static_assert(std::is_constructible<const int&, ImplicitTo<int&&>>::value,
"Error");
static_assert(std::is_constructible<int&&, ImplicitTo<int&&>>::value, "Error");
static_assert(std::is_constructible<const int&, ImplicitTo<int>>::value,
"Error");
static_assert(!std::is_constructible<const int&, ExplicitTo<int>>::value,
"Error");
static_assert(!std::is_constructible<int&&, ExplicitTo<int>>::value, "Error");
// Binding through reference-compatible type is required to perform
// direct-initialization as described in [over.match.ref] p. 1 b. 1:
static_assert(std::is_constructible<int&, ExplicitTo<int&>>::value, "Error");
static_assert(std::is_constructible<const int&, ExplicitTo<int&&>>::value,
"Error");
static_assert(std::is_constructible<int&&, ExplicitTo<int&&>>::value, "Error");
// Binding through temporary behaves like copy-initialization,
// see [dcl.init.ref] p. 5, very last sub-bullet:
static_assert(!std::is_constructible<const int&, ExplicitTo<double&&>>::value,
"Error");
static_assert(!std::is_constructible<int&&, ExplicitTo<double&&>>::value,
"Error");
libstdc++-v3/testsuite/20_util/is_convertible/value.cc
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
// 2009-10-29 Paolo Carlini <paolo.carlini@oracle.com> // 2009-10-29 Paolo Carlini <paolo.carlini@oracle.com>
// //
// Copyright (C) 2009 Free Software Foundation, Inc. // Copyright (C) 2009, 2011 Free Software Foundation, Inc.
// //
// This file is part of the GNU ISO C++ Library. This library is free // This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the // software; you can redistribute it and/or modify it under the
...@@ -58,6 +58,8 @@ void test01() ...@@ -58,6 +58,8 @@ void test01()
VERIFY( (test_relationship<is_convertible, void, volatile void>(true)) ); VERIFY( (test_relationship<is_convertible, void, volatile void>(true)) );
VERIFY( (test_relationship<is_convertible, double&, ExplicitClass>(true)) ); VERIFY( (test_relationship<is_convertible, double&, ExplicitClass>(true)) );
VERIFY( (test_relationship<is_convertible, int(int), int(&)(int)>(true)) );
// Negative tests. // Negative tests.
VERIFY( (test_relationship<is_convertible, const int*, int*>(false)) ); VERIFY( (test_relationship<is_convertible, const int*, int*>(false)) );
VERIFY( (test_relationship<is_convertible, int*, float*>(false)) ); VERIFY( (test_relationship<is_convertible, int*, float*>(false)) );
...@@ -93,8 +95,6 @@ void test01() ...@@ -93,8 +95,6 @@ void test01()
const volatile int&>(false)) ); const volatile int&>(false)) );
VERIFY( (test_relationship<is_convertible, volatile int, VERIFY( (test_relationship<is_convertible, volatile int,
volatile int&>(false)) ); volatile int&>(false)) );
VERIFY( (test_relationship<is_convertible, int(int), int(&)(int)>(true)) );
VERIFY( (test_relationship<is_convertible, int&, ExplicitClass>(false)) ); VERIFY( (test_relationship<is_convertible, int&, ExplicitClass>(false)) );
VERIFY( (test_relationship<is_convertible, void*, ExplicitClass>(false)) ); VERIFY( (test_relationship<is_convertible, void*, ExplicitClass>(false)) );
} }
......
libstdc++-v3/testsuite/20_util/is_default_constructible/requirements/explicit_instantiation.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
namespace std
{
typedef short test_type;
template struct is_default_constructible<test_type>;
}
libstdc++-v3/testsuite/20_util/is_default_constructible/requirements/typedefs.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
// { dg-do compile }
void test01()
{
// Check for required typedefs
typedef std::is_default_constructible<int> test_type;
typedef test_type::value_type value_type;
typedef test_type::type type;
typedef test_type::type::value_type type_value_type;
typedef test_type::type::type type_type;
}
libstdc++-v3/testsuite/20_util/is_default_constructible/value.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <initializer_list>
#include <testsuite_tr1.h>
using namespace __gnu_test::construct_destruct;
static_assert(std::is_default_constructible<int>::value, "Error");
static_assert(std::is_default_constructible<int const>::value, "Error");
static_assert(std::is_default_constructible<int const volatile>::value,
"Error");
static_assert(std::is_default_constructible<int*>::value, "Error");
static_assert(std::is_default_constructible<void*>::value, "Error");
static_assert(std::is_default_constructible<void* const>::value, "Error");
static_assert(std::is_default_constructible<int B::*>::value, "Error");
static_assert(std::is_default_constructible<void(*)()>::value, "Error");
static_assert(std::is_default_constructible<std::nullptr_t>::value, "Error");
static_assert(std::is_default_constructible<std::nullptr_t const>::value,
"Error");
static_assert(std::is_default_constructible<Empty>::value, "Error");
static_assert(std::is_default_constructible<Empty const>::value, "Error");
static_assert(std::is_default_constructible<FromArgs<>>::value, "Error");
static_assert(std::is_default_constructible<FromArgs<> const>::value, "Error");
static_assert(std::is_default_constructible<nAny>::value, "Error");
static_assert(std::is_default_constructible<nAny const>::value, "Error");
static_assert(std::is_default_constructible<Ellipsis>::value, "Error");
static_assert(std::is_default_constructible<Ellipsis const>::value, "Error");
static_assert(std::is_default_constructible<U>::value, "Error");
static_assert(std::is_default_constructible<U const>::value, "Error");
static_assert(std::is_default_constructible<E>::value, "Error");
static_assert(std::is_default_constructible<E const>::value, "Error");
static_assert(std::is_default_constructible<SE>::value, "Error");
static_assert(std::is_default_constructible<SE const>::value, "Error");
static_assert(std::is_default_constructible<OpE>::value, "Error");
static_assert(std::is_default_constructible<OpE const>::value, "Error");
static_assert(std::is_default_constructible<OpSE>::value, "Error");
static_assert(std::is_default_constructible<OpSE const>::value, "Error");
static_assert(std::is_default_constructible<int[1]>::value, "Error");
static_assert(std::is_default_constructible<const int[1]>::value, "Error");
static_assert(std::is_default_constructible<int[1][2]>::value, "Error");
static_assert(std::is_default_constructible<const int[1][2]>::value, "Error");
static_assert(std::is_default_constructible<FromArgs<>[1]>::value, "Error");
static_assert(std::is_default_constructible<const FromArgs<>[1]>::value,
"Error");
static_assert(std::is_default_constructible<U[1]>::value, "Error");
static_assert(std::is_default_constructible<const U[1]>::value, "Error");
static_assert(std::is_default_constructible<Empty[1]>::value, "Error");
static_assert(std::is_default_constructible<const Empty[1]>::value, "Error");
static_assert(std::is_default_constructible<Ellipsis[1]>::value, "Error");
static_assert(std::is_default_constructible<const Ellipsis[1]>::value, "Error");
static_assert(std::is_default_constructible<std::nullptr_t[1]>::value, "Error");
static_assert(std::is_default_constructible<const std::nullptr_t[1]>::value,
"Error");
static_assert(std::is_default_constructible<nAny[1]>::value, "Error");
static_assert(std::is_default_constructible<const nAny[1]>::value, "Error");
static_assert(std::is_default_constructible<E[1]>::value, "Error");
static_assert(std::is_default_constructible<const E[1]>::value, "Error");
static_assert(std::is_default_constructible<SE[1]>::value, "Error");
static_assert(std::is_default_constructible<const SE[1]>::value, "Error");
static_assert(std::is_default_constructible<OpE[1]>::value, "Error");
static_assert(std::is_default_constructible<const OpE[1]>::value, "Error");
static_assert(std::is_default_constructible<OpSE[1]>::value, "Error");
static_assert(std::is_default_constructible<const OpSE[1]>::value, "Error");
static_assert(std::is_default_constructible<int*[1]>::value, "Error");
static_assert(std::is_default_constructible<int* const[1]>::value, "Error");
static_assert(std::is_default_constructible<int B::*[1]>::value, "Error");
static_assert(std::is_default_constructible<int B::* const[1]>::value, "Error");
static_assert(std::is_default_constructible<std::initializer_list<int>>::value,
"Error");
static_assert(std::is_default_constructible<const
std::initializer_list<int>>::value, "Error");
static_assert(std::is_default_constructible<
std::initializer_list<int>[1]>::value, "Error");
static_assert(std::is_default_constructible<const
std::initializer_list<int>[1]>::value, "Error");
static_assert(!std::is_default_constructible<void>::value, "Error");
static_assert(!std::is_default_constructible<const void>::value, "Error");
static_assert(!std::is_default_constructible<Abstract>::value, "Error");
static_assert(!std::is_default_constructible<const Abstract>::value, "Error");
static_assert(!std::is_default_constructible<Any>::value, "Error");
static_assert(!std::is_default_constructible<const Any>::value, "Error");
static_assert(!std::is_default_constructible<FromArgs<int>>::value, "Error");
static_assert(!std::is_default_constructible<const FromArgs<int>>::value,
"Error");
static_assert(!std::is_default_constructible<int&>::value, "Error");
static_assert(!std::is_default_constructible<int&&>::value, "Error");
static_assert(!std::is_default_constructible<void()>::value, "Error");
static_assert(!std::is_default_constructible<void() const volatile>::value,
"Error");
static_assert(!std::is_default_constructible<void(&)()>::value, "Error");
static_assert(!std::is_default_constructible<int(&)[1]>::value, "Error");
static_assert(!std::is_default_constructible<int(&)[]>::value, "Error");
static_assert(!std::is_default_constructible<int[]>::value, "Error");
static_assert(!std::is_default_constructible<const int[]>::value, "Error");
static_assert(!std::is_default_constructible<int[][1][2]>::value, "Error");
static_assert(!std::is_default_constructible<const int[][1][2]>::value,
"Error");
static_assert(!std::is_default_constructible<Any[1]>::value, "Error");
static_assert(!std::is_default_constructible<const Any[1]>::value, "Error");
static_assert(!std::is_default_constructible<FromArgs<int>[1]>::value, "Error");
static_assert(!std::is_default_constructible<const FromArgs<int>[1]>::value,
"Error");
static_assert(!std::is_default_constructible<
FromArgs<std::initializer_list<int>>>::value, "Error");
static_assert(!std::is_default_constructible<const
FromArgs<std::initializer_list<int>>>::value, "Error");
static_assert(!std::is_default_constructible<const
FromArgs<const std::initializer_list<int>>>::value, "Error");
static_assert(!std::is_default_constructible<DelDef>::value, "Error");
static_assert(!std::is_default_constructible<const DelDef>::value, "Error");
static_assert(!std::is_default_constructible<DelCopy>::value, "Error");
static_assert(!std::is_default_constructible<const DelCopy>::value, "Error");
static_assert(!std::is_default_constructible<DelDtor>::value, "Error");
static_assert(!std::is_default_constructible<const DelDtor>::value, "Error");
libstdc++-v3/testsuite/20_util/is_destructible/requirements/explicit_instantiation.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
namespace std
{
typedef short test_type;
template struct is_destructible<test_type>;
}
libstdc++-v3/testsuite/20_util/is_destructible/requirements/typedefs.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
// { dg-do compile }
void test01()
{
// Check for required typedefs
typedef std::is_destructible<int> test_type;
typedef test_type::value_type value_type;
typedef test_type::type type;
typedef test_type::type::value_type type_value_type;
typedef test_type::type::type type_type;
}
libstdc++-v3/testsuite/20_util/is_destructible/value.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <initializer_list>
#include <testsuite_tr1.h>
using namespace __gnu_test::construct_destruct;
static_assert(std::is_destructible<int>::value, "Error");
static_assert(std::is_destructible<const int>::value, "Error");
static_assert(std::is_destructible<bool>::value, "Error");
static_assert(std::is_destructible<const bool>::value, "Error");
static_assert(std::is_destructible<int*>::value, "Error");
static_assert(std::is_destructible<void*>::value, "Error");
static_assert(std::is_destructible<int B::*>::value, "Error");
static_assert(std::is_destructible<const int D::*>::value, "Error");
static_assert(std::is_destructible<E>::value, "Error");
static_assert(std::is_destructible<const E>::value, "Error");
static_assert(std::is_destructible<SE>::value, "Error");
static_assert(std::is_destructible<const SE>::value, "Error");
static_assert(std::is_destructible<OpE>::value, "Error");
static_assert(std::is_destructible<const OpE>::value, "Error");
static_assert(std::is_destructible<OpSE>::value, "Error");
static_assert(std::is_destructible<const OpSE>::value, "Error");
static_assert(std::is_destructible<std::nullptr_t>::value, "Error");
static_assert(std::is_destructible<const std::nullptr_t>::value, "Error");
static_assert(std::is_destructible<B>::value, "Error");
static_assert(std::is_destructible<const B>::value, "Error");
static_assert(std::is_destructible<D>::value, "Error");
static_assert(std::is_destructible<const D>::value, "Error");
static_assert(std::is_destructible<Empty>::value, "Error");
static_assert(std::is_destructible<const Empty>::value, "Error");
static_assert(std::is_destructible<U>::value, "Error");
static_assert(std::is_destructible<const U>::value, "Error");
static_assert(std::is_destructible<Abstract>::value, "Error");
static_assert(std::is_destructible<const Abstract>::value, "Error");
static_assert(std::is_destructible<int[1]>::value, "Error");
static_assert(std::is_destructible<const int[1]>::value, "Error");
static_assert(std::is_destructible<int[1][2]>::value, "Error");
static_assert(std::is_destructible<const int[1][2]>::value, "Error");
static_assert(std::is_destructible<int&>::value, "Error");
static_assert(std::is_destructible<int&&>::value, "Error");
static_assert(std::is_destructible<void(&)()>::value, "Error");
static_assert(std::is_destructible<Ellipsis>::value, "Error");
static_assert(std::is_destructible<const Ellipsis>::value, "Error");
static_assert(std::is_destructible<Any>::value, "Error");
static_assert(std::is_destructible<const Any>::value, "Error");
static_assert(std::is_destructible<nAny>::value, "Error");
static_assert(std::is_destructible<const nAny>::value, "Error");
static_assert(std::is_destructible<DelDef>::value, "Error");
static_assert(std::is_destructible<const DelDef>::value, "Error");
static_assert(std::is_destructible<DelCopy>::value, "Error");
static_assert(std::is_destructible<const DelCopy>::value, "Error");
static_assert(std::is_destructible<DelEllipsis>::value, "Error");
static_assert(std::is_destructible<const DelEllipsis>::value, "Error");
static_assert(std::is_destructible<std::initializer_list<int>>::value,
"Error");
static_assert(std::is_destructible<const std::initializer_list<int>>::value,
"Error");
static_assert(std::is_destructible<void()>::value, "Error");
static_assert(std::is_destructible<void() const>::value, "Error");
static_assert(!std::is_destructible<void>::value, "Error");
static_assert(!std::is_destructible<const void>::value, "Error");
static_assert(!std::is_destructible<int[]>::value, "Error");
static_assert(!std::is_destructible<const int[]>::value, "Error");
static_assert(!std::is_destructible<DelDtor>::value, "Error");
static_assert(!std::is_destructible<const DelDtor>::value, "Error");
static_assert(!std::is_destructible<AbstractDelDtor>::value, "Error");
static_assert(!std::is_destructible<const AbstractDelDtor>::value, "Error");
static_assert(!std::is_destructible<int[][1]>::value, "Error");
static_assert(!std::is_destructible<const int[][1]>::value, "Error");
static_assert(!std::is_destructible<DelDtor[1]>::value, "Error");
static_assert(!std::is_destructible<const DelDtor[1]>::value, "Error");
static_assert(!std::is_destructible<DelDtor[]>::value, "Error");
static_assert(!std::is_destructible<const DelDtor[]>::value, "Error");
// Deleted members in unions with non-trivial members:
static_assert(!std::is_destructible<NontrivialUnion>::value, "Error");
// Unusual copy:
static_assert(std::is_destructible<UnusualCopy>::value, "Error");
libstdc++-v3/testsuite/20_util/is_function/24808.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
//
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
// libstdc++/24808
void test01()
{
bool test __attribute__((unused)) = true;
using std::is_function;
using namespace __gnu_test;
VERIFY( (test_category<is_function, IncompleteClass>(false)) );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/20_util/is_function/35637.cc 0 → 100644
// { dg-options "-std=gnu++0x -pedantic-errors" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <functional>
struct S
{
void F() const {}
};
// libstdc++/35637
void test01()
{
std::function<void (S *)> a(&S::F);
}
libstdc++-v3/testsuite/20_util/is_function/requirements/explicit_instantiation.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
namespace std
{
typedef short test_type;
template struct is_function<test_type>;
}
libstdc++-v3/testsuite/20_util/is_function/requirements/typedefs.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
// NB: This file is for testing tr1/type_traits with NO OTHER INCLUDES.
#include <type_traits>
void test01()
{
// Check for required typedefs
typedef std::is_function<int> test_type;
typedef test_type::value_type value_type;
typedef test_type::type type;
typedef test_type::type::value_type type_value_type;
typedef test_type::type::type type_type;
}
libstdc++-v3/testsuite/20_util/is_function/value.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
//
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
void test01()
{
bool test __attribute__((unused)) = true;
using std::is_function;
using namespace __gnu_test;
// Positive tests.
VERIFY( (test_category<is_function, int (int)>(true)) );
VERIFY( (test_category<is_function, ClassType (ClassType)>(true)) );
VERIFY( (test_category<is_function, float (int, float, int[], int&)>(true)) );
VERIFY( (test_category<is_function, int (int, ...)>(true)) );
// Negative tests.
VERIFY( (test_category<is_function, int&>(false)) );
VERIFY( (test_category<is_function, void>(false)) );
VERIFY( (test_category<is_function, const void>(false)) );
VERIFY( (test_category<is_function, AbstractClass>(false)) );
VERIFY( (test_category<is_function, int(&)(int)>(false)) );
// Sanity check.
VERIFY( (test_category<is_function, ClassType>(false)) );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/20_util/is_fundamental/requirements/explicit_instantiation.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
namespace std
{
typedef short test_type;
template struct is_fundamental<test_type>;
}
libstdc++-v3/testsuite/20_util/is_fundamental/requirements/typedefs.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
// NB: This file is for testing tr1/type_traits with NO OTHER INCLUDES.
#include <type_traits>
void test01()
{
// Check for required typedefs
typedef std::is_fundamental<int> test_type;
typedef test_type::value_type value_type;
typedef test_type::type type;
typedef test_type::type::value_type type_value_type;
typedef test_type::type::type type_type;
}
libstdc++-v3/testsuite/20_util/is_fundamental/value.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
//
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
void test01()
{
bool test __attribute__((unused)) = true;
using std::is_fundamental;
using namespace __gnu_test;
VERIFY( (test_category<is_fundamental, void>(true)) );
VERIFY( (test_category<is_fundamental, char>(true)) );
VERIFY( (test_category<is_fundamental, signed char>(true)) );
VERIFY( (test_category<is_fundamental, unsigned char>(true)) );
#ifdef _GLIBCXX_USE_WCHAR_T
VERIFY( (test_category<is_fundamental, wchar_t>(true)) );
#endif
VERIFY( (test_category<is_fundamental, short>(true)) );
VERIFY( (test_category<is_fundamental, unsigned short>(true)) );
VERIFY( (test_category<is_fundamental, int>(true)) );
VERIFY( (test_category<is_fundamental, unsigned int>(true)) );
VERIFY( (test_category<is_fundamental, long>(true)) );
VERIFY( (test_category<is_fundamental, unsigned long>(true)) );
VERIFY( (test_category<is_fundamental, long long>(true)) );
VERIFY( (test_category<is_fundamental, unsigned long long>(true)) );
VERIFY( (test_category<is_fundamental, float>(true)) );
VERIFY( (test_category<is_fundamental, double>(true)) );
VERIFY( (test_category<is_fundamental, long double>(true)) );
// Sanity check.
VERIFY( (test_category<is_fundamental, ClassType>(false)) );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/20_util/is_member_function_pointer/requirements/explicit_instantiation.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
namespace std
{
typedef short test_type;
template struct is_member_function_pointer<test_type>;
}
libstdc++-v3/testsuite/20_util/is_member_function_pointer/requirements/typedefs.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
// NB: This file is for testing tr1/type_traits with NO OTHER INCLUDES.
#include <type_traits>
void test01()
{
// Check for required typedefs
typedef std::is_member_function_pointer<int> test_type;
typedef test_type::value_type value_type;
typedef test_type::type type;
typedef test_type::type::value_type type_value_type;
typedef test_type::type::type type_type;
}
libstdc++-v3/testsuite/20_util/is_member_function_pointer/value.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
void test01()
{
bool test __attribute__((unused)) = true;
using std::is_member_function_pointer;
using namespace __gnu_test;
// Positive tests.
VERIFY( (test_category<is_member_function_pointer,
int (ClassType::*) (int)>(true)) );
VERIFY( (test_category<is_member_function_pointer,
int (ClassType::*) (int) const>(true)) );
VERIFY( (test_category<is_member_function_pointer,
int (ClassType::*) (float, ...)>(true)) );
VERIFY( (test_category<is_member_function_pointer,
ClassType (ClassType::*) (ClassType)>(true)) );
VERIFY( (test_category<is_member_function_pointer,
float (ClassType::*) (int, float, int[], int&)>(true)) );
// Negative tests.
VERIFY( (test_category<is_member_function_pointer,
int (ClassType::*)>(false)) );
VERIFY( (test_category<is_member_function_pointer,
const int (ClassType::*)>(false)) );
VERIFY( (test_category<is_member_function_pointer,
ClassType (ClassType::*)>(false)) );
// Sanity check.
VERIFY( (test_category<is_member_function_pointer, ClassType>(false)) );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/20_util/is_member_object_pointer/requirements/explicit_instantiation.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
namespace std
{
typedef short test_type;
template struct is_member_object_pointer<test_type>;
}
libstdc++-v3/testsuite/20_util/is_member_object_pointer/requirements/typedefs.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
// NB: This file is for testing tr1/type_traits with NO OTHER INCLUDES.
#include <type_traits>
void test01()
{
// Check for required typedefs
typedef std::is_member_object_pointer<int> test_type;
typedef test_type::value_type value_type;
typedef test_type::type type;
typedef test_type::type::value_type type_value_type;
typedef test_type::type::type type_type;
}
libstdc++-v3/testsuite/20_util/is_member_object_pointer/value.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
void test01()
{
bool test __attribute__((unused)) = true;
using std::is_member_object_pointer;
using namespace __gnu_test;
// Positive tests.
VERIFY( (test_category<is_member_object_pointer,
int (ClassType::*)>(true)) );
VERIFY( (test_category<is_member_object_pointer,
const int (ClassType::*)>(true)) );
VERIFY( (test_category<is_member_object_pointer,
ClassType (ClassType::*)>(true)) );
// Negative tests.
VERIFY( (test_category<is_member_object_pointer,
int (ClassType::*) (int)>(false)) );
VERIFY( (test_category<is_member_object_pointer,
int (ClassType::*) (int) const>(false)) );
VERIFY( (test_category<is_member_object_pointer,
int (ClassType::*) (float, ...)>(false)) );
VERIFY( (test_category<is_member_object_pointer,
ClassType (ClassType::*) (ClassType)>(false)) );
VERIFY( (test_category<is_member_object_pointer,
float (ClassType::*) (int, float, int[], int&)>(false)) );
// Sanity check.
VERIFY( (test_category<is_member_object_pointer, ClassType>(false)) );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/20_util/is_member_pointer/requirements/explicit_instantiation.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
namespace std
{
typedef short test_type;
template struct is_member_pointer<test_type>;
}
libstdc++-v3/testsuite/20_util/is_member_pointer/requirements/typedefs.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
// NB: This file is for testing tr1/type_traits with NO OTHER INCLUDES.
#include <type_traits>
void test01()
{
// Check for required typedefs
typedef std::is_member_pointer<int> test_type;
typedef test_type::value_type value_type;
typedef test_type::type type;
typedef test_type::type::value_type type_value_type;
typedef test_type::type::type type_type;
}
libstdc++-v3/testsuite/20_util/is_member_pointer/value.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
void test01()
{
bool test __attribute__((unused)) = true;
using std::is_member_pointer;
using namespace __gnu_test;
VERIFY( (test_category<is_member_pointer, int (ClassType::*)>(true)) );
VERIFY( (test_category<is_member_pointer, const int (ClassType::*)>(true)) );
VERIFY( (test_category<is_member_pointer, ClassType (ClassType::*)>(true)) );
VERIFY( (test_category<is_member_pointer,
int (ClassType::*) (int)>(true)) );
VERIFY( (test_category<is_member_pointer,
int (ClassType::*) (int) const>(true)) );
VERIFY( (test_category<is_member_pointer,
int (ClassType::*) (float, ...)>(true)) );
VERIFY( (test_category<is_member_pointer,
ClassType (ClassType::*) (ClassType)>(true)) );
VERIFY( (test_category<is_member_pointer,
float (ClassType::*) (int, float, int[], int&)>(true)) );
// Sanity check.
VERIFY( (test_category<is_member_pointer, ClassType>(false)) );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/20_util/is_object/24808.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
// libstdc++/24808
void test01()
{
bool test __attribute__((unused)) = true;
using std::is_object;
using namespace __gnu_test;
VERIFY( (test_category<is_object, IncompleteClass>(true)) );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/20_util/is_object/requirements/explicit_instantiation.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
namespace std
{
typedef short test_type;
template struct is_object<test_type>;
}
libstdc++-v3/testsuite/20_util/is_object/requirements/typedefs.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
// NB: This file is for testing type_traits with NO OTHER INCLUDES.
#include <type_traits>
// { dg-do compile }
void test01()
{
// Check for required typedefs
typedef std::is_object<int> test_type;
typedef test_type::value_type value_type;
typedef test_type::type type;
typedef test_type::type::value_type type_value_type;
typedef test_type::type::type type_type;
}
libstdc++-v3/testsuite/20_util/is_object/value.cc 0 → 100644
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <type_traits>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
void test01()
{
bool test __attribute__((unused)) = true;
using std::is_object;
using namespace __gnu_test;
VERIFY( (test_category<is_object, int (int)>(false)) );
VERIFY( (test_category<is_object, ClassType (ClassType)>(false)) );
VERIFY( (test_category<is_object, float (int, float, int[], int&)>(false)) );
VERIFY( (test_category<is_object, int&>(false)) );
VERIFY( (test_category<is_object, ClassType&>(false)) );
VERIFY( (test_category<is_object, int(&)(int)>(false)) );
VERIFY( (test_category<is_object, void>(false)) );
VERIFY( (test_category<is_object, const void>(false)) );
// Sanity check.
VERIFY( (test_category<is_object, ClassType>(true)) );
}
int main()
{
test01();
return 0;
}
libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
// 2007-05-03 Benjamin Kosnik <bkoz@redhat.com> // 2007-05-03 Benjamin Kosnik <bkoz@redhat.com>
// //
// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc. // Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
// //
// This file is part of the GNU ISO C++ Library. This library is free // This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the // software; you can redistribute it and/or modify it under the
...@@ -48,5 +48,5 @@ void test01() ...@@ -48,5 +48,5 @@ void test01()
// { dg-error "instantiated from here" "" { target *-*-* } 40 } // { dg-error "instantiated from here" "" { target *-*-* } 40 }
// { dg-error "instantiated from here" "" { target *-*-* } 42 } // { dg-error "instantiated from here" "" { target *-*-* } 42 }
// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1097 } // { dg-error "invalid use of incomplete type" "" { target *-*-* } 1302 }
// { dg-error "declaration of" "" { target *-*-* } 1061 } // { dg-error "declaration of" "" { target *-*-* } 1266 }
libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc
...@@ -48,5 +48,5 @@ void test01() ...@@ -48,5 +48,5 @@ void test01()
// { dg-error "instantiated from here" "" { target *-*-* } 40 } // { dg-error "instantiated from here" "" { target *-*-* } 40 }
// { dg-error "instantiated from here" "" { target *-*-* } 42 } // { dg-error "instantiated from here" "" { target *-*-* } 42 }
// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1020 } // { dg-error "invalid use of incomplete type" "" { target *-*-* } 1226 }
// { dg-error "declaration of" "" { target *-*-* } 984 } // { dg-error "declaration of" "" { target *-*-* } 1190 }
libstdc++-v3/testsuite/20_util/ratio/cons/cons_overflow_neg.cc
...@@ -51,4 +51,4 @@ test04() ...@@ -51,4 +51,4 @@ test04()
// { dg-error "instantiated from here" "" { target *-*-* } 46 } // { dg-error "instantiated from here" "" { target *-*-* } 46 }
// { dg-error "denominator cannot be zero" "" { target *-*-* } 155 } // { dg-error "denominator cannot be zero" "" { target *-*-* } 155 }
// { dg-error "out of range" "" { target *-*-* } 156 } // { dg-error "out of range" "" { target *-*-* } 156 }
// { dg-error "overflow in constant expression" "" { target *-*-* } 74 } // { dg-error "overflow in constant expression" "" { target *-*-* } 99 }
libstdc++-v3/testsuite/util/testsuite_tr1.h
// -*- C++ -*- // -*- C++ -*-
// Testing utilities for the tr1 testsuite. // Testing utilities for the tr1 testsuite.
// //
// Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 // Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011
// Free Software Foundation, Inc. // Free Software Foundation, Inc.
// //
// This file is part of the GNU ISO C++ Library. This library is free // This file is part of the GNU ISO C++ Library. This library is free
...@@ -283,6 +283,130 @@ namespace __gnu_test ...@@ -283,6 +283,130 @@ namespace __gnu_test
check_ret_type(T) check_ret_type(T)
{ return true; } { return true; }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
namespace construct_destruct
{
struct Empty {};
struct B { int i; B(){} };
struct D : B {};
enum E { ee1 };
enum E2 { ee2 };
enum class SE { e1 };
enum class SE2 { e2 };
enum OpE : int;
enum class OpSE : bool;
union U { int i; Empty b; };
struct Abstract
{
virtual ~Abstract() = 0;
};
struct AbstractDelDtor
{
~AbstractDelDtor() = delete;
virtual void foo() = 0;
};
struct Ukn;
template<class To>
struct ImplicitTo
{
operator To();
};
template<class To>
struct DelImplicitTo
{
operator To() = delete;
};
template<class To>
struct ExplicitTo
{
explicit operator To();
};
struct Ellipsis
{
Ellipsis(...){}
};
struct DelEllipsis
{
DelEllipsis(...) = delete;
};
struct Any
{
template<class T>
Any(T&&){}
};
struct nAny
{
template<class... T>
nAny(T&&...){}
};
struct DelnAny
{
template<class... T>
DelnAny(T&&...) = delete;
};
template<class... Args>
struct FromArgs
{
FromArgs(Args...);
};
struct DelDef
{
DelDef() = delete;
};
struct DelCopy
{
DelCopy(const DelCopy&) = delete;
};
struct DelDtor
{
DelDtor() = default;
DelDtor(const DelDtor&) = default;
DelDtor(DelDtor&&) = default;
DelDtor(int);
DelDtor(int, B, U);
~DelDtor() = delete;
};
struct Nontrivial
{
Nontrivial();
Nontrivial(const Nontrivial&);
Nontrivial& operator=(const Nontrivial&);
~Nontrivial();
};
union NontrivialUnion
{
int i;
Nontrivial n;
};
struct UnusualCopy
{
UnusualCopy(UnusualCopy&);
};
}
#endif
} // namespace __gnu_test } // namespace __gnu_test
#endif // _GLIBCXX_TESTSUITE_TR1_H #endif // _GLIBCXX_TESTSUITE_TR1_H
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment