Implement C++17 variable templates for type traits.
* include/std/chrono (treat_as_floating_point_v): New. * include/std/ratio (ratio_equal_v, ratio_not_equal_v) (ratio_less_v, ratio_less_equal_v, ratio_greater_v) (ratio_greater_equal_v): Likewise. * include/std/system_error (is_error_code_enum_v) (is_error_condition_enum_v): Likewise. * include/std/tuple (tuple_size_v): Likewise. * type_traits (conjunction_v, disjunction_v, negation_v) (is_void_v, is_null_pointer_v, is_integral_v, is_floating_point_v) (is_array_v, is_pointer_v, is_lvalue_reference_v) (is_rvalue_reference_v, is_member_object_pointer_v) (is_member_function_pointer_v, is_enum_v, is_union_v) (is_class_v, is_function_v, is_reference_v, is_arithmetic_v) (is_fundamental_v, is_object_v, is_scalar_v, is_compound_v) (is_member_pointer_v, is_const_v, is_volatile_v, is_trivial_v) (is_trivially_copyable_v, is_standard_layout_v) (is_pod_v, is_literal_type_v, is_empty_v, is_polymorphic_v) (is_abstract_v, is_final_v, is_signed_v, is_unsigned_v) (is_constructible_v, is_default_constructible_v) (is_copy_constructible_v, is_move_constructible_v) (is_assignable_v, is_copy_assignable_v, is_move_assignable_v) (is_destructible_v, is_trivially_constructible_v) (is_trivially_default_constructible_v) (is_trivially_copy_constructible_v, is_trivially_move_constructible_v) (is_trivially_assignable_v, is_trivially_copy_assignable_v) (is_trivially_move_assignable_v, is_trivially_destructible_v) (is_nothrow_constructible_v, is_nothrow_default_constructible_v) (is_nothrow_copy_constructible_v, is_nothrow_move_constructible_v) (is_nothrow_assignable_v, is_nothrow_copy_assignable_v) (is_nothrow_move_assignable_v, is_nothrow_destructible_v) (has_virtual_destructor_v, alignment_of_v, rank_v, extent_v) (is_same_v, is_base_of_v, is_convertible_v): Likewise. * testsuite/19_diagnostics/error_code/is_error_code_v.cc: Likewise. * testsuite/20_util/duration/requirements/treat_as_floating_point_v.cc: Likewise. * testsuite/20_util/ratio/requirements/ratio_equal_v.cc: Likewise. * testsuite/20_util/tuple/tuple_size_v.cc: Likewise. * testsuite/20_util/variable_templates_for_traits.cc: Likewise. From-SVN: r238892
This commit is contained in:
Ville Voutilainen
Ville Voutilainen
parent
466effe027
commit
137422c80c
|
|
@ -1,3 +1,45 @@
|
|||
2016-07-29 Ville Voutilainen <ville.voutilainen@gmail.com>
|
||||
|
||||
Implement C++17 variable templates for type traits.
|
||||
* include/std/chrono (treat_as_floating_point_v): New.
|
||||
* include/std/ratio (ratio_equal_v, ratio_not_equal_v)
|
||||
(ratio_less_v, ratio_less_equal_v, ratio_greater_v)
|
||||
(ratio_greater_equal_v): Likewise.
|
||||
* include/std/system_error (is_error_code_enum_v)
|
||||
(is_error_condition_enum_v): Likewise.
|
||||
* include/std/tuple (tuple_size_v): Likewise.
|
||||
* type_traits (conjunction_v, disjunction_v, negation_v)
|
||||
(is_void_v, is_null_pointer_v, is_integral_v, is_floating_point_v)
|
||||
(is_array_v, is_pointer_v, is_lvalue_reference_v)
|
||||
(is_rvalue_reference_v, is_member_object_pointer_v)
|
||||
(is_member_function_pointer_v, is_enum_v, is_union_v)
|
||||
(is_class_v, is_function_v, is_reference_v, is_arithmetic_v)
|
||||
(is_fundamental_v, is_object_v, is_scalar_v, is_compound_v)
|
||||
(is_member_pointer_v, is_const_v, is_volatile_v, is_trivial_v)
|
||||
(is_trivially_copyable_v, is_standard_layout_v)
|
||||
(is_pod_v, is_literal_type_v, is_empty_v, is_polymorphic_v)
|
||||
(is_abstract_v, is_final_v, is_signed_v, is_unsigned_v)
|
||||
(is_constructible_v, is_default_constructible_v)
|
||||
(is_copy_constructible_v, is_move_constructible_v)
|
||||
(is_assignable_v, is_copy_assignable_v, is_move_assignable_v)
|
||||
(is_destructible_v, is_trivially_constructible_v)
|
||||
(is_trivially_default_constructible_v)
|
||||
(is_trivially_copy_constructible_v, is_trivially_move_constructible_v)
|
||||
(is_trivially_assignable_v, is_trivially_copy_assignable_v)
|
||||
(is_trivially_move_assignable_v, is_trivially_destructible_v)
|
||||
(is_nothrow_constructible_v, is_nothrow_default_constructible_v)
|
||||
(is_nothrow_copy_constructible_v, is_nothrow_move_constructible_v)
|
||||
(is_nothrow_assignable_v, is_nothrow_copy_assignable_v)
|
||||
(is_nothrow_move_assignable_v, is_nothrow_destructible_v)
|
||||
(has_virtual_destructor_v, alignment_of_v, rank_v, extent_v)
|
||||
(is_same_v, is_base_of_v, is_convertible_v): Likewise.
|
||||
* testsuite/19_diagnostics/error_code/is_error_code_v.cc: Likewise.
|
||||
* testsuite/20_util/duration/requirements/treat_as_floating_point_v.cc:
|
||||
Likewise.
|
||||
* testsuite/20_util/ratio/requirements/ratio_equal_v.cc: Likewise.
|
||||
* testsuite/20_util/tuple/tuple_size_v.cc: Likewise.
|
||||
* testsuite/20_util/variable_templates_for_traits.cc: Likewise.
|
||||
|
||||
2016-07-29 Andreas Schwab <schwab@linux-m68k.org>
|
||||
|
||||
* config/abi/post/aarch64-linux-gnu/baseline_symbols.txt: Update.
|
||||
|
|
|
|||
|
|
@ -208,7 +208,11 @@ _GLIBCXX_END_NAMESPACE_VERSION
|
|||
struct treat_as_floating_point
|
||||
: is_floating_point<_Rep>
|
||||
{ };
|
||||
|
||||
#if __cplusplus > 201402L
|
||||
template <typename _Rep>
|
||||
constexpr bool treat_as_floating_point_v =
|
||||
treat_as_floating_point<_Rep>::value;
|
||||
#endif // C++17
|
||||
/// duration_values
|
||||
template<typename _Rep>
|
||||
struct duration_values
|
||||
|
|
|
|||
|
|
@ -401,6 +401,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
: integral_constant<bool, !ratio_less<_R1, _R2>::value>
|
||||
{ };
|
||||
|
||||
#if __cplusplus > 201402L
|
||||
template <typename _R1, typename _R2>
|
||||
constexpr bool ratio_equal_v = ratio_equal<_R1, _R2>::value;
|
||||
template <typename _R1, typename _R2>
|
||||
constexpr bool ratio_not_equal_v = ratio_not_equal<_R1, _R2>::value;
|
||||
template <typename _R1, typename _R2>
|
||||
constexpr bool ratio_less_v = ratio_less<_R1, _R2>::value;
|
||||
template <typename _R1, typename _R2>
|
||||
constexpr bool ratio_less_equal_v = ratio_less_equal<_R1, _R2>::value;
|
||||
template <typename _R1, typename _R2>
|
||||
constexpr bool ratio_greater_v = ratio_greater<_R1, _R2>::value;
|
||||
template <typename _R1, typename _R2>
|
||||
constexpr bool ratio_greater_equal_v
|
||||
= ratio_greater_equal<_R1, _R2>::value;
|
||||
#endif // C++17
|
||||
|
||||
template<typename _R1, typename _R2,
|
||||
bool = (_R1::num >= 0),
|
||||
bool = (_R2::num >= 0),
|
||||
|
|
|
|||
|
|
@ -60,6 +60,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
struct is_error_condition_enum<errc>
|
||||
: public true_type { };
|
||||
|
||||
#if __cplusplus > 201402L
|
||||
template <typename _Tp>
|
||||
constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_error_condition_enum_v =
|
||||
is_error_condition_enum<_Tp>::value;
|
||||
#endif // C++17
|
||||
inline namespace _V2 {
|
||||
|
||||
/// error_category
|
||||
|
|
|
|||
|
|
@ -1265,6 +1265,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
struct tuple_size<tuple<_Elements...>>
|
||||
: public integral_constant<std::size_t, sizeof...(_Elements)> { };
|
||||
|
||||
#if __cplusplus > 201402L
|
||||
template <typename _Tp>
|
||||
constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
|
||||
#endif
|
||||
|
||||
template<std::size_t __i, typename _Head, typename... _Tail>
|
||||
constexpr _Head&
|
||||
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
|
||||
|
|
|
|||
|
|
@ -172,6 +172,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
struct negation
|
||||
: __not_<_Pp>
|
||||
{ };
|
||||
|
||||
template<typename... _Bn>
|
||||
constexpr bool conjunction_v
|
||||
= conjunction<_Bn...>::value;
|
||||
|
||||
template<typename... _Bn>
|
||||
constexpr bool disjunction_v
|
||||
= disjunction<_Bn...>::value;
|
||||
|
||||
template<typename _Pp>
|
||||
constexpr bool negation_v
|
||||
= negation<_Pp>::value;
|
||||
|
||||
#endif
|
||||
|
||||
// For several sfinae-friendly trait implementations we transport both the
|
||||
|
|
@ -2765,6 +2778,159 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|||
constexpr bool is_nothrow_swappable_with_v =
|
||||
is_nothrow_swappable_with<_Tp, _Up>::value;
|
||||
#endif // __cplusplus >= 201402L
|
||||
|
||||
#if __cplusplus > 201402L
|
||||
template <typename _Tp>
|
||||
constexpr bool is_void_v = is_void<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_integral_v = is_integral<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_array_v = is_array<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_pointer_v = is_pointer<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_member_object_pointer_v =
|
||||
is_member_object_pointer<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_member_function_pointer_v =
|
||||
is_member_function_pointer<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_enum_v = is_enum<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_union_v = is_union<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_class_v = is_class<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_function_v = is_function<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_reference_v = is_reference<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_object_v = is_object<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_scalar_v = is_scalar<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_compound_v = is_compound<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_const_v = is_const<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_volatile_v = is_volatile<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_trivial_v = is_trivial<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_trivially_copyable_v = is_trivially_copyable<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_pod_v = is_pod<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_literal_type_v = is_literal_type<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_empty_v = is_empty<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_abstract_v = is_abstract<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_final_v = is_final<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_signed_v = is_signed<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
|
||||
template <typename _Tp, typename... _Args>
|
||||
constexpr bool is_constructible_v = is_constructible<_Tp, _Args...>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_default_constructible_v =
|
||||
is_default_constructible<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value;
|
||||
template <typename _Tp, typename _Up>
|
||||
constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_destructible_v = is_destructible<_Tp>::value;
|
||||
template <typename _Tp, typename... _Args>
|
||||
constexpr bool is_trivially_constructible_v =
|
||||
is_trivially_constructible<_Tp, _Args...>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_trivially_default_constructible_v =
|
||||
is_trivially_default_constructible<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_trivially_copy_constructible_v =
|
||||
is_trivially_copy_constructible<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_trivially_move_constructible_v =
|
||||
is_trivially_move_constructible<_Tp>::value;
|
||||
template <typename _Tp, typename _Up>
|
||||
constexpr bool is_trivially_assignable_v =
|
||||
is_trivially_assignable<_Tp, _Up>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_trivially_copy_assignable_v =
|
||||
is_trivially_copy_assignable<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_trivially_move_assignable_v =
|
||||
is_trivially_move_assignable<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_trivially_destructible_v =
|
||||
is_trivially_destructible<_Tp>::value;
|
||||
template <typename _Tp, typename... _Args>
|
||||
constexpr bool is_nothrow_constructible_v =
|
||||
is_nothrow_constructible<_Tp, _Args...>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_nothrow_default_constructible_v =
|
||||
is_nothrow_default_constructible<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_nothrow_copy_constructible_v =
|
||||
is_nothrow_copy_constructible<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_nothrow_move_constructible_v =
|
||||
is_nothrow_move_constructible<_Tp>::value;
|
||||
template <typename _Tp, typename _Up>
|
||||
constexpr bool is_nothrow_assignable_v =
|
||||
is_nothrow_assignable<_Tp, _Up>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_nothrow_copy_assignable_v =
|
||||
is_nothrow_copy_assignable<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_nothrow_move_assignable_v =
|
||||
is_nothrow_move_assignable<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool is_nothrow_destructible_v =
|
||||
is_nothrow_destructible<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr bool has_virtual_destructor_v =
|
||||
has_virtual_destructor<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr size_t alignment_of_v = alignment_of<_Tp>::value;
|
||||
template <typename _Tp>
|
||||
constexpr size_t rank_v = rank<_Tp>::value;
|
||||
template <typename _Tp, unsigned _Idx = 0>
|
||||
constexpr size_t extent_v = extent<_Tp, _Idx>::value;
|
||||
template <typename _Tp, typename _Up>
|
||||
constexpr bool is_same_v = is_same<_Tp, _Up>::value;
|
||||
template <typename _Base, typename _Derived>
|
||||
constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value;
|
||||
template <typename _From, typename _To>
|
||||
constexpr bool is_convertible_v = is_convertible<_From, _To>::value;
|
||||
#endif // C++17
|
||||
#endif
|
||||
|
||||
_GLIBCXX_END_NAMESPACE_VERSION
|
||||
|
|
|
|||
|
|
@ -0,0 +1,39 @@
|
|||
// { dg-options "-std=gnu++17" }
|
||||
// { dg-do compile }
|
||||
|
||||
// Copyright (C) 2014-2016 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 moved_to of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
#include <system_error>
|
||||
#include <future>
|
||||
using namespace std;
|
||||
|
||||
// These tests are rather simple, the front-end tests already test
|
||||
// variable templates, and the library tests for the underlying
|
||||
// traits are more elaborate. These are just simple sanity tests.
|
||||
|
||||
static_assert(is_error_code_enum_v<future_errc>
|
||||
&& is_error_code_enum<future_errc>::value, "");
|
||||
|
||||
static_assert(!is_error_code_enum_v<int>
|
||||
&& !is_error_code_enum<int>::value, "");
|
||||
|
||||
static_assert(is_error_condition_enum_v<errc>
|
||||
&& is_error_condition_enum<errc>::value, "");
|
||||
|
||||
static_assert(!is_error_condition_enum_v<int>
|
||||
&& !is_error_condition_enum<int>::value, "");
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
// { dg-options "-std=gnu++17" }
|
||||
// { dg-do compile }
|
||||
|
||||
// Copyright (C) 2014-2016 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 moved_to of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
#include <chrono>
|
||||
|
||||
using namespace std::chrono;
|
||||
|
||||
// These tests are rather simple, the front-end tests already test
|
||||
// variable templates, and the library tests for the underlying
|
||||
// traits are more elaborate. These are just simple sanity tests.
|
||||
|
||||
static_assert(!treat_as_floating_point_v<int>
|
||||
&& !treat_as_floating_point<int>::value, "");
|
||||
|
||||
static_assert(treat_as_floating_point_v<double>
|
||||
&& treat_as_floating_point<double>::value, "");
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
// { dg-options "-std=gnu++17" }
|
||||
// { dg-do compile }
|
||||
|
||||
// Copyright (C) 2014-2016 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 moved_to of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
#include <ratio>
|
||||
|
||||
using namespace std;
|
||||
|
||||
// These tests are rather simple, the front-end tests already test
|
||||
// variable templates, and the library tests for the underlying
|
||||
// traits are more elaborate. These are just simple sanity tests.
|
||||
|
||||
static_assert(ratio_equal_v<ratio<1, 3>, ratio<2, 6>>
|
||||
&& ratio_equal<ratio<1, 3>, ratio<2, 6>>::value, "");
|
||||
|
||||
static_assert(ratio_not_equal_v<ratio<1, 3>, ratio<2, 5>>
|
||||
&& ratio_not_equal<ratio<1, 3>, ratio<2, 5>>::value, "");
|
||||
|
||||
static_assert(ratio_less_v<ratio<1, 4>, ratio<1, 3>>
|
||||
&& ratio_less<ratio<1, 4>, ratio<1, 3>>::value, "");
|
||||
|
||||
static_assert(ratio_less_equal_v<ratio<1, 4>, ratio<1, 4>>
|
||||
&& ratio_less_equal_v<ratio<1, 4>, ratio<1, 3>>
|
||||
&& ratio_less_equal<ratio<1, 4>, ratio<1, 4>>::value
|
||||
&& ratio_less_equal<ratio<1, 4>, ratio<1, 3>>::value, "");
|
||||
|
||||
static_assert(ratio_greater_v<ratio<1, 3>, ratio<1, 4>>
|
||||
&& ratio_greater<ratio<1, 3>, ratio<1, 4>>::value, "");
|
||||
|
||||
static_assert(ratio_greater_equal_v<ratio<1, 4>, ratio<1, 4>>
|
||||
&& ratio_greater_equal_v<ratio<1, 3>, ratio<1, 4>>
|
||||
&& ratio_greater_equal<ratio<1, 4>, ratio<1, 4>>::value
|
||||
&& ratio_greater_equal<ratio<1, 3>, ratio<1, 4>>::value, "");
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
// { dg-options "-std=gnu++17" }
|
||||
// { dg-do compile }
|
||||
|
||||
// Copyright (C) 2014-2016 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 moved_to of the GNU General Public License along
|
||||
// with this library; see the file COPYING3. If not see
|
||||
// <http://www.gnu.org/licenses/>.
|
||||
|
||||
#include <tuple>
|
||||
|
||||
using namespace std;
|
||||
|
||||
// These tests are rather simple, the front-end tests already test
|
||||
// variable templates, and the library tests for the underlying
|
||||
// traits are more elaborate. These are just simple sanity tests.
|
||||
|
||||
static_assert(tuple_size_v<tuple<int>> == 1
|
||||
&& tuple_size<tuple<int>>::value == 1, "");
|
||||
|
||||
static_assert(tuple_size_v<tuple<int, int>> == 2
|
||||
&& tuple_size<tuple<int, int>>::value == 2, "");
|
||||
|
|
@ -0,0 +1,344 @@
|
|||
// { dg-options "-std=gnu++17" }
|
||||
// { dg-do compile }
|
||||
|
||||
// Copyright (C) 2014-2016 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 moved_to 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>
|
||||
|
||||
using namespace std;
|
||||
|
||||
// These tests are rather simple, the front-end tests already test
|
||||
// variable templates, and the library tests for the underlying
|
||||
// traits are more elaborate. These are just simple sanity tests.
|
||||
|
||||
static_assert(is_void_v<void> && is_void<void>::value, "");
|
||||
static_assert(!is_void_v<int> && !is_void<int>::value, "");
|
||||
|
||||
static_assert(is_null_pointer_v<nullptr_t>
|
||||
&& is_null_pointer<nullptr_t>::value, "");
|
||||
static_assert(!is_null_pointer_v<void*>
|
||||
&& !is_null_pointer<void*>::value, "");
|
||||
|
||||
static_assert(is_integral_v<int> && is_integral<int>::value, "");
|
||||
static_assert(!is_integral_v<int*> && !is_integral<int*>::value, "");
|
||||
|
||||
static_assert(is_floating_point_v<float>
|
||||
&& is_floating_point<float>::value, "");
|
||||
static_assert(!is_floating_point_v<int>
|
||||
&& !is_floating_point<int>::value, "");
|
||||
|
||||
static_assert(is_array_v<char[42]> && is_array<char[42]>::value, "");
|
||||
static_assert(!is_array_v<char*> && !is_array<char*>::value, "");
|
||||
|
||||
static_assert(is_pointer_v<int*> && is_pointer<int*>::value, "");
|
||||
static_assert(!is_pointer_v<int> && !is_pointer<int>::value, "");
|
||||
|
||||
static_assert(is_lvalue_reference_v<int&>
|
||||
&& is_lvalue_reference<int&>::value, "");
|
||||
static_assert(!is_lvalue_reference_v<int>
|
||||
&& !is_lvalue_reference<int>::value, "");
|
||||
|
||||
static_assert(is_rvalue_reference_v<int&&>
|
||||
&& is_rvalue_reference<int&&>::value, "");
|
||||
static_assert(!is_rvalue_reference_v<int>
|
||||
&& !is_rvalue_reference<int>::value, "");
|
||||
|
||||
struct EmptyFinal final {};
|
||||
|
||||
static_assert(is_member_object_pointer_v<int (EmptyFinal::*)>
|
||||
&& is_member_object_pointer<int (EmptyFinal::*)>::value, "");
|
||||
static_assert(!is_member_object_pointer_v<void*>
|
||||
&& !is_member_object_pointer<void*>::value, "");
|
||||
|
||||
static_assert(is_member_function_pointer_v<int (EmptyFinal::*)()>
|
||||
&& is_member_function_pointer<int (EmptyFinal::*)()>::value, "");
|
||||
static_assert(!is_member_function_pointer_v<void*>
|
||||
&& !is_member_function_pointer<void*>::value, "");
|
||||
|
||||
enum Enum {};
|
||||
|
||||
static_assert(is_enum_v<Enum> && is_enum<Enum>::value, "");
|
||||
static_assert(!is_enum_v<int> && !is_enum<int>::value, "");
|
||||
|
||||
union Union;
|
||||
|
||||
static_assert(is_union_v<Union> && is_union<Union>::value, "");
|
||||
static_assert(!is_union_v<int> && !is_union<int>::value, "");
|
||||
|
||||
static_assert(is_class_v<EmptyFinal> && is_class<EmptyFinal>::value, "");
|
||||
static_assert(!is_class_v<int> && !is_class<int>::value, "");
|
||||
|
||||
static_assert(is_function_v<void()> && is_function<void()>::value, "");
|
||||
static_assert(!is_function_v<void(*)()> && !is_function<void(*)()>::value, "");
|
||||
|
||||
static_assert(is_reference_v<int&> && is_reference<int&>::value, "");
|
||||
static_assert(!is_reference_v<int> && !is_reference<int>::value, "");
|
||||
|
||||
static_assert(is_arithmetic_v<int> && is_arithmetic<int>::value, "");
|
||||
static_assert(!is_arithmetic_v<void*> && !is_arithmetic<void*>::value, "");
|
||||
|
||||
static_assert(is_fundamental_v<int> && is_fundamental<int>::value, "");
|
||||
static_assert(!is_fundamental_v<EmptyFinal>
|
||||
&& !is_fundamental<EmptyFinal>::value, "");
|
||||
|
||||
static_assert(is_object_v<int> && is_object<int>::value, "");
|
||||
static_assert(!is_object_v<int&> && !is_object<int&>::value, "");
|
||||
|
||||
static_assert(is_scalar_v<int> && is_scalar<int>::value, "");
|
||||
static_assert(!is_scalar_v<int&> && !is_scalar<int&>::value, "");
|
||||
|
||||
static_assert(is_compound_v<EmptyFinal>
|
||||
&& is_compound<EmptyFinal>::value, "");
|
||||
static_assert(!is_compound_v<int> && !is_compound<int>::value, "");
|
||||
|
||||
static_assert(is_member_pointer_v<int (EmptyFinal::*)>
|
||||
&& is_member_pointer<int (EmptyFinal::*)>::value, "");
|
||||
static_assert(!is_member_pointer_v<void*>
|
||||
&& !is_member_pointer<void*>::value, "");
|
||||
|
||||
static_assert(is_const_v<const int> && is_const<const int>::value, "");
|
||||
static_assert(!is_const_v<int> && !is_const<int>::value, "");
|
||||
|
||||
static_assert(is_volatile_v<volatile int>
|
||||
&& is_volatile<volatile int>::value, "");
|
||||
static_assert(!is_volatile_v<int> && !is_volatile<int>::value, "");
|
||||
|
||||
struct NType
|
||||
{
|
||||
NType(int);
|
||||
~NType();
|
||||
int i;
|
||||
private:
|
||||
NType(const NType&);
|
||||
NType& operator=(const NType&);
|
||||
int i2;
|
||||
};
|
||||
|
||||
static_assert(is_trivial_v<int> && is_trivial<int>::value, "");
|
||||
static_assert(!is_trivial_v<NType> && !is_trivial<NType>::value, "");
|
||||
|
||||
static_assert(is_trivially_copyable_v<int>
|
||||
&& is_trivially_copyable<int>::value, "");
|
||||
static_assert(!is_trivially_copyable_v<NType>
|
||||
&& !is_trivially_copyable<NType>::value, "");
|
||||
|
||||
static_assert(is_standard_layout_v<int>
|
||||
&& is_standard_layout<int>::value, "");
|
||||
static_assert(!is_standard_layout_v<NType>
|
||||
&& !is_standard_layout<NType>::value, "");
|
||||
|
||||
static_assert(is_pod_v<int>
|
||||
&& is_pod<int>::value, "");
|
||||
static_assert(!is_pod_v<NType>
|
||||
&& !is_pod<NType>::value, "");
|
||||
|
||||
static_assert(is_literal_type_v<int>
|
||||
&& is_literal_type<int>::value, "");
|
||||
static_assert(!is_literal_type_v<NType>
|
||||
&& !is_literal_type<NType>::value, "");
|
||||
|
||||
static_assert(is_empty_v<EmptyFinal>
|
||||
&& is_empty<EmptyFinal>::value, "");
|
||||
static_assert(!is_empty_v<NType>
|
||||
&& !is_empty<NType>::value, "");
|
||||
|
||||
struct Abstract {protected: virtual ~Abstract() = 0;};
|
||||
struct Poly : Abstract {virtual ~Poly();};
|
||||
|
||||
static_assert(is_polymorphic_v<Poly>
|
||||
&& is_polymorphic<Poly>::value, "");
|
||||
static_assert(!is_polymorphic_v<EmptyFinal>
|
||||
&& !is_polymorphic<EmptyFinal>::value, "");
|
||||
|
||||
|
||||
|
||||
static_assert(is_abstract_v<Abstract>
|
||||
&& is_abstract<Abstract>::value, "");
|
||||
static_assert(!is_abstract_v<EmptyFinal>
|
||||
&& !is_abstract<EmptyFinal>::value, "");
|
||||
|
||||
static_assert(is_final_v<EmptyFinal>
|
||||
&& is_final<EmptyFinal>::value, "");
|
||||
static_assert(!is_final_v<Abstract>
|
||||
&& !is_final<Abstract>::value, "");
|
||||
|
||||
static_assert(is_signed_v<int> && is_signed<int>::value, "");
|
||||
static_assert(!is_signed_v<unsigned int>
|
||||
&& !is_signed<unsigned int>::value, "");
|
||||
|
||||
static_assert(is_constructible_v<int, int>
|
||||
&& is_constructible<int, int>::value, "");
|
||||
static_assert(!is_constructible_v<int, void*>
|
||||
&& !is_constructible<int, void*>::value, "");
|
||||
|
||||
static_assert(is_default_constructible_v<int>
|
||||
&& is_default_constructible<int>::value, "");
|
||||
static_assert(!is_default_constructible_v<NType>
|
||||
&& !is_default_constructible<NType>::value, "");
|
||||
|
||||
static_assert(is_copy_constructible_v<int>
|
||||
&& is_copy_constructible<int>::value, "");
|
||||
static_assert(!is_copy_constructible_v<NType>
|
||||
&& !is_copy_constructible<NType>::value, "");
|
||||
|
||||
static_assert(is_move_constructible_v<int>
|
||||
&& is_copy_constructible<int>::value, "");
|
||||
static_assert(!is_move_constructible_v<NType>
|
||||
&& !is_copy_constructible<NType>::value, "");
|
||||
|
||||
static_assert(is_assignable_v<int&, int>
|
||||
&& is_assignable<int&, int>::value, "");
|
||||
static_assert(!is_assignable_v<int, int>
|
||||
&& !is_assignable<int, int>::value, "");
|
||||
|
||||
static_assert(is_copy_assignable_v<int>
|
||||
&& is_copy_assignable<int>::value, "");
|
||||
static_assert(!is_copy_assignable_v<NType>
|
||||
&& !is_copy_assignable<NType>::value, "");
|
||||
|
||||
static_assert(is_move_assignable_v<int>
|
||||
&& is_move_assignable<int>::value, "");
|
||||
static_assert(!is_move_assignable_v<NType>
|
||||
&& !is_move_assignable<NType>::value, "");
|
||||
|
||||
static_assert(is_destructible_v<int>
|
||||
&& is_destructible<int>::value, "");
|
||||
static_assert(!is_destructible_v<Abstract>
|
||||
&& !is_destructible<Abstract>::value, "");
|
||||
|
||||
static_assert(is_trivially_constructible_v<int, int>
|
||||
&& is_trivially_constructible<int, int>::value, "");
|
||||
static_assert(!is_trivially_constructible_v<NType, NType>
|
||||
&& !is_trivially_constructible<NType, NType>::value, "");
|
||||
|
||||
static_assert(is_trivially_default_constructible_v<int>
|
||||
&& is_trivially_default_constructible<int>::value, "");
|
||||
static_assert(!is_trivially_default_constructible_v<NType>
|
||||
&& !is_trivially_default_constructible<NType>::value, "");
|
||||
|
||||
static_assert(is_trivially_copy_constructible_v<int>
|
||||
&& is_trivially_copy_constructible<int>::value, "");
|
||||
static_assert(!is_trivially_copy_constructible_v<NType>
|
||||
&& !is_trivially_copy_constructible<NType>::value, "");
|
||||
|
||||
static_assert(is_trivially_move_constructible_v<int>
|
||||
&& is_trivially_move_constructible<int>::value, "");
|
||||
static_assert(!is_trivially_move_constructible_v<NType>
|
||||
&& !is_trivially_move_constructible<NType>::value, "");
|
||||
|
||||
static_assert(is_trivially_assignable_v<int&, int>
|
||||
&& is_trivially_assignable<int&, int>::value, "");
|
||||
static_assert(!is_trivially_assignable_v<NType, NType>
|
||||
&& !is_trivially_assignable<NType, NType>::value, "");
|
||||
|
||||
static_assert(is_trivially_copy_assignable_v<int>
|
||||
&& is_trivially_copy_assignable<int>::value, "");
|
||||
static_assert(!is_trivially_copy_assignable_v<NType>
|
||||
&& !is_trivially_copy_assignable<NType>::value, "");
|
||||
|
||||
static_assert(is_trivially_move_assignable_v<int>
|
||||
&& is_trivially_move_assignable<int>::value, "");
|
||||
static_assert(!is_trivially_move_assignable_v<NType>
|
||||
&& !is_trivially_move_assignable<NType>::value, "");
|
||||
|
||||
static_assert(is_trivially_destructible_v<int>
|
||||
&& is_trivially_destructible<int>::value, "");
|
||||
static_assert(!is_trivially_destructible_v<Abstract>
|
||||
&& !is_trivially_destructible<Abstract>::value, "");
|
||||
|
||||
static_assert(is_nothrow_constructible_v<int, int>
|
||||
&& is_nothrow_constructible<int, int>::value, "");
|
||||
static_assert(!is_nothrow_constructible_v<NType, NType>
|
||||
&& !is_nothrow_constructible<NType, NType>::value, "");
|
||||
|
||||
static_assert(is_nothrow_default_constructible_v<int>
|
||||
&& is_nothrow_default_constructible<int>::value, "");
|
||||
static_assert(!is_nothrow_default_constructible_v<NType>
|
||||
&& !is_nothrow_default_constructible<NType>::value, "");
|
||||
|
||||
static_assert(is_nothrow_copy_constructible_v<int>
|
||||
&& is_nothrow_copy_constructible<int>::value, "");
|
||||
static_assert(!is_nothrow_copy_constructible_v<NType>
|
||||
&& !is_nothrow_copy_constructible<NType>::value, "");
|
||||
|
||||
static_assert(is_nothrow_move_constructible_v<int>
|
||||
&& is_nothrow_move_constructible<int>::value, "");
|
||||
static_assert(!is_nothrow_move_constructible_v<NType>
|
||||
&& !is_nothrow_move_constructible<NType>::value, "");
|
||||
|
||||
static_assert(is_nothrow_assignable_v<int&, int>
|
||||
&& is_nothrow_assignable<int&, int>::value, "");
|
||||
static_assert(!is_nothrow_assignable_v<NType, NType>
|
||||
&& !is_nothrow_assignable<NType, NType>::value, "");
|
||||
|
||||
static_assert(is_nothrow_copy_assignable_v<int>
|
||||
&& is_nothrow_copy_assignable<int>::value, "");
|
||||
static_assert(!is_nothrow_copy_assignable_v<NType>
|
||||
&& !is_nothrow_copy_assignable<NType>::value, "");
|
||||
|
||||
static_assert(is_nothrow_move_assignable_v<int>
|
||||
&& is_nothrow_move_assignable<int>::value, "");
|
||||
static_assert(!is_nothrow_move_assignable_v<NType>
|
||||
&& !is_nothrow_move_assignable<NType>::value, "");
|
||||
|
||||
static_assert(has_virtual_destructor_v<Abstract>
|
||||
&& has_virtual_destructor<Abstract>::value, "");
|
||||
static_assert(!has_virtual_destructor_v<NType>
|
||||
&& !has_virtual_destructor<NType>::value, "");
|
||||
|
||||
static_assert(alignment_of_v<int> == alignof(int)
|
||||
&& alignment_of<int>::value == alignof(int) , "");
|
||||
|
||||
static_assert(rank_v<int[1][1]> == rank<int[1][1]>::value, "");
|
||||
|
||||
static_assert(extent_v<int[1][2], 1> == 2
|
||||
&& extent<int[1][2], 1>::value == 2, "");
|
||||
|
||||
static_assert(is_same_v<int, int> && is_same<int, int>::value, "");
|
||||
static_assert(!is_same_v<int, char> && !is_same<int, char>::value, "");
|
||||
|
||||
static_assert(is_base_of_v<Abstract, Poly>
|
||||
&& is_base_of<Abstract, Poly>::value, "");
|
||||
static_assert(!is_base_of_v<Abstract, NType>
|
||||
&& !is_base_of<Abstract, NType>::value, "");
|
||||
|
||||
static_assert(is_convertible_v<int&, const int&>
|
||||
&& is_convertible<int&, const int&>::value, "");
|
||||
static_assert(!is_convertible_v<const int&, int&>
|
||||
&& !is_convertible<const int&, int&>::value, "");
|
||||
|
||||
static_assert(negation_v<false_type>, "");
|
||||
static_assert(!negation_v<true_type>, "");
|
||||
static_assert(conjunction_v<>, "");
|
||||
static_assert(!disjunction_v<>, "");
|
||||
static_assert(conjunction_v<true_type>, "");
|
||||
static_assert(!conjunction_v<false_type>, "");
|
||||
static_assert(disjunction_v<true_type>, "");
|
||||
static_assert(!disjunction_v<false_type>, "");
|
||||
static_assert(conjunction_v<true_type, true_type>, "");
|
||||
static_assert(!conjunction_v<true_type, false_type>, "");
|
||||
static_assert(disjunction_v<false_type, true_type>, "");
|
||||
static_assert(!disjunction_v<false_type, false_type>, "");
|
||||
static_assert(conjunction_v<true_type, true_type,
|
||||
true_type>, "");
|
||||
static_assert(!conjunction_v<true_type, true_type,
|
||||
false_type>, "");
|
||||
static_assert(disjunction_v<false_type, false_type,
|
||||
true_type>, "");
|
||||
static_assert(!disjunction_v<false_type, false_type,
|
||||
false_type>, "");
|
||||
Loading…
Reference in New Issue