This is an archive of the discontinued LLVM Phabricator instance.

Differential D118748

[libc++] [NFC] s/_LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)/!defined(_LIBCPP_HAS_NO_CONCEPTS)/
ClosedPublic

Authored by • Quuxplusone on Feb 1 2022, 5:02 PM.

Details

Reviewers
jloser
ldionne
Group Reviewers
Restricted Project
Commits
rG38db42d0043e: [libc++] [NFC] s/_LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)/!
Summary

Per Discord discussion, we're normalizing on a simple !defined(_LIBCPP_HAS_NO_CONCEPTS) so that we can do a big search-and-replace for !defined(_LIBCPP_HAS_NO_CONCEPTS) back into _LIBCPP_STD_VER > 17 when we're ready to abandon support for concept-syntax-less compilers.

If CI is happy with this, imma push it. (EDIT: no I won't, we'll wait for tomorrow)

Diff Detail

Event Timeline

• Quuxplusone requested review of this revision.Feb 1 2022, 5:02 PM
• Quuxplusone created this revision.
Herald added 1 blocking reviewer(s): Restricted Project. · View Herald TranscriptFeb 1 2022, 5:02 PM
Herald added a subscriber: libcxx-commits. · View Herald Transcript
jloser accepted this revision.Feb 1 2022, 5:18 PM
jloser added a subscriber: jloser.
jloser added inline comments.
libcxx/include/ranges
242

No action required, but this seems like a weird guard for !defined(_LIBCPP_HAS_NO_CONCEPTS). I would have expected the macro used to be something about ranges...

• Quuxplusone edited the summary of this revision. (Show Details)Feb 1 2022, 5:25 PM
• Quuxplusone added inline comments.
libcxx/include/ranges
242

Huh, good point. I have no idea... oh wait, yes I do. 😛 I bet that every single detail header that involves a view type is guarded by !defined(_LIBCPP_HAS_NO_CONCEPTS), because the view types all require some concept or other. Therefore, when _LIBCPP_HAS_NO_CONCEPTS, all of those headers sublimate away, which means nobody ever gets around to defining namespace views { ... }, which means line 244 failed to compile, and nobody ever looked into it. 😛We could certainly fix this via

namespace ranges::views { }
namespace views = ranges::views;

but I'm not sure I care enough.

Harbormaster completed remote builds in B147046: Diff 405128.Feb 1 2022, 7:47 PM
ldionne accepted this revision.Feb 2 2022, 7:46 AM
ldionne added a subscriber: ldionne.

LGTM, please ship this and then cherry-pick it onto release/14.x:

git checkout release/14.x
git cherry-pick -x <SHA>
git push
libcxx/include/ranges
242

I think guarding this is correct. That way, when we move to _LIBCPP_STD_VER > 17, this will be guarded the way we want it.

This revision is now accepted and ready to land.Feb 2 2022, 7:46 AM
Closed by commit rG38db42d0043e: [libc++] [NFC] s/_LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)/! (authored by • arthur.j.odwyer). · Explain WhyFeb 2 2022, 8:04 AM
This revision was automatically updated to reflect the committed changes.
• arthur.j.odwyer added a commit: rG38db42d0043e: [libc++] [NFC] s/_LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)/!.
• Quuxplusone mentioned this in D118809: [libc++] Define `namespace views` in its own detail header..Feb 2 2022, 9:27 AM
• Quuxplusone added inline comments.Feb 2 2022, 9:37 AM
libcxx/include/ranges
242

This is now D118809.

• arthur.j.odwyer mentioned this in rG44cdca37c01a: [libc++] Define `namespace views` in its own detail header..Feb 4 2022, 9:38 AM

Revision Contents

Diff 405286

libcxx/include/__compare/compare_partial_order_fallback.h

Show All 16 Lines
#include <type_traits> #include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg] // [cmp.alg]
namespace __compare_partial_order_fallback { namespace __compare_partial_order_fallback {
struct __fn { struct __fn {
template<class _Tp, class _Up> template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>> requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto _LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<1>) __go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
Show All 27 Lines struct __fn {
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); } { return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
}; };
} // namespace __compare_partial_order_fallback } // namespace __compare_partial_order_fallback
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto compare_partial_order_fallback = __compare_partial_order_fallback::__fn{}; inline constexpr auto compare_partial_order_fallback = __compare_partial_order_fallback::__fn{};
} // namespace __cpo } // namespace __cpo
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_PARTIAL_ORDER_FALLBACK #endif // _LIBCPP___COMPARE_COMPARE_PARTIAL_ORDER_FALLBACK

libcxx/include/__compare/compare_strong_order_fallback.h

Show All 16 Lines
#include <type_traits> #include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg] // [cmp.alg]
namespace __compare_strong_order_fallback { namespace __compare_strong_order_fallback {
struct __fn { struct __fn {
template<class _Tp, class _Up> template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>> requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto _LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<1>) __go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
Show All 24 Lines struct __fn {
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); } { return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
}; };
} // namespace __compare_strong_order_fallback } // namespace __compare_strong_order_fallback
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto compare_strong_order_fallback = __compare_strong_order_fallback::__fn{}; inline constexpr auto compare_strong_order_fallback = __compare_strong_order_fallback::__fn{};
} // namespace __cpo } // namespace __cpo
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_STRONG_ORDER_FALLBACK #endif // _LIBCPP___COMPARE_COMPARE_STRONG_ORDER_FALLBACK

libcxx/include/__compare/compare_three_way.h

Show All 14 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
struct _LIBCPP_TEMPLATE_VIS compare_three_way struct _LIBCPP_TEMPLATE_VIS compare_three_way
{ {
template<class _T1, class _T2> template<class _T1, class _T2>
requires three_way_comparable_with<_T1, _T2> requires three_way_comparable_with<_T1, _T2>
constexpr _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI
auto operator()(_T1&& __t, _T2&& __u) const auto operator()(_T1&& __t, _T2&& __u) const
noexcept(noexcept(_VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u))) noexcept(noexcept(_VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u)))
{ return _VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u); } { return _VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u); }
using is_transparent = void; using is_transparent = void;
}; };
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_H #endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_H

libcxx/include/__compare/compare_weak_order_fallback.h

Show All 16 Lines
#include <type_traits> #include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg] // [cmp.alg]
namespace __compare_weak_order_fallback { namespace __compare_weak_order_fallback {
struct __fn { struct __fn {
template<class _Tp, class _Up> template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>> requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto _LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<1>) __go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
Show All 24 Lines struct __fn {
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); } { return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
}; };
} // namespace __compare_weak_order_fallback } // namespace __compare_weak_order_fallback
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto compare_weak_order_fallback = __compare_weak_order_fallback::__fn{}; inline constexpr auto compare_weak_order_fallback = __compare_weak_order_fallback::__fn{};
} // namespace __cpo } // namespace __cpo
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_WEAK_ORDER_FALLBACK #endif // _LIBCPP___COMPARE_COMPARE_WEAK_ORDER_FALLBACK

libcxx/include/__compare/partial_order.h

Show All 17 Lines
#include <type_traits> #include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg] // [cmp.alg]
namespace __partial_order { namespace __partial_order {
struct __fn { struct __fn {
template<class _Tp, class _Up> template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>> requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto _LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<2>) __go(_Tp&& __t, _Up&& __u, __priority_tag<2>)
Show All 24 Lines struct __fn {
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()); } { return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()); }
}; };
} // namespace __partial_order } // namespace __partial_order
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto partial_order = __partial_order::__fn{}; inline constexpr auto partial_order = __partial_order::__fn{};
} // namespace __cpo } // namespace __cpo
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_PARTIAL_ORDER #endif // _LIBCPP___COMPARE_PARTIAL_ORDER

libcxx/include/__compare/strong_order.h

Show All 23 Lines
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg] // [cmp.alg]
namespace __strong_order { namespace __strong_order {
struct __fn { struct __fn {
template<class _Tp, class _Up> template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>> requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto _LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<2>) __go(_Tp&& __t, _Up&& __u, __priority_tag<2>)
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines struct __fn {
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()); } { return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()); }
}; };
} // namespace __strong_order } // namespace __strong_order
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto strong_order = __strong_order::__fn{}; inline constexpr auto strong_order = __strong_order::__fn{};
} // namespace __cpo } // namespace __cpo
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___COMPARE_STRONG_ORDER #endif // _LIBCPP___COMPARE_STRONG_ORDER

libcxx/include/__compare/synth_three_way.h

Show All 15 Lines
#include <__utility/declval.h> #include <__utility/declval.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [expos.only.func] // [expos.only.func]
_LIBCPP_HIDE_FROM_ABI inline constexpr auto __synth_three_way = _LIBCPP_HIDE_FROM_ABI inline constexpr auto __synth_three_way =
[]<class _Tp, class _Up>(const _Tp& __t, const _Up& __u) []<class _Tp, class _Up>(const _Tp& __t, const _Up& __u)
requires requires { requires requires {
{ __t < __u } -> __boolean_testable; { __t < __u } -> __boolean_testable;
{ __u < __t } -> __boolean_testable; { __u < __t } -> __boolean_testable;
} }
{ {
if constexpr (three_way_comparable_with<_Tp, _Up>) { if constexpr (three_way_comparable_with<_Tp, _Up>) {
return __t <=> __u; return __t <=> __u;
} else { } else {
if (__t < __u) return weak_ordering::less; if (__t < __u) return weak_ordering::less;
if (__u < __t) return weak_ordering::greater; if (__u < __t) return weak_ordering::greater;
return weak_ordering::equivalent; return weak_ordering::equivalent;
} }
}; };
template <class _Tp, class _Up = _Tp> template <class _Tp, class _Up = _Tp>
using __synth_three_way_result = decltype(__synth_three_way(declval<_Tp&>(), declval<_Up&>())); using __synth_three_way_result = decltype(__synth_three_way(declval<_Tp&>(), declval<_Up&>()));
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_SYNTH_THREE_WAY_H #endif // _LIBCPP___COMPARE_SYNTH_THREE_WAY_H

libcxx/include/__compare/three_way_comparable.h

Show All 18 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template<class _Tp, class _Cat> template<class _Tp, class _Cat>
concept __compares_as = concept __compares_as =
same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>; same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
template<class _Tp, class _Cat = partial_ordering> template<class _Tp, class _Cat = partial_ordering>
concept three_way_comparable = concept three_way_comparable =
__weakly_equality_comparable_with<_Tp, _Tp> && __weakly_equality_comparable_with<_Tp, _Tp> &&
Show All 10 Linesconcept three_way_comparable_with =
three_way_comparable<common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _Cat> && three_way_comparable<common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _Cat> &&
__weakly_equality_comparable_with<_Tp, _Up> && __weakly_equality_comparable_with<_Tp, _Up> &&
__partially_ordered_with<_Tp, _Up> && __partially_ordered_with<_Tp, _Up> &&
requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) { requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
{ __t <=> __u } -> __compares_as<_Cat>; { __t <=> __u } -> __compares_as<_Cat>;
{ __u <=> __t } -> __compares_as<_Cat>; { __u <=> __t } -> __compares_as<_Cat>;
}; };
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_THREE_WAY_COMPARABLE_H #endif // _LIBCPP___COMPARE_THREE_WAY_COMPARABLE_H

libcxx/include/__compare/weak_order.h

Show All 18 Lines
#include <type_traits> #include <type_traits>
#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [cmp.alg] // [cmp.alg]
namespace __weak_order { namespace __weak_order {
struct __fn { struct __fn {
template<class _Tp, class _Up> template<class _Tp, class _Up>
requires is_same_v<decay_t<_Tp>, decay_t<_Up>> requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
_LIBCPP_HIDE_FROM_ABI static constexpr auto _LIBCPP_HIDE_FROM_ABI static constexpr auto
__go(_Tp&& __t, _Up&& __u, __priority_tag<3>) __go(_Tp&& __t, _Up&& __u, __priority_tag<3>)
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines struct __fn {
{ return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<3>()); } { return __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<3>()); }
}; };
} // namespace __weak_order } // namespace __weak_order
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto weak_order = __weak_order::__fn{}; inline constexpr auto weak_order = __weak_order::__fn{};
} // namespace __cpo } // namespace __cpo
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_WEAK_ORDER #endif // _LIBCPP___COMPARE_WEAK_ORDER

libcxx/include/__concepts/arithmetic.h

Show All 12 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concepts.arithmetic], arithmetic concepts // [concepts.arithmetic], arithmetic concepts
template<class _Tp> template<class _Tp>
concept integral = is_integral_v<_Tp>; concept integral = is_integral_v<_Tp>;
template<class _Tp> template<class _Tp>
concept signed_integral = integral<_Tp> && is_signed_v<_Tp>; concept signed_integral = integral<_Tp> && is_signed_v<_Tp>;
template<class _Tp> template<class _Tp>
concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>; concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
template<class _Tp> template<class _Tp>
concept floating_point = is_floating_point_v<_Tp>; concept floating_point = is_floating_point_v<_Tp>;
// Concept helpers for the internal type traits for the fundamental types. // Concept helpers for the internal type traits for the fundamental types.
template <class _Tp> template <class _Tp>
concept __libcpp_unsigned_integer = __libcpp_is_unsigned_integer<_Tp>::value; concept __libcpp_unsigned_integer = __libcpp_is_unsigned_integer<_Tp>::value;
template <class _Tp> template <class _Tp>
concept __libcpp_signed_integer = __libcpp_is_signed_integer<_Tp>::value; concept __libcpp_signed_integer = __libcpp_is_signed_integer<_Tp>::value;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_ARITHMETIC_H #endif // _LIBCPP___CONCEPTS_ARITHMETIC_H

libcxx/include/__concepts/assignable.h

Show All 15 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.assignable] // [concept.assignable]
template<class _Lhs, class _Rhs> template<class _Lhs, class _Rhs>
concept assignable_from = concept assignable_from =
is_lvalue_reference_v<_Lhs> && is_lvalue_reference_v<_Lhs> &&
common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> && common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> &&
requires (_Lhs __lhs, _Rhs&& __rhs) { requires (_Lhs __lhs, _Rhs&& __rhs) {
{ __lhs = _VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>; { __lhs = _VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
}; };
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_ASSIGNABLE_H #endif // _LIBCPP___CONCEPTS_ASSIGNABLE_H

libcxx/include/__concepts/boolean_testable.h

Show All 13 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concepts.booleantestable] // [concepts.booleantestable]
template<class _Tp> template<class _Tp>
concept __boolean_testable_impl = convertible_to<_Tp, bool>; concept __boolean_testable_impl = convertible_to<_Tp, bool>;
template<class _Tp> template<class _Tp>
concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) { concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
{ !_VSTD::forward<_Tp>(__t) } -> __boolean_testable_impl; { !_VSTD::forward<_Tp>(__t) } -> __boolean_testable_impl;
}; };
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_BOOLEAN_TESTABLE_H #endif // _LIBCPP___CONCEPTS_BOOLEAN_TESTABLE_H

libcxx/include/__concepts/class_or_enum.h

Show All 12 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// Whether a type is a class type or enumeration type according to the Core wording. // Whether a type is a class type or enumeration type according to the Core wording.
template<class _Tp> template<class _Tp>
concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>; concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;
// Work around Clang bug https://llvm.org/PR52970 // Work around Clang bug https://llvm.org/PR52970
template<class _Tp> template<class _Tp>
concept __workaround_52970 = is_class_v<__uncvref_t<_Tp>> || is_union_v<__uncvref_t<_Tp>>; concept __workaround_52970 = is_class_v<__uncvref_t<_Tp>> || is_union_v<__uncvref_t<_Tp>>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_CLASS_OR_ENUM_H #endif // _LIBCPP___CONCEPTS_CLASS_OR_ENUM_H

libcxx/include/__concepts/common_reference_with.h

Show All 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.commonref] // [concept.commonref]
template<class _Tp, class _Up> template<class _Tp, class _Up>
concept common_reference_with = concept common_reference_with =
same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> && same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&
convertible_to<_Tp, common_reference_t<_Tp, _Up>> && convertible_to<_Tp, common_reference_t<_Tp, _Up>> &&
convertible_to<_Up, common_reference_t<_Tp, _Up>>; convertible_to<_Up, common_reference_t<_Tp, _Up>>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_COMMON_REFERENCE_WITH_H #endif // _LIBCPP___CONCEPTS_COMMON_REFERENCE_WITH_H

libcxx/include/__concepts/common_with.h

Show All 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.common] // [concept.common]
template<class _Tp, class _Up> template<class _Tp, class _Up>
concept common_with = concept common_with =
same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> && same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
requires { requires {
static_cast<common_type_t<_Tp, _Up>>(declval<_Tp>()); static_cast<common_type_t<_Tp, _Up>>(declval<_Tp>());
static_cast<common_type_t<_Tp, _Up>>(declval<_Up>()); static_cast<common_type_t<_Tp, _Up>>(declval<_Up>());
} && } &&
common_reference_with< common_reference_with<
add_lvalue_reference_t<const _Tp>, add_lvalue_reference_t<const _Tp>,
add_lvalue_reference_t<const _Up>> && add_lvalue_reference_t<const _Up>> &&
common_reference_with< common_reference_with<
add_lvalue_reference_t<common_type_t<_Tp, _Up>>, add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
common_reference_t< common_reference_t<
add_lvalue_reference_t<const _Tp>, add_lvalue_reference_t<const _Tp>,
add_lvalue_reference_t<const _Up>>>; add_lvalue_reference_t<const _Up>>>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_COMMON_WITH_H #endif // _LIBCPP___CONCEPTS_COMMON_WITH_H

libcxx/include/__concepts/constructible.h

Show All 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.constructible] // [concept.constructible]
template<class _Tp, class... _Args> template<class _Tp, class... _Args>
concept constructible_from = concept constructible_from =
destructible<_Tp> && is_constructible_v<_Tp, _Args...>; destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
// [concept.default.init] // [concept.default.init]
Show All 12 Lines
// [concept.copyconstructible] // [concept.copyconstructible]
template<class _Tp> template<class _Tp>
concept copy_constructible = concept copy_constructible =
move_constructible<_Tp> && move_constructible<_Tp> &&
constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> && constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> && constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>; constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_CONSTRUCTIBLE_H #endif // _LIBCPP___CONCEPTS_CONSTRUCTIBLE_H

libcxx/include/__concepts/convertible_to.h

Show All 13 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.convertible] // [concept.convertible]
template<class _From, class _To> template<class _From, class _To>
concept convertible_to = concept convertible_to =
is_convertible_v<_From, _To> && is_convertible_v<_From, _To> &&
requires { requires {
static_cast<_To>(declval<_From>()); static_cast<_To>(declval<_From>());
}; };
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_CONVERTIBLE_TO_H #endif // _LIBCPP___CONCEPTS_CONVERTIBLE_TO_H

libcxx/include/__concepts/copyable.h

Show All 14 Lines
#include <__config> #include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concepts.object] // [concepts.object]
template<class _Tp> template<class _Tp>
concept copyable = concept copyable =
copy_constructible<_Tp> && copy_constructible<_Tp> &&
movable<_Tp> && movable<_Tp> &&
assignable_from<_Tp&, _Tp&> && assignable_from<_Tp&, _Tp&> &&
assignable_from<_Tp&, const _Tp&> && assignable_from<_Tp&, const _Tp&> &&
assignable_from<_Tp&, const _Tp>; assignable_from<_Tp&, const _Tp>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_COPYABLE_H #endif // _LIBCPP___CONCEPTS_COPYABLE_H

libcxx/include/__concepts/derived_from.h

Show All 12 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.derived] // [concept.derived]
template<class _Dp, class _Bp> template<class _Dp, class _Bp>
concept derived_from = concept derived_from =
is_base_of_v<_Bp, _Dp> && is_base_of_v<_Bp, _Dp> &&
is_convertible_v<const volatile _Dp*, const volatile _Bp*>; is_convertible_v<const volatile _Dp*, const volatile _Bp*>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_DERIVED_FROM_H #endif // _LIBCPP___CONCEPTS_DERIVED_FROM_H

libcxx/include/__concepts/destructible.h

Show All 12 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.destructible] // [concept.destructible]
template<class _Tp> template<class _Tp>
concept destructible = is_nothrow_destructible_v<_Tp>; concept destructible = is_nothrow_destructible_v<_Tp>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_DESTRUCTIBLE_H #endif // _LIBCPP___CONCEPTS_DESTRUCTIBLE_H

libcxx/include/__concepts/different_from.h

Show All 13 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template<class _Tp, class _Up> template<class _Tp, class _Up>
concept __different_from = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>; concept __different_from = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_DIFFERENT_FROM_H #endif // _LIBCPP___CONCEPTS_DIFFERENT_FROM_H

libcxx/include/__concepts/equality_comparable.h

Show All 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.equalitycomparable] // [concept.equalitycomparable]
template<class _Tp, class _Up> template<class _Tp, class _Up>
concept __weakly_equality_comparable_with = concept __weakly_equality_comparable_with =
requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) { requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
{ __t == __u } -> __boolean_testable; { __t == __u } -> __boolean_testable;
{ __t != __u } -> __boolean_testable; { __t != __u } -> __boolean_testable;
Show All 9 Linesconcept equality_comparable_with =
equality_comparable<_Tp> && equality_comparable<_Up> && equality_comparable<_Tp> && equality_comparable<_Up> &&
common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> && common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
equality_comparable< equality_comparable<
common_reference_t< common_reference_t<
__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Tp>,
__make_const_lvalue_ref<_Up>>> && __make_const_lvalue_ref<_Up>>> &&
__weakly_equality_comparable_with<_Tp, _Up>; __weakly_equality_comparable_with<_Tp, _Up>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_EQUALITY_COMPARABLE_H #endif // _LIBCPP___CONCEPTS_EQUALITY_COMPARABLE_H

libcxx/include/__concepts/invocable.h

Show All 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.invocable] // [concept.invocable]
template<class _Fn, class... _Args> template<class _Fn, class... _Args>
concept invocable = requires(_Fn&& __fn, _Args&&... __args) { concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
_VSTD::invoke(_VSTD::forward<_Fn>(__fn), _VSTD::forward<_Args>(__args)...); // not required to be equality preserving _VSTD::invoke(_VSTD::forward<_Fn>(__fn), _VSTD::forward<_Args>(__args)...); // not required to be equality preserving
}; };
// [concept.regular.invocable] // [concept.regular.invocable]
template<class _Fn, class... _Args> template<class _Fn, class... _Args>
concept regular_invocable = invocable<_Fn, _Args...>; concept regular_invocable = invocable<_Fn, _Args...>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_INVOCABLE_H #endif // _LIBCPP___CONCEPTS_INVOCABLE_H

libcxx/include/__concepts/movable.h

Show All 15 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concepts.object] // [concepts.object]
template<class _Tp> template<class _Tp>
concept movable = concept movable =
is_object_v<_Tp> && is_object_v<_Tp> &&
move_constructible<_Tp> && move_constructible<_Tp> &&
assignable_from<_Tp&, _Tp> && assignable_from<_Tp&, _Tp> &&
swappable<_Tp>; swappable<_Tp>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_MOVABLE_H #endif // _LIBCPP___CONCEPTS_MOVABLE_H

libcxx/include/__concepts/predicate.h

Show All 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.predicate] // [concept.predicate]
template<class _Fn, class... _Args> template<class _Fn, class... _Args>
concept predicate = concept predicate =
regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>; regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_PREDICATE_H #endif // _LIBCPP___CONCEPTS_PREDICATE_H

libcxx/include/__concepts/regular.h

Show All 13 Lines
#include <__config> #include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.object] // [concept.object]
template<class _Tp> template<class _Tp>
concept regular = semiregular<_Tp> && equality_comparable<_Tp>; concept regular = semiregular<_Tp> && equality_comparable<_Tp>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_REGULAR_H #endif // _LIBCPP___CONCEPTS_REGULAR_H

libcxx/include/__concepts/relation.h

Show All 12 Lines
#include <__config> #include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.relation] // [concept.relation]
template<class _Rp, class _Tp, class _Up> template<class _Rp, class _Tp, class _Up>
concept relation = concept relation =
predicate<_Rp, _Tp, _Tp> && predicate<_Rp, _Up, _Up> && predicate<_Rp, _Tp, _Tp> && predicate<_Rp, _Up, _Up> &&
predicate<_Rp, _Tp, _Up> && predicate<_Rp, _Up, _Tp>; predicate<_Rp, _Tp, _Up> && predicate<_Rp, _Up, _Tp>;
// [concept.equiv] // [concept.equiv]
template<class _Rp, class _Tp, class _Up> template<class _Rp, class _Tp, class _Up>
concept equivalence_relation = relation<_Rp, _Tp, _Up>; concept equivalence_relation = relation<_Rp, _Tp, _Up>;
// [concept.strictweakorder] // [concept.strictweakorder]
template<class _Rp, class _Tp, class _Up> template<class _Rp, class _Tp, class _Up>
concept strict_weak_order = relation<_Rp, _Tp, _Up>; concept strict_weak_order = relation<_Rp, _Tp, _Up>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_RELATION_H #endif // _LIBCPP___CONCEPTS_RELATION_H

libcxx/include/__concepts/same_as.h

Show All 12 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.same] // [concept.same]
template<class _Tp, class _Up> template<class _Tp, class _Up>
concept __same_as_impl = _IsSame<_Tp, _Up>::value; concept __same_as_impl = _IsSame<_Tp, _Up>::value;
template<class _Tp, class _Up> template<class _Tp, class _Up>
concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>; concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_SAME_AS_H #endif // _LIBCPP___CONCEPTS_SAME_AS_H

libcxx/include/__concepts/semiregular.h

Show All 13 Lines
#include <__config> #include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.object] // [concept.object]
template<class _Tp> template<class _Tp>
concept semiregular = copyable<_Tp> && default_initializable<_Tp>; concept semiregular = copyable<_Tp> && default_initializable<_Tp>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_SEMIREGULAR_H #endif // _LIBCPP___CONCEPTS_SEMIREGULAR_H

libcxx/include/__concepts/swappable.h

Show All 19 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.swappable] // [concept.swappable]
namespace ranges { namespace ranges {
namespace __swap { namespace __swap {
template<class _Tp> template<class _Tp>
void swap(_Tp&, _Tp&) = delete; void swap(_Tp&, _Tp&) = delete;
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Linesconcept swappable_with =
common_reference_with<_Tp, _Up> && common_reference_with<_Tp, _Up> &&
requires(_Tp&& __t, _Up&& __u) { requires(_Tp&& __t, _Up&& __u) {
ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Tp>(__t)); ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Tp>(__t));
ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Up>(__u)); ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Up>(__u));
ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)); ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Tp>(__t)); ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Tp>(__t));
}; };
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_SWAPPABLE_H #endif // _LIBCPP___CONCEPTS_SWAPPABLE_H

libcxx/include/__concepts/totally_ordered.h

Show All 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [concept.totallyordered] // [concept.totallyordered]
template<class _Tp, class _Up> template<class _Tp, class _Up>
concept __partially_ordered_with = concept __partially_ordered_with =
requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) { requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
{ __t < __u } -> __boolean_testable; { __t < __u } -> __boolean_testable;
{ __t > __u } -> __boolean_testable; { __t > __u } -> __boolean_testable;
Show All 13 Linesconcept totally_ordered_with =
totally_ordered<_Tp> && totally_ordered<_Up> && totally_ordered<_Tp> && totally_ordered<_Up> &&
equality_comparable_with<_Tp, _Up> && equality_comparable_with<_Tp, _Up> &&
totally_ordered< totally_ordered<
common_reference_t< common_reference_t<
__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Tp>,
__make_const_lvalue_ref<_Up>>> && __make_const_lvalue_ref<_Up>>> &&
__partially_ordered_with<_Tp, _Up>; __partially_ordered_with<_Tp, _Up>;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_TOTALLY_ORDERED_H #endif // _LIBCPP___CONCEPTS_TOTALLY_ORDERED_H

libcxx/include/__iterator/distance.h

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
template <class _InputIter> template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
typename iterator_traits<_InputIter>::difference_type typename iterator_traits<_InputIter>::difference_type
distance(_InputIter __first, _InputIter __last) distance(_InputIter __first, _InputIter __last)
{ {
return _VSTD::__distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category()); return _VSTD::__distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category());
} }
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [range.iter.op.distance] // [range.iter.op.distance]
namespace ranges { namespace ranges {
namespace __distance { namespace __distance {
struct __fn { struct __fn {
template<class _Ip, sentinel_for<_Ip> _Sp> template<class _Ip, sentinel_for<_Ip> _Sp>
Show All 31 Lines
} // namespace __distance } // namespace __distance
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto distance = __distance::__fn{}; inline constexpr auto distance = __distance::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_DISTANCE_H #endif // _LIBCPP___ITERATOR_DISTANCE_H

libcxx/include/__iterator/insert_iterator.h

Show All 18 Lines
#include <cstddef> #include <cstddef>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _Container> template <class _Container>
using __insert_iterator_iter_t = ranges::iterator_t<_Container>; using __insert_iterator_iter_t = ranges::iterator_t<_Container>;
#else #else
template <class _Container> template <class _Container>
using __insert_iterator_iter_t = typename _Container::iterator; using __insert_iterator_iter_t = typename _Container::iterator;
#endif #endif
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/include/__iterator/reverse_iterator.h

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Lines
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
bool bool
operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{ {
return __x.base() >= __y.base(); return __x.base() >= __y.base();
} }
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2> template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
compare_three_way_result_t<_Iter1, _Iter2> compare_three_way_result_t<_Iter1, _Iter2>
operator<=>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator<=>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
{ {
return __y.base() <=> __x.base(); return __y.base() <=> __x.base();
} }
#endif #endif
Show All 40 Lines

libcxx/include/__random/uniform_random_bit_generator.h

Show All 18 Lines
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [rand.req.urng] // [rand.req.urng]
template<class _Gen> template<class _Gen>
concept uniform_random_bit_generator = concept uniform_random_bit_generator =
invocable<_Gen&> && unsigned_integral<invoke_result_t<_Gen&>> && invocable<_Gen&> && unsigned_integral<invoke_result_t<_Gen&>> &&
requires { requires {
{ _Gen::min() } -> same_as<invoke_result_t<_Gen&>>; { _Gen::min() } -> same_as<invoke_result_t<_Gen&>>;
{ _Gen::max() } -> same_as<invoke_result_t<_Gen&>>; { _Gen::max() } -> same_as<invoke_result_t<_Gen&>>;
requires bool_constant<(_Gen::min() < _Gen::max())>::value; requires bool_constant<(_Gen::min() < _Gen::max())>::value;
}; };
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H #endif // _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H

libcxx/include/__ranges/enable_borrowed_range.h

Show All 16 Lines
#include <__config> #include <__config>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace ranges namespace ranges
{ {
// [range.range], ranges // [range.range], ranges
template <class> template <class>
inline constexpr bool enable_borrowed_range = false; inline constexpr bool enable_borrowed_range = false;
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_ENABLE_BORROWED_RANGE_H #endif // _LIBCPP___RANGES_ENABLE_BORROWED_RANGE_H

libcxx/include/__ranges/non_propagating_cache.h

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines public:
constexpr _Tp& __emplace(_Args&& ...__args) { constexpr _Tp& __emplace(_Args&& ...__args) {
return __value_.emplace(__forward_tag{}, _VSTD::forward<_Args>(__args)...).__t_; return __value_.emplace(__forward_tag{}, _VSTD::forward<_Args>(__args)...).__t_;
} }
}; };
struct __empty_cache { }; struct __empty_cache { };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H #endif // _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H

libcxx/include/__utility/cmp.h

Show All 18 Lines
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template<class _Tp, class... _Up> template<class _Tp, class... _Up>
struct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...> {}; struct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...> {};
template<class _Tp> template<class _Tp>
concept __is_safe_integral_cmp = is_integral_v<_Tp> && concept __is_safe_integral_cmp = is_integral_v<_Tp> &&
!_IsSameAsAny<_Tp, bool, char !_IsSameAsAny<_Tp, bool, char
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
, char8_t , char8_t
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

libcxx/include/__utility/pair.h

Show First 20 Lines • Show All 324 Lines • ▼ Show 20 Lines
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool bool
operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) operator==(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{ {
return __x.first == __y.first && __x.second == __y.second; return __x.first == __y.first && __x.second == __y.second;
} }
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
common_comparison_category_t< common_comparison_category_t<
__synth_three_way_result<_T1>, __synth_three_way_result<_T1>,
__synth_three_way_result<_T2> > __synth_three_way_result<_T2> >
operator<=>(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) operator<=>(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{ {
if (auto __c = _VSTD::__synth_three_way(__x.first, __y.first); __c != 0) { if (auto __c = _VSTD::__synth_three_way(__x.first, __y.first); __c != 0) {
return __c; return __c;
} }
return _VSTD::__synth_three_way(__x.second, __y.second); return _VSTD::__synth_three_way(__x.second, __y.second);
} }
#else // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #else // !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool bool
operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
Show All 25 Lines
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool bool
operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y) operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
{ {
return !(__y < __x); return !(__y < __x);
} }
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER > 20
template <class _T1, class _T2, class _U1, class _U2, template<class> class _TQual, template<class> class _UQual> template <class _T1, class _T2, class _U1, class _U2, template<class> class _TQual, template<class> class _UQual>
requires requires { typename pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>, requires requires { typename pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
common_reference_t<_TQual<_T2>, _UQual<_U2>>>; } common_reference_t<_TQual<_T2>, _UQual<_U2>>>; }
struct basic_common_reference<pair<_T1, _T2>, pair<_U1, _U2>, _TQual, _UQual> { struct basic_common_reference<pair<_T1, _T2>, pair<_U1, _U2>, _TQual, _UQual> {
using type = pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>, using type = pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
common_reference_t<_TQual<_T2>, _UQual<_U2>>>; common_reference_t<_TQual<_T2>, _UQual<_U2>>>;
▲ Show 20 Lines • Show All 227 Lines • Show Last 20 Lines

libcxx/include/numbers

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
} }
*/ */
#include <__config> #include <__config>
#include <concepts> #include <concepts>
#include <type_traits> #include <type_traits>
#include <version> #include <version>
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace numbers { namespace numbers {
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
inline constexpr double inv_sqrt3 = inv_sqrt3_v<double>; inline constexpr double inv_sqrt3 = inv_sqrt3_v<double>;
inline constexpr double egamma = egamma_v<double>; inline constexpr double egamma = egamma_v<double>;
inline constexpr double phi = phi_v<double>; inline constexpr double phi = phi_v<double>;
} // namespace numbers } // namespace numbers
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif //_LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif //!defined(_LIBCPP_HAS_NO_CONCEPTS)
#endif // _LIBCPP_NUMBERS #endif // _LIBCPP_NUMBERS

libcxx/include/ranges

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
jloserUnsubmitted
Not Done
ReplyInline Actions

No action required, but this seems like a weird guard for !defined(_LIBCPP_HAS_NO_CONCEPTS). I would have expected the macro used to be something about ranges...

jloser: No action required, but this seems like a weird guard for `!defined(_LIBCPP_HAS_NO_CONCEPTS)`.
QuuxplusoneAuthorUnsubmitted
Done
ReplyInline Actions

Huh, good point. I have no idea... oh wait, yes I do. 😛 I bet that every single detail header that involves a view type is guarded by !defined(_LIBCPP_HAS_NO_CONCEPTS), because the view types all require some concept or other. Therefore, when _LIBCPP_HAS_NO_CONCEPTS, all of those headers sublimate away, which means nobody ever gets around to defining namespace views { ... }, which means line 244 failed to compile, and nobody ever looked into it. 😛We could certainly fix this via

namespace ranges::views { }
namespace views = ranges::views;

but I'm not sure I care enough.

Quuxplusone: Huh, good point. I have no idea... oh wait, yes I do. 😛 I bet that every single detail header…
ldionneUnsubmitted
Done
ReplyInline Actions

I think guarding this is correct. That way, when we move to _LIBCPP_STD_VER > 17, this will be guarded the way we want it.

ldionne: I think guarding this is correct. That way, when we move to `_LIBCPP_STD_VER > 17`, this will…
QuuxplusoneAuthorUnsubmitted
Done
ReplyInline Actions

This is now D118809.

Quuxplusone: This is now D118809.
namespace views = ranges::views; namespace views = ranges::views;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES) #endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
#endif // _LIBCPP_RANGES #endif // _LIBCPP_RANGES

libcxx/include/string_view

Show First 20 Lines • Show All 280 Lines • ▼ Show 20 Linespublic:
basic_string_view(const _CharT* __s, size_type __len) _NOEXCEPT basic_string_view(const _CharT* __s, size_type __len) _NOEXCEPT
: __data(__s), __size(__len) : __data(__s), __size(__len)
{ {
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER > 11
_LIBCPP_ASSERT(__len == 0 || __s != nullptr, "string_view::string_view(_CharT *, size_t): received nullptr"); _LIBCPP_ASSERT(__len == 0 || __s != nullptr, "string_view::string_view(_CharT *, size_t): received nullptr");
#endif #endif
} }
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <contiguous_iterator _It, sized_sentinel_for<_It> _End> template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
requires (is_same_v<iter_value_t<_It>, _CharT> && !is_convertible_v<_End, size_type>) requires (is_same_v<iter_value_t<_It>, _CharT> && !is_convertible_v<_End, size_type>)
constexpr _LIBCPP_HIDE_FROM_ABI basic_string_view(_It __begin, _End __end) constexpr _LIBCPP_HIDE_FROM_ABI basic_string_view(_It __begin, _End __end)
: __data(_VSTD::to_address(__begin)), __size(__end - __begin) : __data(_VSTD::to_address(__begin)), __size(__end - __begin)
{ {
_LIBCPP_ASSERT((__end - __begin) >= 0, "std::string_view::string_view(iterator, sentinel) received invalid range"); _LIBCPP_ASSERT((__end - __begin) >= 0, "std::string_view::string_view(iterator, sentinel) received invalid range");
} }
#endif #endif
▲ Show 20 Lines • Show All 404 Lines • ▼ Show 20 Lines#if _LIBCPP_STD_VER > 20
{ return find(__s) != npos; } { return find(__s) != npos; }
#endif #endif
private: private:
const value_type* __data; const value_type* __data;
size_type __size; size_type __size;
}; };
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
inline constexpr bool ranges::enable_view<basic_string_view<_CharT, _Traits>> = true; inline constexpr bool ranges::enable_view<basic_string_view<_CharT, _Traits>> = true;
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
inline constexpr bool ranges::enable_borrowed_range<basic_string_view<_CharT, _Traits> > = true; inline constexpr bool ranges::enable_borrowed_range<basic_string_view<_CharT, _Traits> > = true;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [string.view.deduct] // [string.view.deduct]
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <contiguous_iterator _It, sized_sentinel_for<_It> _End> template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>; basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>;
#endif #endif
#if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if _LIBCPP_STD_VER > 20 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <ranges::contiguous_range _Range> template <ranges::contiguous_range _Range>
basic_string_view(_Range) -> basic_string_view<ranges::range_value_t<_Range>>; basic_string_view(_Range) -> basic_string_view<ranges::range_value_t<_Range>>;
▲ Show 20 Lines • Show All 229 Lines • Show Last 20 Lines

libcxx/include/tuple

Show First 20 Lines • Show All 1,327 Lines • ▼ Show 20 Lines
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool bool
operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{ {
static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes"); static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
return __tuple_equal<sizeof...(_Tp)>()(__x, __y); return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
} }
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// operator<=> // operator<=>
template <class ..._Tp, class ..._Up, size_t ..._Is> template <class ..._Tp, class ..._Up, size_t ..._Is>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
auto auto
__tuple_compare_three_way(const tuple<_Tp...>& __x, const tuple<_Up...>& __y, index_sequence<_Is...>) { __tuple_compare_three_way(const tuple<_Tp...>& __x, const tuple<_Up...>& __y, index_sequence<_Is...>) {
common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...> __result = strong_ordering::equal; common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...> __result = strong_ordering::equal;
static_cast<void>(((__result = _VSTD::__synth_three_way(_VSTD::get<_Is>(__x), _VSTD::get<_Is>(__y)), __result != 0) || ...)); static_cast<void>(((__result = _VSTD::__synth_three_way(_VSTD::get<_Is>(__x), _VSTD::get<_Is>(__y)), __result != 0) || ...));
return __result; return __result;
} }
template <class ..._Tp, class ..._Up> template <class ..._Tp, class ..._Up>
requires (sizeof...(_Tp) == sizeof...(_Up)) requires (sizeof...(_Tp) == sizeof...(_Up))
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...> common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>
operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{ {
return _VSTD::__tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{}); return _VSTD::__tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{});
} }
#else // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #else // !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class ..._Tp, class ..._Up> template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool bool
operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
template <class ..._Tp, class ..._Up> template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
bool bool
operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
{ {
return !(__y < __x); return !(__y < __x);
} }
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
// tuple_cat // tuple_cat
template <class _Tp, class _Up> struct __tuple_cat_type; template <class _Tp, class _Up> struct __tuple_cat_type;
template <class ..._Ttypes, class ..._Utypes> template <class ..._Ttypes, class ..._Utypes>
struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> > struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
{ {
▲ Show 20 Lines • Show All 197 Lines • Show Last 20 Lines

libcxx/include/type_traits

Show First 20 Lines • Show All 2,436 Lines • ▼ Show 20 Lines
}; };
template <class _From, class _To> template <class _From, class _To>
using __copy_cvref_t = typename __copy_cvref<_From, _To>::type; using __copy_cvref_t = typename __copy_cvref<_From, _To>::type;
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER > 11
// common_reference // common_reference
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// Let COND_RES(X, Y) be: // Let COND_RES(X, Y) be:
template <class _Xp, class _Yp> template <class _Xp, class _Yp>
using __cond_res = using __cond_res =
decltype(false ? declval<_Xp(&)()>()() : declval<_Yp(&)()>()()); decltype(false ? declval<_Xp(&)()>()() : declval<_Yp(&)()>()());
// Let `XREF(A)` denote a unary alias template `T` such that `T<U>` denotes the same type as `U` // Let `XREF(A)` denote a unary alias template `T` such that `T<U>` denotes the same type as `U`
// with the addition of `A`'s cv and reference qualifiers, for a non-reference cv-unqualified type // with the addition of `A`'s cv and reference qualifiers, for a non-reference cv-unqualified type
// `U`. // `U`.
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines
requires requires { typename common_reference_t<_Tp, _Up>; } requires requires { typename common_reference_t<_Tp, _Up>; }
struct common_reference<_Tp, _Up, _Vp, _Rest...> struct common_reference<_Tp, _Up, _Vp, _Rest...>
: common_reference<common_reference_t<_Tp, _Up>, _Vp, _Rest...> : common_reference<common_reference_t<_Tp, _Up>, _Vp, _Rest...>
{}; {};
// bullet 5 - Otherwise, there shall be no member `type`. // bullet 5 - Otherwise, there shall be no member `type`.
template <class...> struct common_reference {}; template <class...> struct common_reference {};
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
// is_assignable // is_assignable
template<typename, typename _Tp> struct __select_2nd { typedef _LIBCPP_NODEBUG _Tp type; }; template<typename, typename _Tp> struct __select_2nd { typedef _LIBCPP_NODEBUG _Tp type; };
#if __has_keyword(__is_assignable) #if __has_keyword(__is_assignable)
template<class _Tp, class _Up> template<class _Tp, class _Up>
▲ Show 20 Lines • Show All 1,548 Lines • Show Last 20 Lines