git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

libstdc++: Add std::__conditional_t alias template 

This change is inspired by the suggestion in
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1715r0.html

The new std::__conditional_t alias template is functionally equivalent
to std::conditional_t but should be more efficient to compile, due to
only ever instantiating two specializations (std::__conditional<true>
and std::__conditional<false>) rather than a new specialization for
every use of std::conditional.

The new alias template is also available in C++11, unlike the C++14
std::conditional_t alias.

Signed-off-by: Jonathan Wakely <jwakely@redhat.com>

libstdc++-v3/ChangeLog:

	* include/std/type_traits (__conditional): New class template
	for internal uses of std::conditional.
	(__conditional_t): New alias template to replace conditional_t.
	(__and_, __or_, __result_of_memfun, __result_of_memobj): Use
	__conditional_t instead of conditional::type.
	* include/bits/atomic_base.h (__atomic_impl::_Diff): Likewise.
	* include/bits/hashtable.h (_Hashtable): Likewise.
	* include/bits/hashtable_policy.h (_Node_iterator, _Insert_base)
	(_Local_iterator): Likewise. Replace typedefs with
	using-declarations.
	* include/bits/move.h (move_if_noexcept): Use __conditional_t.
	* include/bits/parse_numbers.h (_Select_int_base): Likewise.
	* include/bits/ptr_traits.h (__make_not_void): Likewise.
	* include/bits/ranges_algobase.h (__copy_or_move_backward)
	(__copy_or_move): Likewise.
	* include/bits/ranges_base.h (borrowed_iterator_t): Likewise.
	* include/bits/ranges_util.h (borrowed_subrange_t): Likewise.
	* include/bits/regex_compiler.h (_BracketMatcher): Use
	__conditional_t. Replace typedefs with using-declarations.
	* include/bits/shared_ptr_base.h (__shared_count): Use
	__conditional_t.
	* include/bits/stl_algobase.h (__copy_move, __copy_move_backward):
	Likewise.
	* include/bits/stl_iterator.h (__detail::__clamp_iter_cat)
	(reverse_iterator::iterator_concept)
	(__make_move_if_noexcept_iterator)
	(iterator_traits<common_iterator<_It, _Sent>>)
	(iterator_traits<counted_iterator<_It>>): Likewise.
	* include/bits/stl_pair.h (_PCC, pair::operator=): Likewise.
	* include/bits/stl_tree.h (_Rb_tree::insert_return_type)
	(_Rb_tree::_M_clone_node): Likewise.
	* include/bits/unique_ptr.h (unique_ptr(unique_ptr<U,E>&&)):
	Likewise.
	* include/bits/uses_allocator.h (__uses_alloc): Likewise.
	(__is_uses_allocator_predicate): Likewise.
	* include/debug/functions.h (__foreign_iterator_aux2): Likewise.
	* include/experimental/any (any::_Manager, __any_caster):
	Likewise.
	* include/experimental/executor (async_completion): Likewise.
	* include/experimental/functional (__boyer_moore_base_t):
	Likewise.
	* include/std/any (any::_Manager): Likewise.
	* include/std/functional (__boyer_moore_base_t): Likewise.
	* include/std/ranges (borrowed_iterator_t)
	(borrowed_subrange_t, __detail::__maybe_present_t)
	(__detail::__maybe_const_t, split_view): Likewise.
	* include/std/tuple (__empty_not_final, tuple::operator=):
	Likewise.
	* include/std/variant (__detail::__variant::__get_t): Likewise.
This commit is contained in:
Jonathan Wakely 2021-05-06 16:26:21 +01:00
parent cfb582f627
commit a09bb4a852
27 changed files with 168 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libstdc++-v3/include/bits/atomic_base.h
View File

@ -946,7 +946,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// As above, but for difference_type arguments.
template<typename _Tp>
using _Diff = conditional_t<is_pointer_v<_Tp>, ptrdiff_t, _Val<_Tp>>;
using _Diff = __conditional_t<is_pointer_v<_Tp>, ptrdiff_t, _Val<_Tp>>;
template<size_t _Size, size_t _Align>
_GLIBCXX_ALWAYS_INLINE bool

14
libstdc++-v3/include/bits/hashtable.h
View File

@ -317,8 +317,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Ht>
static constexpr
typename conditional<std::is_lvalue_reference<_Ht>::value,
const value_type&, value_type&&>::type
__conditional_t<std::is_lvalue_reference<_Ht>::value,
const value_type&, value_type&&>
__fwd_value_for(value_type& __val) noexcept
{ return std::move(__val); }
@ -875,10 +875,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_insert_unique(_Kt&&, _Arg&&, const _NodeGenerator&);
template<typename _Kt>
static typename conditional<
static __conditional_t<
__and_<__is_nothrow_invocable<_Hash&, const key_type&>,
__not_<__is_nothrow_invocable<_Hash&, _Kt>>>::value,
key_type, _Kt&&>::type
key_type, _Kt&&>
_S_forward_key(_Kt&& __k)
{ return std::forward<_Kt>(__k); }
@ -1540,9 +1540,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
__alloc_node_gen_t __alloc_gen(*this);
using _Fwd_Ht = typename
conditional<__move_if_noexcept_cond<value_type>::value,
const _Hashtable&, _Hashtable&&>::type;
using _Fwd_Ht = __conditional_t<
__move_if_noexcept_cond<value_type>::value,
const _Hashtable&, _Hashtable&&>;
_M_assign(std::forward<_Fwd_Ht>(__ht), __alloc_gen);
__ht.clear();
}

39
libstdc++-v3/include/bits/hashtable_policy.h
View File

@ -360,15 +360,15 @@ namespace __detail
using __node_type = typename __base_type::__node_type;
public:
typedef _Value value_type;
typedef std::ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
using value_type = _Value;
using difference_type = std::ptrdiff_t;
using iterator_category = std::forward_iterator_tag;
using pointer = typename std::conditional<__constant_iterators,
const value_type*, value_type*>::type;
using pointer = __conditional_t<__constant_iterators,
const value_type*, value_type*>;
using reference = typename std::conditional<__constant_iterators,
const value_type&, value_type&>::type;
using reference = __conditional_t<__constant_iterators,
const value_type&, value_type&>;
_Node_iterator() = default;
@ -867,12 +867,13 @@ namespace __detail
using iterator = _Node_iterator<_Value, __constant_iterators::value,
__hash_cached::value>;
using const_iterator = _Node_const_iterator<_Value, __constant_iterators::value,
using const_iterator = _Node_const_iterator<_Value,
__constant_iterators::value,
__hash_cached::value>;
using __ireturn_type = typename std::conditional<__unique_keys::value,
std::pair<iterator, bool>,
iterator>::type;
using __ireturn_type = __conditional_t<__unique_keys::value,
std::pair<iterator, bool>,
iterator>;
__ireturn_type
insert(const value_type& __v)
@ -1482,15 +1483,13 @@ namespace __detail
using __hash_code_base = typename __base_type::__hash_code_base;
public:
typedef _Value value_type;
typedef typename std::conditional<__constant_iterators,
const value_type*, value_type*>::type
pointer;
typedef typename std::conditional<__constant_iterators,
const value_type&, value_type&>::type
reference;
typedef std::ptrdiff_t difference_type;
typedef std::forward_iterator_tag iterator_category;
using value_type = _Value;
using pointer = __conditional_t<__constant_iterators,
const value_type*, value_type*>;
using reference = __conditional_t<__constant_iterators,
const value_type&, value_type&>;
using difference_type = ptrdiff_t;
using iterator_category = forward_iterator_tag;
_Local_iterator() = default;

4
libstdc++-v3/include/bits/move.h
View File

@ -120,8 +120,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
template<typename _Tp>
_GLIBCXX_NODISCARD
constexpr typename
conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
constexpr
__conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>
move_if_noexcept(_Tp& __x) noexcept
{ return std::move(__x); }

6
libstdc++-v3/include/bits/parse_numbers.h
View File

@ -266,9 +266,9 @@ namespace __select_int
template<unsigned long long _Val, typename _IntType, typename... _Ints>
struct _Select_int_base<_Val, _IntType, _Ints...>
: conditional_t<(_Val <= __gnu_cxx::__int_traits<_IntType>::__max),
integral_constant<_IntType, (_IntType)_Val>,
_Select_int_base<_Val, _Ints...>>
: __conditional_t<(_Val <= __gnu_cxx::__int_traits<_IntType>::__max),
integral_constant<_IntType, (_IntType)_Val>,
_Select_int_base<_Val, _Ints...>>
{ };
template<unsigned long long _Val>

2
libstdc++-v3/include/bits/ptr_traits.h
View File

@ -73,7 +73,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp>
using __make_not_void
= typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;
= __conditional_t<is_void<_Tp>::value, __undefined, _Tp>;
/**
* @brief Uniform interface to all pointer-like types

18
libstdc++-v3/include/bits/ranges_algobase.h
View File

@ -195,9 +195,9 @@ namespace ranges
requires (_IsMove
? indirectly_movable<_Iter, _Out>
: indirectly_copyable<_Iter, _Out>)
constexpr conditional_t<_IsMove,
move_backward_result<_Iter, _Out>,
copy_backward_result<_Iter, _Out>>
constexpr __conditional_t<_IsMove,
move_backward_result<_Iter, _Out>,
copy_backward_result<_Iter, _Out>>
__copy_or_move_backward(_Iter __first, _Sent __last, _Out __result);
template<bool _IsMove,
@ -206,9 +206,9 @@ namespace ranges
requires (_IsMove
? indirectly_movable<_Iter, _Out>
: indirectly_copyable<_Iter, _Out>)
constexpr conditional_t<_IsMove,
move_result<_Iter, _Out>,
copy_result<_Iter, _Out>>
constexpr __conditional_t<_IsMove,
move_result<_Iter, _Out>,
copy_result<_Iter, _Out>>
__copy_or_move(_Iter __first, _Sent __last, _Out __result)
{
// TODO: implement more specializations to be at least on par with
@ -349,9 +349,9 @@ namespace ranges
requires (_IsMove
? indirectly_movable<_Iter, _Out>
: indirectly_copyable<_Iter, _Out>)
constexpr conditional_t<_IsMove,
move_backward_result<_Iter, _Out>,
copy_backward_result<_Iter, _Out>>
constexpr __conditional_t<_IsMove,
move_backward_result<_Iter, _Out>,
copy_backward_result<_Iter, _Out>>
__copy_or_move_backward(_Iter __first, _Sent __last, _Out __result)
{
// TODO: implement more specializations to be at least on par with

6
libstdc++-v3/include/bits/ranges_base.h
View File

@ -907,9 +907,9 @@ namespace ranges
};
template<range _Range>
using borrowed_iterator_t = conditional_t<borrowed_range<_Range>,
iterator_t<_Range>,
dangling>;
using borrowed_iterator_t = __conditional_t<borrowed_range<_Range>,
iterator_t<_Range>,
dangling>;
} // namespace ranges
_GLIBCXX_END_NAMESPACE_VERSION

6
libstdc++-v3/include/bits/ranges_util.h
View File

@ -418,9 +418,9 @@ namespace ranges
enable_borrowed_range<subrange<_It, _Sent, _Kind>> = true;
template<range _Range>
using borrowed_subrange_t = conditional_t<borrowed_range<_Range>,
subrange<iterator_t<_Range>>,
dangling>;
using borrowed_subrange_t = __conditional_t<borrowed_range<_Range>,
subrange<iterator_t<_Range>>,
dangling>;
} // namespace ranges
// The following ranges algorithms are used by <ranges>, and are defined here

10
libstdc++-v3/include/bits/regex_compiler.h
View File

@ -485,17 +485,17 @@ namespace __detail
private:
// Currently we only use the cache for char
typedef typename std::is_same<_CharT, char>::type _UseCache;
using _UseCache = typename std::is_same<_CharT, char>::type;
static constexpr size_t
_S_cache_size =
1ul << (sizeof(_CharT) * __CHAR_BIT__ * int(_UseCache::value));
struct _Dummy { };
typedef typename std::conditional<_UseCache::value,
std::bitset<_S_cache_size>,
_Dummy>::type _CacheT;
typedef typename std::make_unsigned<_CharT>::type _UnsignedCharT;
using _CacheT = std::__conditional_t<_UseCache::value,
std::bitset<_S_cache_size>,
_Dummy>;
using _UnsignedCharT = typename std::make_unsigned<_CharT>::type;
bool
_M_apply(_CharT __ch, false_type) const;

4
libstdc++-v3/include/bits/shared_ptr_base.h
View File

@ -675,9 +675,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return;
using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
using _Del2 = typename conditional<is_reference<_Del>::value,
using _Del2 = __conditional_t<is_reference<_Del>::value,
reference_wrapper<typename remove_reference<_Del>::type>,
_Del>::type;
_Del>;
using _Sp_cd_type
= _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
using _Alloc = allocator<_Sp_cd_type>;

16
libstdc++-v3/include/bits/stl_algobase.h
View File

@ -420,11 +420,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
{
#if __cplusplus >= 201103L
using __assignable = conditional<_IsMove,
is_move_assignable<_Tp>,
is_copy_assignable<_Tp>>;
using __assignable = __conditional_t<_IsMove,
is_move_assignable<_Tp>,
is_copy_assignable<_Tp>>;
// trivial types can have deleted assignment
static_assert( __assignable::type::value, "type must be assignable" );
static_assert( __assignable::value, "type must be assignable" );
#endif
const ptrdiff_t _Num = __last - __first;
if (_Num)
@ -731,11 +731,11 @@ _GLIBCXX_END_NAMESPACE_CONTAINER
__copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
{
#if __cplusplus >= 201103L
using __assignable = conditional<_IsMove,
is_move_assignable<_Tp>,
is_copy_assignable<_Tp>>;
using __assignable = __conditional_t<_IsMove,
is_move_assignable<_Tp>,
is_copy_assignable<_Tp>>;
// trivial types can have deleted assignment
static_assert( __assignable::type::value, "type must be assignable" );
static_assert( __assignable::value, "type must be assignable" );
#endif
const ptrdiff_t _Num = __last - __first;
if (_Num)

34
libstdc++-v3/include/bits/stl_iterator.h
View File

@ -100,7 +100,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// otherwise use _Otherwise.
template<typename _Cat, typename _Limit, typename _Otherwise = _Cat>
using __clamp_iter_cat
= conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
= __conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
}
#endif
@ -155,9 +155,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef typename __traits_type::reference reference;
#else
using iterator_concept
= conditional_t<random_access_iterator<_Iterator>,
random_access_iterator_tag,
bidirectional_iterator_tag>;
= __conditional_t<random_access_iterator<_Iterator>,
random_access_iterator_tag,
bidirectional_iterator_tag>;
using iterator_category
= __detail::__clamp_iter_cat<typename __traits_type::iterator_category,
random_access_iterator_tag>;
@ -1455,9 +1455,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef _Iterator pointer;
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2106. move_iterator wrapping iterators returning prvalues
typedef typename conditional<is_reference<__base_ref>::value,
typename remove_reference<__base_ref>::type&&,
__base_ref>::type reference;
using reference
= __conditional_t<is_reference<__base_ref>::value,
typename remove_reference<__base_ref>::type&&,
__base_ref>;
#endif
_GLIBCXX17_CONSTEXPR
@ -1762,9 +1763,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return move_iterator<_Iterator>(std::move(__i)); }
template<typename _Iterator, typename _ReturnType
= typename conditional<__move_if_noexcept_cond
= __conditional_t<__move_if_noexcept_cond
<typename iterator_traits<_Iterator>::value_type>::value,
_Iterator, move_iterator<_Iterator>>::type>
_Iterator, move_iterator<_Iterator>>>
inline _GLIBCXX17_CONSTEXPR _ReturnType
__make_move_if_noexcept_iterator(_Iterator __i)
{ return _ReturnType(__i); }
@ -1772,8 +1773,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Overload for pointers that matches std::move_if_noexcept more closely,
// returning a constant iterator when we don't want to move.
template<typename _Tp, typename _ReturnType
= typename conditional<__move_if_noexcept_cond<_Tp>::value,
const _Tp*, move_iterator<_Tp*>>::type>
= __conditional_t<__move_if_noexcept_cond<_Tp>::value,
const _Tp*, move_iterator<_Tp*>>>
inline _GLIBCXX17_CONSTEXPR _ReturnType
__make_move_if_noexcept_iterator(_Tp* __i)
{ return _ReturnType(__i); }
@ -2178,8 +2179,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
public:
using iterator_concept = conditional_t<forward_iterator<_It>,
forward_iterator_tag, input_iterator_tag>;
using iterator_concept = __conditional_t<forward_iterator<_It>,
forward_iterator_tag,
input_iterator_tag>;
using iterator_category = decltype(_S_iter_cat());
using value_type = iter_value_t<_It>;
using difference_type = iter_difference_t<_It>;
@ -2459,9 +2461,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
requires same_as<__detail::__iter_traits<_It>, iterator_traits<_It>>
struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
{
using pointer = conditional_t<contiguous_iterator<_It>,
add_pointer_t<iter_reference_t<_It>>,
void>;
using pointer = __conditional_t<contiguous_iterator<_It>,
add_pointer_t<iter_reference_t<_It>>,
void>;
};
#endif // C++20

21
libstdc++-v3/include/bits/stl_pair.h
View File

@ -129,15 +129,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
is_convertible<_U2&&, _T2>>::value;
}
template <bool __implicit, typename _U1, typename _U2>
static constexpr bool _DeprConsPair()
{
using __do_converts = __and_<is_convertible<_U1&&, _T1>,
is_convertible<_U2&&, _T2>>;
using __converts = typename conditional<__implicit,
__do_converts,
__not_<__do_converts>>::type;
using __converts = __conditional_t<__implicit,
__do_converts,
__not_<__do_converts>>;
return __and_<is_constructible<_T1, _U1&&>,
is_constructible<_T2, _U2&&>,
__converts
@ -561,10 +560,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
second(std::forward<_U2>(__p.second)) { }
pair&
operator=(typename conditional<
__and_<is_copy_assignable<_T1>,
is_copy_assignable<_T2>>::value,
const pair&, const __nonesuch&>::type __p)
operator=(__conditional_t<__and_<is_copy_assignable<_T1>,
is_copy_assignable<_T2>>::value,
const pair&, const __nonesuch&> __p)
{
first = __p.first;
second = __p.second;
@ -572,10 +570,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
pair&
operator=(typename conditional<
__and_<is_move_assignable<_T1>,
is_move_assignable<_T2>>::value,
pair&&, __nonesuch&&>::type __p)
operator=(__conditional_t<__and_<is_move_assignable<_T1>,
is_move_assignable<_T2>>::value,
pair&&, __nonesuch&&> __p)
noexcept(__and_<is_nothrow_move_assignable<_T1>,
is_nothrow_move_assignable<_T2>>::value)
{

8
libstdc++-v3/include/bits/stl_tree.h
View File

@ -637,9 +637,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_clone_node(_Link_type __x, _NodeGen& __node_gen)
{
#if __cplusplus >= 201103L
using _Vp = typename conditional<_MoveValue,
value_type&&,
const value_type&>::type;
using _Vp = __conditional_t<_MoveValue,
value_type&&,
const value_type&>;
#endif
_Link_type __tmp
= __node_gen(_GLIBCXX_FORWARD(_Vp, *__x->_M_valptr()));
@ -821,7 +821,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#if __cplusplus > 201402L
using node_type = _Node_handle<_Key, _Val, _Node_allocator>;
using insert_return_type = _Node_insert_return<
conditional_t<is_same_v<_Key, _Val>, const_iterator, iterator>,
__conditional_t<is_same_v<_Key, _Val>, const_iterator, iterator>,
node_type>;
#endif

12
libstdc++-v3/include/bits/unique_ptr.h
View File

@ -338,9 +338,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
template<typename _Up, typename _Ep, typename = _Require<
__safe_conversion_up<_Up, _Ep>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type>>
__conditional_t<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
@ -605,9 +605,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Up, typename _Ep, typename = _Require<
__safe_conversion_up<_Up, _Ep>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type>>
__conditional_t<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

8
libstdc++-v3/include/bits/uses_allocator.h
View File

@ -86,10 +86,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Alloc, typename... _Args>
struct __uses_alloc<true, _Tp, _Alloc, _Args...>
: conditional<
: __conditional_t<
is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value,
__uses_alloc1<_Alloc>,
__uses_alloc2<_Alloc>>::type
__uses_alloc2<_Alloc>>
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2586. Wrong value category used in scoped_allocator_adaptor::construct
@ -131,10 +131,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<template<typename...> class _Predicate,
typename _Tp, typename _Alloc, typename... _Args>
struct __is_uses_allocator_predicate
: conditional<uses_allocator<_Tp, _Alloc>::value,
: __conditional_t<uses_allocator<_Tp, _Alloc>::value,
__or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>,
_Predicate<_Tp, _Args..., _Alloc>>,
_Predicate<_Tp, _Args...>>::type { };
_Predicate<_Tp, _Args...>> { };
template<typename _Tp, typename _Alloc, typename... _Args>
struct __is_uses_allocator_constructible

6
libstdc++-v3/include/debug/functions.h
View File

@ -33,7 +33,7 @@
#if __cplusplus >= 201103L
# include <bits/stl_iterator.h> // for __miter_base
# include <type_traits> // for is_lvalue_reference and conditional.
# include <type_traits> // for is_lvalue_reference and __conditional_t.
#endif
#include <debug/helper_functions.h>
@ -158,8 +158,8 @@ namespace __gnu_debug
using __lvalref = std::is_lvalue_reference<
typename std::iterator_traits<_InputIterator>::reference>;
using __contiguous = _Is_contiguous_sequence<_Sequence>;
using __tag = typename std::conditional<__lvalref::value, __contiguous,
std::__false_type>::type;
using __tag = std::__conditional_t<__lvalref::value, __contiguous,
std::__false_type>;
#endif
return __foreign_iterator_aux3(__it, __other, __other_end, __tag());
}

10
libstdc++-v3/include/experimental/any
View File

@ -115,9 +115,9 @@ inline namespace fundamentals_v1
struct _Manager_external; // creates contained object on the heap
template<typename _Tp>
using _Manager = conditional_t<_Internal<_Tp>::value,
_Manager_internal<_Tp>,
_Manager_external<_Tp>>;
using _Manager = __conditional_t<_Internal<_Tp>::value,
_Manager_internal<_Tp>,
_Manager_external<_Tp>>;
template<typename _Tp, typename _Decayed = decay_t<_Tp>>
using _Decay = enable_if_t<!is_same<_Decayed, any>::value, _Decayed>;
@ -430,8 +430,8 @@ inline namespace fundamentals_v1
// If the type _Tp could never be stored in an any we don't want to
// instantiate _Manager<_Tp>, so use _Manager<any::_Op> instead, which
// is explicitly specialized and has a no-op _S_manage function.
using _Vp = conditional_t<__and_<__does_not_decay, __is_copyable>::value,
_Up, any::_Op>;
using _Vp = __conditional_t<__and_<__does_not_decay, __is_copyable>{},
_Up, any::_Op>;
// First try comparing function addresses, which works without RTTI
if (__any->_M_manager == &any::_Manager<_Vp>::_S_manage
#if __cpp_rtti

2
libstdc++-v3/include/experimental/executor
View File

@ -389,7 +389,7 @@ inline namespace v1
= typename __result_type::completion_handler_type;
private:
using __handler_type = conditional_t<
using __handler_type = __conditional_t<
is_same<_CompletionToken, completion_handler_type>::value,
completion_handler_type&,
completion_handler_type>;

6
libstdc++-v3/include/experimental/functional
View File

@ -164,9 +164,9 @@ inline namespace fundamentals_v1
typename _Val = typename iterator_traits<_RAIter>::value_type,
typename _Diff = typename iterator_traits<_RAIter>::difference_type>
using __boyer_moore_base_t
= std::conditional_t<std::__is_byte_like<_Val, _Pred>::value,
__boyer_moore_array_base<_Diff, 256, _Pred>,
__boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>;
= std::__conditional_t<std::__is_byte_like<_Val, _Pred>::value,
__boyer_moore_array_base<_Diff, 256, _Pred>,
__boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>;
template<typename _RAIter, typename _Hash
= std::hash<typename std::iterator_traits<_RAIter>::value_type>,

6
libstdc++-v3/include/std/any
View File

@ -102,9 +102,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct _Manager_external; // creates contained object on the heap
template<typename _Tp>
using _Manager = conditional_t<_Internal<_Tp>::value,
_Manager_internal<_Tp>,
_Manager_external<_Tp>>;
using _Manager = __conditional_t<_Internal<_Tp>::value,
_Manager_internal<_Tp>,
_Manager_external<_Tp>>;
template<typename _Tp, typename _VTp = decay_t<_Tp>>
using _Decay_if_not_any = enable_if_t<!is_same_v<_VTp, any>, _VTp>;

6
libstdc++-v3/include/std/functional
View File

@ -1117,9 +1117,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename _Val = typename iterator_traits<_RAIter>::value_type,
typename _Diff = typename iterator_traits<_RAIter>::difference_type>
using __boyer_moore_base_t
= conditional_t<__is_byte_like<_Val, _Pred>::value,
__boyer_moore_array_base<_Diff, 256, _Pred>,
__boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>;
= __conditional_t<__is_byte_like<_Val, _Pred>::value,
__boyer_moore_array_base<_Diff, 256, _Pred>,
__boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>;
template<typename _RAIter, typename _Hash
= hash<typename iterator_traits<_RAIter>::value_type>,

10
libstdc++-v3/include/std/ranges
View File

@ -770,11 +770,11 @@ namespace __detail
// Data members using this alias should use [[no_unique_address]] so that
// they take no space when not needed.
template<bool _Present, typename _Tp>
using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>;
using __maybe_present_t = __conditional_t<_Present, _Tp, _Empty>;
// Alias for a type that is conditionally const.
template<bool _Const, typename _Tp>
using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>;
using __maybe_const_t = __conditional_t<_Const, const _Tp, _Tp>;
} // namespace __detail
@ -2920,9 +2920,9 @@ namespace views::__adaptor
bool _M_trailing_empty = false;
public:
using iterator_concept = conditional_t<forward_range<_Base>,
forward_iterator_tag,
input_iterator_tag>;
using iterator_concept = __conditional_t<forward_range<_Base>,
forward_iterator_tag,
input_iterator_tag>;
// iterator_category defined in __lazy_split_view_outer_iter_cat
using difference_type = range_difference_t<_Base>;

28
libstdc++-v3/include/std/tuple
View File

@ -66,8 +66,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Use the Empty Base-class Optimization for empty, non-final types.
template<typename _Tp>
using __empty_not_final
= typename conditional<__is_final(_Tp), false_type,
__is_empty_non_tuple<_Tp>>::type;
= __conditional_t<__is_final(_Tp), false_type,
__is_empty_non_tuple<_Tp>>;
template<size_t _Idx, typename _Head,
bool = __empty_not_final<_Head>::value>
@ -905,9 +905,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX20_CONSTEXPR
tuple&
operator=(typename conditional<__assignable<const _Elements&...>(),
const tuple&,
const __nonesuch&>::type __in)
operator=(__conditional_t<__assignable<const _Elements&...>(),
const tuple&,
const __nonesuch&> __in)
noexcept(__nothrow_assignable<const _Elements&...>())
{
this->_M_assign(__in);
@ -916,9 +916,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX20_CONSTEXPR
tuple&
operator=(typename conditional<__assignable<_Elements...>(),
tuple&&,
__nonesuch&&>::type __in)
operator=(__conditional_t<__assignable<_Elements...>(),
tuple&&,
__nonesuch&&> __in)
noexcept(__nothrow_assignable<_Elements...>())
{
this->_M_assign(std::move(__in));
@ -1274,9 +1274,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX20_CONSTEXPR
tuple&
operator=(typename conditional<__assignable<const _T1&, const _T2&>(),
const tuple&,
const __nonesuch&>::type __in)
operator=(__conditional_t<__assignable<const _T1&, const _T2&>(),
const tuple&,
const __nonesuch&> __in)
noexcept(__nothrow_assignable<const _T1&, const _T2&>())
{
this->_M_assign(__in);
@ -1285,9 +1285,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX20_CONSTEXPR
tuple&
operator=(typename conditional<__assignable<_T1, _T2>(),
tuple&&,
__nonesuch&&>::type __in)
operator=(__conditional_t<__assignable<_T1, _T2>(),
tuple&&,
__nonesuch&&> __in)
noexcept(__nothrow_assignable<_T1, _T2>())
{
this->_M_assign(std::move(__in));

36
libstdc++-v3/include/std/type_traits
View File

@ -100,8 +100,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Metaprogramming helper types.
template<bool, typename, typename>
struct conditional;
template<bool>
struct __conditional
{
template<typename _Tp, typename>
using type = _Tp;
};
template<>
struct __conditional<false>
{
template<typename, typename _Up>
using type = _Up;
};
// More efficient version of std::conditional_t for internal use (and C++11)
template<bool _Cond, typename _If, typename _Else>
using __conditional_t
= typename __conditional<_Cond>::template type<_If, _Else>;
/// @cond undocumented
template <typename _Type>
@ -126,12 +142,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _B1, typename _B2>
struct __or_<_B1, _B2>
: public conditional<_B1::value, _B1, _B2>::type
: public __conditional_t<_B1::value, _B1, _B2>
{ };
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
: public __conditional_t<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>
{ };
template<typename...>
@ -149,12 +165,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _B1, typename _B2>
struct __and_<_B1, _B2>
: public conditional<_B1::value, _B2, _B1>::type
: public __conditional_t<_B1::value, _B2, _B1>
{ };
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
: public __conditional_t<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>
{ };
template<typename _Pp>
@ -2491,11 +2507,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
typedef __remove_cvref_t<_Arg> _Argval;
typedef _Res _Class::* _MemPtr;
typedef typename conditional<__or_<is_same<_Argval, _Class>,
typedef typename __conditional_t<__or_<is_same<_Argval, _Class>,
is_base_of<_Class, _Argval>>::value,
__result_of_memobj_ref<_MemPtr, _Arg>,
__result_of_memobj_deref<_MemPtr, _Arg>
>::type::type type;
>::type type;
};
template<typename _MemPtr, typename _Arg, typename... _Args>
@ -2506,10 +2522,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
typedef typename remove_reference<_Arg>::type _Argval;
typedef _Res _Class::* _MemPtr;
typedef typename conditional<is_base_of<_Class, _Argval>::value,
typedef typename __conditional_t<is_base_of<_Class, _Argval>::value,
__result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
__result_of_memfun_deref<_MemPtr, _Arg, _Args...>
>::type::type type;
>::type type;
};
// _GLIBCXX_RESOLVE_LIB_DEFECTS

2
libstdc++-v3/include/std/variant
View File

@ -1096,7 +1096,7 @@ namespace __variant
typename _AsV = decltype(__variant::__as(std::declval<_Variant>())),
typename _Tp = variant_alternative_t<_Np, remove_reference_t<_AsV>>>
using __get_t
= conditional_t<is_lvalue_reference_v<_Variant>, _Tp&, _Tp&&>;
= __conditional_t<is_lvalue_reference_v<_Variant>, _Tp&, _Tp&&>;
// Return type of std::visit.
template<typename _Visitor, typename... _Variants>