This is an archive of the discontinued LLVM Phabricator instance.

Differential D143962

[libc++][NFC] Replace _LIBCPP_STD_VER > x with _LIBCPP_STD_VER >= x
ClosedPublic

Authored by philnik on Feb 13 2023, 4:05 PM.

Details

Reviewers
ldionne
Mordante
var-const
huixie90
Group Reviewers
Restricted Project
Commits
rG4f15267d3dd7: [libc++][NFC] Replace _LIBCPP_STD_VER > x with _LIBCPP_STD_VER >= x
Summary

This change is almost fully mechanical. The only interesting change is in generate_feature_test_macro_components.py to generate _LIBCPP_STD_VER >= instead. To avoid churn in the git-blame this commit should be added to the .git-blame-ignore-revs once committed.

Diff Detail

Event Timeline

philnik created this revision.Feb 13 2023, 4:05 PM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 13 2023, 4:05 PM
Herald added subscribers: wenlei, arphaman, arichardson. · View Herald Transcript
philnik requested review of this revision.Feb 13 2023, 4:05 PM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 13 2023, 4:05 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
var-const accepted this revision as: var-const.Feb 13 2023, 4:30 PM

LGTM, but I'll leave the approval to @ldionne (I remember this was discussed before and want to make sure this reflects the final decision; personally, I fully support this and think it's long overdue).

jloser added a subscriber: jloser.Feb 13 2023, 4:35 PM
jloser added inline comments.
libcxx/utils/generate_feature_test_macro_components.py
286

Out of curiosity, did we decide (or should we) to do the same for TEST_STD_VER? It seems slightly out of place seeing it use >. WDYT?

Harbormaster completed remote builds in B213530: Diff 497141.Feb 13 2023, 5:31 PM
ldionne accepted this revision.Feb 15 2023, 7:22 AM
ldionne added inline comments.
libcxx/utils/generate_feature_test_macro_components.py
286

I agree, however that touches even more files. Let's do it separately if at all.

This revision is now accepted and ready to land.Feb 15 2023, 7:22 AM
ldionne added a comment.Feb 15 2023, 7:22 AM

Please commit this ASAP to avoid conflicts

This revision was landed with ongoing or failed builds.Feb 15 2023, 7:52 AM
Closed by commit rG4f15267d3dd7: [libc++][NFC] Replace _LIBCPP_STD_VER > x with _LIBCPP_STD_VER >= x (authored by philnik). · Explain Why
This revision was automatically updated to reflect the committed changes.
philnik added a commit: rG4f15267d3dd7: [libc++][NFC] Replace _LIBCPP_STD_VER > x with _LIBCPP_STD_VER >= x.
Mordante added a comment.Feb 15 2023, 8:14 AM
In D143962#4124621, @var-const wrote:

LGTM, but I'll leave the approval to @ldionne (I remember this was discussed before and want to make sure this reflects the final decision; personally, I fully support this and think it's long overdue).

AFAIK we never made a decision :-(

I really would like to discuss this upfront instead of rushing it in. I expect merge conflicts in is some of my formatting patches. Not hard to fix, but it's quite annoying.

ldionne added a comment.Feb 15 2023, 12:50 PM
In D143962#4129268, @Mordante wrote:
In D143962#4124621, @var-const wrote:

LGTM, but I'll leave the approval to @ldionne (I remember this was discussed before and want to make sure this reflects the final decision; personally, I fully support this and think it's long overdue).

AFAIK we never made a decision :-(

I really would like to discuss this upfront instead of rushing it in. I expect merge conflicts in is some of my formatting patches. Not hard to fix, but it's quite annoying.

Mark and I talked about this offline. So my recollection is that we did have a discussion at some point on a review (or on Discord) where we had agreed to do this. I think I was initially against but had ended up agreeing since most folks wanted to do it. Clearly, this wasn't unanimous.

Mark and I agreed to set up an infrequent meeting with regular libc++ contributors to discuss these sorts of broad "policy" decisions in the future to make sure we had a clear agreement on those beforehand. We would take a few notes and publish them to Discourse or add them to a design document of sorts in the repository, making sure that those decisions are recorded somewhere.

Revision Contents

PathSize
libcxx/
include/
__algorithm/
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
8 lines
2 lines
4 lines
6 lines
4 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
4 lines
2 lines
4 lines
4 lines
6 lines
__bit/
4 lines
4 lines
4 lines
__charconv/
4 lines
6 lines
4 lines
4 lines
6 lines
__chrono/
4 lines
4 lines
4 lines
10 lines
8 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
__compare/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
__concepts/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
22 lines
__coroutine/
4 lines
4 lines
4 lines
4 lines
__filesystem/
4 lines
4 lines
2 lines
__format/
4 lines
8 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
8 lines
4 lines
8 lines
4 lines
4 lines
4 lines
8 lines
4 lines
10 lines
4 lines
8 lines
4 lines
4 lines
20 lines
__functional/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
74 lines
4 lines
4 lines
4 lines
4 lines
__fwd/
2 lines
8 lines
__iterator/
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
4 lines
4 lines
4 lines
2 lines
4 lines
4 lines
4 lines
8 lines
8 lines
4 lines
4 lines
18 lines
4 lines
26 lines
4 lines
4 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
54 lines
6 lines
4 lines
4 lines
2 lines
__memory/
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
12 lines
2 lines
4 lines
4 lines
2 lines
36 lines
4 lines
4 lines
8 lines
2 lines
4 lines
__memory_resource/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
__numeric/
4 lines
4 lines
4 lines
2 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
4 lines
2 lines
__random/
4 lines
__ranges/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
__string/
10 lines
12 lines
__tuple_dir/
4 lines
2 lines
__type_traits/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
4 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
__utility/
2 lines
4 lines
4 lines
4 lines
4 lines
8 lines
6 lines
2 lines
2 lines
__variant/
10 lines
4 lines
6 lines
14 lines
4 lines
2 lines
6 lines
2 lines
2 lines
2 lines
4 lines
22 lines
experimental/
4 lines
4 lines
4 lines
4 lines
16 lines
4 lines
4 lines
24 lines
62 lines
4 lines
10 lines
4 lines
16 lines
8 lines
8 lines
2 lines
16 lines
2 lines
50 lines
6 lines
8 lines
8 lines
4 lines
38 lines
36 lines
10 lines
52 lines
2 lines
66 lines
58 lines
2 lines
16 lines
40 lines
10 lines
utils/
4 lines
4 lines
8 lines

Diff 497678

libcxx/include/__algorithm/clamp.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 > 14 #if _LIBCPP_STD_VER >= 17
template<class _Tp, class _Compare> template<class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
const _Tp& const _Tp&
clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi, _Compare __comp) clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
{ {
_LIBCPP_ASSERT(!__comp(__hi, __lo), "Bad bounds passed to std::clamp"); _LIBCPP_ASSERT(!__comp(__hi, __lo), "Bad bounds passed to std::clamp");
return __comp(__v, __lo) ? __lo : __comp(__hi, __v) ? __hi : __v; return __comp(__v, __lo) ? __lo : __comp(__hi, __v) ? __hi : __v;
Show All 16 Lines

libcxx/include/__algorithm/equal.h

Show All 30 Lines
} }
template <class _InputIterator1, class _InputIterator2> template <class _InputIterator1, class _InputIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) { equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) {
return std::equal(__first1, __last1, __first2, __equal_to()); return std::equal(__first1, __last1, __first2, __equal_to());
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _BinaryPredicate, class _InputIterator1, class _InputIterator2> template <class _BinaryPredicate, class _InputIterator1, class _InputIterator2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
__equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, __equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
_BinaryPredicate __pred, input_iterator_tag, input_iterator_tag) { _BinaryPredicate __pred, input_iterator_tag, input_iterator_tag) {
for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2) for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2)
if (!__pred(*__first1, *__first2)) if (!__pred(*__first1, *__first2))
return false; return false;
return __first1 == __last1 && __first2 == __last2; return __first1 == __last1 && __first2 == __last2;
Show All 39 Lines

libcxx/include/__algorithm/for_each_n.h

Show All 13 Lines
#include <__utility/convert_to_integral.h> #include <__utility/convert_to_integral.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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _InputIterator, class _Size, class _Function> template <class _InputIterator, class _Size, class _Function>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator for_each_n(_InputIterator __first, inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator for_each_n(_InputIterator __first,
_Size __orig_n, _Size __orig_n,
_Function __f) { _Function __f) {
typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize; typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
_IntegralSize __n = __orig_n; _IntegralSize __n = __orig_n;
while (__n > 0) { while (__n > 0) {
Show All 12 Lines

libcxx/include/__algorithm/in_found_result.h

Show All 12 Lines
#include <__concepts/convertible_to.h> #include <__concepts/convertible_to.h>
#include <__config> #include <__config>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter1> template <class _InIter1>
struct in_found_result { struct in_found_result {
_LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in; _LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in;
bool found; bool found;
Show All 9 Linesstruct in_found_result {
_LIBCPP_HIDE_FROM_ABI constexpr operator in_found_result<_InIter2>() && { _LIBCPP_HIDE_FROM_ABI constexpr operator in_found_result<_InIter2>() && {
return {std::move(in), found}; return {std::move(in), found};
} }
}; };
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_IN_FOUND_RESULT_H #endif // _LIBCPP___ALGORITHM_IN_FOUND_RESULT_H

libcxx/include/__algorithm/in_fun_result.h

Show All 14 Lines
#include <__utility/move.h> #include <__utility/move.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template <class _InIter1, class _Func1> template <class _InIter1, class _Func1>
struct in_fun_result { struct in_fun_result {
_LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in; _LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in;
_LIBCPP_NO_UNIQUE_ADDRESS _Func1 fun; _LIBCPP_NO_UNIQUE_ADDRESS _Func1 fun;
template <class _InIter2, class _Func2> template <class _InIter2, class _Func2>
requires convertible_to<const _InIter1&, _InIter2> && convertible_to<const _Func1&, _Func2> requires convertible_to<const _InIter1&, _InIter2> && convertible_to<const _Func1&, _Func2>
_LIBCPP_HIDE_FROM_ABI constexpr operator in_fun_result<_InIter2, _Func2>() const & { _LIBCPP_HIDE_FROM_ABI constexpr operator in_fun_result<_InIter2, _Func2>() const & {
return {in, fun}; return {in, fun};
} }
template <class _InIter2, class _Func2> template <class _InIter2, class _Func2>
requires convertible_to<_InIter1, _InIter2> && convertible_to<_Func1, _Func2> requires convertible_to<_InIter1, _InIter2> && convertible_to<_Func1, _Func2>
_LIBCPP_HIDE_FROM_ABI constexpr operator in_fun_result<_InIter2, _Func2>() && { _LIBCPP_HIDE_FROM_ABI constexpr operator in_fun_result<_InIter2, _Func2>() && {
return {std::move(in), std::move(fun)}; return {std::move(in), std::move(fun)};
} }
}; };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IN_FUN_RESULT_H #endif // _LIBCPP___ALGORITHM_IN_FUN_RESULT_H

libcxx/include/__algorithm/in_in_out_result.h

Show All 14 Lines
#include <__utility/move.h> #include <__utility/move.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template <class _InIter1, class _InIter2, class _OutIter1> template <class _InIter1, class _InIter2, class _OutIter1>
struct in_in_out_result { struct in_in_out_result {
_LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in1; _LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in1;
_LIBCPP_NO_UNIQUE_ADDRESS _InIter2 in2; _LIBCPP_NO_UNIQUE_ADDRESS _InIter2 in2;
_LIBCPP_NO_UNIQUE_ADDRESS _OutIter1 out; _LIBCPP_NO_UNIQUE_ADDRESS _OutIter1 out;
Show All 12 Linesstruct in_in_out_result {
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
operator in_in_out_result<_InIter3, _InIter4, _OutIter2>() && { operator in_in_out_result<_InIter3, _InIter4, _OutIter2>() && {
return {std::move(in1), std::move(in2), std::move(out)}; return {std::move(in1), std::move(in2), std::move(out)};
} }
}; };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IN_IN_OUT_RESULT_H #endif // _LIBCPP___ALGORITHM_IN_IN_OUT_RESULT_H

libcxx/include/__algorithm/in_in_result.h

Show All 14 Lines
#include <__utility/move.h> #include <__utility/move.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template <class _InIter1, class _InIter2> template <class _InIter1, class _InIter2>
struct in_in_result { struct in_in_result {
_LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in1; _LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in1;
_LIBCPP_NO_UNIQUE_ADDRESS _InIter2 in2; _LIBCPP_NO_UNIQUE_ADDRESS _InIter2 in2;
Show All 9 Linesstruct in_in_result {
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
operator in_in_result<_InIter3, _InIter4>() && { operator in_in_result<_InIter3, _InIter4>() && {
return {std::move(in1), std::move(in2)}; return {std::move(in1), std::move(in2)};
} }
}; };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IN_IN_RESULT_H #endif // _LIBCPP___ALGORITHM_IN_IN_RESULT_H

libcxx/include/__algorithm/in_out_out_result.h

Show All 14 Lines
#include <__utility/move.h> #include <__utility/move.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template <class _InIter1, class _OutIter1, class _OutIter2> template <class _InIter1, class _OutIter1, class _OutIter2>
struct in_out_out_result { struct in_out_out_result {
_LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in; _LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in;
_LIBCPP_NO_UNIQUE_ADDRESS _OutIter1 out1; _LIBCPP_NO_UNIQUE_ADDRESS _OutIter1 out1;
_LIBCPP_NO_UNIQUE_ADDRESS _OutIter2 out2; _LIBCPP_NO_UNIQUE_ADDRESS _OutIter2 out2;
Show All 10 Lines requires convertible_to<_InIter1, _InIter2>
&& convertible_to<_OutIter1, _OutIter3> && convertible_to<_OutIter2, _OutIter4> && convertible_to<_OutIter1, _OutIter3> && convertible_to<_OutIter2, _OutIter4>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
operator in_out_out_result<_InIter2, _OutIter3, _OutIter4>() && { operator in_out_out_result<_InIter2, _OutIter3, _OutIter4>() && {
return {std::move(in), std::move(out1), std::move(out2)}; return {std::move(in), std::move(out1), std::move(out2)};
} }
}; };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IN_OUT_OUT_RESULT_H #endif // _LIBCPP___ALGORITHM_IN_OUT_OUT_RESULT_H

libcxx/include/__algorithm/in_out_result.h

Show All 14 Lines
#include <__utility/move.h> #include <__utility/move.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<class _InIter1, class _OutIter1> template<class _InIter1, class _OutIter1>
struct in_out_result { struct in_out_result {
_LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in; _LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in;
_LIBCPP_NO_UNIQUE_ADDRESS _OutIter1 out; _LIBCPP_NO_UNIQUE_ADDRESS _OutIter1 out;
Show All 9 Linesstruct in_out_result {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr operator in_out_result<_InIter2, _OutIter2>() && { constexpr operator in_out_result<_InIter2, _OutIter2>() && {
return {std::move(in), std::move(out)}; return {std::move(in), std::move(out)};
} }
}; };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IN_OUT_RESULT_H #endif // _LIBCPP___ALGORITHM_IN_OUT_RESULT_H

libcxx/include/__algorithm/is_permutation.h

Show All 25 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class = void> template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class = void>
struct _ConstTimeDistance : false_type {}; struct _ConstTimeDistance : false_type {};
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Iter1, class _Sent1, class _Iter2, class _Sent2> template <class _Iter1, class _Sent1, class _Iter2, class _Sent2>
struct _ConstTimeDistance<_Iter1, _Sent1, _Iter2, _Sent2, __enable_if_t< struct _ConstTimeDistance<_Iter1, _Sent1, _Iter2, _Sent2, __enable_if_t<
sized_sentinel_for<_Sent1, _Iter1> && sized_sentinel_for<_Sent1, _Iter1> &&
sized_sentinel_for<_Sent2, _Iter2> sized_sentinel_for<_Sent2, _Iter2>
>> : true_type {}; >> : true_type {};
#else #else
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
struct _ConstTimeDistance<_Iter1, _Iter1, _Iter2, _Iter2, __enable_if_t< struct _ConstTimeDistance<_Iter1, _Iter1, _Iter2, _Iter2, __enable_if_t<
is_same<typename iterator_traits<_Iter1>::iterator_category, random_access_iterator_tag>::value && is_same<typename iterator_traits<_Iter1>::iterator_category, random_access_iterator_tag>::value &&
is_same<typename iterator_traits<_Iter2>::iterator_category, random_access_iterator_tag>::value is_same<typename iterator_traits<_Iter2>::iterator_category, random_access_iterator_tag>::value
> > : true_type {}; > > : true_type {};
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
// Internal functions // Internal functions
// For each element in [f1, l1) see if there are the same number of equal elements in [f2, l2) // For each element in [f1, l1) see if there are the same number of equal elements in [f2, l2)
template <class _AlgPolicy, template <class _AlgPolicy,
class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Iter1, class _Sent1, class _Iter2, class _Sent2,
class _Proj1, class _Proj2, class _Pred> class _Proj1, class _Proj2, class _Pred>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
▲ Show 20 Lines • Show All 138 Lines • ▼ Show 20 Lines
// 2+1 iterators // 2+1 iterators
template <class _ForwardIterator1, class _ForwardIterator2> template <class _ForwardIterator1, class _ForwardIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
return std::is_permutation(__first1, __last1, __first2, __equal_to()); return std::is_permutation(__first1, __last1, __first2, __equal_to());
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
// 2+2 iterators // 2+2 iterators
template <class _ForwardIterator1, class _ForwardIterator2> template <class _ForwardIterator1, class _ForwardIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool is_permutation( _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool is_permutation(
_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) { _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
return std::__is_permutation<_ClassicAlgPolicy>( return std::__is_permutation<_ClassicAlgPolicy>(
std::move(__first1), std::move(__first1),
std::move(__last1), std::move(__last1),
Show All 12 Linesis_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value, static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value,
"The predicate has to be callable"); "The predicate has to be callable");
return std::__is_permutation<_ClassicAlgPolicy>( return std::__is_permutation<_ClassicAlgPolicy>(
std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
__pred, __identity(), __identity()); __pred, __identity(), __identity());
} }
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IS_PERMUTATION_H #endif // _LIBCPP___ALGORITHM_IS_PERMUTATION_H

libcxx/include/__algorithm/iterator_operations.h

Show All 31 Lines
#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
template <class _AlgPolicy> struct _IterOps; template <class _AlgPolicy> struct _IterOps;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
struct _RangeAlgPolicy {}; struct _RangeAlgPolicy {};
template <> template <>
struct _IterOps<_RangeAlgPolicy> { struct _IterOps<_RangeAlgPolicy> {
template <class _Iter> template <class _Iter>
using __value_type = iter_value_t<_Iter>; using __value_type = iter_value_t<_Iter>;
▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

libcxx/include/__algorithm/lexicographical_compare_three_way.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 #if _LIBCPP_STD_VER >= 20
// Fast path for random access iterators which computes the number of loop iterations up-front and // Fast path for random access iterators which computes the number of loop iterations up-front and
// then skips the iterator comparisons inside the loop. // then skips the iterator comparisons inside the loop.
template <class _InputIterator1, class _InputIterator2, class _Cmp> template <class _InputIterator1, class _InputIterator2, class _Cmp>
_LIBCPP_HIDE_FROM_ABI constexpr auto __lexicographical_compare_three_way_fast_path( _LIBCPP_HIDE_FROM_ABI constexpr auto __lexicographical_compare_three_way_fast_path(
_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Cmp& __comp) _InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Cmp& __comp)
-> decltype(__comp(*__first1, *__first2)) { -> decltype(__comp(*__first1, *__first2)) {
static_assert( static_assert(
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
template <class _InputIterator1, class _InputIterator2> template <class _InputIterator1, class _InputIterator2>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto lexicographical_compare_three_way( _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto lexicographical_compare_three_way(
_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) { _InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
return std::lexicographical_compare_three_way( return std::lexicographical_compare_three_way(
std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), std::compare_three_way()); std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), std::compare_three_way());
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___ALGORITHM_LEXICOGRAPHICAL_COMPARE_THREE_WAY_H #endif // _LIBCPP___ALGORITHM_LEXICOGRAPHICAL_COMPARE_THREE_WAY_H

libcxx/include/__algorithm/make_projected.h

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
}; };
template <class _Pred, class _Proj, class = void> template <class _Pred, class _Proj, class = void>
struct __can_use_pristine_comp : false_type {}; struct __can_use_pristine_comp : false_type {};
template <class _Pred, class _Proj> template <class _Pred, class _Proj>
struct __can_use_pristine_comp<_Pred, _Proj, __enable_if_t< struct __can_use_pristine_comp<_Pred, _Proj, __enable_if_t<
!is_member_pointer<typename decay<_Pred>::type>::value && ( !is_member_pointer<typename decay<_Pred>::type>::value && (
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
is_same<typename decay<_Proj>::type, identity>::value || is_same<typename decay<_Proj>::type, identity>::value ||
#endif #endif
is_same<typename decay<_Proj>::type, __identity>::value is_same<typename decay<_Proj>::type, __identity>::value
) )
> > : true_type {}; > > : true_type {};
template <class _Pred, class _Proj> template <class _Pred, class _Proj>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static
Show All 15 Lines__enable_if_t<
_Pred& _Pred&
> >
__make_projected(_Pred& __pred, _Proj&) { __make_projected(_Pred& __pred, _Proj&) {
return __pred; return __pred;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _Comp, class _Proj1, class _Proj2> template <class _Comp, class _Proj1, class _Proj2>
_LIBCPP_HIDE_FROM_ABI constexpr static _LIBCPP_HIDE_FROM_ABI constexpr static
decltype(auto) __make_projected_comp(_Comp& __comp, _Proj1& __proj1, _Proj2& __proj2) { decltype(auto) __make_projected_comp(_Comp& __comp, _Proj1& __proj1, _Proj2& __proj2) {
Show All 11 Lines if constexpr (same_as<decay_t<_Proj1>, identity> && same_as<decay_t<_Proj2>, identity> &&
}; };
} }
} }
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_MAKE_PROJECTED_H #endif // _LIBCPP___ALGORITHM_MAKE_PROJECTED_H

libcxx/include/__algorithm/min_max_result.h

Show All 17 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template <class _T1> template <class _T1>
struct min_max_result { struct min_max_result {
_LIBCPP_NO_UNIQUE_ADDRESS _T1 min; _LIBCPP_NO_UNIQUE_ADDRESS _T1 min;
_LIBCPP_NO_UNIQUE_ADDRESS _T1 max; _LIBCPP_NO_UNIQUE_ADDRESS _T1 max;
template <class _T2> template <class _T2>
requires convertible_to<const _T1&, _T2> requires convertible_to<const _T1&, _T2>
_LIBCPP_HIDE_FROM_ABI constexpr operator min_max_result<_T2>() const & { _LIBCPP_HIDE_FROM_ABI constexpr operator min_max_result<_T2>() const & {
return {min, max}; return {min, max};
} }
template <class _T2> template <class _T2>
requires convertible_to<_T1, _T2> requires convertible_to<_T1, _T2>
_LIBCPP_HIDE_FROM_ABI constexpr operator min_max_result<_T2>() && { _LIBCPP_HIDE_FROM_ABI constexpr operator min_max_result<_T2>() && {
return {std::move(min), std::move(max)}; return {std::move(min), std::move(max)};
} }
}; };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___ALGORITHM_MIN_MAX_RESULT_H #endif // _LIBCPP___ALGORITHM_MIN_MAX_RESULT_H

libcxx/include/__algorithm/mismatch.h

Show All 32 Lines
template <class _InputIterator1, class _InputIterator2> template <class _InputIterator1, class _InputIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2> _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) { mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) {
return std::mismatch(__first1, __last1, __first2, __equal_to()); return std::mismatch(__first1, __last1, __first2, __equal_to());
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate> template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2> _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
_BinaryPredicate __pred) { _BinaryPredicate __pred) {
for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2) for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2)
if (!__pred(*__first1, *__first2)) if (!__pred(*__first1, *__first2))
break; break;
Show All 14 Lines

libcxx/include/__algorithm/ranges_adjacent_find.h

Show All 18 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __adjacent_find { namespace __adjacent_find {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Proj, class _Pred> template <class _Iter, class _Sent, class _Proj, class _Pred>
Show All 32 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto adjacent_find = __adjacent_find::__fn{}; inline constexpr auto adjacent_find = __adjacent_find::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_ADJACENT_FIND_H #endif // _LIBCPP___ALGORITHM_RANGES_ADJACENT_FIND_H

libcxx/include/__algorithm/ranges_all_of.h

Show All 16 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __all_of { namespace __all_of {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Proj, class _Pred> template <class _Iter, class _Sent, class _Proj, class _Pred>
Show All 24 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto all_of = __all_of::__fn{}; inline constexpr auto all_of = __all_of::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_ALL_OF_H #endif // _LIBCPP___ALGORITHM_RANGES_ALL_OF_H

libcxx/include/__algorithm/ranges_any_of.h

Show All 16 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __any_of { namespace __any_of {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Proj, class _Pred> template <class _Iter, class _Sent, class _Proj, class _Pred>
Show All 24 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto any_of = __any_of::__fn{}; inline constexpr auto any_of = __any_of::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_ANY_OF_H #endif // _LIBCPP___ALGORITHM_RANGES_ANY_OF_H

libcxx/include/__algorithm/ranges_binary_search.h

Show All 18 Lines
#include <__iterator/projected.h> #include <__iterator/projected.h>
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __binary_search { namespace __binary_search {
struct __fn { struct __fn {
template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity, template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity,
indirect_strict_weak_order<const _Type*, projected<_Iter, _Proj>> _Comp = ranges::less> indirect_strict_weak_order<const _Type*, projected<_Iter, _Proj>> _Comp = ranges::less>
Show All 17 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto binary_search = __binary_search::__fn{}; inline constexpr auto binary_search = __binary_search::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_BINARY_SEARCH_H #endif // _LIBCPP___ALGORITHM_RANGES_BINARY_SEARCH_H

libcxx/include/__algorithm/ranges_clamp.h

Show All 16 Lines
#include <__iterator/concepts.h> #include <__iterator/concepts.h>
#include <__iterator/projected.h> #include <__iterator/projected.h>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __clamp { namespace __clamp {
struct __fn { struct __fn {
template <class _Type, template <class _Type,
Show All 21 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto clamp = __clamp::__fn{}; inline constexpr auto clamp = __clamp::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_CLAMP_H #endif // _LIBCPP___ALGORITHM_RANGES_CLAMP_H

libcxx/include/__algorithm/ranges_copy.h

Show All 19 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using copy_result = in_out_result<_InIter, _OutIter>; using copy_result = in_out_result<_InIter, _OutIter>;
Show All 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto copy = __copy::__fn{}; inline constexpr auto copy = __copy::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_COPY_H #endif // _LIBCPP___ALGORITHM_RANGES_COPY_H

libcxx/include/__algorithm/ranges_copy_backward.h

Show All 17 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template<class _Ip, class _Op> template<class _Ip, class _Op>
using copy_backward_result = in_out_result<_Ip, _Op>; using copy_backward_result = in_out_result<_Ip, _Op>;
Show All 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto copy_backward = __copy_backward::__fn{}; inline constexpr auto copy_backward = __copy_backward::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_COPY_BACKWARD_H #endif // _LIBCPP___ALGORITHM_RANGES_COPY_BACKWARD_H

libcxx/include/__algorithm/ranges_copy_if.h

Show All 18 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template<class _Ip, class _Op> template<class _Ip, class _Op>
using copy_if_result = in_out_result<_Ip, _Op>; using copy_if_result = in_out_result<_Ip, _Op>;
Show All 35 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto copy_if = __copy_if::__fn{}; inline constexpr auto copy_if = __copy_if::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_COPY_IF_H #endif // _LIBCPP___ALGORITHM_RANGES_COPY_IF_H

libcxx/include/__algorithm/ranges_copy_n.h

Show All 21 Lines
#include <__utility/move.h> #include <__utility/move.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template <class _Ip, class _Op> template <class _Ip, class _Op>
using copy_n_result = in_out_result<_Ip, _Op>; using copy_n_result = in_out_result<_Ip, _Op>;
namespace __copy_n { namespace __copy_n {
struct __fn { struct __fn {
Show All 26 Lines
}; };
} // namespace __copy_n } // namespace __copy_n
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto copy_n = __copy_n::__fn{}; inline constexpr auto copy_n = __copy_n::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_RANGES_COPY_N_H #endif // _LIBCPP___ALGORITHM_RANGES_COPY_N_H

libcxx/include/__algorithm/ranges_count.h

Show All 19 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __count { namespace __count {
struct __fn { struct __fn {
template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity> template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity>
requires indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Type*> requires indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Type*>
Show All 15 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto count = __count::__fn{}; inline constexpr auto count = __count::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_COUNT_H #endif // _LIBCPP___ALGORITHM_RANGES_COUNT_H

libcxx/include/__algorithm/ranges_count_if.h

Show All 19 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _Iter, class _Sent, class _Proj, class _Pred> template <class _Iter, class _Sent, class _Proj, class _Pred>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
iter_difference_t<_Iter> __count_if_impl(_Iter __first, _Sent __last, iter_difference_t<_Iter> __count_if_impl(_Iter __first, _Sent __last,
_Pred& __pred, _Proj& __proj) { _Pred& __pred, _Proj& __proj) {
Show All 25 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto count_if = __count_if::__fn{}; inline constexpr auto count_if = __count_if::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_COUNT_IF_H #endif // _LIBCPP___ALGORITHM_RANGES_COUNT_IF_H

libcxx/include/__algorithm/ranges_equal.h

Show All 18 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __equal { namespace __equal {
struct __fn { struct __fn {
private: private:
template <class _Iter1, class _Sent1, template <class _Iter1, class _Sent1,
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto equal = __equal::__fn{}; inline constexpr auto equal = __equal::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_EQUAL_H #endif // _LIBCPP___ALGORITHM_RANGES_EQUAL_H

libcxx/include/__algorithm/ranges_equal_range.h

Show All 24 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __equal_range { namespace __equal_range {
struct __fn { struct __fn {
template < template <
Show All 26 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto equal_range = __equal_range::__fn{}; inline constexpr auto equal_range = __equal_range::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_EQUAL_RANGE_H #endif // _LIBCPP___ALGORITHM_RANGES_EQUAL_RANGE_H

libcxx/include/__algorithm/ranges_fill.h

Show All 14 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __fill { namespace __fill {
struct __fn { struct __fn {
template <class _Type, output_iterator<const _Type&> _Iter, sentinel_for<_Iter> _Sent> template <class _Type, output_iterator<const _Type&> _Iter, sentinel_for<_Iter> _Sent>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
Show All 17 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto fill = __fill::__fn{}; inline constexpr auto fill = __fill::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_FILL_H #endif // _LIBCPP___ALGORITHM_RANGES_FILL_H

libcxx/include/__algorithm/ranges_fill_n.h

Show All 11 Lines
#include <__config> #include <__config>
#include <__iterator/concepts.h> #include <__iterator/concepts.h>
#include <__iterator/incrementable_traits.h> #include <__iterator/incrementable_traits.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __fill_n { namespace __fill_n {
struct __fn { struct __fn {
template <class _Type, output_iterator<const _Type&> _Iter> template <class _Type, output_iterator<const _Type&> _Iter>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
Show All 9 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto fill_n = __fill_n::__fn{}; inline constexpr auto fill_n = __fill_n::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_FILL_N_H #endif // _LIBCPP___ALGORITHM_RANGES_FILL_N_H

libcxx/include/__algorithm/ranges_find.h

Show All 20 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __find { namespace __find {
struct __fn { struct __fn {
template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Tp, class _Proj = identity> template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Tp, class _Proj = identity>
requires indirect_binary_predicate<ranges::equal_to, projected<_Ip, _Proj>, const _Tp*> requires indirect_binary_predicate<ranges::equal_to, projected<_Ip, _Proj>, const _Tp*>
Show All 15 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto find = __find::__fn{}; inline constexpr auto find = __find::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_FIND_H #endif // _LIBCPP___ALGORITHM_RANGES_FIND_H

libcxx/include/__algorithm/ranges_find_end.h

Show All 21 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/subrange.h> #include <__ranges/subrange.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __find_end { namespace __find_end {
struct __fn { struct __fn {
template <forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1, template <forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2, forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto find_end = __find_end::__fn{}; inline constexpr auto find_end = __find_end::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_FIND_END_H #endif // _LIBCPP___ALGORITHM_RANGES_FIND_END_H

libcxx/include/__algorithm/ranges_find_first_of.h

Show All 18 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __find_first_of { namespace __find_first_of {
struct __fn { struct __fn {
template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2> template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto find_first_of = __find_first_of::__fn{}; inline constexpr auto find_first_of = __find_first_of::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_FIND_FIRST_OF_H #endif // _LIBCPP___ALGORITHM_RANGES_FIND_FIRST_OF_H

libcxx/include/__algorithm/ranges_find_if.h

Show All 18 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _Ip, class _Sp, class _Pred, class _Proj> template <class _Ip, class _Sp, class _Pred, class _Proj>
_LIBCPP_HIDE_FROM_ABI static constexpr _LIBCPP_HIDE_FROM_ABI static constexpr
_Ip __find_if_impl(_Ip __first, _Sp __last, _Pred& __pred, _Proj& __proj) { _Ip __find_if_impl(_Ip __first, _Sp __last, _Pred& __pred, _Proj& __proj) {
Show All 25 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto find_if = __find_if::__fn{}; inline constexpr auto find_if = __find_if::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_FIND_IF_H #endif // _LIBCPP___ALGORITHM_RANGES_FIND_IF_H

libcxx/include/__algorithm/ranges_find_if_not.h

Show All 20 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __find_if_not { namespace __find_if_not {
struct __fn { struct __fn {
template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity, template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
indirect_unary_predicate<projected<_Ip, _Proj>> _Pred> indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
Show All 15 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto find_if_not = __find_if_not::__fn{}; inline constexpr auto find_if_not = __find_if_not::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_FIND_IF_NOT_H #endif // _LIBCPP___ALGORITHM_RANGES_FIND_IF_NOT_H

libcxx/include/__algorithm/ranges_for_each.h

Show All 18 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _Iter, class _Func> template <class _Iter, class _Func>
using for_each_result = in_fun_result<_Iter, _Func>; using for_each_result = in_fun_result<_Iter, _Func>;
Show All 32 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto for_each = __for_each::__fn{}; inline constexpr auto for_each = __for_each::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_FOR_EACH_H #endif // _LIBCPP___ALGORITHM_RANGES_FOR_EACH_H

libcxx/include/__algorithm/ranges_for_each_n.h

Show All 18 Lines
#include <__iterator/projected.h> #include <__iterator/projected.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _Iter, class _Func> template <class _Iter, class _Func>
using for_each_n_result = in_fun_result<_Iter, _Func>; using for_each_n_result = in_fun_result<_Iter, _Func>;
Show All 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto for_each_n = __for_each_n::__fn{}; inline constexpr auto for_each_n = __for_each_n::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_FOR_EACH_N_H #endif // _LIBCPP___ALGORITHM_RANGES_FOR_EACH_N_H

libcxx/include/__algorithm/ranges_generate.h

Show All 18 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __generate { namespace __generate {
struct __fn { struct __fn {
Show All 27 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto generate = __generate::__fn{}; inline constexpr auto generate = __generate::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_GENERATE_H #endif // _LIBCPP___ALGORITHM_RANGES_GENERATE_H

libcxx/include/__algorithm/ranges_generate_n.h

Show All 19 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __generate_n { namespace __generate_n {
struct __fn { struct __fn {
Show All 15 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto generate_n = __generate_n::__fn{}; inline constexpr auto generate_n = __generate_n::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_GENERATE_N_H #endif // _LIBCPP___ALGORITHM_RANGES_GENERATE_N_H

libcxx/include/__algorithm/ranges_includes.h

Show All 21 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __includes { namespace __includes {
struct __fn { struct __fn {
template < template <
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto includes = __includes::__fn{}; inline constexpr auto includes = __includes::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_INCLUDES_H #endif // _LIBCPP___ALGORITHM_RANGES_INCLUDES_H

libcxx/include/__algorithm/ranges_inplace_merge.h

Show All 25 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __inplace_merge { namespace __inplace_merge {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Comp, class _Proj> template <class _Iter, class _Sent, class _Comp, class _Proj>
Show All 32 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto inplace_merge = __inplace_merge::__fn{}; inline constexpr auto inplace_merge = __inplace_merge::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_INPLACE_MERGE_H #endif // _LIBCPP___ALGORITHM_RANGES_INPLACE_MERGE_H

libcxx/include/__algorithm/ranges_is_heap.h

Show All 20 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __is_heap { namespace __is_heap {
struct __fn { struct __fn {
Show All 26 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto is_heap = __is_heap::__fn{}; inline constexpr auto is_heap = __is_heap::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_IS_HEAP_H #endif // _LIBCPP___ALGORITHM_RANGES_IS_HEAP_H

libcxx/include/__algorithm/ranges_is_heap_until.h

Show All 21 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __is_heap_until { namespace __is_heap_until {
struct __fn { struct __fn {
Show All 26 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto is_heap_until = __is_heap_until::__fn{}; inline constexpr auto is_heap_until = __is_heap_until::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_IS_HEAP_UNTIL_H #endif // _LIBCPP___ALGORITHM_RANGES_IS_HEAP_UNTIL_H

libcxx/include/__algorithm/ranges_is_partitioned.h

Show All 17 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __is_partitioned { namespace __is_partitioned {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Proj, class _Pred> template <class _Iter, class _Sent, class _Proj, class _Pred>
Show All 36 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto is_partitioned = __is_partitioned::__fn{}; inline constexpr auto is_partitioned = __is_partitioned::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_IS_PARTITIONED_H #endif // _LIBCPP___ALGORITHM_RANGES_IS_PARTITIONED_H

libcxx/include/__algorithm/ranges_is_permutation.h

Show All 19 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __is_permutation { namespace __is_permutation {
struct __fn { struct __fn {
template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, template <class _Iter1, class _Sent1, class _Iter2, class _Sent2,
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto is_permutation = __is_permutation::__fn{}; inline constexpr auto is_permutation = __is_permutation::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_IS_PERMUTATION_H #endif // _LIBCPP___ALGORITHM_RANGES_IS_PERMUTATION_H

libcxx/include/__algorithm/ranges_is_sorted.h

Show All 17 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __is_sorted { namespace __is_sorted {
struct __fn { struct __fn {
template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, template <forward_iterator _Iter, sentinel_for<_Iter> _Sent,
class _Proj = identity, class _Proj = identity,
Show All 16 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto is_sorted = __is_sorted::__fn{}; inline constexpr auto is_sorted = __is_sorted::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP__ALGORITHM_RANGES_IS_SORTED_H #endif // _LIBCPP__ALGORITHM_RANGES_IS_SORTED_H

libcxx/include/__algorithm/ranges_is_sorted_until.h

Show All 18 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _Iter, class _Sent, class _Proj, class _Comp> template <class _Iter, class _Sent, class _Proj, class _Comp>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
_Iter __is_sorted_until_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) { _Iter __is_sorted_until_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
Show All 30 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto is_sorted_until = __is_sorted_until::__fn{}; inline constexpr auto is_sorted_until = __is_sorted_until::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP__ALGORITHM_RANGES_IS_SORTED_UNTIL_H #endif // _LIBCPP__ALGORITHM_RANGES_IS_SORTED_UNTIL_H

libcxx/include/__algorithm/ranges_iterator_concept.h

Show All 12 Lines
#include <__iterator/concepts.h> #include <__iterator/concepts.h>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__type_traits/remove_cvref.h> #include <__type_traits/remove_cvref.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _IterMaybeQualified> template <class _IterMaybeQualified>
consteval auto __get_iterator_concept() { consteval auto __get_iterator_concept() {
using _Iter = __remove_cvref_t<_IterMaybeQualified>; using _Iter = __remove_cvref_t<_IterMaybeQualified>;
Show All 11 Lines
} }
template <class _Iter> template <class _Iter>
using __iterator_concept = decltype(__get_iterator_concept<_Iter>()); using __iterator_concept = decltype(__get_iterator_concept<_Iter>());
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_ITERATOR_CONCEPT_H #endif // _LIBCPP___ALGORITHM_RANGES_ITERATOR_CONCEPT_H

libcxx/include/__algorithm/ranges_lexicographical_compare.h

Show All 17 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __lexicographical_compare { namespace __lexicographical_compare {
struct __fn { struct __fn {
template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Proj1, class _Proj2, class _Comp> template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Proj1, class _Proj2, class _Comp>
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto lexicographical_compare = __lexicographical_compare::__fn{}; inline constexpr auto lexicographical_compare = __lexicographical_compare::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_LEXICOGRAPHICAL_COMPARE_H #endif // _LIBCPP___ALGORITHM_RANGES_LEXICOGRAPHICAL_COMPARE_H

libcxx/include/__algorithm/ranges_lower_bound.h

Show All 21 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __lower_bound { namespace __lower_bound {
struct __fn { struct __fn {
template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity, template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity,
Show All 17 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto lower_bound = __lower_bound::__fn{}; inline constexpr auto lower_bound = __lower_bound::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_LOWER_BOUND_H #endif // _LIBCPP___ALGORITHM_RANGES_LOWER_BOUND_H

libcxx/include/__algorithm/ranges_make_heap.h

Show All 26 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __make_heap { namespace __make_heap {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Comp, class _Proj> template <class _Iter, class _Sent, class _Comp, class _Proj>
Show All 26 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto make_heap = __make_heap::__fn{}; inline constexpr auto make_heap = __make_heap::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_MAKE_HEAP_H #endif // _LIBCPP___ALGORITHM_RANGES_MAKE_HEAP_H

libcxx/include/__algorithm/ranges_max.h

Show All 21 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <initializer_list> #include <initializer_list>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __max { namespace __max {
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesinline namespace __cpo {
inline constexpr auto max = __max::__fn{}; inline constexpr auto max = __max::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_STD_VER > 17 && #endif // _LIBCPP_STD_VER >= 20 &&
#endif // _LIBCPP___ALGORITHM_RANGES_MAX_H #endif // _LIBCPP___ALGORITHM_RANGES_MAX_H

libcxx/include/__algorithm/ranges_max_element.h

Show All 18 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __max_element { namespace __max_element {
struct __fn { struct __fn {
template <forward_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity, template <forward_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
indirect_strict_weak_order<projected<_Ip, _Proj>> _Comp = ranges::less> indirect_strict_weak_order<projected<_Ip, _Proj>> _Comp = ranges::less>
Show All 15 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto max_element = __max_element::__fn{}; inline constexpr auto max_element = __max_element::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_MAX_ELEMENT_H #endif // _LIBCPP___ALGORITHM_RANGES_MAX_ELEMENT_H

libcxx/include/__algorithm/ranges_merge.h

Show All 21 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__type_traits/remove_cvref.h> #include <__type_traits/remove_cvref.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter1, class _InIter2, class _OutIter> template <class _InIter1, class _InIter2, class _OutIter>
using merge_result = in_in_out_result<_InIter1, _InIter2, _OutIter>; using merge_result = in_in_out_result<_InIter1, _InIter2, _OutIter>;
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto merge = __merge::__fn{}; inline constexpr auto merge = __merge::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_MERGE_H #endif // _LIBCPP___ALGORITHM_RANGES_MERGE_H

libcxx/include/__algorithm/ranges_min.h

Show All 20 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <initializer_list> #include <initializer_list>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __min { namespace __min {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesinline namespace __cpo {
inline constexpr auto min = __min::__fn{}; inline constexpr auto min = __min::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_STD_VER > 17 && #endif // _LIBCPP_STD_VER >= 20 &&
#endif // _LIBCPP___ALGORITHM_RANGES_MIN_H #endif // _LIBCPP___ALGORITHM_RANGES_MIN_H

libcxx/include/__algorithm/ranges_min_element.h

Show All 18 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
// TODO(ranges): `ranges::min_element` can now simply delegate to `std::__min_element`. // TODO(ranges): `ranges::min_element` can now simply delegate to `std::__min_element`.
template <class _Ip, class _Sp, class _Proj, class _Comp> template <class _Ip, class _Sp, class _Proj, class _Comp>
_LIBCPP_HIDE_FROM_ABI static constexpr _LIBCPP_HIDE_FROM_ABI static constexpr
Show All 28 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto min_element = __min_element::__fn{}; inline constexpr auto min_element = __min_element::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_MIN_ELEMENT_H #endif // _LIBCPP___ALGORITHM_RANGES_MIN_ELEMENT_H

libcxx/include/__algorithm/ranges_minmax.h

Show All 26 Lines
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.h>
#include <initializer_list> #include <initializer_list>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _T1> template <class _T1>
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Linesinline namespace __cpo {
inline constexpr auto minmax = __minmax::__fn{}; inline constexpr auto minmax = __minmax::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_MINMAX_H #endif // _LIBCPP___ALGORITHM_RANGES_MINMAX_H

libcxx/include/__algorithm/ranges_minmax_element.h

Show All 22 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _T1> template <class _T1>
using minmax_element_result = min_max_result<_T1>; using minmax_element_result = min_max_result<_T1>;
Show All 21 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto minmax_element = __minmax_element::__fn{}; inline constexpr auto minmax_element = __minmax_element::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_MINMAX_H #endif // _LIBCPP___ALGORITHM_RANGES_MINMAX_H

libcxx/include/__algorithm/ranges_mismatch.h

Show All 21 Lines
#include <__utility/move.h> #include <__utility/move.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template <class _I1, class _I2> template <class _I1, class _I2>
using mismatch_result = in_in_result<_I1, _I2>; using mismatch_result = in_in_result<_I1, _I2>;
namespace __mismatch { namespace __mismatch {
struct __fn { struct __fn {
Show All 34 Lines
}; };
} // namespace __mismatch } // namespace __mismatch
inline namespace __cpo { inline namespace __cpo {
constexpr inline auto mismatch = __mismatch::__fn{}; constexpr inline auto mismatch = __mismatch::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_RANGES_MISMATCH_H #endif // _LIBCPP___ALGORITHM_RANGES_MISMATCH_H

libcxx/include/__algorithm/ranges_move.h

Show All 17 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using move_result = in_out_result<_InIter, _OutIter>; using move_result = in_out_result<_InIter, _OutIter>;
Show All 26 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto move = __move::__fn{}; inline constexpr auto move = __move::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_MOVE_H #endif // _LIBCPP___ALGORITHM_RANGES_MOVE_H

libcxx/include/__algorithm/ranges_move_backward.h

Show All 19 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using move_backward_result = in_out_result<_InIter, _OutIter>; using move_backward_result = in_out_result<_InIter, _OutIter>;
Show All 26 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto move_backward = __move_backward::__fn{}; inline constexpr auto move_backward = __move_backward::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_MOVE_BACKWARD_H #endif // _LIBCPP___ALGORITHM_RANGES_MOVE_BACKWARD_H

libcxx/include/__algorithm/ranges_next_permutation.h

Show All 22 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter> template <class _InIter>
using next_permutation_result = in_found_result<_InIter>; using next_permutation_result = in_found_result<_InIter>;
Show All 23 Lines
inline namespace __cpo { inline namespace __cpo {
constexpr inline auto next_permutation = __next_permutation::__fn{}; constexpr inline auto next_permutation = __next_permutation::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_NEXT_PERMUTATION_H #endif // _LIBCPP___ALGORITHM_RANGES_NEXT_PERMUTATION_H

libcxx/include/__algorithm/ranges_none_of.h

Show All 16 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __none_of { namespace __none_of {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Proj, class _Pred> template <class _Iter, class _Sent, class _Proj, class _Pred>
Show All 24 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto none_of = __none_of::__fn{}; inline constexpr auto none_of = __none_of::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_NONE_OF_H #endif // _LIBCPP___ALGORITHM_RANGES_NONE_OF_H

libcxx/include/__algorithm/ranges_nth_element.h

Show All 25 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __nth_element { namespace __nth_element {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Comp, class _Proj> template <class _Iter, class _Sent, class _Comp, class _Proj>
Show All 27 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto nth_element = __nth_element::__fn{}; inline constexpr auto nth_element = __nth_element::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_NTH_ELEMENT_H #endif // _LIBCPP___ALGORITHM_RANGES_NTH_ELEMENT_H

libcxx/include/__algorithm/ranges_partial_sort.h

Show All 27 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __partial_sort { namespace __partial_sort {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Comp, class _Proj> template <class _Iter, class _Sent, class _Comp, class _Proj>
Show All 23 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto partial_sort = __partial_sort::__fn{}; inline constexpr auto partial_sort = __partial_sort::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_PARTIAL_SORT_H #endif // _LIBCPP___ALGORITHM_RANGES_PARTIAL_SORT_H

libcxx/include/__algorithm/ranges_partial_sort_copy.h

Show All 24 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using partial_sort_copy_result = in_out_result<_InIter, _OutIter>; using partial_sort_copy_result = in_out_result<_InIter, _OutIter>;
Show All 40 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto partial_sort_copy = __partial_sort_copy::__fn{}; inline constexpr auto partial_sort_copy = __partial_sort_copy::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_PARTIAL_SORT_COPY_H #endif // _LIBCPP___ALGORITHM_RANGES_PARTIAL_SORT_COPY_H

libcxx/include/__algorithm/ranges_partition.h

Show All 26 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __partition { namespace __partition {
struct __fn { struct __fn {
Show All 28 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto partition = __partition::__fn{}; inline constexpr auto partition = __partition::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_PARTITION_H #endif // _LIBCPP___ALGORITHM_RANGES_PARTITION_H

libcxx/include/__algorithm/ranges_partition_copy.h

Show All 19 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter1, class _OutIter2> template <class _InIter, class _OutIter1, class _OutIter2>
using partition_copy_result = in_out_out_result<_InIter, _OutIter1, _OutIter2>; using partition_copy_result = in_out_out_result<_InIter, _OutIter1, _OutIter2>;
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto partition_copy = __partition_copy::__fn{}; inline constexpr auto partition_copy = __partition_copy::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_PARTITION_COPY_H #endif // _LIBCPP___ALGORITHM_RANGES_PARTITION_COPY_H

libcxx/include/__algorithm/ranges_partition_point.h

Show All 21 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __partition_point { namespace __partition_point {
struct __fn { struct __fn {
Show All 39 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto partition_point = __partition_point::__fn{}; inline constexpr auto partition_point = __partition_point::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_PARTITION_POINT_H #endif // _LIBCPP___ALGORITHM_RANGES_PARTITION_POINT_H

libcxx/include/__algorithm/ranges_pop_heap.h

Show All 26 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __pop_heap { namespace __pop_heap {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Comp, class _Proj> template <class _Iter, class _Sent, class _Comp, class _Proj>
Show All 27 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto pop_heap = __pop_heap::__fn{}; inline constexpr auto pop_heap = __pop_heap::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_POP_HEAP_H #endif // _LIBCPP___ALGORITHM_RANGES_POP_HEAP_H

libcxx/include/__algorithm/ranges_prev_permutation.h

Show All 22 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter> template <class _InIter>
using prev_permutation_result = in_found_result<_InIter>; using prev_permutation_result = in_found_result<_InIter>;
Show All 27 Lines
inline namespace __cpo { inline namespace __cpo {
constexpr inline auto prev_permutation = __prev_permutation::__fn{}; constexpr inline auto prev_permutation = __prev_permutation::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_PREV_PERMUTATION_H #endif // _LIBCPP___ALGORITHM_RANGES_PREV_PERMUTATION_H

libcxx/include/__algorithm/ranges_push_heap.h

Show All 26 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __push_heap { namespace __push_heap {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Comp, class _Proj> template <class _Iter, class _Sent, class _Comp, class _Proj>
Show All 26 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto push_heap = __push_heap::__fn{}; inline constexpr auto push_heap = __push_heap::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_PUSH_HEAP_H #endif // _LIBCPP___ALGORITHM_RANGES_PUSH_HEAP_H

libcxx/include/__algorithm/ranges_remove.h

Show All 19 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/subrange.h> #include <__ranges/subrange.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __remove { namespace __remove {
struct __fn { struct __fn {
template <permutable _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity> template <permutable _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity>
Show All 17 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto remove = __remove::__fn{}; inline constexpr auto remove = __remove::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_H #endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_H

libcxx/include/__algorithm/ranges_remove_copy.h

Show All 20 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using remove_copy_result = in_out_result<_InIter, _OutIter>; using remove_copy_result = in_out_result<_InIter, _OutIter>;
Show All 28 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto remove_copy = __remove_copy::__fn{}; inline constexpr auto remove_copy = __remove_copy::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_COPY_H #endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_COPY_H

libcxx/include/__algorithm/ranges_remove_copy_if.h

Show All 23 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using remove_copy_if_result = in_out_result<_InIter, _OutIter>; using remove_copy_if_result = in_out_result<_InIter, _OutIter>;
Show All 39 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto remove_copy_if = __remove_copy_if::__fn{}; inline constexpr auto remove_copy_if = __remove_copy_if::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_COPY_IF_H #endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_COPY_IF_H

libcxx/include/__algorithm/ranges_remove_if.h

Show All 21 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/subrange.h> #include <__ranges/subrange.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _Iter, class _Sent, class _Proj, class _Pred> template <class _Iter, class _Sent, class _Proj, class _Pred>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
subrange<_Iter> __remove_if_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) { subrange<_Iter> __remove_if_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
Show All 36 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto remove_if = __remove_if::__fn{}; inline constexpr auto remove_if = __remove_if::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_IF_H #endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_IF_H

libcxx/include/__algorithm/ranges_replace.h

Show All 18 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __replace { namespace __replace {
struct __fn { struct __fn {
template <input_iterator _Iter, sentinel_for<_Iter> _Sent, template <input_iterator _Iter, sentinel_for<_Iter> _Sent,
Show All 28 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto replace = __replace::__fn{}; inline constexpr auto replace = __replace::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_H #endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_H

libcxx/include/__algorithm/ranges_replace_copy.h

Show All 20 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using replace_copy_result = in_out_result<_InIter, _OutIter>; using replace_copy_result = in_out_result<_InIter, _OutIter>;
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto replace_copy = __replace_copy::__fn{}; inline constexpr auto replace_copy = __replace_copy::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_COPY_H #endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_COPY_H

libcxx/include/__algorithm/ranges_replace_copy_if.h

Show All 18 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using replace_copy_if_result = in_out_result<_InIter, _OutIter>; using replace_copy_if_result = in_out_result<_InIter, _OutIter>;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto replace_copy_if = __replace_copy_if::__fn{}; inline constexpr auto replace_copy_if = __replace_copy_if::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_COPY_IF_H #endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_COPY_IF_H

libcxx/include/__algorithm/ranges_replace_if.h

Show All 17 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _Iter, class _Sent, class _Type, class _Proj, class _Pred> template <class _Iter, class _Sent, class _Type, class _Proj, class _Pred>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
_Iter __replace_if_impl(_Iter __first, _Sent __last, _Pred& __pred, const _Type& __new_value, _Proj& __proj) { _Iter __replace_if_impl(_Iter __first, _Sent __last, _Pred& __pred, const _Type& __new_value, _Proj& __proj) {
Show All 32 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto replace_if = __replace_if::__fn{}; inline constexpr auto replace_if = __replace_if::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_IF_H #endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_IF_H

libcxx/include/__algorithm/ranges_reverse.h

Show All 16 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __reverse { namespace __reverse {
struct __fn { struct __fn {
template <bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent> template <bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent>
Show All 39 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto reverse = __reverse::__fn{}; inline constexpr auto reverse = __reverse::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_REVERSE_H #endif // _LIBCPP___ALGORITHM_RANGES_REVERSE_H

libcxx/include/__algorithm/ranges_reverse_copy.h

Show All 19 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__ranges/subrange.h> #include <__ranges/subrange.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using reverse_copy_result = in_out_result<_InIter, _OutIter>; using reverse_copy_result = in_out_result<_InIter, _OutIter>;
Show All 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto reverse_copy = __reverse_copy::__fn{}; inline constexpr auto reverse_copy = __reverse_copy::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_REVERSE_COPY_H #endif // _LIBCPP___ALGORITHM_RANGES_REVERSE_COPY_H

libcxx/include/__algorithm/ranges_rotate.h

Show All 19 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/subrange.h> #include <__ranges/subrange.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __rotate { namespace __rotate {
struct __fn { struct __fn {
Show All 24 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto rotate = __rotate::__fn{}; inline constexpr auto rotate = __rotate::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_ROTATE_H #endif // _LIBCPP___ALGORITHM_RANGES_ROTATE_H

libcxx/include/__algorithm/ranges_rotate_copy.h

Show All 17 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using rotate_copy_result = in_out_result<_InIter, _OutIter>; using rotate_copy_result = in_out_result<_InIter, _OutIter>;
Show All 23 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto rotate_copy = __rotate_copy::__fn{}; inline constexpr auto rotate_copy = __rotate_copy::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_ROTATE_COPY_H #endif // _LIBCPP___ALGORITHM_RANGES_ROTATE_COPY_H

libcxx/include/__algorithm/ranges_sample.h

Show All 21 Lines
#include <__type_traits/remove_reference.h> #include <__type_traits/remove_reference.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __sample { namespace __sample {
struct __fn { struct __fn {
Show All 25 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto sample = __sample::__fn{}; inline constexpr auto sample = __sample::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_SAMPLE_H #endif // _LIBCPP___ALGORITHM_RANGES_SAMPLE_H

libcxx/include/__algorithm/ranges_search.h

Show All 22 Lines
#include <__ranges/size.h> #include <__ranges/size.h>
#include <__ranges/subrange.h> #include <__ranges/subrange.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __search { namespace __search {
struct __fn { struct __fn {
template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2> template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
_LIBCPP_HIDE_FROM_ABI static constexpr subrange<_Iter1> __ranges_search_impl( _LIBCPP_HIDE_FROM_ABI static constexpr subrange<_Iter1> __ranges_search_impl(
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto search = __search::__fn{}; inline constexpr auto search = __search::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_SEARCH_H #endif // _LIBCPP___ALGORITHM_RANGES_SEARCH_H

libcxx/include/__algorithm/ranges_search_n.h

Show All 25 Lines
#include <__ranges/subrange.h> #include <__ranges/subrange.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __search_n { namespace __search_n {
struct __fn { struct __fn {
template <class _Iter1, class _Sent1, class _SizeT, class _Type, class _Pred, class _Proj> template <class _Iter1, class _Sent1, class _SizeT, class _Type, class _Pred, class _Proj>
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto search_n = __search_n::__fn{}; inline constexpr auto search_n = __search_n::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_SEARCH_N_H #endif // _LIBCPP___ALGORITHM_RANGES_SEARCH_N_H

libcxx/include/__algorithm/ranges_set_difference.h

Show All 24 Lines
#include <__type_traits/decay.h> #include <__type_traits/decay.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using set_difference_result = in_out_result<_InIter, _OutIter>; using set_difference_result = in_out_result<_InIter, _OutIter>;
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto set_difference = __set_difference::__fn{}; inline constexpr auto set_difference = __set_difference::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_SET_DIFFERENCE_H #endif // _LIBCPP___ALGORITHM_RANGES_SET_DIFFERENCE_H

libcxx/include/__algorithm/ranges_set_intersection.h

Show All 22 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter1, class _InIter2, class _OutIter> template <class _InIter1, class _InIter2, class _OutIter>
using set_intersection_result = in_in_out_result<_InIter1, _InIter2, _OutIter>; using set_intersection_result = in_in_out_result<_InIter1, _InIter2, _OutIter>;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto set_intersection = __set_intersection::__fn{}; inline constexpr auto set_intersection = __set_intersection::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_SET_INTERSECTION_H #endif // _LIBCPP___ALGORITHM_RANGES_SET_INTERSECTION_H

libcxx/include/__algorithm/ranges_set_symmetric_difference.h

Show All 22 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter1, class _InIter2, class _OutIter> template <class _InIter1, class _InIter2, class _OutIter>
using set_symmetric_difference_result = in_in_out_result<_InIter1, _InIter2, _OutIter>; using set_symmetric_difference_result = in_in_out_result<_InIter1, _InIter2, _OutIter>;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto set_symmetric_difference = __set_symmetric_difference::__fn{}; inline constexpr auto set_symmetric_difference = __set_symmetric_difference::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_SET_SYMMETRIC_DIFFERENCE_H #endif // _LIBCPP___ALGORITHM_RANGES_SET_SYMMETRIC_DIFFERENCE_H

libcxx/include/__algorithm/ranges_set_union.h

Show All 25 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter1, class _InIter2, class _OutIter> template <class _InIter1, class _InIter2, class _OutIter>
using set_union_result = in_in_out_result<_InIter1, _InIter2, _OutIter>; using set_union_result = in_in_out_result<_InIter1, _InIter2, _OutIter>;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto set_union = __set_union::__fn{}; inline constexpr auto set_union = __set_union::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_SET_UNION_H #endif // _LIBCPP___ALGORITHM_RANGES_SET_UNION_H

libcxx/include/__algorithm/ranges_shuffle.h

Show All 25 Lines
#include <__type_traits/remove_reference.h> #include <__type_traits/remove_reference.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __shuffle { namespace __shuffle {
struct __fn { struct __fn {
Show All 18 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto shuffle = __shuffle::__fn{}; inline constexpr auto shuffle = __shuffle::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_SHUFFLE_H #endif // _LIBCPP___ALGORITHM_RANGES_SHUFFLE_H

libcxx/include/__algorithm/ranges_sort.h

Show All 25 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __sort { namespace __sort {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Comp, class _Proj> template <class _Iter, class _Sent, class _Comp, class _Proj>
Show All 26 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto sort = __sort::__fn{}; inline constexpr auto sort = __sort::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_SORT_H #endif // _LIBCPP___ALGORITHM_RANGES_SORT_H

libcxx/include/__algorithm/ranges_sort_heap.h

Show All 26 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __sort_heap { namespace __sort_heap {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Comp, class _Proj> template <class _Iter, class _Sent, class _Comp, class _Proj>
Show All 26 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto sort_heap = __sort_heap::__fn{}; inline constexpr auto sort_heap = __sort_heap::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_SORT_HEAP_H #endif // _LIBCPP___ALGORITHM_RANGES_SORT_HEAP_H

libcxx/include/__algorithm/ranges_stable_partition.h

Show All 28 Lines
#include <__type_traits/remove_cvref.h> #include <__type_traits/remove_cvref.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __stable_partition { namespace __stable_partition {
struct __fn { struct __fn {
Show All 32 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto stable_partition = __stable_partition::__fn{}; inline constexpr auto stable_partition = __stable_partition::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_STABLE_PARTITION_H #endif // _LIBCPP___ALGORITHM_RANGES_STABLE_PARTITION_H

libcxx/include/__algorithm/ranges_stable_sort.h

Show All 25 Lines
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __stable_sort { namespace __stable_sort {
struct __fn { struct __fn {
template <class _Iter, class _Sent, class _Comp, class _Proj> template <class _Iter, class _Sent, class _Comp, class _Proj>
Show All 26 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto stable_sort = __stable_sort::__fn{}; inline constexpr auto stable_sort = __stable_sort::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_STABLE_SORT_H #endif // _LIBCPP___ALGORITHM_RANGES_STABLE_SORT_H

libcxx/include/__algorithm/ranges_swap_ranges.h

Show All 18 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _I1, class _I2> template <class _I1, class _I2>
using swap_ranges_result = in_in_result<_I1, _I2>; using swap_ranges_result = in_in_result<_I1, _I2>;
Show All 22 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto swap_ranges = __swap_ranges::__fn{}; inline constexpr auto swap_ranges = __swap_ranges::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_SWAP_RANGES_H #endif // _LIBCPP___ALGORITHM_RANGES_SWAP_RANGES_H

libcxx/include/__algorithm/ranges_transform.h

Show All 20 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.h>
#include <__utility/move.h> #include <__utility/move.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _Ip, class _Op> template <class _Ip, class _Op>
using unary_transform_result = in_out_result<_Ip, _Op>; using unary_transform_result = in_out_result<_Ip, _Op>;
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto transform = __transform::__fn{}; inline constexpr auto transform = __transform::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_TRANSFORM_H #endif // _LIBCPP___ALGORITHM_RANGES_TRANSFORM_H

libcxx/include/__algorithm/ranges_unique.h

Show All 26 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __unique { namespace __unique {
struct __fn { struct __fn {
template < template <
Show All 25 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto unique = __unique::__fn{}; inline constexpr auto unique = __unique::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_UNIQUE_H #endif // _LIBCPP___ALGORITHM_RANGES_UNIQUE_H

libcxx/include/__algorithm/ranges_unique_copy.h

Show All 27 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#include <__utility/move.h> #include <__utility/move.h>
#include <__utility/pair.h> #include <__utility/pair.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
template <class _InIter, class _OutIter> template <class _InIter, class _OutIter>
using unique_copy_result = in_out_result<_InIter, _OutIter>; using unique_copy_result = in_out_result<_InIter, _OutIter>;
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto unique_copy = __unique_copy::__fn{}; inline constexpr auto unique_copy = __unique_copy::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_UNIQUE_COPY_H #endif // _LIBCPP___ALGORITHM_RANGES_UNIQUE_COPY_H

libcxx/include/__algorithm/ranges_upper_bound.h

Show All 19 Lines
#include <__ranges/access.h> #include <__ranges/access.h>
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/dangling.h> #include <__ranges/dangling.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges { namespace ranges {
namespace __upper_bound { namespace __upper_bound {
struct __fn { struct __fn {
template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity, template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity,
indirect_strict_weak_order<const _Type*, projected<_Iter, _Proj>> _Comp = ranges::less> indirect_strict_weak_order<const _Type*, projected<_Iter, _Proj>> _Comp = ranges::less>
Show All 28 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto upper_bound = __upper_bound::__fn{}; inline constexpr auto upper_bound = __upper_bound::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_UPPER_BOUND_H #endif // _LIBCPP___ALGORITHM_RANGES_UPPER_BOUND_H

libcxx/include/__algorithm/sample.h

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines_SampleIterator __sample(_PopulationIterator __first,
using _Difference = typename _IterOps<_AlgPolicy>::template __difference_type<_PopulationIterator>; using _Difference = typename _IterOps<_AlgPolicy>::template __difference_type<_PopulationIterator>;
using _CommonType = typename common_type<_Distance, _Difference>::type; using _CommonType = typename common_type<_Distance, _Difference>::type;
return std::__sample<_AlgPolicy>( return std::__sample<_AlgPolicy>(
std::move(__first), std::move(__last), std::move(__output_iter), _CommonType(__n), std::move(__first), std::move(__last), std::move(__output_iter), _CommonType(__n),
__g, _PopIterCategory()); __g, _PopIterCategory());
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _PopulationIterator, class _SampleIterator, class _Distance, template <class _PopulationIterator, class _SampleIterator, class _Distance,
class _UniformRandomNumberGenerator> class _UniformRandomNumberGenerator>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_SampleIterator sample(_PopulationIterator __first, _SampleIterator sample(_PopulationIterator __first,
_PopulationIterator __last, _SampleIterator __output_iter, _PopulationIterator __last, _SampleIterator __output_iter,
_Distance __n, _UniformRandomNumberGenerator&& __g) { _Distance __n, _UniformRandomNumberGenerator&& __g) {
static_assert(__is_cpp17_forward_iterator<_PopulationIterator>::value || static_assert(__is_cpp17_forward_iterator<_PopulationIterator>::value ||
__is_cpp17_random_access_iterator<_SampleIterator>::value, __is_cpp17_random_access_iterator<_SampleIterator>::value,
"SampleIterator must meet the requirements of RandomAccessIterator"); "SampleIterator must meet the requirements of RandomAccessIterator");
return std::__sample<_ClassicAlgPolicy>( return std::__sample<_ClassicAlgPolicy>(
std::move(__first), std::move(__last), std::move(__output_iter), __n, __g); std::move(__first), std::move(__last), std::move(__output_iter), __n, __g);
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___ALGORITHM_SAMPLE_H #endif // _LIBCPP___ALGORITHM_SAMPLE_H

libcxx/include/__algorithm/search.h

Show First 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
template <class _ForwardIterator1, class _ForwardIterator2> template <class _ForwardIterator1, class _ForwardIterator2>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2) { _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
return std::search(__first1, __last1, __first2, __last2, __equal_to()); return std::search(__first1, __last1, __first2, __last2, __equal_to());
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _ForwardIterator, class _Searcher> template <class _ForwardIterator, class _Searcher>
_LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher& __s) { search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher& __s) {
return __s(__f, __l).first; return __s(__f, __l).first;
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_SEARCH_H #endif // _LIBCPP___ALGORITHM_SEARCH_H

libcxx/include/__algorithm/shift_left.h

Show All 13 Lines
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.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 #if _LIBCPP_STD_VER >= 20
template <class _ForwardIterator> template <class _ForwardIterator>
inline _LIBCPP_INLINE_VISIBILITY constexpr inline _LIBCPP_INLINE_VISIBILITY constexpr
_ForwardIterator _ForwardIterator
shift_left(_ForwardIterator __first, _ForwardIterator __last, shift_left(_ForwardIterator __first, _ForwardIterator __last,
typename iterator_traits<_ForwardIterator>::difference_type __n) typename iterator_traits<_ForwardIterator>::difference_type __n)
{ {
if (__n == 0) { if (__n == 0) {
Show All 12 Lines if constexpr (__is_cpp17_random_access_iterator<_ForwardIterator>::value) {
return __first; return __first;
} }
++__m; ++__m;
} }
} }
return _VSTD::move(__m, __last, __first); return _VSTD::move(__m, __last, __first);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_SHIFT_LEFT_H #endif // _LIBCPP___ALGORITHM_SHIFT_LEFT_H

libcxx/include/__algorithm/shift_right.h

Show All 16 Lines
#include <__utility/swap.h> #include <__utility/swap.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 #if _LIBCPP_STD_VER >= 20
template <class _ForwardIterator> template <class _ForwardIterator>
inline _LIBCPP_INLINE_VISIBILITY constexpr inline _LIBCPP_INLINE_VISIBILITY constexpr
_ForwardIterator _ForwardIterator
shift_right(_ForwardIterator __first, _ForwardIterator __last, shift_right(_ForwardIterator __first, _ForwardIterator __last,
typename iterator_traits<_ForwardIterator>::difference_type __n) typename iterator_traits<_ForwardIterator>::difference_type __n)
{ {
if (__n == 0) { if (__n == 0) {
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines if constexpr (__is_cpp17_random_access_iterator<_ForwardIterator>::value) {
++__lead; ++__lead;
if (__mid == __ret) { if (__mid == __ret) {
__mid = __first; __mid = __first;
} }
} }
} }
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_SHIFT_RIGHT_H #endif // _LIBCPP___ALGORITHM_SHIFT_RIGHT_H

libcxx/include/__algorithm/sort.h

Show First 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
struct __is_simple_comparator : false_type {}; struct __is_simple_comparator : false_type {};
template <class _Tp> template <class _Tp>
struct __is_simple_comparator<__less<_Tp>&> : true_type {}; struct __is_simple_comparator<__less<_Tp>&> : true_type {};
template <class _Tp> template <class _Tp>
struct __is_simple_comparator<less<_Tp>&> : true_type {}; struct __is_simple_comparator<less<_Tp>&> : true_type {};
template <class _Tp> template <class _Tp>
struct __is_simple_comparator<greater<_Tp>&> : true_type {}; struct __is_simple_comparator<greater<_Tp>&> : true_type {};
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <> template <>
struct __is_simple_comparator<ranges::less&> : true_type {}; struct __is_simple_comparator<ranges::less&> : true_type {};
template <> template <>
struct __is_simple_comparator<ranges::greater&> : true_type {}; struct __is_simple_comparator<ranges::greater&> : true_type {};
#endif #endif
template <class _Compare, class _Iter, class _Tp = typename iterator_traits<_Iter>::value_type> template <class _Compare, class _Iter, class _Tp = typename iterator_traits<_Iter>::value_type>
using __use_branchless_sort = using __use_branchless_sort =
▲ Show 20 Lines • Show All 805 Lines • Show Last 20 Lines

libcxx/include/__algorithm/three_way_comp_ref_type.h

Show All 14 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 #if _LIBCPP_STD_VER >= 20
template <class _Comp> template <class _Comp>
struct __debug_three_way_comp { struct __debug_three_way_comp {
_Comp& __comp_; _Comp& __comp_;
_LIBCPP_HIDE_FROM_ABI constexpr __debug_three_way_comp(_Comp& __c) : __comp_(__c) {} _LIBCPP_HIDE_FROM_ABI constexpr __debug_three_way_comp(_Comp& __c) : __comp_(__c) {}
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __x, _Up& __y) { _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __x, _Up& __y) {
Show All 26 Lines
# ifndef _LIBCPP_ENABLE_DEBUG_MODE # ifndef _LIBCPP_ENABLE_DEBUG_MODE
template <class _Comp> template <class _Comp>
using __three_way_comp_ref_type = __debug_three_way_comp<_Comp>; using __three_way_comp_ref_type = __debug_three_way_comp<_Comp>;
# else # else
template <class _Comp> template <class _Comp>
using __three_way_comp_ref_type = _Comp&; using __three_way_comp_ref_type = _Comp&;
# endif # endif
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_THREE_WAY_COMP_REF_TYPE_H #endif // _LIBCPP___ALGORITHM_THREE_WAY_COMP_REF_TYPE_H

libcxx/include/__algorithm/uniform_random_bit_generator_adaptor.h

Show All 11 Lines
#include <__config> #include <__config>
#include <__functional/invoke.h> #include <__functional/invoke.h>
#include <__type_traits/remove_cvref.h> #include <__type_traits/remove_cvref.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// Range versions of random algorithms (e.g. `std::shuffle`) are less constrained than their classic counterparts. // Range versions of random algorithms (e.g. `std::shuffle`) are less constrained than their classic counterparts.
// Range algorithms only require the given generator to satisfy the `std::uniform_random_bit_generator` concept. // Range algorithms only require the given generator to satisfy the `std::uniform_random_bit_generator` concept.
Show All 23 Linespublic:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()() const { return __gen_(); } constexpr auto operator()() const { return __gen_(); }
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___ALGORITHM_RANGES_UNIFORM_RANDOM_BIT_GENERATOR_ADAPTOR_H #endif // _LIBCPP___ALGORITHM_RANGES_UNIFORM_RANDOM_BIT_GENERATOR_ADAPTOR_H

libcxx/include/__algorithm/unwrap_range.h

Show All 22 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// __unwrap_range and __rewrap_range are used to unwrap ranges which may have different iterator and sentinel types. // __unwrap_range and __rewrap_range are used to unwrap ranges which may have different iterator and sentinel types.
// __unwrap_iter and __rewrap_iter don't work for this, because they assume that the iterator and sentinel have // __unwrap_iter and __rewrap_iter don't work for this, because they assume that the iterator and sentinel have
// the same type. __unwrap_range tries to get two iterators and then forward to __unwrap_iter. // the same type. __unwrap_range tries to get two iterators and then forward to __unwrap_iter.
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Iter, class _Sent> template <class _Iter, class _Sent>
struct __unwrap_range_impl { struct __unwrap_range_impl {
_LIBCPP_HIDE_FROM_ABI static constexpr auto __unwrap(_Iter __first, _Sent __sent) _LIBCPP_HIDE_FROM_ABI static constexpr auto __unwrap(_Iter __first, _Sent __sent)
requires random_access_iterator<_Iter> && sized_sentinel_for<_Sent, _Iter> requires random_access_iterator<_Iter> && sized_sentinel_for<_Sent, _Iter>
{ {
auto __last = ranges::next(__first, __sent); auto __last = ranges::next(__first, __sent);
return pair{std::__unwrap_iter(std::move(__first)), std::__unwrap_iter(std::move(__last))}; return pair{std::__unwrap_iter(std::move(__first)), std::__unwrap_iter(std::move(__last))};
} }
Show All 35 Lines
template < template <
class _Sent, class _Sent,
class _Iter, class _Iter,
class _Unwrapped = decltype(std::__unwrap_range(std::declval<_Iter>(), std::declval<_Sent>()))> class _Unwrapped = decltype(std::__unwrap_range(std::declval<_Iter>(), std::declval<_Sent>()))>
_LIBCPP_HIDE_FROM_ABI constexpr _Iter __rewrap_range(_Iter __orig_iter, _Unwrapped __iter) { _LIBCPP_HIDE_FROM_ABI constexpr _Iter __rewrap_range(_Iter __orig_iter, _Unwrapped __iter) {
return __unwrap_range_impl<_Iter, _Sent>::__rewrap(std::move(__orig_iter), std::move(__iter)); return __unwrap_range_impl<_Iter, _Sent>::__rewrap(std::move(__orig_iter), std::move(__iter));
} }
#else // _LIBCPP_STD_VER > 17 #else // _LIBCPP_STD_VER >= 20
template <class _Iter, class _Unwrapped = decltype(std::__unwrap_iter(std::declval<_Iter>()))> template <class _Iter, class _Unwrapped = decltype(std::__unwrap_iter(std::declval<_Iter>()))>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR pair<_Unwrapped, _Unwrapped> __unwrap_range(_Iter __first, _Iter __last) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR pair<_Unwrapped, _Unwrapped> __unwrap_range(_Iter __first, _Iter __last) {
return std::make_pair(std::__unwrap_iter(std::move(__first)), std::__unwrap_iter(std::move(__last))); return std::make_pair(std::__unwrap_iter(std::move(__first)), std::__unwrap_iter(std::move(__last)));
} }
template <class _Iter, class _Unwrapped = decltype(std::__unwrap_iter(std::declval<_Iter>()))> template <class _Iter, class _Unwrapped = decltype(std::__unwrap_iter(std::declval<_Iter>()))>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Iter __rewrap_range(_Iter __orig_iter, _Unwrapped __iter) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Iter __rewrap_range(_Iter __orig_iter, _Unwrapped __iter) {
return std::__rewrap_iter(std::move(__orig_iter), std::move(__iter)); return std::__rewrap_iter(std::move(__orig_iter), std::move(__iter));
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_UNWRAP_RANGE_H #endif // _LIBCPP___ALGORITHM_UNWRAP_RANGE_H

libcxx/include/__bit/bit_cast.h

Show All 13 Lines
#include <__type_traits/is_trivially_copyable.h> #include <__type_traits/is_trivially_copyable.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 #if _LIBCPP_STD_VER >= 20
template <class _ToType, class _FromType> template <class _ToType, class _FromType>
requires(sizeof(_ToType) == sizeof(_FromType) && requires(sizeof(_ToType) == sizeof(_FromType) &&
is_trivially_copyable_v<_ToType> && is_trivially_copyable_v<_ToType> &&
is_trivially_copyable_v<_FromType>) is_trivially_copyable_v<_FromType>)
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr _ToType bit_cast(const _FromType& __from) noexcept { _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr _ToType bit_cast(const _FromType& __from) noexcept {
return __builtin_bit_cast(_ToType, __from); return __builtin_bit_cast(_ToType, __from);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___BIT_BIT_CAST_H #endif // _LIBCPP___BIT_BIT_CAST_H

libcxx/include/__bit/byteswap.h

Show All 15 Lines
#include <cstdlib> #include <cstdlib>
#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 > 20 #if _LIBCPP_STD_VER >= 23
template <integral _Tp> template <integral _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _Tp byteswap(_Tp __val) noexcept { _LIBCPP_HIDE_FROM_ABI constexpr _Tp byteswap(_Tp __val) noexcept {
if constexpr (sizeof(_Tp) == 1) { if constexpr (sizeof(_Tp) == 1) {
return __val; return __val;
} else if constexpr (sizeof(_Tp) == 2) { } else if constexpr (sizeof(_Tp) == 2) {
return __builtin_bswap16(__val); return __builtin_bswap16(__val);
Show All 10 Lines return static_cast<_Tp>(byteswap(static_cast<uint64_t>(__val))) << 64 |
static_cast<_Tp>(byteswap(static_cast<uint64_t>(__val >> 64))); static_cast<_Tp>(byteswap(static_cast<uint64_t>(__val >> 64)));
#endif // __has_builtin(__builtin_bswap128) #endif // __has_builtin(__builtin_bswap128)
#endif // _LIBCPP_HAS_NO_INT128 #endif // _LIBCPP_HAS_NO_INT128
} else { } else {
static_assert(sizeof(_Tp) == 0, "byteswap is unimplemented for integral types of this size"); static_assert(sizeof(_Tp) == 0, "byteswap is unimplemented for integral types of this size");
} }
} }
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___BIT_BYTESWAP_H #endif // _LIBCPP___BIT_BYTESWAP_H

libcxx/include/__bit_reference

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Linespublic:
{ {
if (__x) if (__x)
*__seg_ |= __mask_; *__seg_ |= __mask_;
else else
*__seg_ &= ~__mask_; *__seg_ &= ~__mask_;
return *this; return *this;
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr const __bit_reference& operator=(bool __x) const noexcept { _LIBCPP_HIDE_FROM_ABI constexpr const __bit_reference& operator=(bool __x) const noexcept {
if (__x) if (__x)
*__seg_ |= __mask_; *__seg_ |= __mask_;
else else
*__seg_ &= ~__mask_; *__seg_ &= ~__mask_;
return *this; return *this;
} }
#endif #endif
▲ Show 20 Lines • Show All 1,043 Lines • ▼ Show 20 Lines typedef __conditional_t<_IsConst, typename _Cp::__const_storage_pointer, typename _Cp::__storage_pointer>
__storage_pointer; __storage_pointer;
static const unsigned __bits_per_word = _Cp::__bits_per_word; static const unsigned __bits_per_word = _Cp::__bits_per_word;
__storage_pointer __seg_; __storage_pointer __seg_;
unsigned __ctz_; unsigned __ctz_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator() _NOEXCEPT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator() _NOEXCEPT
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
: __seg_(nullptr), __ctz_(0) : __seg_(nullptr), __ctz_(0)
#endif #endif
{} {}
// When _IsConst=false, this is the copy constructor. // When _IsConst=false, this is the copy constructor.
// It is non-trivial. Making it trivial would break ABI. // It is non-trivial. Making it trivial would break ABI.
// When _IsConst=true, this is a converting constructor; // When _IsConst=true, this is a converting constructor;
// the copy and move constructors are implicitly generated // the copy and move constructors are implicitly generated
▲ Show 20 Lines • Show All 214 Lines • Show Last 20 Lines

libcxx/include/__charconv/chars_format.h

Show All 13 Lines
#include <__utility/to_underlying.h> #include <__utility/to_underlying.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 > 14 #if _LIBCPP_STD_VER >= 17
enum class _LIBCPP_ENUM_VIS chars_format enum class _LIBCPP_ENUM_VIS chars_format
{ {
scientific = 0x1, scientific = 0x1,
fixed = 0x2, fixed = 0x2,
hex = 0x4, hex = 0x4,
general = fixed | scientific general = fixed | scientific
}; };
Show All 34 Lines
} }
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 chars_format& inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 chars_format&
operator^=(chars_format& __x, chars_format __y) { operator^=(chars_format& __x, chars_format __y) {
__x = __x ^ __y; __x = __x ^ __y;
return __x; return __x;
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CHARCONV_CHARS_FORMAT_H #endif // _LIBCPP___CHARCONV_CHARS_FORMAT_H

libcxx/include/__charconv/from_chars_result.h

Show All 13 Lines
#include <__errc> #include <__errc>
#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 > 14 #if _LIBCPP_STD_VER >= 17
struct _LIBCPP_TYPE_VIS from_chars_result struct _LIBCPP_TYPE_VIS from_chars_result
{ {
const char* ptr; const char* ptr;
errc ec; errc ec;
# if _LIBCPP_STD_VER > 17 # if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI friend bool operator==(const from_chars_result&, const from_chars_result&) = default; _LIBCPP_HIDE_FROM_ABI friend bool operator==(const from_chars_result&, const from_chars_result&) = default;
# endif # endif
}; };
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CHARCONV_FROM_CHARS_RESULT_H #endif // _LIBCPP___CHARCONV_FROM_CHARS_RESULT_H

libcxx/include/__charconv/tables.h

Show All 13 Lines
#include <cstdint> #include <cstdint>
#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 > 14 #if _LIBCPP_STD_VER >= 17
namespace __itoa { namespace __itoa {
inline constexpr char __base_2_lut[64] = { inline constexpr char __base_2_lut[64] = {
'0', '0', '0', '0', '0', '0', '0', '1', '0', '0', '1', '0', '0', '0', '1', '1', '0', '1', '0', '0', '0', '1', '0', '0', '0', '0', '0', '0', '0', '1', '0', '0', '1', '0', '0', '0', '1', '1', '0', '1', '0', '0', '0', '1',
'0', '1', '0', '1', '1', '0', '0', '1', '1', '1', '1', '0', '0', '0', '1', '0', '0', '1', '1', '0', '1', '0', '0', '1', '0', '1', '1', '0', '0', '1', '1', '1', '1', '0', '0', '0', '1', '0', '0', '1', '1', '0', '1', '0',
'1', '0', '1', '1', '1', '1', '0', '0', '1', '1', '0', '1', '1', '1', '1', '0', '1', '1', '1', '1'}; '1', '0', '1', '1', '1', '1', '0', '0', '1', '1', '0', '1', '1', '1', '1', '0', '1', '1', '1', '1'};
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Linesinline constexpr char __digits_base_10[200] = {
'6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6', '7', '6', '8', '6', '9', '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6', '7', '6', '8', '6', '9',
'7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7', '6', '7', '7', '7', '8', '7', '9', '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7', '6', '7', '7', '7', '8', '7', '9',
'8', '0', '8', '1', '8', '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', '8', '0', '8', '1', '8', '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9',
'9', '0', '9', '1', '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'}; '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'};
// clang-format on // clang-format on
} // namespace __itoa } // namespace __itoa
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CHARCONV_TABLES #endif // _LIBCPP___CHARCONV_TABLES

libcxx/include/__charconv/to_chars_base_10.h

Show All 19 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 > 14 #if _LIBCPP_STD_VER >= 17
namespace __itoa { namespace __itoa {
_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __append1(char* __first, uint32_t __value) noexcept { _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __append1(char* __first, uint32_t __value) noexcept {
*__first = '0' + static_cast<char>(__value); *__first = '0' + static_cast<char>(__value);
return __first + 1; return __first + 1;
} }
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines_LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char* __base_10_u128(char* __buffer, __uint128_t __value) noexcept {
__buffer = __itoa::__append9(__buffer, static_cast<uint32_t>(__value / 10000000000)); __buffer = __itoa::__append9(__buffer, static_cast<uint32_t>(__value / 10000000000));
__buffer = __itoa::__append10(__buffer, static_cast<uint64_t>(__value % 10000000000)); __buffer = __itoa::__append10(__buffer, static_cast<uint64_t>(__value % 10000000000));
return __buffer; return __buffer;
} }
# endif # endif
} // namespace __itoa } // namespace __itoa
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___CHARCONV_TO_CHARS_BASE_10_H #endif // _LIBCPP___CHARCONV_TO_CHARS_BASE_10_H

libcxx/include/__charconv/to_chars_result.h

Show All 13 Lines
#include <__errc> #include <__errc>
#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 > 14 #if _LIBCPP_STD_VER >= 17
struct _LIBCPP_TYPE_VIS to_chars_result struct _LIBCPP_TYPE_VIS to_chars_result
{ {
char* ptr; char* ptr;
errc ec; errc ec;
# if _LIBCPP_STD_VER > 17 # if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI friend bool operator==(const to_chars_result&, const to_chars_result&) = default; _LIBCPP_HIDE_FROM_ABI friend bool operator==(const to_chars_result&, const to_chars_result&) = default;
# endif # endif
}; };
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CHARCONV_TO_CHARS_RESULT_H #endif // _LIBCPP___CHARCONV_TO_CHARS_RESULT_H

libcxx/include/__chrono/calendar.h

Show All 12 Lines
#include <__chrono/duration.h> #include <__chrono/duration.h>
#include <__chrono/time_point.h> #include <__chrono/time_point.h>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
struct local_t {}; struct local_t {};
template<class Duration> template<class Duration>
using local_time = time_point<local_t, Duration>; using local_time = time_point<local_t, Duration>;
using local_seconds = local_time<seconds>; using local_seconds = local_time<seconds>;
using local_days = local_time<days>; using local_days = local_time<days>;
struct last_spec { _LIBCPP_HIDE_FROM_ABI explicit last_spec() = default; }; struct last_spec { _LIBCPP_HIDE_FROM_ABI explicit last_spec() = default; };
inline constexpr last_spec last{}; inline constexpr last_spec last{};
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___CHRONO_CALENDAR_H #endif // _LIBCPP___CHRONO_CALENDAR_H

libcxx/include/__chrono/convert_to_tm.h

Show All 36 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 #if _LIBCPP_STD_VER >= 20
// Conerts a chrono date and weekday to a given _Tm type. // Conerts a chrono date and weekday to a given _Tm type.
// //
// This is an implementation detail for the function // This is an implementation detail for the function
// template <class _Tm, class _ChronoT> // template <class _Tm, class _ChronoT>
// _Tm __convert_to_tm(const _ChronoT& __value) // _Tm __convert_to_tm(const _ChronoT& __value)
// //
// This manually converts the two values to the proper type. It is possible to // This manually converts the two values to the proper type. It is possible to
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines if constexpr (sizeof(std::chrono::hours::rep) > sizeof(__result.tm_hour))
std::__throw_format_error("Formatting hh_mm_ss, encountered an hour overflow"); std::__throw_format_error("Formatting hh_mm_ss, encountered an hour overflow");
__result.tm_hour = __value.hours().count(); __result.tm_hour = __value.hours().count();
} else } else
static_assert(sizeof(_ChronoT) == 0, "Add the missing type specialization"); static_assert(sizeof(_ChronoT) == 0, "Add the missing type specialization");
return __result; return __result;
} }
#endif //if _LIBCPP_STD_VER > 17 #endif //if _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___CHRONO_CONVERT_TO_TM_H #endif // _LIBCPP___CHRONO_CONVERT_TO_TM_H

libcxx/include/__chrono/day.h

Show All 12 Lines
#include <__chrono/duration.h> #include <__chrono/duration.h>
#include <__config> #include <__config>
#include <compare> #include <compare>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
class day { class day {
private: private:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
_LIBCPP_HIDE_FROM_ABI inline constexpr _LIBCPP_HIDE_FROM_ABI inline constexpr
day& day::operator-=(const days& __dd) noexcept day& day::operator-=(const days& __dd) noexcept
{ *this = *this - __dd; return *this; } { *this = *this - __dd; return *this; }
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___CHRONO_DAY_H #endif // _LIBCPP___CHRONO_DAY_H

libcxx/include/__chrono/duration.h

Show First 20 Lines • Show All 124 Lines • ▼ Show 20 Lines
duration_cast(const duration<_Rep, _Period>& __fd) duration_cast(const duration<_Rep, _Period>& __fd)
{ {
return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd); return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
} }
template <class _Rep> template <class _Rep>
struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {}; struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Rep> template <class _Rep>
inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value; inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value;
#endif #endif
template <class _Rep> template <class _Rep>
struct _LIBCPP_TEMPLATE_VIS duration_values struct _LIBCPP_TEMPLATE_VIS duration_values
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT {return _Rep(0);} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT {return _Rep(0);}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() _NOEXCEPT {return numeric_limits<_Rep>::max();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() _NOEXCEPT {return numeric_limits<_Rep>::max();}
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() _NOEXCEPT {return numeric_limits<_Rep>::lowest();} _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() _NOEXCEPT {return numeric_limits<_Rep>::lowest();}
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _ToDuration, class _Rep, class _Period> template <class _ToDuration, class _Rep, class _Period>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
typename enable_if typename enable_if
< <
__is_duration<_ToDuration>::value, __is_duration<_ToDuration>::value,
_ToDuration _ToDuration
>::type >::type
floor(const duration<_Rep, _Period>& __d) floor(const duration<_Rep, _Period>& __d)
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Lines
}; };
typedef duration<long long, nano> nanoseconds; typedef duration<long long, nano> nanoseconds;
typedef duration<long long, micro> microseconds; typedef duration<long long, micro> microseconds;
typedef duration<long long, milli> milliseconds; typedef duration<long long, milli> milliseconds;
typedef duration<long long > seconds; typedef duration<long long > seconds;
typedef duration< long, ratio< 60> > minutes; typedef duration< long, ratio< 60> > minutes;
typedef duration< long, ratio<3600> > hours; typedef duration< long, ratio<3600> > hours;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
typedef duration< int, ratio_multiply<ratio<24>, hours::period>> days; typedef duration< int, ratio_multiply<ratio<24>, hours::period>> days;
typedef duration< int, ratio_multiply<ratio<7>, days::period>> weeks; typedef duration< int, ratio_multiply<ratio<7>, days::period>> weeks;
typedef duration< int, ratio_multiply<ratio<146097, 400>, days::period>> years; typedef duration< int, ratio_multiply<ratio<146097, 400>, days::period>> years;
typedef duration< int, ratio_divide<years::period, ratio<12>>> months; typedef duration< int, ratio_divide<years::period, ratio<12>>> months;
#endif #endif
// Duration == // Duration ==
template <class _LhsDuration, class _RhsDuration> template <class _LhsDuration, class _RhsDuration>
▲ Show 20 Lines • Show All 206 Lines • ▼ Show 20 Lines
{ {
typedef typename common_type<_Rep1, _Rep2>::type _Cr; typedef typename common_type<_Rep1, _Rep2>::type _Cr;
typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd; typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count())); return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
} }
} // namespace chrono } // namespace chrono
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
// Suffixes for duration literals [time.duration.literals] // Suffixes for duration literals [time.duration.literals]
inline namespace literals inline namespace literals
{ {
inline namespace chrono_literals inline namespace chrono_literals
{ {
_LIBCPP_HIDE_FROM_ABI constexpr chrono::hours operator""h(unsigned long long __h) _LIBCPP_HIDE_FROM_ABI constexpr chrono::hours operator""h(unsigned long long __h)
{ {
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
} // namespace chrono_literals } // namespace chrono_literals
} // namespace literals } // namespace literals
namespace chrono { // hoist the literals into namespace std::chrono namespace chrono { // hoist the literals into namespace std::chrono
using namespace literals::chrono_literals; using namespace literals::chrono_literals;
} // namespace chrono } // namespace chrono
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP___CHRONO_DURATION_H #endif // _LIBCPP___CHRONO_DURATION_H

libcxx/include/__chrono/file_clock.h

Show All 21 Lines
#endif #endif
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
struct _FilesystemClock; struct _FilesystemClock;
_LIBCPP_END_NAMESPACE_FILESYSTEM _LIBCPP_END_NAMESPACE_FILESYSTEM
#endif // !_LIBCPP_CXX03_LANG #endif // !_LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
// [time.clock.file], type file_clock // [time.clock.file], type file_clock
using file_clock = _VSTD_FS::_FilesystemClock; using file_clock = _VSTD_FS::_FilesystemClock;
template<class _Duration> template<class _Duration>
using file_time = time_point<file_clock, _Duration>; using file_time = time_point<file_clock, _Duration>;
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
struct _FilesystemClock { struct _FilesystemClock {
#if !defined(_LIBCPP_HAS_NO_INT128) #if !defined(_LIBCPP_HAS_NO_INT128)
typedef __int128_t rep; typedef __int128_t rep;
typedef nano period; typedef nano period;
#else #else
typedef long long rep; typedef long long rep;
typedef nano period; typedef nano period;
#endif #endif
typedef chrono::duration<rep, period> duration; typedef chrono::duration<rep, period> duration;
typedef chrono::time_point<_FilesystemClock> time_point; typedef chrono::time_point<_FilesystemClock> time_point;
_LIBCPP_EXPORTED_FROM_ABI _LIBCPP_EXPORTED_FROM_ABI
static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = false; static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = false;
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS static time_point now() noexcept; _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS static time_point now() noexcept;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Duration> template <class _Duration>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static chrono::sys_time<_Duration> to_sys(const chrono::file_time<_Duration>& __t) { static chrono::sys_time<_Duration> to_sys(const chrono::file_time<_Duration>& __t) {
return chrono::sys_time<_Duration>(__t.time_since_epoch()); return chrono::sys_time<_Duration>(__t.time_since_epoch());
} }
template <class _Duration> template <class _Duration>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static chrono::file_time<_Duration> from_sys(const chrono::sys_time<_Duration>& __t) { static chrono::file_time<_Duration> from_sys(const chrono::sys_time<_Duration>& __t) {
return chrono::file_time<_Duration>(__t.time_since_epoch()); return chrono::file_time<_Duration>(__t.time_since_epoch());
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
}; };
_LIBCPP_END_NAMESPACE_FILESYSTEM _LIBCPP_END_NAMESPACE_FILESYSTEM
#endif // !_LIBCPP_CXX03_LANG #endif // !_LIBCPP_CXX03_LANG
#endif // _LIBCPP___CHRONO_FILE_CLOCK_H #endif // _LIBCPP___CHRONO_FILE_CLOCK_H

libcxx/include/__chrono/formatter.h

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
#include <string_view> #include <string_view>
#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_INCOMPLETE_FORMAT) #if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
namespace __formatter { namespace __formatter {
/// Formats a time based on a tm struct. /// Formats a time based on a tm struct.
/// ///
/// This formatter passes the formatting to time_put which uses strftime. When /// This formatter passes the formatting to time_put which uses strftime. When
/// the value is outside the valid range it's unspecified what strftime will /// the value is outside the valid range it's unspecified what strftime will
/// output. For example weekday 8 can print 1 when the day is processed modulo /// output. For example weekday 8 can print 1 when the day is processed modulo
▲ Show 20 Lines • Show All 703 Lines • ▼ Show 20 Lines
public: public:
using _Base = __formatter_chrono<_CharT>; using _Base = __formatter_chrono<_CharT>;
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx) _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
-> decltype(__parse_ctx.begin()) { -> decltype(__parse_ctx.begin()) {
return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__time); return _Base::__parse(__parse_ctx, __format_spec::__fields_chrono, __format_spec::__flags::__time);
} }
}; };
#endif // if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) #endif // if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CHRONO_FORMATTER_H #endif // _LIBCPP___CHRONO_FORMATTER_H

libcxx/include/__chrono/hh_mm_ss.h

Show All 14 Lines
#include <__config> #include <__config>
#include <ratio> #include <ratio>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
template <class _Duration> template <class _Duration>
class hh_mm_ss class hh_mm_ss
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines if (__is_pm)
return __h == hours(12) ? __h : __h + hours(12); return __h == hours(12) ? __h : __h + hours(12);
else else
return __h == hours(12) ? hours(0) : __h; return __h == hours(12) ? hours(0) : __h;
} }
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___CHRONO_HH_MM_SS_H #endif // _LIBCPP___CHRONO_HH_MM_SS_H

libcxx/include/__chrono/literals.h

Show All 12 Lines
#include <__chrono/day.h> #include <__chrono/day.h>
#include <__chrono/year.h> #include <__chrono/year.h>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
inline namespace literals inline namespace literals
{ {
inline namespace chrono_literals inline namespace chrono_literals
{ {
_LIBCPP_HIDE_FROM_ABI constexpr chrono::day operator ""d(unsigned long long __d) noexcept _LIBCPP_HIDE_FROM_ABI constexpr chrono::day operator ""d(unsigned long long __d) noexcept
Show All 9 Lines
} // namespace literals } // namespace literals
namespace chrono { // hoist the literals into namespace std::chrono namespace chrono { // hoist the literals into namespace std::chrono
using namespace literals::chrono_literals; using namespace literals::chrono_literals;
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___CHRONO_LITERALS_H #endif // _LIBCPP___CHRONO_LITERALS_H

libcxx/include/__chrono/month.h

Show All 12 Lines
#include <__chrono/duration.h> #include <__chrono/duration.h>
#include <__config> #include <__config>
#include <compare> #include <compare>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
class month { class month {
private: private:
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
inline constexpr month October{10}; inline constexpr month October{10};
inline constexpr month November{11}; inline constexpr month November{11};
inline constexpr month December{12}; inline constexpr month December{12};
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___CHRONO_MONTH_H #endif // _LIBCPP___CHRONO_MONTH_H

libcxx/include/__chrono/month_weekday.h

Show All 12 Lines
#include <__chrono/month.h> #include <__chrono/month.h>
#include <__chrono/weekday.h> #include <__chrono/weekday.h>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
class month_weekday { class month_weekday {
private: private:
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
_LIBCPP_HIDE_FROM_ABI inline constexpr _LIBCPP_HIDE_FROM_ABI inline constexpr
month_weekday_last operator/(const weekday_last& __lhs, int __rhs) noexcept month_weekday_last operator/(const weekday_last& __lhs, int __rhs) noexcept
{ return month_weekday_last{month(__rhs), __lhs}; } { return month_weekday_last{month(__rhs), __lhs}; }
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___CHRONO_MONTH_WEEKDAY_H #endif // _LIBCPP___CHRONO_MONTH_WEEKDAY_H

libcxx/include/__chrono/monthday.h

Show All 14 Lines
#include <__chrono/month.h> #include <__chrono/month.h>
#include <__config> #include <__config>
#include <compare> #include <compare>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
class month_day { class month_day {
private: private:
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines
_LIBCPP_HIDE_FROM_ABI inline constexpr _LIBCPP_HIDE_FROM_ABI inline constexpr
month_day_last operator/(last_spec, int __rhs) noexcept month_day_last operator/(last_spec, int __rhs) noexcept
{ return month_day_last{month(__rhs)}; } { return month_day_last{month(__rhs)}; }
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___CHRONO_MONTHDAY_H #endif // _LIBCPP___CHRONO_MONTHDAY_H

libcxx/include/__chrono/ostream.h

Show All 28 Lines
#include <ratio> #include <ratio>
#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_INCOMPLETE_FORMAT) #if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
namespace chrono { namespace chrono {
// Depending on the type the return is a const _CharT* or a basic_string<_CharT> // Depending on the type the return is a const _CharT* or a basic_string<_CharT>
template <class _CharT, class _Period> template <class _CharT, class _Period>
_LIBCPP_HIDE_FROM_ABI auto __units_suffix() { _LIBCPP_HIDE_FROM_ABI auto __units_suffix() {
// TODO FMT LWG issue the suffixes are always char and not STATICALLY-WIDEN'ed. // TODO FMT LWG issue the suffixes are always char and not STATICALLY-WIDEN'ed.
if constexpr (same_as<typename _Period::type, atto>) if constexpr (same_as<typename _Period::type, atto>)
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines
template <class _CharT, class _Traits, class _Duration> template <class _CharT, class _Traits, class _Duration>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const hh_mm_ss<_Duration> __hms) { operator<<(basic_ostream<_CharT, _Traits>& __os, const hh_mm_ss<_Duration> __hms) {
return __os << std::format(__os.getloc(), _LIBCPP_STATICALLY_WIDEN(_CharT, "{:L%T}"), __hms); return __os << std::format(__os.getloc(), _LIBCPP_STATICALLY_WIDEN(_CharT, "{:L%T}"), __hms);
} }
} // namespace chrono } // namespace chrono
#endif //if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) #endif //if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CHRONO_OSTREAM_H #endif // _LIBCPP___CHRONO_OSTREAM_H

libcxx/include/__chrono/parser_std_format_spec.h

Show All 18 Lines
#include <string_view> #include <string_view>
#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_INCOMPLETE_FORMAT) #if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
namespace __format_spec { namespace __format_spec {
// By not placing this constant in the formatter class it's not duplicated for char and wchar_t // By not placing this constant in the formatter class it's not duplicated for char and wchar_t
inline constexpr __fields __fields_chrono_fractional{ inline constexpr __fields __fields_chrono_fractional{
.__precision_ = true, .__locale_specific_form_ = true, .__type_ = false}; .__precision_ = true, .__locale_specific_form_ = true, .__type_ = false};
inline constexpr __fields __fields_chrono{.__locale_specific_form_ = true, .__type_ = false}; inline constexpr __fields __fields_chrono{.__locale_specific_form_ = true, .__type_ = false};
▲ Show 20 Lines • Show All 368 Lines • ▼ Show 20 Lines __parse_modifier_O(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
default: default:
std::__throw_format_error("The date time type specifier for modifier O is invalid"); std::__throw_format_error("The date time type specifier for modifier O is invalid");
} }
} }
}; };
} // namespace __format_spec } // namespace __format_spec
#endif //_LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) #endif //_LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CHRONO_PARSER_STD_FORMAT_SPEC_H #endif // _LIBCPP___CHRONO_PARSER_STD_FORMAT_SPEC_H

libcxx/include/__chrono/statically_widen.h

Show All 16 Lines
#include <__format/concepts.h> #include <__format/concepts.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 #if _LIBCPP_STD_VER >= 20
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS # ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
_LIBCPP_HIDE_FROM_ABI constexpr const _CharT* __statically_widen(const char* __str, const wchar_t* __wstr) { _LIBCPP_HIDE_FROM_ABI constexpr const _CharT* __statically_widen(const char* __str, const wchar_t* __wstr) {
if constexpr (same_as<_CharT, char>) if constexpr (same_as<_CharT, char>)
return __str; return __str;
else else
return __wstr; return __wstr;
} }
# define _LIBCPP_STATICALLY_WIDEN(_CharT, __str) ::std::__statically_widen<_CharT>(__str, L##__str) # define _LIBCPP_STATICALLY_WIDEN(_CharT, __str) ::std::__statically_widen<_CharT>(__str, L##__str)
# else // _LIBCPP_HAS_NO_WIDE_CHARACTERS # else // _LIBCPP_HAS_NO_WIDE_CHARACTERS
// Without this indirection the unit test test/libcxx/modules_include.sh.cpp // Without this indirection the unit test test/libcxx/modules_include.sh.cpp
// fails for the CI build "No wide characters". This seems like a bug. // fails for the CI build "No wide characters". This seems like a bug.
// TODO FMT investigate why this is needed. // TODO FMT investigate why this is needed.
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
_LIBCPP_HIDE_FROM_ABI constexpr const _CharT* __statically_widen(const char* __str) { _LIBCPP_HIDE_FROM_ABI constexpr const _CharT* __statically_widen(const char* __str) {
return __str; return __str;
} }
# define _LIBCPP_STATICALLY_WIDEN(_CharT, __str) ::std::__statically_widen<_CharT>(__str) # define _LIBCPP_STATICALLY_WIDEN(_CharT, __str) ::std::__statically_widen<_CharT>(__str)
# endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS # endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CHRONO_STATICALLY_WIDEN_H #endif // _LIBCPP___CHRONO_STATICALLY_WIDEN_H

libcxx/include/__chrono/system_clock.h

Show All 32 Linespublic:
typedef chrono::time_point<system_clock> time_point; typedef chrono::time_point<system_clock> time_point;
static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = false; static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = false;
static time_point now() _NOEXCEPT; static time_point now() _NOEXCEPT;
static time_t to_time_t (const time_point& __t) _NOEXCEPT; static time_t to_time_t (const time_point& __t) _NOEXCEPT;
static time_point from_time_t(time_t __t) _NOEXCEPT; static time_point from_time_t(time_t __t) _NOEXCEPT;
}; };
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Duration> template <class _Duration>
using sys_time = time_point<system_clock, _Duration>; using sys_time = time_point<system_clock, _Duration>;
using sys_seconds = sys_time<seconds>; using sys_seconds = sys_time<seconds>;
using sys_days = sys_time<days>; using sys_days = sys_time<days>;
#endif #endif
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CHRONO_SYSTEM_CLOCK_H #endif // _LIBCPP___CHRONO_SYSTEM_CLOCK_H

libcxx/include/__chrono/time_point.h

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
template <class _ToDuration, class _Clock, class _Duration> template <class _ToDuration, class _Clock, class _Duration>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
time_point<_Clock, _ToDuration> time_point<_Clock, _ToDuration>
time_point_cast(const time_point<_Clock, _Duration>& __t) time_point_cast(const time_point<_Clock, _Duration>& __t)
{ {
return time_point<_Clock, _ToDuration>(chrono::duration_cast<_ToDuration>(__t.time_since_epoch())); return time_point<_Clock, _ToDuration>(chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _ToDuration, class _Clock, class _Duration> template <class _ToDuration, class _Clock, class _Duration>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
typename enable_if typename enable_if
< <
__is_duration<_ToDuration>::value, __is_duration<_ToDuration>::value,
time_point<_Clock, _ToDuration> time_point<_Clock, _ToDuration>
>::type >::type
floor(const time_point<_Clock, _Duration>& __t) floor(const time_point<_Clock, _Duration>& __t)
Show All 31 Lines
< <
numeric_limits<_Rep>::is_signed, numeric_limits<_Rep>::is_signed,
duration<_Rep, _Period> duration<_Rep, _Period>
>::type >::type
abs(duration<_Rep, _Period> __d) abs(duration<_Rep, _Period> __d)
{ {
return __d >= __d.zero() ? +__d : -__d; return __d >= __d.zero() ? +__d : -__d;
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
// time_point == // time_point ==
template <class _Clock, class _Duration1, class _Duration2> template <class _Clock, class _Duration1, class _Duration2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
bool bool
operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
{ {
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

libcxx/include/__chrono/weekday.h

Show All 14 Lines
#include <__chrono/system_clock.h> #include <__chrono/system_clock.h>
#include <__chrono/time_point.h> #include <__chrono/time_point.h>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
class weekday_indexed; class weekday_indexed;
class weekday_last; class weekday_last;
▲ Show 20 Lines • Show All 143 Lines • ▼ Show 20 Lines
inline constexpr weekday Thursday{4}; inline constexpr weekday Thursday{4};
inline constexpr weekday Friday{5}; inline constexpr weekday Friday{5};
inline constexpr weekday Saturday{6}; inline constexpr weekday Saturday{6};
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___CHRONO_WEEKDAY_H #endif // _LIBCPP___CHRONO_WEEKDAY_H

libcxx/include/__chrono/year.h

Show All 16 Lines
#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_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
class year { class year {
private: private:
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines_LIBCPP_HIDE_FROM_ABI constexpr bool year::ok() const noexcept {
static_assert(static_cast<int>(std::numeric_limits<decltype(__y_)>::max()) == static_cast<int>(max())); static_assert(static_cast<int>(std::numeric_limits<decltype(__y_)>::max()) == static_cast<int>(max()));
return static_cast<int>(min()) <= __y_; return static_cast<int>(min()) <= __y_;
} }
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___CHRONO_YEAR_H #endif // _LIBCPP___CHRONO_YEAR_H

libcxx/include/__chrono/year_month.h

Show All 14 Lines
#include <__chrono/year.h> #include <__chrono/year.h>
#include <__config> #include <__config>
#include <compare> #include <compare>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
class year_month { class year_month {
chrono::year __y_; chrono::year __y_;
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
year_month operator-(const year_month& __lhs, const years& __rhs) noexcept year_month operator-(const year_month& __lhs, const years& __rhs) noexcept
{ return __lhs + -__rhs; } { return __lhs + -__rhs; }
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___CHRONO_YEAR_MONTH_H #endif // _LIBCPP___CHRONO_YEAR_MONTH_H

libcxx/include/__chrono/year_month_day.h

Show All 21 Lines
#include <__config> #include <__config>
#include <compare> #include <compare>
#include <limits> #include <limits>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
class year_month_day_last; class year_month_day_last;
▲ Show 20 Lines • Show All 258 Lines • ▼ Show 20 Linesbool year_month_day::ok() const noexcept
if (!__y_.ok() || !__m_.ok()) return false; if (!__y_.ok() || !__m_.ok()) return false;
return chrono::day{1} <= __d_ && __d_ <= (__y_ / __m_ / last).day(); return chrono::day{1} <= __d_ && __d_ <= (__y_ / __m_ / last).day();
} }
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___CHRONO_YEAR_MONTH_DAY_H #endif // _LIBCPP___CHRONO_YEAR_MONTH_DAY_H

libcxx/include/__chrono/year_month_weekday.h

Show All 21 Lines
#include <__chrono/year_month.h> #include <__chrono/year_month.h>
#include <__chrono/year_month_day.h> #include <__chrono/year_month_day.h>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace chrono namespace chrono
{ {
class year_month_weekday { class year_month_weekday {
chrono::year __y_; chrono::year __y_;
▲ Show 20 Lines • Show All 206 Lines • ▼ Show 20 Lines
_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; } _LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; }
_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const years& __dy) noexcept { *this = *this + __dy; return *this; } _LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const years& __dy) noexcept { *this = *this + __dy; return *this; }
_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const years& __dy) noexcept { *this = *this - __dy; return *this; } _LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const years& __dy) noexcept { *this = *this - __dy; return *this; }
} // namespace chrono } // namespace chrono
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP___CHRONO_YEAR_MONTH_WEEKDAY_H #endif // _LIBCPP___CHRONO_YEAR_MONTH_WEEKDAY_H

libcxx/include/__compare/common_comparison_category.h

Show All 14 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 #if _LIBCPP_STD_VER >= 20
namespace __comp_detail { namespace __comp_detail {
enum _ClassifyCompCategory : unsigned { enum _ClassifyCompCategory : unsigned {
_None, _None,
_PartialOrd, _PartialOrd,
_WeakOrd, _WeakOrd,
_StrongOrd, _StrongOrd,
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
template<class... _Ts> template<class... _Ts>
struct _LIBCPP_TEMPLATE_VIS common_comparison_category { struct _LIBCPP_TEMPLATE_VIS common_comparison_category {
using type = decltype(__comp_detail::__get_comp_type<_Ts...>()); using type = decltype(__comp_detail::__get_comp_type<_Ts...>());
}; };
template<class... _Ts> template<class... _Ts>
using common_comparison_category_t = typename common_comparison_category<_Ts...>::type; using common_comparison_category_t = typename common_comparison_category<_Ts...>::type;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMMON_COMPARISON_CATEGORY_H #endif // _LIBCPP___COMPARE_COMMON_COMPARISON_CATEGORY_H

libcxx/include/__compare/compare_partial_order_fallback.h

Show All 17 Lines
#include <__utility/priority_tag.h> #include <__utility/priority_tag.h>
#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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 17 Lines
#include <__utility/priority_tag.h> #include <__utility/priority_tag.h>
#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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 #if _LIBCPP_STD_VER >= 20
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 #endif // _LIBCPP_STD_VER >= 20
_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_three_way_result.h

Show All 13 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 #if _LIBCPP_STD_VER >= 20
template<class, class, class> template<class, class, class>
struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result { }; struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result { };
template<class _Tp, class _Up> template<class _Tp, class _Up>
struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result<_Tp, _Up, decltype( struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result<_Tp, _Up, decltype(
std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>(), void() std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>(), void()
)> { )> {
using type = decltype(std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>()); using type = decltype(std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>());
}; };
template<class _Tp, class _Up = _Tp> template<class _Tp, class _Up = _Tp>
struct _LIBCPP_TEMPLATE_VIS compare_three_way_result : __compare_three_way_result<_Tp, _Up, void> { }; struct _LIBCPP_TEMPLATE_VIS compare_three_way_result : __compare_three_way_result<_Tp, _Up, void> { };
template<class _Tp, class _Up = _Tp> template<class _Tp, class _Up = _Tp>
using compare_three_way_result_t = typename compare_three_way_result<_Tp, _Up>::type; using compare_three_way_result_t = typename compare_three_way_result<_Tp, _Up>::type;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_RESULT_H #endif // _LIBCPP___COMPARE_COMPARE_THREE_WAY_RESULT_H

libcxx/include/__compare/compare_weak_order_fallback.h

Show All 17 Lines
#include <__utility/priority_tag.h> #include <__utility/priority_tag.h>
#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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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/is_eq.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 #if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_eq(partial_ordering __c) noexcept { return __c == 0; } _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_eq(partial_ordering __c) noexcept { return __c == 0; }
_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_neq(partial_ordering __c) noexcept { return __c != 0; } _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_neq(partial_ordering __c) noexcept { return __c != 0; }
_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_lt(partial_ordering __c) noexcept { return __c < 0; } _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_lt(partial_ordering __c) noexcept { return __c < 0; }
_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_lteq(partial_ordering __c) noexcept { return __c <= 0; } _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_lteq(partial_ordering __c) noexcept { return __c <= 0; }
_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_gt(partial_ordering __c) noexcept { return __c > 0; } _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_gt(partial_ordering __c) noexcept { return __c > 0; }
_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_gteq(partial_ordering __c) noexcept { return __c >= 0; } _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_gteq(partial_ordering __c) noexcept { return __c >= 0; }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_IS_EQ_H #endif // _LIBCPP___COMPARE_IS_EQ_H

libcxx/include/__compare/ordering.h

Show All 13 Lines
#include <__type_traits/is_same.h> #include <__type_traits/is_same.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 #if _LIBCPP_STD_VER >= 20
// exposition only // exposition only
enum class _LIBCPP_ENUM_VIS _OrdResult : signed char { enum class _LIBCPP_ENUM_VIS _OrdResult : signed char {
__less = -1, __less = -1,
__equiv = 0, __equiv = 0,
__greater = 1 __greater = 1
}; };
▲ Show 20 Lines • Show All 283 Lines • ▼ Show 20 Lines
inline constexpr strong_ordering strong_ordering::greater(_OrdResult::__greater); inline constexpr strong_ordering strong_ordering::greater(_OrdResult::__greater);
/// [cmp.categories.pre]/1 /// [cmp.categories.pre]/1
/// The types partial_ordering, weak_ordering, and strong_ordering are /// The types partial_ordering, weak_ordering, and strong_ordering are
/// collectively termed the comparison category types. /// collectively termed the comparison category types.
template <class _Tp> template <class _Tp>
concept __comparison_category = __one_of_v<_Tp, partial_ordering, weak_ordering, strong_ordering>; concept __comparison_category = __one_of_v<_Tp, partial_ordering, weak_ordering, strong_ordering>;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___COMPARE_ORDERING_H #endif // _LIBCPP___COMPARE_ORDERING_H

libcxx/include/__compare/partial_order.h

Show All 18 Lines
#include <__utility/priority_tag.h> #include <__utility/priority_tag.h>
#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 #if _LIBCPP_STD_VER >= 20
// [cmp.alg] // [cmp.alg]
namespace __partial_order { namespace __partial_order {
struct __fn { struct __fn {
// NOLINTBEGIN(libcpp-robust-against-adl) partial_order should use ADL, but only here // NOLINTBEGIN(libcpp-robust-against-adl) partial_order should use ADL, but only here
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
Show All 26 Lines // NOLINTEND(libcpp-robust-against-adl)
{ 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 #endif // _LIBCPP_STD_VER >= 20
_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 24 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 #if _LIBCPP_STD_VER >= 20
// [cmp.alg] // [cmp.alg]
namespace __strong_order { namespace __strong_order {
struct __fn { struct __fn {
// NOLINTBEGIN(libcpp-robust-against-adl) strong_order should use ADL, but only here // NOLINTBEGIN(libcpp-robust-against-adl) strong_order should use ADL, but only here
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
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines // NOLINTEND(libcpp-robust-against-adl)
{ 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 #endif // _LIBCPP_STD_VER >= 20
_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 #if _LIBCPP_STD_VER >= 20
// [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(std::__synth_three_way(std::declval<_Tp&>(), std::declval<_Up&>())); using __synth_three_way_result = decltype(std::__synth_three_way(std::declval<_Tp&>(), std::declval<_Up&>()));
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_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 19 Lines
#include <__type_traits/make_const_lvalue_ref.h> #include <__type_traits/make_const_lvalue_ref.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 #if _LIBCPP_STD_VER >= 20
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 #endif // _LIBCPP_STD_VER >= 20
_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 <cmath> #include <cmath>
#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 #if _LIBCPP_STD_VER >= 20
// [cmp.alg] // [cmp.alg]
namespace __weak_order { namespace __weak_order {
struct __fn { struct __fn {
// NOLINTBEGIN(libcpp-robust-against-adl) weak_order should use ADL, but only here // NOLINTBEGIN(libcpp-robust-against-adl) weak_order should use ADL, but only here
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
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines // NOLINTEND(libcpp-robust-against-adl)
{ 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 #endif // _LIBCPP_STD_VER >= 20
_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 16 Lines
#include <__type_traits/is_unsigned_integer.h> #include <__type_traits/is_unsigned_integer.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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 16 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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 15 Lines
#include <__type_traits/remove_cvref.h> #include <__type_traits/remove_cvref.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 #if _LIBCPP_STD_VER >= 20
// 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
// TODO: remove this workaround once libc++ no longer has to support Clang 13 (it was fixed in Clang 14). // TODO: remove this workaround once libc++ no longer has to support Clang 13 (it was fixed in Clang 14).
template<class _Tp> template<class _Tp>
concept __workaround_52970 = is_class_v<__remove_cvref_t<_Tp>> || is_union_v<__remove_cvref_t<_Tp>>; concept __workaround_52970 = is_class_v<__remove_cvref_t<_Tp>> || is_union_v<__remove_cvref_t<_Tp>>;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_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/common_reference.h> #include <__type_traits/common_reference.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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 17 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 #if _LIBCPP_STD_VER >= 20
// [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>>(std::declval<_Tp>()); static_cast<common_type_t<_Tp, _Up>>(std::declval<_Tp>());
static_cast<common_type_t<_Tp, _Up>>(std::declval<_Up>()); static_cast<common_type_t<_Tp, _Up>>(std::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 #endif // _LIBCPP_STD_VER >= 20
_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/is_constructible.h> #include <__type_traits/is_constructible.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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 <__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 #if _LIBCPP_STD_VER >= 20
// [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>(std::declval<_From>()); static_cast<_To>(std::declval<_From>());
}; };
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 13 Lines
#include <__type_traits/is_convertible.h> #include <__type_traits/is_convertible.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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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/is_nothrow_destructible.h> #include <__type_traits/is_nothrow_destructible.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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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/remove_cvref.h> #include <__type_traits/remove_cvref.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 #if _LIBCPP_STD_VER >= 20
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 #endif // _LIBCPP_STD_VER >= 20
_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 15 Lines
#include <__type_traits/make_const_lvalue_ref.h> #include <__type_traits/make_const_lvalue_ref.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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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/is_object.h> #include <__type_traits/is_object.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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 <__functional/invoke.h> #include <__functional/invoke.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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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/is_same.h> #include <__type_traits/is_same.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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 24 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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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 15 Lines
#include <__type_traits/make_const_lvalue_ref.h> #include <__type_traits/make_const_lvalue_ref.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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___CONCEPTS_TOTALLY_ORDERED_H #endif // _LIBCPP___CONCEPTS_TOTALLY_ORDERED_H

libcxx/include/__config

Show First 20 Lines • Show All 659 Lines • ▼ Show 20 Lines
// Inline namespaces are available in Clang/GCC/MSVC regardless of C++ dialect. // Inline namespaces are available in Clang/GCC/MSVC regardless of C++ dialect.
// clang-format off // clang-format off
# define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { inline namespace _LIBCPP_ABI_NAMESPACE { # define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { inline namespace _LIBCPP_ABI_NAMESPACE {
# define _LIBCPP_END_NAMESPACE_STD }} # define _LIBCPP_END_NAMESPACE_STD }}
# define _VSTD std # define _VSTD std
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
# if _LIBCPP_STD_VER > 14 # if _LIBCPP_STD_VER >= 17
# define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM \ # define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM \
_LIBCPP_BEGIN_NAMESPACE_STD inline namespace __fs { namespace filesystem { _LIBCPP_BEGIN_NAMESPACE_STD inline namespace __fs { namespace filesystem {
# else # else
# define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM \ # define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM \
_LIBCPP_BEGIN_NAMESPACE_STD namespace __fs { namespace filesystem { _LIBCPP_BEGIN_NAMESPACE_STD namespace __fs { namespace filesystem {
# endif # endif
# define _LIBCPP_END_NAMESPACE_FILESYSTEM _LIBCPP_END_NAMESPACE_STD }} # define _LIBCPP_END_NAMESPACE_FILESYSTEM _LIBCPP_END_NAMESPACE_STD }}
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Lines
// Deprecation macros. // Deprecation macros.
// //
// Deprecations warnings are always enabled, except when users explicitly opt-out // Deprecations warnings are always enabled, except when users explicitly opt-out
// by defining _LIBCPP_DISABLE_DEPRECATION_WARNINGS. // by defining _LIBCPP_DISABLE_DEPRECATION_WARNINGS.
# if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) # if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
# if __has_attribute(__deprecated__) # if __has_attribute(__deprecated__)
# define _LIBCPP_DEPRECATED __attribute__((__deprecated__)) # define _LIBCPP_DEPRECATED __attribute__((__deprecated__))
# define _LIBCPP_DEPRECATED_(m) __attribute__((__deprecated__(m))) # define _LIBCPP_DEPRECATED_(m) __attribute__((__deprecated__(m)))
# elif _LIBCPP_STD_VER > 11 # elif _LIBCPP_STD_VER >= 14
# define _LIBCPP_DEPRECATED [[deprecated]] # define _LIBCPP_DEPRECATED [[deprecated]]
# define _LIBCPP_DEPRECATED_(m) [[deprecated(m)]] # define _LIBCPP_DEPRECATED_(m) [[deprecated(m)]]
# else # else
# define _LIBCPP_DEPRECATED # define _LIBCPP_DEPRECATED
# define _LIBCPP_DEPRECATED_(m) # define _LIBCPP_DEPRECATED_(m)
# endif # endif
# else # else
# define _LIBCPP_DEPRECATED # define _LIBCPP_DEPRECATED
# define _LIBCPP_DEPRECATED_(m) # define _LIBCPP_DEPRECATED_(m)
# endif # endif
# if !defined(_LIBCPP_CXX03_LANG) # if !defined(_LIBCPP_CXX03_LANG)
# define _LIBCPP_DEPRECATED_IN_CXX11 _LIBCPP_DEPRECATED # define _LIBCPP_DEPRECATED_IN_CXX11 _LIBCPP_DEPRECATED
# else # else
# define _LIBCPP_DEPRECATED_IN_CXX11 # define _LIBCPP_DEPRECATED_IN_CXX11
# endif # endif
# if _LIBCPP_STD_VER > 11 # if _LIBCPP_STD_VER >= 14
# define _LIBCPP_DEPRECATED_IN_CXX14 _LIBCPP_DEPRECATED # define _LIBCPP_DEPRECATED_IN_CXX14 _LIBCPP_DEPRECATED
# else # else
# define _LIBCPP_DEPRECATED_IN_CXX14 # define _LIBCPP_DEPRECATED_IN_CXX14
# endif # endif
# if _LIBCPP_STD_VER > 14 # if _LIBCPP_STD_VER >= 17
# define _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_DEPRECATED # define _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_DEPRECATED
# else # else
# define _LIBCPP_DEPRECATED_IN_CXX17 # define _LIBCPP_DEPRECATED_IN_CXX17
# endif # endif
# if _LIBCPP_STD_VER > 17 # if _LIBCPP_STD_VER >= 20
# define _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_DEPRECATED # define _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_DEPRECATED
# else # else
# define _LIBCPP_DEPRECATED_IN_CXX20 # define _LIBCPP_DEPRECATED_IN_CXX20
# endif # endif
#if _LIBCPP_STD_VER >= 23 #if _LIBCPP_STD_VER >= 23
# define _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_DEPRECATED # define _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_DEPRECATED
#else #else
Show All 18 Lines
# endif # endif
# if _LIBCPP_STD_VER <= 11 # if _LIBCPP_STD_VER <= 11
# define _LIBCPP_EXPLICIT_SINCE_CXX14 # define _LIBCPP_EXPLICIT_SINCE_CXX14
# else # else
# define _LIBCPP_EXPLICIT_SINCE_CXX14 explicit # define _LIBCPP_EXPLICIT_SINCE_CXX14 explicit
# endif # endif
# if _LIBCPP_STD_VER > 11 # if _LIBCPP_STD_VER >= 14
# define _LIBCPP_CONSTEXPR_SINCE_CXX14 constexpr # define _LIBCPP_CONSTEXPR_SINCE_CXX14 constexpr
# else # else
# define _LIBCPP_CONSTEXPR_SINCE_CXX14 # define _LIBCPP_CONSTEXPR_SINCE_CXX14
# endif # endif
# if _LIBCPP_STD_VER > 14 # if _LIBCPP_STD_VER >= 17
# define _LIBCPP_CONSTEXPR_SINCE_CXX17 constexpr # define _LIBCPP_CONSTEXPR_SINCE_CXX17 constexpr
# else # else
# define _LIBCPP_CONSTEXPR_SINCE_CXX17 # define _LIBCPP_CONSTEXPR_SINCE_CXX17
# endif # endif
# if _LIBCPP_STD_VER > 17 # if _LIBCPP_STD_VER >= 20
# define _LIBCPP_CONSTEXPR_SINCE_CXX20 constexpr # define _LIBCPP_CONSTEXPR_SINCE_CXX20 constexpr
# else # else
# define _LIBCPP_CONSTEXPR_SINCE_CXX20 # define _LIBCPP_CONSTEXPR_SINCE_CXX20
# endif # endif
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
# define _LIBCPP_CONSTEXPR_SINCE_CXX23 constexpr # define _LIBCPP_CONSTEXPR_SINCE_CXX23 constexpr
# else # else
# define _LIBCPP_CONSTEXPR_SINCE_CXX23 # define _LIBCPP_CONSTEXPR_SINCE_CXX23
# endif # endif
# if __has_cpp_attribute(nodiscard) # if __has_cpp_attribute(nodiscard)
# define _LIBCPP_NODISCARD [[nodiscard]] # define _LIBCPP_NODISCARD [[nodiscard]]
# else # else
// We can't use GCC's [[gnu::warn_unused_result]] and // We can't use GCC's [[gnu::warn_unused_result]] and
// __attribute__((warn_unused_result)), because GCC does not silence them via // __attribute__((warn_unused_result)), because GCC does not silence them via
// (void) cast. // (void) cast.
# define _LIBCPP_NODISCARD # define _LIBCPP_NODISCARD
# endif # endif
// _LIBCPP_NODISCARD_EXT may be used to apply [[nodiscard]] to entities not // _LIBCPP_NODISCARD_EXT may be used to apply [[nodiscard]] to entities not
// specified as such as an extension. // specified as such as an extension.
# if !defined(_LIBCPP_DISABLE_NODISCARD_EXT) # if !defined(_LIBCPP_DISABLE_NODISCARD_EXT)
# define _LIBCPP_NODISCARD_EXT _LIBCPP_NODISCARD # define _LIBCPP_NODISCARD_EXT _LIBCPP_NODISCARD
# else # else
# define _LIBCPP_NODISCARD_EXT # define _LIBCPP_NODISCARD_EXT
# endif # endif
# if _LIBCPP_STD_VER > 17 || !defined(_LIBCPP_DISABLE_NODISCARD_EXT) # if _LIBCPP_STD_VER >= 20 || !defined(_LIBCPP_DISABLE_NODISCARD_EXT)
# define _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_NODISCARD # define _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_NODISCARD
# else # else
# define _LIBCPP_NODISCARD_AFTER_CXX17 # define _LIBCPP_NODISCARD_AFTER_CXX17
# endif # endif
# if __has_attribute(__no_destroy__) # if __has_attribute(__no_destroy__)
# define _LIBCPP_NO_DESTROY __attribute__((__no_destroy__)) # define _LIBCPP_NO_DESTROY __attribute__((__no_destroy__))
# else # else
▲ Show 20 Lines • Show All 149 Lines • ▼ Show 20 Lines
# endif # endif
# ifdef _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS # ifdef _LIBCPP_HAS_THREAD_SAFETY_ANNOTATIONS
# define _LIBCPP_THREAD_SAFETY_ANNOTATION(x) __attribute__((x)) # define _LIBCPP_THREAD_SAFETY_ANNOTATION(x) __attribute__((x))
# else # else
# define _LIBCPP_THREAD_SAFETY_ANNOTATION(x) # define _LIBCPP_THREAD_SAFETY_ANNOTATION(x)
# endif # endif
# if _LIBCPP_STD_VER > 17 # if _LIBCPP_STD_VER >= 20
# define _LIBCPP_CONSTINIT constinit # define _LIBCPP_CONSTINIT constinit
# elif __has_attribute(__require_constant_initialization__) # elif __has_attribute(__require_constant_initialization__)
# define _LIBCPP_CONSTINIT __attribute__((__require_constant_initialization__)) # define _LIBCPP_CONSTINIT __attribute__((__require_constant_initialization__))
# else # else
# define _LIBCPP_CONSTINIT # define _LIBCPP_CONSTINIT
# endif # endif
# if __has_attribute(__diagnose_if__) && !defined(_LIBCPP_DISABLE_ADDITIONAL_DIAGNOSTICS) # if __has_attribute(__diagnose_if__) && !defined(_LIBCPP_DISABLE_ADDITIONAL_DIAGNOSTICS)
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

libcxx/include/__coroutine/coroutine_handle.h

Show All 15 Lines
#include <__type_traits/remove_cv.h> #include <__type_traits/remove_cv.h>
#include <compare> #include <compare>
#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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// [coroutine.handle] // [coroutine.handle]
template <class _Promise = void> template <class _Promise = void>
struct _LIBCPP_TEMPLATE_VIS coroutine_handle; struct _LIBCPP_TEMPLATE_VIS coroutine_handle;
template <> template <>
▲ Show 20 Lines • Show All 160 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
struct hash<coroutine_handle<_Tp>> { struct hash<coroutine_handle<_Tp>> {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(const coroutine_handle<_Tp>& __v) const noexcept { return hash<void*>()(__v.address()); } size_t operator()(const coroutine_handle<_Tp>& __v) const noexcept { return hash<void*>()(__v.address()); }
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // __LIBCPP_STD_VER > 17 #endif // __LIBCPP_STD_VER >= 20
#endif // _LIBCPP___COROUTINE_COROUTINE_HANDLE_H #endif // _LIBCPP___COROUTINE_COROUTINE_HANDLE_H

libcxx/include/__coroutine/coroutine_traits.h

Show All 10 Lines
#include <__config> #include <__config>
#include <__type_traits/void_t.h> #include <__type_traits/void_t.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// [coroutine.traits] // [coroutine.traits]
// [coroutine.traits.primary] // [coroutine.traits.primary]
// The header <coroutine> defined the primary template coroutine_traits such that // The header <coroutine> defined the primary template coroutine_traits such that
// if ArgTypes is a parameter pack of types and if the qualified-id R::promise_type // if ArgTypes is a parameter pack of types and if the qualified-id R::promise_type
// is valid and denotes a type ([temp.deduct]), then coroutine_traits<R, ArgTypes...> // is valid and denotes a type ([temp.deduct]), then coroutine_traits<R, ArgTypes...>
Show All 15 Lines
template <class _Ret, class... _Args> template <class _Ret, class... _Args>
struct coroutine_traits struct coroutine_traits
: public __coroutine_traits_sfinae<_Ret> : public __coroutine_traits_sfinae<_Ret>
{ {
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // __LIBCPP_STD_VER > 17 #endif // __LIBCPP_STD_VER >= 20
#endif // _LIBCPP___COROUTINE_COROUTINE_TRAITS_H #endif // _LIBCPP___COROUTINE_COROUTINE_TRAITS_H

libcxx/include/__coroutine/noop_coroutine_handle.h

Show All 10 Lines
#include <__config> #include <__config>
#include <__coroutine/coroutine_handle.h> #include <__coroutine/coroutine_handle.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__builtin_coro_noop) || defined(_LIBCPP_COMPILER_GCC) #if __has_builtin(__builtin_coro_noop) || defined(_LIBCPP_COMPILER_GCC)
// [coroutine.noop] // [coroutine.noop]
// [coroutine.promise.noop] // [coroutine.promise.noop]
struct noop_coroutine_promise {}; struct noop_coroutine_promise {};
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines
// [coroutine.noop.coroutine] // [coroutine.noop.coroutine]
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
noop_coroutine_handle noop_coroutine() noexcept { return noop_coroutine_handle(); } noop_coroutine_handle noop_coroutine() noexcept { return noop_coroutine_handle(); }
#endif // __has_builtin(__builtin_coro_noop) || defined(_LIBCPP_COMPILER_GCC) #endif // __has_builtin(__builtin_coro_noop) || defined(_LIBCPP_COMPILER_GCC)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // __LIBCPP_STD_VER > 17 #endif // __LIBCPP_STD_VER >= 20
#endif // _LIBCPP___COROUTINE_NOOP_COROUTINE_HANDLE_H #endif // _LIBCPP___COROUTINE_NOOP_COROUTINE_HANDLE_H

libcxx/include/__coroutine/trivial_awaitables.h

Show All 10 Lines
#include <__config> #include <__config>
#include <__coroutine/coroutine_handle.h> #include <__coroutine/coroutine_handle.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
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// [coroutine.trivial.awaitables] // [coroutine.trivial.awaitables]
struct suspend_never { struct suspend_never {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr bool await_ready() const noexcept { return true; } constexpr bool await_ready() const noexcept { return true; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr void await_suspend(coroutine_handle<>) const noexcept {} constexpr void await_suspend(coroutine_handle<>) const noexcept {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr void await_resume() const noexcept {} constexpr void await_resume() const noexcept {}
}; };
struct suspend_always { struct suspend_always {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr bool await_ready() const noexcept { return false; } constexpr bool await_ready() const noexcept { return false; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr void await_suspend(coroutine_handle<>) const noexcept {} constexpr void await_suspend(coroutine_handle<>) const noexcept {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr void await_resume() const noexcept {} constexpr void await_resume() const noexcept {}
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // __LIBCPP_STD_VER > 17 #endif // __LIBCPP_STD_VER >= 20
#endif // __LIBCPP___COROUTINE_TRIVIAL_AWAITABLES_H #endif // __LIBCPP___COROUTINE_TRIVIAL_AWAITABLES_H

libcxx/include/__filesystem/directory_iterator.h

Show First 20 Lines • Show All 142 Lines • ▼ Show 20 Lines
end(directory_iterator) noexcept { end(directory_iterator) noexcept {
return directory_iterator(); return directory_iterator();
} }
_LIBCPP_AVAILABILITY_FILESYSTEM_POP _LIBCPP_AVAILABILITY_FILESYSTEM_POP
_LIBCPP_END_NAMESPACE_FILESYSTEM _LIBCPP_END_NAMESPACE_FILESYSTEM
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <> template <>
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_AVAILABILITY_FILESYSTEM
inline constexpr bool _VSTD::ranges::enable_borrowed_range<_VSTD_FS::directory_iterator> = true; inline constexpr bool _VSTD::ranges::enable_borrowed_range<_VSTD_FS::directory_iterator> = true;
template <> template <>
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_AVAILABILITY_FILESYSTEM
inline constexpr bool _VSTD::ranges::enable_view<_VSTD_FS::directory_iterator> = true; inline constexpr bool _VSTD::ranges::enable_view<_VSTD_FS::directory_iterator> = true;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#endif // _LIBCPP___FILESYSTEM_DIRECTORY_ITERATOR_H #endif // _LIBCPP___FILESYSTEM_DIRECTORY_ITERATOR_H

libcxx/include/__filesystem/recursive_directory_iterator.h

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Lines
end(recursive_directory_iterator) noexcept { end(recursive_directory_iterator) noexcept {
return recursive_directory_iterator(); return recursive_directory_iterator();
} }
_LIBCPP_AVAILABILITY_FILESYSTEM_POP _LIBCPP_AVAILABILITY_FILESYSTEM_POP
_LIBCPP_END_NAMESPACE_FILESYSTEM _LIBCPP_END_NAMESPACE_FILESYSTEM
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <> template <>
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_AVAILABILITY_FILESYSTEM
inline constexpr bool _VSTD::ranges::enable_borrowed_range<_VSTD_FS::recursive_directory_iterator> = true; inline constexpr bool _VSTD::ranges::enable_borrowed_range<_VSTD_FS::recursive_directory_iterator> = true;
template <> template <>
_LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_AVAILABILITY_FILESYSTEM
inline constexpr bool _VSTD::ranges::enable_view<_VSTD_FS::recursive_directory_iterator> = true; inline constexpr bool _VSTD::ranges::enable_view<_VSTD_FS::recursive_directory_iterator> = true;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#endif // _LIBCPP___FILESYSTEM_RECURSIVE_DIRECTORY_ITERATOR_H #endif // _LIBCPP___FILESYSTEM_RECURSIVE_DIRECTORY_ITERATOR_H

libcxx/include/__filesystem/space_info.h

Show All 23 Lines
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
struct _LIBCPP_TYPE_VIS space_info { struct _LIBCPP_TYPE_VIS space_info {
uintmax_t capacity; uintmax_t capacity;
uintmax_t free; uintmax_t free;
uintmax_t available; uintmax_t available;
# if _LIBCPP_STD_VER > 17 # if _LIBCPP_STD_VER >= 20
friend _LIBCPP_HIDE_FROM_ABI bool operator==(const space_info&, const space_info&) = default; friend _LIBCPP_HIDE_FROM_ABI bool operator==(const space_info&, const space_info&) = default;
# endif # endif
}; };
_LIBCPP_AVAILABILITY_FILESYSTEM_POP _LIBCPP_AVAILABILITY_FILESYSTEM_POP
_LIBCPP_END_NAMESPACE_FILESYSTEM _LIBCPP_END_NAMESPACE_FILESYSTEM
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#endif // _LIBCPP___FILESYSTEM_SPACE_INFO_H #endif // _LIBCPP___FILESYSTEM_SPACE_INFO_H

libcxx/include/__format/buffer.h

Show All 36 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 #if _LIBCPP_STD_VER >= 20
namespace __format { namespace __format {
/// A "buffer" that handles writing to the proper iterator. /// A "buffer" that handles writing to the proper iterator.
/// ///
/// This helper is used together with the @ref back_insert_iterator to offer /// This helper is used together with the @ref back_insert_iterator to offer
/// type-erasure for the formatting functions. This reduces the number to /// type-erasure for the formatting functions. This reduces the number to
/// template instantiations. /// template instantiations.
▲ Show 20 Lines • Show All 505 Lines • ▼ Show 20 Lines
private: private:
// Use vector instead of string to avoid adding zeros after every append // Use vector instead of string to avoid adding zeros after every append
// operation. The buffer is exposed as a string_view and not as a c-string. // operation. The buffer is exposed as a string_view and not as a c-string.
vector<_CharT> __buffer_; vector<_CharT> __buffer_;
}; };
} // namespace __format } // namespace __format
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___FORMAT_BUFFER_H #endif // _LIBCPP___FORMAT_BUFFER_H

libcxx/include/__format/concepts.h

Show All 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 #if _LIBCPP_STD_VER >= 20
/// The character type specializations of \ref formatter. /// The character type specializations of \ref formatter.
template <class _CharT> template <class _CharT>
concept __fmt_char_type = concept __fmt_char_type =
same_as<_CharT, char> same_as<_CharT, char>
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS # ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
|| same_as<_CharT, wchar_t> || same_as<_CharT, wchar_t>
# endif # endif
Show All 13 Lines requires(formatter<remove_cvref_t<_Tp>, _CharT> __f,
const formatter<remove_cvref_t<_Tp>, _CharT> __cf, const formatter<remove_cvref_t<_Tp>, _CharT> __cf,
_Tp __t, _Tp __t,
basic_format_context<__fmt_iter_for<_CharT>, _CharT> __fc, basic_format_context<__fmt_iter_for<_CharT>, _CharT> __fc,
basic_format_parse_context<_CharT> __pc) { basic_format_parse_context<_CharT> __pc) {
{ __f.parse(__pc) } -> same_as<typename basic_format_parse_context<_CharT>::iterator>; { __f.parse(__pc) } -> same_as<typename basic_format_parse_context<_CharT>::iterator>;
{ __cf.format(__t, __fc) } -> same_as<__fmt_iter_for<_CharT>>; { __cf.format(__t, __fc) } -> same_as<__fmt_iter_for<_CharT>>;
}; };
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
template <class _Tp, class _CharT> template <class _Tp, class _CharT>
concept formattable = __formattable<_Tp, _CharT>; concept formattable = __formattable<_Tp, _CharT>;
// [tuple.like] defines a tuple-like exposition only concept. This concept is // [tuple.like] defines a tuple-like exposition only concept. This concept is
// not related to that. Therefore it uses a different name for the concept. // not related to that. Therefore it uses a different name for the concept.
// //
// TODO FMT Add a test to validate we fail when using that concept after P2165 // TODO FMT Add a test to validate we fail when using that concept after P2165
// has been implemented. // has been implemented.
template <class _Tp> template <class _Tp>
concept __fmt_pair_like = __is_specialization_v<_Tp, pair> || concept __fmt_pair_like = __is_specialization_v<_Tp, pair> ||
// Use a requires since tuple_size_v may fail to instantiate, // Use a requires since tuple_size_v may fail to instantiate,
(__is_specialization_v<_Tp, tuple> && requires { tuple_size_v<_Tp> == 2; }); (__is_specialization_v<_Tp, tuple> && requires { tuple_size_v<_Tp> == 2; });
# endif //_LIBCPP_STD_VER > 20 # endif //_LIBCPP_STD_VER >= 23
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_CONCEPTS_H #endif // _LIBCPP___FORMAT_CONCEPTS_H

libcxx/include/__format/container_adaptor.h

Show All 18 Lines
#include <__format/concepts.h> #include <__format/concepts.h>
#include <__format/formatter.h> #include <__format/formatter.h>
#include <__format/range_default_formatter.h> #include <__format/range_default_formatter.h>
#include <queue> #include <queue>
#include <stack> #include <stack>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
// [container.adaptors.format] only specifies the library should provide the // [container.adaptors.format] only specifies the library should provide the
// formatter specializations, not which header should provide them. // formatter specializations, not which header should provide them.
// Since <format> includes a lot of headers, add these headers here instead of // Since <format> includes a lot of headers, add these headers here instead of
// adding more dependencies like, locale, optinal, string, tuple, etc. to the // adding more dependencies like, locale, optinal, string, tuple, etc. to the
// adaptor headers. To use the format functions users already include <format>. // adaptor headers. To use the format functions users already include <format>.
template <class _Adaptor, class _CharT> template <class _Adaptor, class _CharT>
Show All 22 Lines
template <class _CharT, class _Tp, class _Container, class _Compare> template <class _CharT, class _Tp, class _Container, class _Compare>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<priority_queue<_Tp, _Container, _Compare>, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<priority_queue<_Tp, _Container, _Compare>, _CharT>
: public __formatter_container_adaptor<priority_queue<_Tp, _Container, _Compare>, _CharT> {}; : public __formatter_container_adaptor<priority_queue<_Tp, _Container, _Compare>, _CharT> {};
template <class _CharT, class _Tp, formattable<_CharT> _Container> template <class _CharT, class _Tp, formattable<_CharT> _Container>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<stack<_Tp, _Container>, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<stack<_Tp, _Container>, _CharT>
: public __formatter_container_adaptor<stack<_Tp, _Container>, _CharT> {}; : public __formatter_container_adaptor<stack<_Tp, _Container>, _CharT> {};
#endif //_LIBCPP_STD_VER > 20 #endif //_LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_CONTAINER_ADAPTOR_H #endif // _LIBCPP___FORMAT_CONTAINER_ADAPTOR_H

libcxx/include/__format/enable_insertable.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 #if _LIBCPP_STD_VER >= 20
namespace __format { namespace __format {
/// Opt-in to enable \ref __insertable for a \a _Container. /// Opt-in to enable \ref __insertable for a \a _Container.
template <class _Container> template <class _Container>
inline constexpr bool __enable_insertable = false; inline constexpr bool __enable_insertable = false;
} // namespace __format } // namespace __format
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_ENABLE_INSERTABLE_H #endif // _LIBCPP___FORMAT_ENABLE_INSERTABLE_H

libcxx/include/__format/escaped_output_table.h

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
#include <cstdint> #include <cstdint>
#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 > 20 #if _LIBCPP_STD_VER >= 23
namespace __escaped_output_table { namespace __escaped_output_table {
/// The entries of the characters to escape in format's debug string. /// The entries of the characters to escape in format's debug string.
/// ///
/// Contains the entries for [format.string.escaped]/2.2.1.2.1 /// Contains the entries for [format.string.escaped]/2.2.1.2.1
/// CE is a Unicode encoding and C corresponds to either a UCS scalar value /// CE is a Unicode encoding and C corresponds to either a UCS scalar value
/// whose Unicode property General_Category has a value in the groups /// whose Unicode property General_Category has a value in the groups
▲ Show 20 Lines • Show All 942 Lines • ▼ Show 20 Lines[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool __needs_escape(const char32_t __code_point) noexcept {
--__i; --__i;
uint32_t __upper_bound = (__entries[__i] >> 11) + (__entries[__i] & 0x7ffu); uint32_t __upper_bound = (__entries[__i] >> 11) + (__entries[__i] & 0x7ffu);
return __code_point <= __upper_bound; return __code_point <= __upper_bound;
} }
} // namespace __escaped_output_table } // namespace __escaped_output_table
#endif //_LIBCPP_STD_VER > 20 #endif //_LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_ESCAPED_OUTPUT_TABLE_H #endif // _LIBCPP___FORMAT_ESCAPED_OUTPUT_TABLE_H

libcxx/include/__format/extended_grapheme_cluster_table.h

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
#include <cstdint> #include <cstdint>
#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 #if _LIBCPP_STD_VER >= 20
namespace __extended_grapheme_custer_property_boundary { namespace __extended_grapheme_custer_property_boundary {
enum class __property : uint8_t { enum class __property : uint8_t {
// Values generated from the data files. // Values generated from the data files.
__CR, __CR,
__Control, __Control,
__Extend, __Extend,
▲ Show 20 Lines • Show All 1,564 Lines • ▼ Show 20 Lines[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __property __get_property(const char32_t __code_point) noexcept {
if (__code_point <= __upper_bound) if (__code_point <= __upper_bound)
return static_cast<__property>(__entries[__i] & 0xf); return static_cast<__property>(__entries[__i] & 0xf);
return __property::__none; return __property::__none;
} }
} // namespace __extended_grapheme_custer_property_boundary } // namespace __extended_grapheme_custer_property_boundary
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_EXTENDED_GRAPHEME_CLUSTER_TABLE_H #endif // _LIBCPP___FORMAT_EXTENDED_GRAPHEME_CLUSTER_TABLE_H

libcxx/include/__format/format_arg.h

Show All 24 Lines
#include <string_view> #include <string_view>
#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 #if _LIBCPP_STD_VER >= 20
namespace __format { namespace __format {
/// The type stored in @ref basic_format_arg. /// The type stored in @ref basic_format_arg.
/// ///
/// @note The 128-bit types are unconditionally in the list to avoid the values /// @note The 128-bit types are unconditionally in the list to avoid the values
/// of the enums to depend on the availability of 128-bit integers. /// of the enums to depend on the availability of 128-bit integers.
/// ///
/// @note The value is stored as a 5-bit value in the __packed_arg_t_bits. This /// @note The value is stored as a 5-bit value in the __packed_arg_t_bits. This
▲ Show 20 Lines • Show All 248 Lines • ▼ Show 20 Lines case __format::__arg_t::__u128: {
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h}); return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
} }
# endif # endif
default: default:
return _VSTD::__visit_format_arg(_VSTD::forward<_Visitor>(__vis), __arg); return _VSTD::__visit_format_arg(_VSTD::forward<_Visitor>(__vis), __arg);
} }
} }
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_ARG_H #endif // _LIBCPP___FORMAT_FORMAT_ARG_H

libcxx/include/__format/format_arg_store.h

Show All 21 Lines
#include <__utility/forward.h> #include <__utility/forward.h>
#include <cstring> #include <cstring>
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <type_traits> #include <type_traits>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
namespace __format { namespace __format {
/// \returns The @c __arg_t based on the type of the formatting argument. /// \returns The @c __arg_t based on the type of the formatting argument.
/// ///
/// \pre \c __formattable<_Tp, typename _Context::char_type> /// \pre \c __formattable<_Tp, typename _Context::char_type>
template <class _Context, class _Tp> template <class _Context, class _Tp>
consteval __arg_t __determine_arg_t(); consteval __arg_t __determine_arg_t();
▲ Show 20 Lines • Show All 203 Lines • ▼ Show 20 Linesstruct _LIBCPP_TEMPLATE_VIS __format_arg_store {
using _Storage = conditional_t<__format::__use_packed_format_arg_store(sizeof...(_Args)), using _Storage = conditional_t<__format::__use_packed_format_arg_store(sizeof...(_Args)),
__format::__packed_format_arg_store<_Context, sizeof...(_Args)>, __format::__packed_format_arg_store<_Context, sizeof...(_Args)>,
__format::__unpacked_format_arg_store<_Context, sizeof...(_Args)>>; __format::__unpacked_format_arg_store<_Context, sizeof...(_Args)>>;
_Storage __storage; _Storage __storage;
}; };
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_ARG_STORE_H #endif // _LIBCPP___FORMAT_FORMAT_ARG_STORE_H

libcxx/include/__format/format_args.h

Show All 18 Lines
#include <cstdint> #include <cstdint>
#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 #if _LIBCPP_STD_VER >= 20
template <class _Context> template <class _Context>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_args { class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_args {
public: public:
_LIBCPP_HIDE_FROM_ABI basic_format_args() noexcept = default; _LIBCPP_HIDE_FROM_ABI basic_format_args() noexcept = default;
template <class... _Args> template <class... _Args>
_LIBCPP_HIDE_FROM_ABI basic_format_args(const __format_arg_store<_Context, _Args...>& __store) noexcept _LIBCPP_HIDE_FROM_ABI basic_format_args(const __format_arg_store<_Context, _Args...>& __store) noexcept
Show All 32 Lines struct {
const __basic_format_arg_value<_Context>* __values_; const __basic_format_arg_value<_Context>* __values_;
uint64_t __types_; uint64_t __types_;
}; };
const basic_format_arg<_Context>* __args_; const basic_format_arg<_Context>* __args_;
}; };
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_format_args); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_format_args);
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_ARGS_H #endif // _LIBCPP___FORMAT_FORMAT_ARGS_H

libcxx/include/__format/format_context.h

Show All 31 Lines
#endif #endif
#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 #if _LIBCPP_STD_VER >= 20
template <class _OutIt, class _CharT> template <class _OutIt, class _CharT>
requires output_iterator<_OutIt, const _CharT&> requires output_iterator<_OutIt, const _CharT&>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_context; class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_context;
#ifndef _LIBCPP_HAS_NO_LOCALIZATION #ifndef _LIBCPP_HAS_NO_LOCALIZATION
/** /**
* Helper to create a basic_format_context. * Helper to create a basic_format_context.
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Lines# ifndef _LIBCPP_HAS_NO_LOCALIZATION
std::locale (*__loc_)(void* __ctx); std::locale (*__loc_)(void* __ctx);
# endif # endif
void* __ctx_; void* __ctx_;
basic_format_arg<basic_format_context> (*__arg_)(void* __ctx, size_t __id); basic_format_arg<basic_format_context> (*__arg_)(void* __ctx, size_t __id);
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_format_context); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_format_context);
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_CONTEXT_H #endif // _LIBCPP___FORMAT_FORMAT_CONTEXT_H

libcxx/include/__format/format_error.h

Show All 14 Lines
#include <stdexcept> #include <stdexcept>
#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 #if _LIBCPP_STD_VER >= 20
class _LIBCPP_EXCEPTION_ABI format_error : public runtime_error { class _LIBCPP_EXCEPTION_ABI format_error : public runtime_error {
public: public:
_LIBCPP_HIDE_FROM_ABI explicit format_error(const string& __s) _LIBCPP_HIDE_FROM_ABI explicit format_error(const string& __s)
: runtime_error(__s) {} : runtime_error(__s) {}
_LIBCPP_HIDE_FROM_ABI explicit format_error(const char* __s) _LIBCPP_HIDE_FROM_ABI explicit format_error(const char* __s)
: runtime_error(__s) {} : runtime_error(__s) {}
// TODO FMT Remove when format is no longer experimental. // TODO FMT Remove when format is no longer experimental.
Show All 11 Lines
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
throw format_error(__s); throw format_error(__s);
#else #else
(void)__s; (void)__s;
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_ERROR_H #endif // _LIBCPP___FORMAT_FORMAT_ERROR_H

libcxx/include/__format/format_functions.h

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
#endif #endif
#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 #if _LIBCPP_STD_VER >= 20
// TODO FMT Evaluate which templates should be external templates. This // TODO FMT Evaluate which templates should be external templates. This
// improves the efficiency of the header. However since the header is still // improves the efficiency of the header. However since the header is still
// under heavy development and not all classes are stable it makes no sense // under heavy development and not all classes are stable it makes no sense
// to do this optimization now. // to do this optimization now.
using format_args = basic_format_args<format_context>; using format_args = basic_format_args<format_context>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
▲ Show 20 Lines • Show All 584 Lines • ▼ Show 20 Lines
formatted_size(locale __loc, wformat_string<_Args...> __fmt, _Args&&... __args) { formatted_size(locale __loc, wformat_string<_Args...> __fmt, _Args&&... __args) {
return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.get(), basic_format_args{_VSTD::make_wformat_args(__args...)}); return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.get(), basic_format_args{_VSTD::make_wformat_args(__args...)});
} }
#endif #endif
#endif // _LIBCPP_HAS_NO_LOCALIZATION #endif // _LIBCPP_HAS_NO_LOCALIZATION
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) #endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
#endif // _LIBCPP___FORMAT_FORMAT_FUNCTIONS #endif // _LIBCPP___FORMAT_FORMAT_FUNCTIONS

libcxx/include/__format/format_fwd.h

Show All 14 Lines
#include <__iterator/concepts.h> #include <__iterator/concepts.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 #if _LIBCPP_STD_VER >= 20
template <class _Context> template <class _Context>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_arg; class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_arg;
template <class _OutIt, class _CharT> template <class _OutIt, class _CharT>
requires output_iterator<_OutIt, const _CharT&> requires output_iterator<_OutIt, const _CharT&>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_context; class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_context;
template <class _Tp, class _CharT = char> template <class _Tp, class _CharT = char>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter; struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter;
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_FWD_H #endif // _LIBCPP___FORMAT_FORMAT_FWD_H

libcxx/include/__format/format_parse_context.h

Show All 14 Lines
#include <string_view> #include <string_view>
#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 #if _LIBCPP_STD_VER >= 20
template <class _CharT> template <class _CharT>
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_parse_context { class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_parse_context {
public: public:
using char_type = _CharT; using char_type = _CharT;
using const_iterator = typename basic_string_view<_CharT>::const_iterator; using const_iterator = typename basic_string_view<_CharT>::const_iterator;
using iterator = const_iterator; using iterator = const_iterator;
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_format_parse_context); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_format_parse_context);
using format_parse_context = basic_format_parse_context<char>; using format_parse_context = basic_format_parse_context<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
using wformat_parse_context = basic_format_parse_context<wchar_t>; using wformat_parse_context = basic_format_parse_context<wchar_t>;
#endif #endif
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_PARSE_CONTEXT_H #endif // _LIBCPP___FORMAT_FORMAT_PARSE_CONTEXT_H

libcxx/include/__format/format_string.h

Show All 18 Lines
#include <cstdint> #include <cstdint>
#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 #if _LIBCPP_STD_VER >= 20
namespace __format { namespace __format {
template <contiguous_iterator _Iterator> template <contiguous_iterator _Iterator>
struct _LIBCPP_TEMPLATE_VIS __parse_number_result { struct _LIBCPP_TEMPLATE_VIS __parse_number_result {
_Iterator __last; _Iterator __last;
uint32_t __value; uint32_t __value;
}; };
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines__parse_arg_id(_Iterator __begin, _Iterator __end, auto& __parse_ctx) {
if (*__begin < _CharT('0') || *__begin > _CharT('9')) if (*__begin < _CharT('0') || *__begin > _CharT('9'))
std::__throw_format_error("The arg-id of the format-spec starts with an invalid character"); std::__throw_format_error("The arg-id of the format-spec starts with an invalid character");
return __detail::__parse_manual(__begin, __end, __parse_ctx); return __detail::__parse_manual(__begin, __end, __parse_ctx);
} }
} // namespace __format } // namespace __format
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_STRING_H #endif // _LIBCPP___FORMAT_FORMAT_STRING_H

libcxx/include/__format/format_to_n_result.h

Show All 13 Lines
#include <__iterator/incrementable_traits.h> #include <__iterator/incrementable_traits.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 #if _LIBCPP_STD_VER >= 20
template <class _OutIt> template <class _OutIt>
struct _LIBCPP_TEMPLATE_VIS format_to_n_result { struct _LIBCPP_TEMPLATE_VIS format_to_n_result {
_OutIt out; _OutIt out;
iter_difference_t<_OutIt> size; iter_difference_t<_OutIt> size;
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(format_to_n_result); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(format_to_n_result);
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_TO_N_RESULT_H #endif // _LIBCPP___FORMAT_FORMAT_TO_N_RESULT_H

libcxx/include/__format/formatter.h

Show All 14 Lines
#include <__format/format_fwd.h> #include <__format/format_fwd.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 #if _LIBCPP_STD_VER >= 20
/// The default formatter template. /// The default formatter template.
/// ///
/// [format.formatter.spec]/5 /// [format.formatter.spec]/5
/// If F is a disabled specialization of formatter, these values are false: /// If F is a disabled specialization of formatter, these values are false:
/// - is_default_constructible_v<F>, /// - is_default_constructible_v<F>,
/// - is_copy_constructible_v<F>, /// - is_copy_constructible_v<F>,
/// - is_move_constructible_v<F>, /// - is_move_constructible_v<F>,
/// - is_copy_assignable<F>, and /// - is_copy_assignable<F>, and
/// - is_move_assignable<F>. /// - is_move_assignable<F>.
template <class _Tp, class _CharT> template <class _Tp, class _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter { struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter {
formatter() = delete; formatter() = delete;
formatter(const formatter&) = delete; formatter(const formatter&) = delete;
formatter& operator=(const formatter&) = delete; formatter& operator=(const formatter&) = delete;
}; };
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr void __set_debug_format(_Tp& __formatter) { _LIBCPP_HIDE_FROM_ABI constexpr void __set_debug_format(_Tp& __formatter) {
if constexpr (requires { __formatter.set_debug_format(); }) if constexpr (requires { __formatter.set_debug_format(); })
__formatter.set_debug_format(); __formatter.set_debug_format();
} }
# endif // _LIBCPP_STD_VER > 20 # endif // _LIBCPP_STD_VER >= 23
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_H #endif // _LIBCPP___FORMAT_FORMATTER_H

libcxx/include/__format/formatter_bool.h

Show All 27 Lines
#endif #endif
#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 #if _LIBCPP_STD_VER >= 20
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<bool, _CharT> { struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<bool, _CharT> {
public: public:
_LIBCPP_HIDE_FROM_ABI constexpr auto _LIBCPP_HIDE_FROM_ABI constexpr auto
parse(basic_format_parse_context<_CharT>& __parse_ctx) -> decltype(__parse_ctx.begin()) { parse(basic_format_parse_context<_CharT>& __parse_ctx) -> decltype(__parse_ctx.begin()) {
auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_integral); auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_integral);
__format_spec::__process_parsed_bool(__parser_); __format_spec::__process_parsed_bool(__parser_);
Show All 21 Lines default:
_LIBCPP_ASSERT(false, "The parse function should have validated the type"); _LIBCPP_ASSERT(false, "The parse function should have validated the type");
__libcpp_unreachable(); __libcpp_unreachable();
} }
} }
__format_spec::__parser<_CharT> __parser_; __format_spec::__parser<_CharT> __parser_;
}; };
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_BOOL_H #endif // _LIBCPP___FORMAT_FORMATTER_BOOL_H

libcxx/include/__format/formatter_char.h

Show All 22 Lines
#include <__type_traits/is_signed.h> #include <__type_traits/is_signed.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 #if _LIBCPP_STD_VER >= 20
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_char { struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_char {
public: public:
_LIBCPP_HIDE_FROM_ABI constexpr auto _LIBCPP_HIDE_FROM_ABI constexpr auto
parse(basic_format_parse_context<_CharT>& __parse_ctx) -> decltype(__parse_ctx.begin()) { parse(basic_format_parse_context<_CharT>& __parse_ctx) -> decltype(__parse_ctx.begin()) {
auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_integral); auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_integral);
__format_spec::__process_parsed_char(__parser_); __format_spec::__process_parsed_char(__parser_);
return __result; return __result;
} }
_LIBCPP_HIDE_FROM_ABI auto format(_CharT __value, auto& __ctx) const -> decltype(__ctx.out()) { _LIBCPP_HIDE_FROM_ABI auto format(_CharT __value, auto& __ctx) const -> decltype(__ctx.out()) {
if (__parser_.__type_ == __format_spec::__type::__default || __parser_.__type_ == __format_spec::__type::__char) if (__parser_.__type_ == __format_spec::__type::__default || __parser_.__type_ == __format_spec::__type::__char)
return __formatter::__format_char(__value, __ctx.out(), __parser_.__get_parsed_std_specifications(__ctx)); return __formatter::__format_char(__value, __ctx.out(), __parser_.__get_parsed_std_specifications(__ctx));
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
if (__parser_.__type_ == __format_spec::__type::__debug) if (__parser_.__type_ == __format_spec::__type::__debug)
return __formatter::__format_escaped_char(__value, __ctx.out(), __parser_.__get_parsed_std_specifications(__ctx)); return __formatter::__format_escaped_char(__value, __ctx.out(), __parser_.__get_parsed_std_specifications(__ctx));
# endif # endif
if constexpr (sizeof(_CharT) <= sizeof(int)) if constexpr (sizeof(_CharT) <= sizeof(int))
// Promotes _CharT to an integral type. This reduces the number of // Promotes _CharT to an integral type. This reduces the number of
// instantiations of __format_integer reducing code size. // instantiations of __format_integer reducing code size.
return __formatter::__format_integer( return __formatter::__format_integer(
static_cast<conditional_t<is_signed_v<_CharT>, int, unsigned>>(__value), static_cast<conditional_t<is_signed_v<_CharT>, int, unsigned>>(__value),
__ctx, __ctx,
__parser_.__get_parsed_std_specifications(__ctx)); __parser_.__get_parsed_std_specifications(__ctx));
else else
return __formatter::__format_integer(__value, __ctx, __parser_.__get_parsed_std_specifications(__ctx)); return __formatter::__format_integer(__value, __ctx, __parser_.__get_parsed_std_specifications(__ctx));
} }
_LIBCPP_HIDE_FROM_ABI auto format(char __value, auto& __ctx) const -> decltype(__ctx.out()) _LIBCPP_HIDE_FROM_ABI auto format(char __value, auto& __ctx) const -> decltype(__ctx.out())
requires(same_as<_CharT, wchar_t>) requires(same_as<_CharT, wchar_t>)
{ {
return format(static_cast<wchar_t>(__value), __ctx); return format(static_cast<wchar_t>(__value), __ctx);
} }
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr void set_debug_format() { __parser_.__type_ = __format_spec::__type::__debug; } _LIBCPP_HIDE_FROM_ABI constexpr void set_debug_format() { __parser_.__type_ = __format_spec::__type::__debug; }
# endif # endif
__format_spec::__parser<_CharT> __parser_; __format_spec::__parser<_CharT> __parser_;
}; };
template <> template <>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<char, char> : public __formatter_char<char> {}; struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<char, char> : public __formatter_char<char> {};
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS # ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<char, wchar_t> : public __formatter_char<wchar_t> {}; struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<char, wchar_t> : public __formatter_char<wchar_t> {};
template <> template <>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<wchar_t, wchar_t> : public __formatter_char<wchar_t> { struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<wchar_t, wchar_t> : public __formatter_char<wchar_t> {
}; };
# endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS # endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_CHAR_H #endif // _LIBCPP___FORMAT_FORMATTER_CHAR_H

libcxx/include/__format/formatter_floating_point.h

Show All 37 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 #if _LIBCPP_STD_VER >= 20
namespace __formatter { namespace __formatter {
template <floating_point _Tp> template <floating_point _Tp>
_LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last, _Tp __value) { _LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last, _Tp __value) {
to_chars_result __r = _VSTD::to_chars(__first, __last, __value); to_chars_result __r = _VSTD::to_chars(__first, __last, __value);
_LIBCPP_ASSERT(__r.ec == errc(0), "Internal buffer too small"); _LIBCPP_ASSERT(__r.ec == errc(0), "Internal buffer too small");
return __r.ptr; return __r.ptr;
▲ Show 20 Lines • Show All 688 Lines • ▼ Show 20 Linesstruct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<float, _CharT>
: public __formatter_floating_point<_CharT> {}; : public __formatter_floating_point<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<double, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<double, _CharT>
: public __formatter_floating_point<_CharT> {}; : public __formatter_floating_point<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long double, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<long double, _CharT>
: public __formatter_floating_point<_CharT> {}; : public __formatter_floating_point<_CharT> {};
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H #endif // _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H

libcxx/include/__format/formatter_integer.h

Show All 22 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 #if _LIBCPP_STD_VER >= 20
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_integer { struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_integer {
public: public:
_LIBCPP_HIDE_FROM_ABI constexpr auto _LIBCPP_HIDE_FROM_ABI constexpr auto
parse(basic_format_parse_context<_CharT>& __parse_ctx) -> decltype(__parse_ctx.begin()) { parse(basic_format_parse_context<_CharT>& __parse_ctx) -> decltype(__parse_ctx.begin()) {
auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_integral); auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_integral);
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned long long, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<unsigned long long, _CharT>
: public __formatter_integer<_CharT> {}; : public __formatter_integer<_CharT> {};
# ifndef _LIBCPP_HAS_NO_INT128 # ifndef _LIBCPP_HAS_NO_INT128
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<__uint128_t, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<__uint128_t, _CharT>
: public __formatter_integer<_CharT> {}; : public __formatter_integer<_CharT> {};
# endif # endif
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_INTEGER_H #endif // _LIBCPP___FORMAT_FORMATTER_INTEGER_H

libcxx/include/__format/formatter_integral.h

Show All 30 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 #if _LIBCPP_STD_VER >= 20
namespace __formatter { namespace __formatter {
// //
// Generic // Generic
// //
_LIBCPP_HIDE_FROM_ABI inline char* __insert_sign(char* __buf, bool __negative, __format_spec::__sign __sign) { _LIBCPP_HIDE_FROM_ABI inline char* __insert_sign(char* __buf, bool __negative, __format_spec::__sign __sign) {
▲ Show 20 Lines • Show All 301 Lines • ▼ Show 20 Lines
# endif # endif
basic_string_view<_CharT> __str = basic_string_view<_CharT> __str =
__value ? __formatter::__bool_strings<_CharT>::__true : __formatter::__bool_strings<_CharT>::__false; __value ? __formatter::__bool_strings<_CharT>::__true : __formatter::__bool_strings<_CharT>::__false;
return __formatter::__write(__str.begin(), __str.end(), __ctx.out(), __specs); return __formatter::__write(__str.begin(), __str.end(), __ctx.out(), __specs);
} }
} // namespace __formatter } // namespace __formatter
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H #endif // _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H

libcxx/include/__format/formatter_output.h

Show All 33 Lines
#include <string_view> #include <string_view>
#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 #if _LIBCPP_STD_VER >= 20
namespace __formatter { namespace __formatter {
_LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char __c) { _LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char __c) {
switch (__c) { switch (__c) {
case 'a': case 'a':
return 'A'; return 'A';
case 'b': case 'b':
▲ Show 20 Lines • Show All 328 Lines • ▼ Show 20 Lines_LIBCPP_HIDE_FROM_ABI auto __write_string(
if (!__specs.__has_precision()) if (!__specs.__has_precision())
return __formatter::__write_string_no_precision(__str, _VSTD::move(__out_it), __specs); return __formatter::__write_string_no_precision(__str, _VSTD::move(__out_it), __specs);
int __size = __formatter::__truncate(__str, __specs.__precision_); int __size = __formatter::__truncate(__str, __specs.__precision_);
return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __specs, __size); return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __specs, __size);
} }
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
struct __nul_terminator {}; struct __nul_terminator {};
template <class _CharT> template <class _CharT>
_LIBCPP_HIDE_FROM_ABI bool operator==(const _CharT* __cstr, __nul_terminator) { _LIBCPP_HIDE_FROM_ABI bool operator==(const _CharT* __cstr, __nul_terminator) {
return *__cstr == _CharT('\0'); return *__cstr == _CharT('\0');
} }
▲ Show 20 Lines • Show All 160 Lines • ▼ Show 20 Lines__format_escaped_string(basic_string_view<_CharT> __values,
__format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) { __format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) {
basic_string<_CharT> __str; basic_string<_CharT> __str;
__str += _CharT('"'); __str += _CharT('"');
__formatter::__escape(__str, __values, __escape_quotation_mark::__double_quote); __formatter::__escape(__str, __values, __escape_quotation_mark::__double_quote);
__str += _CharT('"'); __str += _CharT('"');
return __formatter::__write_string(basic_string_view{__str}, _VSTD::move(__out_it), __specs); return __formatter::__write_string(basic_string_view{__str}, _VSTD::move(__out_it), __specs);
} }
# endif // _LIBCPP_STD_VER > 20 # endif // _LIBCPP_STD_VER >= 23
} // namespace __formatter } // namespace __formatter
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_OUTPUT_H #endif // _LIBCPP___FORMAT_FORMATTER_OUTPUT_H

libcxx/include/__format/formatter_pointer.h

Show All 21 Lines
#include <cstdint> #include <cstdint>
#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 #if _LIBCPP_STD_VER >= 20
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS __formatter_pointer { struct _LIBCPP_TEMPLATE_VIS __formatter_pointer {
public: public:
constexpr __formatter_pointer() { __parser_.__alignment_ = __format_spec::__alignment::__right; } constexpr __formatter_pointer() { __parser_.__alignment_ = __format_spec::__alignment::__right; }
_LIBCPP_HIDE_FROM_ABI constexpr auto _LIBCPP_HIDE_FROM_ABI constexpr auto
parse(basic_format_parse_context<_CharT>& __parse_ctx) -> decltype(__parse_ctx.begin()) { parse(basic_format_parse_context<_CharT>& __parse_ctx) -> decltype(__parse_ctx.begin()) {
Show All 22 Linesstruct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<nullptr_t, _CharT>
: public __formatter_pointer<_CharT> {}; : public __formatter_pointer<_CharT> {};
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<void*, _CharT> : public __formatter_pointer<_CharT> { struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<void*, _CharT> : public __formatter_pointer<_CharT> {
}; };
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<const void*, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<const void*, _CharT>
: public __formatter_pointer<_CharT> {}; : public __formatter_pointer<_CharT> {};
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_POINTER_H #endif // _LIBCPP___FORMAT_FORMATTER_POINTER_H

libcxx/include/__format/formatter_string.h

Show All 21 Lines
#include <string_view> #include <string_view>
#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 #if _LIBCPP_STD_VER >= 20
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS __formatter_string { struct _LIBCPP_TEMPLATE_VIS __formatter_string {
public: public:
_LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx) _LIBCPP_HIDE_FROM_ABI constexpr auto parse(basic_format_parse_context<_CharT>& __parse_ctx)
-> decltype(__parse_ctx.begin()) { -> decltype(__parse_ctx.begin()) {
auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_string); auto __result = __parser_.__parse(__parse_ctx, __format_spec::__fields_string);
__format_spec::__process_display_type_string(__parser_.__type_); __format_spec::__process_display_type_string(__parser_.__type_);
return __result; return __result;
} }
_LIBCPP_HIDE_FROM_ABI auto format(basic_string_view<_CharT> __str, auto& __ctx) const -> decltype(__ctx.out()) { _LIBCPP_HIDE_FROM_ABI auto format(basic_string_view<_CharT> __str, auto& __ctx) const -> decltype(__ctx.out()) {
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
if (__parser_.__type_ == __format_spec::__type::__debug) if (__parser_.__type_ == __format_spec::__type::__debug)
return __formatter::__format_escaped_string(__str, __ctx.out(), __parser_.__get_parsed_std_specifications(__ctx)); return __formatter::__format_escaped_string(__str, __ctx.out(), __parser_.__get_parsed_std_specifications(__ctx));
# endif # endif
return __formatter::__write_string(__str, __ctx.out(), __parser_.__get_parsed_std_specifications(__ctx)); return __formatter::__write_string(__str, __ctx.out(), __parser_.__get_parsed_std_specifications(__ctx));
} }
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr void set_debug_format() { __parser_.__type_ = __format_spec::__type::__debug; } _LIBCPP_HIDE_FROM_ABI constexpr void set_debug_format() { __parser_.__type_ = __format_spec::__type::__debug; }
# endif # endif
__format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__left}; __format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__left};
}; };
// Formatter const char*. // Formatter const char*.
template <__fmt_char_type _CharT> template <__fmt_char_type _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<const _CharT*, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<const _CharT*, _CharT>
: public __formatter_string<_CharT> { : public __formatter_string<_CharT> {
using _Base = __formatter_string<_CharT>; using _Base = __formatter_string<_CharT>;
_LIBCPP_HIDE_FROM_ABI auto format(const _CharT* __str, auto& __ctx) const -> decltype(__ctx.out()) { _LIBCPP_HIDE_FROM_ABI auto format(const _CharT* __str, auto& __ctx) const -> decltype(__ctx.out()) {
_LIBCPP_ASSERT(__str, "The basic_format_arg constructor should have " _LIBCPP_ASSERT(__str, "The basic_format_arg constructor should have "
"prevented an invalid pointer."); "prevented an invalid pointer.");
__format_spec::__parsed_specifications<_CharT> __specs = _Base::__parser_.__get_parsed_std_specifications(__ctx); __format_spec::__parsed_specifications<_CharT> __specs = _Base::__parser_.__get_parsed_std_specifications(__ctx);
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
if (_Base::__parser_.__type_ == __format_spec::__type::__debug) if (_Base::__parser_.__type_ == __format_spec::__type::__debug)
return __formatter::__format_escaped_string(basic_string_view<_CharT>{__str}, __ctx.out(), __specs); return __formatter::__format_escaped_string(basic_string_view<_CharT>{__str}, __ctx.out(), __specs);
# endif # endif
// When using a center or right alignment and the width option the length // When using a center or right alignment and the width option the length
// of __str must be known to add the padding upfront. This case is handled // of __str must be known to add the padding upfront. This case is handled
// by the base class by converting the argument to a basic_string_view. // by the base class by converting the argument to a basic_string_view.
// //
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Linesstruct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<basic_string_view<_CharT, _Traits>, _CharT>
_LIBCPP_HIDE_FROM_ABI auto format(basic_string_view<_CharT, _Traits> __str, auto& __ctx) const _LIBCPP_HIDE_FROM_ABI auto format(basic_string_view<_CharT, _Traits> __str, auto& __ctx) const
-> decltype(__ctx.out()) { -> decltype(__ctx.out()) {
// Drop _Traits to have one std::basic_string_view formatter. // Drop _Traits to have one std::basic_string_view formatter.
return _Base::format(basic_string_view<_CharT>(__str.data(), __str.size()), __ctx); return _Base::format(basic_string_view<_CharT>(__str.data(), __str.size()), __ctx);
} }
}; };
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_STRING_H #endif // _LIBCPP___FORMAT_FORMATTER_STRING_H

libcxx/include/__format/formatter_tuple.h

Show All 30 Lines
#include <tuple> #include <tuple>
#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 > 20 #if _LIBCPP_STD_VER >= 23
template <__fmt_char_type _CharT, class _Tuple, formattable<_CharT>... _Args> template <__fmt_char_type _CharT, class _Tuple, formattable<_CharT>... _Args>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_tuple { struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __formatter_tuple {
_LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) { _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) {
__separator_ = __separator; __separator_ = __separator;
} }
_LIBCPP_HIDE_FROM_ABI constexpr void _LIBCPP_HIDE_FROM_ABI constexpr void
set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) { set_brackets(basic_string_view<_CharT> __opening_bracket, basic_string_view<_CharT> __closing_bracket) {
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines
template <__fmt_char_type _CharT, formattable<_CharT>... _Args> template <__fmt_char_type _CharT, formattable<_CharT>... _Args>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<pair<_Args...>, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<pair<_Args...>, _CharT>
: public __formatter_tuple<_CharT, pair<_Args...>, _Args...> {}; : public __formatter_tuple<_CharT, pair<_Args...>, _Args...> {};
template <__fmt_char_type _CharT, formattable<_CharT>... _Args> template <__fmt_char_type _CharT, formattable<_CharT>... _Args>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<tuple<_Args...>, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<tuple<_Args...>, _CharT>
: public __formatter_tuple<_CharT, tuple<_Args...>, _Args...> {}; : public __formatter_tuple<_CharT, tuple<_Args...>, _Args...> {};
#endif //_LIBCPP_STD_VER > 20 #endif //_LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMATTER_TUPLE_H #endif // _LIBCPP___FORMAT_FORMATTER_TUPLE_H

libcxx/include/__format/parser_std_format_spec.h

Show All 39 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 #if _LIBCPP_STD_VER >= 20
namespace __format_spec { namespace __format_spec {
template <contiguous_iterator _Iterator> template <contiguous_iterator _Iterator>
_LIBCPP_HIDE_FROM_ABI constexpr __format::__parse_number_result<_Iterator> _LIBCPP_HIDE_FROM_ABI constexpr __format::__parse_number_result<_Iterator>
__parse_arg_id(_Iterator __begin, _Iterator __end, auto& __parse_ctx) { __parse_arg_id(_Iterator __begin, _Iterator __end, auto& __parse_ctx) {
using _CharT = iter_value_t<_Iterator>; using _CharT = iter_value_t<_Iterator>;
// This function is a wrapper to call the real parser. But it does the // This function is a wrapper to call the real parser. But it does the
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Linesinline constexpr __fields __fields_floating_point{
.__alternate_form_ = true, .__alternate_form_ = true,
.__zero_padding_ = true, .__zero_padding_ = true,
.__precision_ = true, .__precision_ = true,
.__locale_specific_form_ = true, .__locale_specific_form_ = true,
.__type_ = true}; .__type_ = true};
inline constexpr __fields __fields_string{.__precision_ = true, .__type_ = true}; inline constexpr __fields __fields_string{.__precision_ = true, .__type_ = true};
inline constexpr __fields __fields_pointer{.__type_ = true}; inline constexpr __fields __fields_pointer{.__type_ = true};
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
inline constexpr __fields __fields_tuple{.__type_ = false, .__allow_colon_in_fill_ = true}; inline constexpr __fields __fields_tuple{.__type_ = false, .__allow_colon_in_fill_ = true};
inline constexpr __fields __fields_range{.__type_ = false, .__allow_colon_in_fill_ = true}; inline constexpr __fields __fields_range{.__type_ = false, .__allow_colon_in_fill_ = true};
# endif # endif
enum class _LIBCPP_ENUM_VIS __alignment : uint8_t { enum class _LIBCPP_ENUM_VIS __alignment : uint8_t {
/// No alignment is set in the format string. /// No alignment is set in the format string.
__default, __default,
__left, __left,
▲ Show 20 Lines • Show All 425 Lines • ▼ Show 20 Lines case 'p':
__type_ = __type::__pointer; __type_ = __type::__pointer;
break; break;
case 's': case 's':
__type_ = __type::__string; __type_ = __type::__string;
break; break;
case 'x': case 'x':
__type_ = __type::__hexadecimal_lower_case; __type_ = __type::__hexadecimal_lower_case;
break; break;
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
case '?': case '?':
__type_ = __type::__debug; __type_ = __type::__debug;
break; break;
# endif # endif
default: default:
return; return;
} }
++__begin; ++__begin;
▲ Show 20 Lines • Show All 360 Lines • ▼ Show 20 Lines__estimate_column_width(basic_string_view<_CharT> __str, size_t __maximum, __column_width_rounding) noexcept {
size_t __width_ = _VSTD::min(__str.size(), __maximum); size_t __width_ = _VSTD::min(__str.size(), __maximum);
return {__width_, __str.begin() + __width_}; return {__width_, __str.begin() + __width_};
} }
# endif // !defined(_LIBCPP_HAS_NO_UNICODE) # endif // !defined(_LIBCPP_HAS_NO_UNICODE)
} // namespace __format_spec } // namespace __format_spec
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H #endif // _LIBCPP___FORMAT_PARSER_STD_FORMAT_SPEC_H

libcxx/include/__format/range_default_formatter.h

Show All 23 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__type_traits/remove_cvref.h> #include <__type_traits/remove_cvref.h>
#include <__utility/pair.h> #include <__utility/pair.h>
#include <string_view> #include <string_view>
#include <tuple> #include <tuple>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _Rp, class _CharT> template <class _Rp, class _CharT>
concept __const_formattable_range = concept __const_formattable_range =
ranges::input_range<const _Rp> && formattable<ranges::range_reference_t<const _Rp>, _CharT>; ranges::input_range<const _Rp> && formattable<ranges::range_reference_t<const _Rp>, _CharT>;
template <class _Rp, class _CharT> template <class _Rp, class _CharT>
using __fmt_maybe_const = conditional_t<__const_formattable_range<_Rp, _CharT>, const _Rp, _Rp>; using __fmt_maybe_const = conditional_t<__const_formattable_range<_Rp, _CharT>, const _Rp, _Rp>;
▲ Show 20 Lines • Show All 148 Lines • ▼ Show 20 Linesstruct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT __range_default_formatter<_Kp, _Rp, _CharT> {
__range_default_formatter() = delete; // TODO FMT Implement __range_default_formatter() = delete; // TODO FMT Implement
}; };
template <ranges::input_range _Rp, class _CharT> template <ranges::input_range _Rp, class _CharT>
requires(format_kind<_Rp> != range_format::disabled && formattable<ranges::range_reference_t<_Rp>, _CharT>) requires(format_kind<_Rp> != range_format::disabled && formattable<ranges::range_reference_t<_Rp>, _CharT>)
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<_Rp, _CharT> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<_Rp, _CharT>
: __range_default_formatter<format_kind<_Rp>, _Rp, _CharT> {}; : __range_default_formatter<format_kind<_Rp>, _Rp, _CharT> {};
#endif //_LIBCPP_STD_VER > 20 #endif //_LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H #endif // _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H

libcxx/include/__format/range_formatter.h

Show All 30 Lines
#include <__ranges/concepts.h> #include <__ranges/concepts.h>
#include <__ranges/data.h> #include <__ranges/data.h>
#include <__ranges/size.h> #include <__ranges/size.h>
#include <__type_traits/remove_cvref.h> #include <__type_traits/remove_cvref.h>
#include <string_view> #include <string_view>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _Tp, class _CharT = char> template <class _Tp, class _CharT = char>
requires same_as<remove_cvref_t<_Tp>, _Tp> && formattable<_Tp, _CharT> requires same_as<remove_cvref_t<_Tp>, _Tp> && formattable<_Tp, _CharT>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT range_formatter { struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT range_formatter {
_LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) { _LIBCPP_HIDE_FROM_ABI constexpr void set_separator(basic_string_view<_CharT> __separator) {
__separator_ = __separator; __separator_ = __separator;
} }
_LIBCPP_HIDE_FROM_ABI constexpr void _LIBCPP_HIDE_FROM_ABI constexpr void
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Linesprivate:
} }
formatter<_Tp, _CharT> __underlying_; formatter<_Tp, _CharT> __underlying_;
basic_string_view<_CharT> __separator_ = _LIBCPP_STATICALLY_WIDEN(_CharT, ", "); basic_string_view<_CharT> __separator_ = _LIBCPP_STATICALLY_WIDEN(_CharT, ", ");
basic_string_view<_CharT> __opening_bracket_ = _LIBCPP_STATICALLY_WIDEN(_CharT, "["); basic_string_view<_CharT> __opening_bracket_ = _LIBCPP_STATICALLY_WIDEN(_CharT, "[");
basic_string_view<_CharT> __closing_bracket_ = _LIBCPP_STATICALLY_WIDEN(_CharT, "]"); basic_string_view<_CharT> __closing_bracket_ = _LIBCPP_STATICALLY_WIDEN(_CharT, "]");
}; };
#endif //_LIBCPP_STD_VER > 20 #endif //_LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_RANGE_FORMATTER_H #endif // _LIBCPP___FORMAT_RANGE_FORMATTER_H

libcxx/include/__format/unicode.h

Show All 21 Lines
#include <string_view> #include <string_view>
#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 #if _LIBCPP_STD_VER >= 20
namespace __unicode { namespace __unicode {
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
/// The result of consuming a code point using P2286' semantics /// The result of consuming a code point using P2286' semantics
/// ///
/// TODO FMT Combine __consume and __consume_p2286 in one function. /// TODO FMT Combine __consume and __consume_p2286 in one function.
struct __consume_p2286_result { struct __consume_p2286_result {
// A size of 0 means well formed. This to differenciate between // A size of 0 means well formed. This to differenciate between
// a valid code point and a code unit that's invalid like 0b11111xxx. // a valid code point and a code unit that's invalid like 0b11111xxx.
int __ill_formed_size; int __ill_formed_size;
// If well formed the consumed code point. // If well formed the consumed code point.
// Otherwise the ill-formed code units as unsigned 8-bit values. They are // Otherwise the ill-formed code units as unsigned 8-bit values. They are
// stored in reverse order, to make it easier to extract the values. // stored in reverse order, to make it easier to extract the values.
char32_t __value; char32_t __value;
}; };
# endif // _LIBCPP_STD_VER > 20 # endif // _LIBCPP_STD_VER >= 23
# ifndef _LIBCPP_HAS_NO_UNICODE # ifndef _LIBCPP_HAS_NO_UNICODE
/// Implements the grapheme cluster boundary rules /// Implements the grapheme cluster boundary rules
/// ///
/// These rules are used to implement format's width estimation as stated in /// These rules are used to implement format's width estimation as stated in
/// [format.string.std]/11 /// [format.string.std]/11
/// ///
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines _LIBCPP_HIDE_FROM_ABI constexpr char32_t __consume() noexcept {
} }
// An invalid number of leading ones can be garbage or a code unit in the // An invalid number of leading ones can be garbage or a code unit in the
// middle of a code point. By consuming one code unit the parser may get // middle of a code point. By consuming one code unit the parser may get
// "in sync" after a few code units. // "in sync" after a few code units.
++__first_; ++__first_;
return __replacement_character; return __replacement_character;
} }
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr __consume_p2286_result __consume_p2286() noexcept { _LIBCPP_HIDE_FROM_ABI constexpr __consume_p2286_result __consume_p2286() noexcept {
_LIBCPP_ASSERT(__first_ != __last_, "can't move beyond the end of input"); _LIBCPP_ASSERT(__first_ != __last_, "can't move beyond the end of input");
// Based on the number of leading 1 bits the number of code units in the // Based on the number of leading 1 bits the number of code units in the
// code point can be determined. See // code point can be determined. See
// https://en.wikipedia.org/wiki/UTF-8#Encoding // https://en.wikipedia.org/wiki/UTF-8#Encoding
switch (std::countl_one(static_cast<unsigned char>(*__first_))) { switch (std::countl_one(static_cast<unsigned char>(*__first_))) {
case 0: case 0:
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines case 4:
} }
break; break;
} }
// An invalid number of leading ones can be garbage or a code unit in the // An invalid number of leading ones can be garbage or a code unit in the
// middle of a code point. By consuming one code unit the parser may get // middle of a code point. By consuming one code unit the parser may get
// "in sync" after a few code units. // "in sync" after a few code units.
return {1, static_cast<unsigned char>(*__first_++)}; return {1, static_cast<unsigned char>(*__first_++)};
} }
# endif // _LIBCPP_STD_VER > 20 # endif // _LIBCPP_STD_VER >= 23
private: private:
_Iterator __first_; _Iterator __first_;
_Iterator __last_; _Iterator __last_;
}; };
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS # ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_HIDE_FROM_ABI constexpr bool __is_surrogate_pair_high(wchar_t __value) { _LIBCPP_HIDE_FROM_ABI constexpr bool __is_surrogate_pair_high(wchar_t __value) {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines if constexpr (sizeof(wchar_t) == 2) {
if (__result > 0x10FFFF) [[unlikely]] if (__result > 0x10FFFF) [[unlikely]]
return __replacement_character; return __replacement_character;
return __result; return __result;
} else { } else {
__libcpp_unreachable(); __libcpp_unreachable();
} }
} }
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr __consume_p2286_result __consume_p2286() noexcept { _LIBCPP_HIDE_FROM_ABI constexpr __consume_p2286_result __consume_p2286() noexcept {
_LIBCPP_ASSERT(__first_ != __last_, "can't move beyond the end of input"); _LIBCPP_ASSERT(__first_ != __last_, "can't move beyond the end of input");
char32_t __result = *__first_++; char32_t __result = *__first_++;
if constexpr (sizeof(wchar_t) == 2) { if constexpr (sizeof(wchar_t) == 2) {
// https://en.wikipedia.org/wiki/UTF-16#U+D800_to_U+DFFF // https://en.wikipedia.org/wiki/UTF-16#U+D800_to_U+DFFF
if (__is_surrogate_pair_high(__result)) { if (__is_surrogate_pair_high(__result)) {
// Malformed Unicode. // Malformed Unicode.
Show All 9 Lines if constexpr (sizeof(wchar_t) == 2) {
return {1, __result}; return {1, __result};
} else { } else {
if (__result > 0x10FFFF) [[unlikely]] if (__result > 0x10FFFF) [[unlikely]]
return {1, __result}; return {1, __result};
} }
return {0, __result}; return {0, __result};
} }
# endif // _LIBCPP_STD_VER > 20 # endif // _LIBCPP_STD_VER >= 23
private: private:
_Iterator __first_; _Iterator __first_;
_Iterator __last_; _Iterator __last_;
}; };
# endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS # endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
_LIBCPP_HIDE_FROM_ABI constexpr bool __at_extended_grapheme_cluster_break( _LIBCPP_HIDE_FROM_ABI constexpr bool __at_extended_grapheme_cluster_break(
▲ Show 20 Lines • Show All 163 Lines • ▼ Show 20 Linespublic:
_LIBCPP_HIDE_FROM_ABI constexpr bool __at_end() const noexcept { return __first_ == __last_; } _LIBCPP_HIDE_FROM_ABI constexpr bool __at_end() const noexcept { return __first_ == __last_; }
_LIBCPP_HIDE_FROM_ABI constexpr _Iterator __position() const noexcept { return __first_; } _LIBCPP_HIDE_FROM_ABI constexpr _Iterator __position() const noexcept { return __first_; }
_LIBCPP_HIDE_FROM_ABI constexpr char32_t __consume() noexcept { _LIBCPP_HIDE_FROM_ABI constexpr char32_t __consume() noexcept {
_LIBCPP_ASSERT(__first_ != __last_, "can't move beyond the end of input"); _LIBCPP_ASSERT(__first_ != __last_, "can't move beyond the end of input");
return *__first_++; return *__first_++;
} }
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr __consume_p2286_result __consume_p2286() noexcept { _LIBCPP_HIDE_FROM_ABI constexpr __consume_p2286_result __consume_p2286() noexcept {
_LIBCPP_ASSERT(__first_ != __last_, "can't move beyond the end of input"); _LIBCPP_ASSERT(__first_ != __last_, "can't move beyond the end of input");
return {0, std::make_unsigned_t<_CharT>(*__first_++)}; return {0, std::make_unsigned_t<_CharT>(*__first_++)};
} }
# endif // _LIBCPP_STD_VER > 20 # endif // _LIBCPP_STD_VER >= 23
private: private:
_Iterator __first_; _Iterator __first_;
_Iterator __last_; _Iterator __last_;
}; };
# endif // _LIBCPP_HAS_NO_UNICODE # endif // _LIBCPP_HAS_NO_UNICODE
} // namespace __unicode } // namespace __unicode
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_UNICODE_H #endif // _LIBCPP___FORMAT_UNICODE_H

libcxx/include/__functional/bind.h

Show All 24 Lines
template<class _Tp> template<class _Tp>
struct is_bind_expression : _If< struct is_bind_expression : _If<
_IsSame<_Tp, __remove_cvref_t<_Tp> >::value, _IsSame<_Tp, __remove_cvref_t<_Tp> >::value,
false_type, false_type,
is_bind_expression<__remove_cvref_t<_Tp> > is_bind_expression<__remove_cvref_t<_Tp> >
> {}; > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value; inline constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value;
#endif #endif
template<class _Tp> template<class _Tp>
struct is_placeholder : _If< struct is_placeholder : _If<
_IsSame<_Tp, __remove_cvref_t<_Tp> >::value, _IsSame<_Tp, __remove_cvref_t<_Tp> >::value,
integral_constant<int, 0>, integral_constant<int, 0>,
is_placeholder<__remove_cvref_t<_Tp> > is_placeholder<__remove_cvref_t<_Tp> >
> {}; > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value; inline constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value;
#endif #endif
namespace placeholders namespace placeholders
{ {
template <int _Np> struct __ph {}; template <int _Np> struct __ph {};
▲ Show 20 Lines • Show All 336 Lines • Show Last 20 Lines

libcxx/include/__functional/bind_back.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 #if _LIBCPP_STD_VER >= 20
template <size_t _NBound, class = make_index_sequence<_NBound>> template <size_t _NBound, class = make_index_sequence<_NBound>>
struct __bind_back_op; struct __bind_back_op;
template <size_t _NBound, size_t ..._Ip> template <size_t _NBound, size_t ..._Ip>
struct __bind_back_op<_NBound, index_sequence<_Ip...>> { struct __bind_back_op<_NBound, index_sequence<_Ip...>> {
template <class _Fn, class _BoundArgs, class... _Args> template <class _Fn, class _BoundArgs, class... _Args>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&& __f, _BoundArgs&& __bound_args, _Args&&... __args) const _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&& __f, _BoundArgs&& __bound_args, _Args&&... __args) const
Show All 16 Linestemplate <class _Fn, class ..._Args, class = enable_if_t<
>::value >::value
>> >>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr auto __bind_back(_Fn&& __f, _Args&&... __args) constexpr auto __bind_back(_Fn&& __f, _Args&&... __args)
noexcept(noexcept(__bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)))) noexcept(noexcept(__bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...))))
-> decltype( __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...))) -> decltype( __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)))
{ return __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); } { return __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_BIND_BACK_H #endif // _LIBCPP___FUNCTIONAL_BIND_BACK_H

libcxx/include/__functional/bind_front.h

Show All 16 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 #if _LIBCPP_STD_VER >= 20
struct __bind_front_op { struct __bind_front_op {
template <class ..._Args> template <class ..._Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()(_Args&& ...__args) const constexpr auto operator()(_Args&& ...__args) const
noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Args>(__args)...))) noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Args>(__args)...)))
-> decltype( _VSTD::invoke(_VSTD::forward<_Args>(__args)...)) -> decltype( _VSTD::invoke(_VSTD::forward<_Args>(__args)...))
{ return _VSTD::invoke(_VSTD::forward<_Args>(__args)...); } { return _VSTD::invoke(_VSTD::forward<_Args>(__args)...); }
Show All 12 Lines _And<
is_move_constructible<decay_t<_Args>>... is_move_constructible<decay_t<_Args>>...
>::value >::value
>> >>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr auto bind_front(_Fn&& __f, _Args&&... __args) { constexpr auto bind_front(_Fn&& __f, _Args&&... __args) {
return __bind_front_t<decay_t<_Fn>, decay_t<_Args>...>(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...); return __bind_front_t<decay_t<_Fn>, decay_t<_Args>...>(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_BIND_FRONT_H #endif // _LIBCPP___FUNCTIONAL_BIND_FRONT_H

libcxx/include/__functional/boyer_moore_searcher.h

Show All 19 Lines
#include <__iterator/distance.h> #include <__iterator/distance.h>
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.h>
#include <__memory/shared_ptr.h> #include <__memory/shared_ptr.h>
#include <__utility/pair.h> #include <__utility/pair.h>
#include <array> #include <array>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Key, template <class _Key,
class _Value, class _Value,
▲ Show 20 Lines • Show All 268 Lines • ▼ Show 20 Linesprivate:
} }
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(boyer_moore_horspool_searcher); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(boyer_moore_horspool_searcher);
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#endif // _LIBCPP___FUNCTIONAL_BOYER_MOORE_SEARCHER_H #endif // _LIBCPP___FUNCTIONAL_BOYER_MOORE_SEARCHER_H

libcxx/include/__functional/compose.h

Show All 16 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 #if _LIBCPP_STD_VER >= 20
struct __compose_op { struct __compose_op {
template<class _Fn1, class _Fn2, class ..._Args> template<class _Fn1, class _Fn2, class ..._Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr auto operator()(_Fn1&& __f1, _Fn2&& __f2, _Args&&... __args) const constexpr auto operator()(_Fn1&& __f1, _Fn2&& __f2, _Args&&... __args) const
noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...)))) noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...))))
-> decltype( _VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...))) -> decltype( _VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...)))
{ return _VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...)); } { return _VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...)); }
}; };
template <class _Fn1, class _Fn2> template <class _Fn1, class _Fn2>
struct __compose_t : __perfect_forward<__compose_op, _Fn1, _Fn2> { struct __compose_t : __perfect_forward<__compose_op, _Fn1, _Fn2> {
using __perfect_forward<__compose_op, _Fn1, _Fn2>::__perfect_forward; using __perfect_forward<__compose_op, _Fn1, _Fn2>::__perfect_forward;
}; };
template <class _Fn1, class _Fn2> template <class _Fn1, class _Fn2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr auto __compose(_Fn1&& __f1, _Fn2&& __f2) constexpr auto __compose(_Fn1&& __f1, _Fn2&& __f2)
noexcept(noexcept(__compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2)))) noexcept(noexcept(__compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2))))
-> decltype( __compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2))) -> decltype( __compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2)))
{ return __compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2)); } { return __compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2)); }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_COMPOSE_H #endif // _LIBCPP___FUNCTIONAL_COMPOSE_H

libcxx/include/__functional/default_searcher.h

Show All 17 Lines
#include <__utility/pair.h> #include <__utility/pair.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 > 14 #if _LIBCPP_STD_VER >= 17
// default searcher // default searcher
template<class _ForwardIterator, class _BinaryPredicate = equal_to<>> template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
class _LIBCPP_TEMPLATE_VIS default_searcher { class _LIBCPP_TEMPLATE_VIS default_searcher {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
default_searcher(_ForwardIterator __f, _ForwardIterator __l, default_searcher(_ForwardIterator __f, _ForwardIterator __l,
_BinaryPredicate __p = _BinaryPredicate()) _BinaryPredicate __p = _BinaryPredicate())
Show All 10 Lines
private: private:
_ForwardIterator __first_; _ForwardIterator __first_;
_ForwardIterator __last_; _ForwardIterator __last_;
_BinaryPredicate __pred_; _BinaryPredicate __pred_;
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(default_searcher); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(default_searcher);
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_DEFAULT_SEARCHER_H #endif // _LIBCPP___FUNCTIONAL_DEFAULT_SEARCHER_H

libcxx/include/__functional/hash.h

Show First 20 Lines • Show All 634 Lines • ▼ Show 20 Linesstruct _LIBCPP_TEMPLATE_VIS __enum_hash<_Tp, false> {
__enum_hash& operator=(__enum_hash const&) = delete; __enum_hash& operator=(__enum_hash const&) = delete;
}; };
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS hash : public __enum_hash<_Tp> struct _LIBCPP_TEMPLATE_VIS hash : public __enum_hash<_Tp>
{ {
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<nullptr_t> struct _LIBCPP_TEMPLATE_VIS hash<nullptr_t>
: public __unary_function<nullptr_t, size_t> : public __unary_function<nullptr_t, size_t>
{ {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
size_t operator()(nullptr_t) const _NOEXCEPT { size_t operator()(nullptr_t) const _NOEXCEPT {
return 662607004ull; return 662607004ull;
Show All 10 Lines
>; >;
template <class _Key, class _Hash = hash<_Key> > template <class _Key, class _Hash = hash<_Key> >
using __has_enabled_hash _LIBCPP_NODEBUG = integral_constant<bool, using __has_enabled_hash _LIBCPP_NODEBUG = integral_constant<bool,
__check_hash_requirements<_Key, _Hash>::value && __check_hash_requirements<_Key, _Hash>::value &&
is_default_constructible<_Hash>::value is_default_constructible<_Hash>::value
>; >;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Type, class> template <class _Type, class>
using __enable_hash_helper_imp _LIBCPP_NODEBUG = _Type; using __enable_hash_helper_imp _LIBCPP_NODEBUG = _Type;
template <class _Type, class ..._Keys> template <class _Type, class ..._Keys>
using __enable_hash_helper _LIBCPP_NODEBUG = __enable_hash_helper_imp<_Type, using __enable_hash_helper _LIBCPP_NODEBUG = __enable_hash_helper_imp<_Type,
typename enable_if<__all<__has_enabled_hash<_Keys>::value...>::value>::type typename enable_if<__all<__has_enabled_hash<_Keys>::value...>::value>::type
>; >;
#else #else
Show All 9 Lines

libcxx/include/__functional/identity.h

Show All 22 Linesstruct __identity {
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD _LIBCPP_CONSTEXPR _Tp&& operator()(_Tp&& __t) const _NOEXCEPT { _LIBCPP_NODISCARD _LIBCPP_CONSTEXPR _Tp&& operator()(_Tp&& __t) const _NOEXCEPT {
return std::forward<_Tp>(__t); return std::forward<_Tp>(__t);
} }
using is_transparent = void; using is_transparent = void;
}; };
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
struct identity { struct identity {
template<class _Tp> template<class _Tp>
_LIBCPP_NODISCARD_EXT constexpr _Tp&& operator()(_Tp&& __t) const noexcept _LIBCPP_NODISCARD_EXT constexpr _Tp&& operator()(_Tp&& __t) const noexcept
{ {
return _VSTD::forward<_Tp>(__t); return _VSTD::forward<_Tp>(__t);
} }
using is_transparent = void; using is_transparent = void;
}; };
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_IDENTITY_H #endif // _LIBCPP___FUNCTIONAL_IDENTITY_H

libcxx/include/__functional/invoke.h

Show First 20 Lines • Show All 482 Lines • ▼ Show 20 Lines
struct __invoke_void_return_wrapper<_Ret, true> struct __invoke_void_return_wrapper<_Ret, true>
{ {
template <class ..._Args> template <class ..._Args>
static void __call(_Args&&... __args) { static void __call(_Args&&... __args) {
std::__invoke(std::forward<_Args>(__args)...); std::__invoke(std::forward<_Args>(__args)...);
} }
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
// is_invocable // is_invocable
template <class _Fn, class ..._Args> template <class _Fn, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_invocable struct _LIBCPP_TEMPLATE_VIS is_invocable
: integral_constant<bool, __invokable<_Fn, _Args...>::value> {}; : integral_constant<bool, __invokable<_Fn, _Args...>::value> {};
template <class _Ret, class _Fn, class ..._Args> template <class _Ret, class _Fn, class ..._Args>
Show All 34 Lines
template <class _Fn, class ..._Args> template <class _Fn, class ..._Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 invoke_result_t<_Fn, _Args...> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 invoke_result_t<_Fn, _Args...>
invoke(_Fn&& __f, _Args&&... __args) invoke(_Fn&& __f, _Args&&... __args)
noexcept(is_nothrow_invocable_v<_Fn, _Args...>) noexcept(is_nothrow_invocable_v<_Fn, _Args...>)
{ {
return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...); return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#if _LIBCPP_STD_VER >= 23 #if _LIBCPP_STD_VER >= 23
template <class _Result, class _Fn, class... _Args> template <class _Result, class _Fn, class... _Args>
requires is_invocable_r_v<_Result, _Fn, _Args...> requires is_invocable_r_v<_Result, _Fn, _Args...>
_LIBCPP_HIDE_FROM_ABI constexpr _Result _LIBCPP_HIDE_FROM_ABI constexpr _Result
invoke_r(_Fn&& __f, _Args&&... __args) noexcept(is_nothrow_invocable_r_v<_Result, _Fn, _Args...>) { invoke_r(_Fn&& __f, _Args&&... __args) noexcept(is_nothrow_invocable_r_v<_Result, _Fn, _Args...>) {
if constexpr (is_void_v<_Result>) { if constexpr (is_void_v<_Result>) {
static_cast<void>(std::invoke(std::forward<_Fn>(__f), std::forward<_Args>(__args)...)); static_cast<void>(std::invoke(std::forward<_Fn>(__f), std::forward<_Args>(__args)...));
Show All 15 Lines

libcxx/include/__functional/is_transparent.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 > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp, class, class = void> template <class _Tp, class, class = void>
struct __is_transparent : false_type {}; struct __is_transparent : false_type {};
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __is_transparent<_Tp, _Up, __void_t<typename _Tp::is_transparent> > struct __is_transparent<_Tp, _Up, __void_t<typename _Tp::is_transparent> >
: true_type {}; : true_type {};
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_IS_TRANSPARENT #endif // _LIBCPP___FUNCTIONAL_IS_TRANSPARENT

libcxx/include/__functional/not_fn.h

Show All 16 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 > 14 #if _LIBCPP_STD_VER >= 17
struct __not_fn_op { struct __not_fn_op {
template <class... _Args> template <class... _Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_LIBCPP_CONSTEXPR_SINCE_CXX20 auto operator()(_Args&&... __args) const _LIBCPP_CONSTEXPR_SINCE_CXX20 auto operator()(_Args&&... __args) const
noexcept(noexcept(!_VSTD::invoke(_VSTD::forward<_Args>(__args)...))) noexcept(noexcept(!_VSTD::invoke(_VSTD::forward<_Args>(__args)...)))
-> decltype( !_VSTD::invoke(_VSTD::forward<_Args>(__args)...)) -> decltype( !_VSTD::invoke(_VSTD::forward<_Args>(__args)...))
{ return !_VSTD::invoke(_VSTD::forward<_Args>(__args)...); } { return !_VSTD::invoke(_VSTD::forward<_Args>(__args)...); }
}; };
template <class _Fn> template <class _Fn>
struct __not_fn_t : __perfect_forward<__not_fn_op, _Fn> { struct __not_fn_t : __perfect_forward<__not_fn_op, _Fn> {
using __perfect_forward<__not_fn_op, _Fn>::__perfect_forward; using __perfect_forward<__not_fn_op, _Fn>::__perfect_forward;
}; };
template <class _Fn, class = enable_if_t< template <class _Fn, class = enable_if_t<
is_constructible_v<decay_t<_Fn>, _Fn> && is_constructible_v<decay_t<_Fn>, _Fn> &&
is_move_constructible_v<decay_t<_Fn>> is_move_constructible_v<decay_t<_Fn>>
>> >>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_LIBCPP_CONSTEXPR_SINCE_CXX20 auto not_fn(_Fn&& __f) { _LIBCPP_CONSTEXPR_SINCE_CXX20 auto not_fn(_Fn&& __f) {
return __not_fn_t<decay_t<_Fn>>(_VSTD::forward<_Fn>(__f)); return __not_fn_t<decay_t<_Fn>>(_VSTD::forward<_Fn>(__f));
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_NOT_FN_H #endif // _LIBCPP___FUNCTIONAL_NOT_FN_H

libcxx/include/__functional/operations.h

Show All 17 Lines
#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
// Arithmetic operations // Arithmetic operations
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS plus struct _LIBCPP_TEMPLATE_VIS plus
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x + __y;} {return __x + __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(plus); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(plus);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS plus<void> struct _LIBCPP_TEMPLATE_VIS plus<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS minus struct _LIBCPP_TEMPLATE_VIS minus
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x - __y;} {return __x - __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(minus); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(minus);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS minus<void> struct _LIBCPP_TEMPLATE_VIS minus<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS multiplies struct _LIBCPP_TEMPLATE_VIS multiplies
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x * __y;} {return __x * __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(multiplies); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(multiplies);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS multiplies<void> struct _LIBCPP_TEMPLATE_VIS multiplies<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS divides struct _LIBCPP_TEMPLATE_VIS divides
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x / __y;} {return __x / __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(divides); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(divides);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS divides<void> struct _LIBCPP_TEMPLATE_VIS divides<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS modulus struct _LIBCPP_TEMPLATE_VIS modulus
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x % __y;} {return __x % __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(modulus); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(modulus);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS modulus<void> struct _LIBCPP_TEMPLATE_VIS modulus<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS negate struct _LIBCPP_TEMPLATE_VIS negate
: __unary_function<_Tp, _Tp> : __unary_function<_Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x) const _Tp operator()(const _Tp& __x) const
{return -__x;} {return -__x;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(negate); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(negate);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS negate<void> struct _LIBCPP_TEMPLATE_VIS negate<void>
{ {
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_Tp&& __x) const auto operator()(_Tp&& __x) const
noexcept(noexcept(- _VSTD::forward<_Tp>(__x))) noexcept(noexcept(- _VSTD::forward<_Tp>(__x)))
-> decltype( - _VSTD::forward<_Tp>(__x)) -> decltype( - _VSTD::forward<_Tp>(__x))
{ return - _VSTD::forward<_Tp>(__x); } { return - _VSTD::forward<_Tp>(__x); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
// Bitwise operations // Bitwise operations
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS bit_and struct _LIBCPP_TEMPLATE_VIS bit_and
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x & __y;} {return __x & __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_and); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_and);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_and<void> struct _LIBCPP_TEMPLATE_VIS bit_and<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
struct _LIBCPP_TEMPLATE_VIS bit_not struct _LIBCPP_TEMPLATE_VIS bit_not
: __unary_function<_Tp, _Tp> : __unary_function<_Tp, _Tp>
{ {
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x) const _Tp operator()(const _Tp& __x) const
{return ~__x;} {return ~__x;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_not); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_not);
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_not<void> struct _LIBCPP_TEMPLATE_VIS bit_not<void>
{ {
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_Tp&& __x) const auto operator()(_Tp&& __x) const
noexcept(noexcept(~_VSTD::forward<_Tp>(__x))) noexcept(noexcept(~_VSTD::forward<_Tp>(__x)))
-> decltype( ~_VSTD::forward<_Tp>(__x)) -> decltype( ~_VSTD::forward<_Tp>(__x))
{ return ~_VSTD::forward<_Tp>(__x); } { return ~_VSTD::forward<_Tp>(__x); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS bit_or struct _LIBCPP_TEMPLATE_VIS bit_or
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x | __y;} {return __x | __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_or); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_or);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_or<void> struct _LIBCPP_TEMPLATE_VIS bit_or<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS bit_xor struct _LIBCPP_TEMPLATE_VIS bit_xor
: __binary_function<_Tp, _Tp, _Tp> : __binary_function<_Tp, _Tp, _Tp>
{ {
typedef _Tp __result_type; // used by valarray typedef _Tp __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
_Tp operator()(const _Tp& __x, const _Tp& __y) const _Tp operator()(const _Tp& __x, const _Tp& __y) const
{return __x ^ __y;} {return __x ^ __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_xor); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_xor);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS bit_xor<void> struct _LIBCPP_TEMPLATE_VIS bit_xor<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
// Comparison operations // Comparison operations
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS equal_to struct _LIBCPP_TEMPLATE_VIS equal_to
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x == __y;} {return __x == __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(equal_to); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(equal_to);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS equal_to<void> struct _LIBCPP_TEMPLATE_VIS equal_to<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS not_equal_to struct _LIBCPP_TEMPLATE_VIS not_equal_to
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x != __y;} {return __x != __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(not_equal_to); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(not_equal_to);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS not_equal_to<void> struct _LIBCPP_TEMPLATE_VIS not_equal_to<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS less struct _LIBCPP_TEMPLATE_VIS less
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x < __y;} {return __x < __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS less<void> struct _LIBCPP_TEMPLATE_VIS less<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS less_equal struct _LIBCPP_TEMPLATE_VIS less_equal
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x <= __y;} {return __x <= __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less_equal); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less_equal);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS less_equal<void> struct _LIBCPP_TEMPLATE_VIS less_equal<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS greater_equal struct _LIBCPP_TEMPLATE_VIS greater_equal
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x >= __y;} {return __x >= __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater_equal); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater_equal);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS greater_equal<void> struct _LIBCPP_TEMPLATE_VIS greater_equal<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS greater struct _LIBCPP_TEMPLATE_VIS greater
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x > __y;} {return __x > __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS greater<void> struct _LIBCPP_TEMPLATE_VIS greater<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
// Logical operations // Logical operations
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS logical_and struct _LIBCPP_TEMPLATE_VIS logical_and
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x && __y;} {return __x && __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_and); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_and);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS logical_and<void> struct _LIBCPP_TEMPLATE_VIS logical_and<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS logical_not struct _LIBCPP_TEMPLATE_VIS logical_not
: __unary_function<_Tp, bool> : __unary_function<_Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x) const bool operator()(const _Tp& __x) const
{return !__x;} {return !__x;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_not); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_not);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS logical_not<void> struct _LIBCPP_TEMPLATE_VIS logical_not<void>
{ {
template <class _Tp> template <class _Tp>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
auto operator()(_Tp&& __x) const auto operator()(_Tp&& __x) const
noexcept(noexcept(!_VSTD::forward<_Tp>(__x))) noexcept(noexcept(!_VSTD::forward<_Tp>(__x)))
-> decltype( !_VSTD::forward<_Tp>(__x)) -> decltype( !_VSTD::forward<_Tp>(__x))
{ return !_VSTD::forward<_Tp>(__x); } { return !_VSTD::forward<_Tp>(__x); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp = void> template <class _Tp = void>
#else #else
template <class _Tp> template <class _Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS logical_or struct _LIBCPP_TEMPLATE_VIS logical_or
: __binary_function<_Tp, _Tp, bool> : __binary_function<_Tp, _Tp, bool>
{ {
typedef bool __result_type; // used by valarray typedef bool __result_type; // used by valarray
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Tp& __x, const _Tp& __y) const bool operator()(const _Tp& __x, const _Tp& __y) const
{return __x || __y;} {return __x || __y;}
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_or); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_or);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <> template <>
struct _LIBCPP_TEMPLATE_VIS logical_or<void> struct _LIBCPP_TEMPLATE_VIS logical_or<void>
{ {
template <class _T1, class _T2> template <class _T1, class _T2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
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)))
-> decltype( _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)) -> decltype( _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); }
typedef void is_transparent; typedef void is_transparent;
}; };
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_OPERATIONS_H #endif // _LIBCPP___FUNCTIONAL_OPERATIONS_H

libcxx/include/__functional/perfect_forward.h

Show All 17 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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _Op, class _Indices, class... _BoundArgs> template <class _Op, class _Indices, class... _BoundArgs>
struct __perfect_forward_impl; struct __perfect_forward_impl;
template <class _Op, size_t... _Idx, class... _BoundArgs> template <class _Op, size_t... _Idx, class... _BoundArgs>
struct __perfect_forward_impl<_Op, index_sequence<_Idx...>, _BoundArgs...> { struct __perfect_forward_impl<_Op, index_sequence<_Idx...>, _BoundArgs...> {
private: private:
tuple<_BoundArgs...> __bound_args_; tuple<_BoundArgs...> __bound_args_;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linespublic:
template <class... _Args, class = enable_if_t<!is_invocable_v<_Op, _BoundArgs const..., _Args...>>> template <class... _Args, class = enable_if_t<!is_invocable_v<_Op, _BoundArgs const..., _Args...>>>
auto operator()(_Args&&...) const&& = delete; auto operator()(_Args&&...) const&& = delete;
}; };
// __perfect_forward implements a perfect-forwarding call wrapper as explained in [func.require]. // __perfect_forward implements a perfect-forwarding call wrapper as explained in [func.require].
template <class _Op, class ..._Args> template <class _Op, class ..._Args>
using __perfect_forward = __perfect_forward_impl<_Op, index_sequence_for<_Args...>, _Args...>; using __perfect_forward = __perfect_forward_impl<_Op, index_sequence_for<_Args...>, _Args...>;
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H #endif // _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H

libcxx/include/__functional/ranges_operations.h

Show All 15 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
struct equal_to { struct equal_to {
template <class _Tp, class _Up> template <class _Tp, class _Up>
requires equality_comparable_with<_Tp, _Up> requires equality_comparable_with<_Tp, _Up>
[[nodiscard]] constexpr bool operator()(_Tp &&__t, _Up &&__u) const [[nodiscard]] constexpr bool operator()(_Tp &&__t, _Up &&__u) const
noexcept(noexcept(bool(_VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u)))) { noexcept(noexcept(bool(_VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u)))) {
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines [[nodiscard]] constexpr bool operator()(_Tp &&__t, _Up &&__u) const
return !(_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u)); return !(_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u));
} }
using is_transparent = void; using is_transparent = void;
}; };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_RANGES_OPERATIONS_H #endif // _LIBCPP___FUNCTIONAL_RANGES_OPERATIONS_H

libcxx/include/__functional/reference_wrapper.h

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Linespublic:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
type& get() const _NOEXCEPT {return *__f_;} type& get() const _NOEXCEPT {return *__f_;}
// invoke // invoke
template <class... _ArgTypes> template <class... _ArgTypes>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
typename __invoke_of<type&, _ArgTypes...>::type typename __invoke_of<type&, _ArgTypes...>::type
operator() (_ArgTypes&&... __args) const operator() (_ArgTypes&&... __args) const
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
// Since is_nothrow_invocable requires C++17 LWG3764 is not backported // Since is_nothrow_invocable requires C++17 LWG3764 is not backported
// to earlier versions. // to earlier versions.
noexcept(is_nothrow_invocable_v<_Tp&, _ArgTypes...>) noexcept(is_nothrow_invocable_v<_Tp&, _ArgTypes...>)
#endif #endif
{ {
return std::__invoke(get(), std::forward<_ArgTypes>(__args)...); return std::__invoke(get(), std::forward<_ArgTypes>(__args)...);
} }
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;
#endif #endif
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
reference_wrapper<_Tp> reference_wrapper<_Tp>
ref(_Tp& __t) _NOEXCEPT ref(_Tp& __t) _NOEXCEPT
Show All 34 Lines

libcxx/include/__functional/unwrap_ref.h

Show All 24 Lines
class reference_wrapper; class reference_wrapper;
template <class _Tp> template <class _Tp>
struct __unwrap_reference<reference_wrapper<_Tp> > { typedef _LIBCPP_NODEBUG _Tp& type; }; struct __unwrap_reference<reference_wrapper<_Tp> > { typedef _LIBCPP_NODEBUG _Tp& type; };
template <class _Tp> template <class _Tp>
struct decay; struct decay;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Tp> template <class _Tp>
struct unwrap_reference : __unwrap_reference<_Tp> { }; struct unwrap_reference : __unwrap_reference<_Tp> { };
template <class _Tp> template <class _Tp>
using unwrap_reference_t = typename unwrap_reference<_Tp>::type; using unwrap_reference_t = typename unwrap_reference<_Tp>::type;
template <class _Tp> template <class _Tp>
struct unwrap_ref_decay : unwrap_reference<typename decay<_Tp>::type> { }; struct unwrap_ref_decay : unwrap_reference<typename decay<_Tp>::type> { };
template <class _Tp> template <class _Tp>
using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type; using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
#endif // > C++17 #endif // > C++17
template <class _Tp> template <class _Tp>
struct __unwrap_ref_decay struct __unwrap_ref_decay
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
: unwrap_ref_decay<_Tp> : unwrap_ref_decay<_Tp>
#else #else
: __unwrap_reference<typename decay<_Tp>::type> : __unwrap_reference<typename decay<_Tp>::type>
#endif #endif
{ }; { };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_UNWRAP_REF_H #endif // _LIBCPP___FUNCTIONAL_UNWRAP_REF_H

libcxx/include/__fwd/span.h

Show All 17 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 #if _LIBCPP_STD_VER >= 20
inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max(); inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();
template <typename _Tp, size_t _Extent = dynamic_extent> class span; template <typename _Tp, size_t _Extent = dynamic_extent> class span;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___FWD_SPAN_H #endif // _LIBCPP___FWD_SPAN_H

libcxx/include/__hash_table

Show First 20 Lines • Show All 820 Lines • ▼ Show 20 Lines void operator()(pointer __p) _NOEXCEPT
__alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_)); __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
if (__p) if (__p)
__alloc_traits::deallocate(__na_, __p, 1); __alloc_traits::deallocate(__na_, __p, 1);
} }
template <class> friend class __hash_map_node_destructor; template <class> friend class __hash_map_node_destructor;
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _NodeType, class _Alloc> template <class _NodeType, class _Alloc>
struct __generic_container_node_destructor; struct __generic_container_node_destructor;
template <class _Tp, class _VoidPtr, class _Alloc> template <class _Tp, class _VoidPtr, class _Alloc>
struct __generic_container_node_destructor<__hash_node<_Tp, _VoidPtr>, _Alloc> struct __generic_container_node_destructor<__hash_node<_Tp, _VoidPtr>, _Alloc>
: __hash_node_destructor<_Alloc> : __hash_node_destructor<_Alloc>
{ {
using __hash_node_destructor<_Alloc>::__hash_node_destructor; using __hash_node_destructor<_Alloc>::__hash_node_destructor;
▲ Show 20 Lines • Show All 278 Lines • ▼ Show 20 Lines iterator __insert_multi(const_iterator __p, _Pp&& __x) {
return __emplace_hint_multi(__p, _VSTD::forward<_Pp>(__x)); return __emplace_hint_multi(__p, _VSTD::forward<_Pp>(__x));
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> __insert_unique(const __container_value_type& __x) { pair<iterator, bool> __insert_unique(const __container_value_type& __x) {
return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x);
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _NodeHandle, class _InsertReturnType> template <class _NodeHandle, class _InsertReturnType>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_InsertReturnType __node_handle_insert_unique(_NodeHandle&& __nh); _InsertReturnType __node_handle_insert_unique(_NodeHandle&& __nh);
template <class _NodeHandle> template <class _NodeHandle>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator __node_handle_insert_unique(const_iterator __hint, iterator __node_handle_insert_unique(const_iterator __hint,
_NodeHandle&& __nh); _NodeHandle&& __nh);
template <class _Table> template <class _Table>
▲ Show 20 Lines • Show All 950 Lines • ▼ Show 20 Lines _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
"unordered container::emplace_hint(const_iterator, args...) called with an iterator not" "unordered container::emplace_hint(const_iterator, args...) called with an iterator not"
" referring to this unordered container"); " referring to this unordered container");
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...); __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
iterator __r = __node_insert_multi(__p, __h.get()); iterator __r = __node_insert_multi(__p, __h.get());
__h.release(); __h.release();
return __r; return __r;
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Hash, class _Equal, class _Alloc> template <class _Tp, class _Hash, class _Equal, class _Alloc>
template <class _NodeHandle, class _InsertReturnType> template <class _NodeHandle, class _InsertReturnType>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_InsertReturnType _InsertReturnType
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_insert_unique( __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_insert_unique(
_NodeHandle&& __nh) _NodeHandle&& __nh)
{ {
if (__nh.empty()) if (__nh.empty())
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines for (typename _Table::iterator __it = __source.begin();
size_t __src_hash = hash_function()(__src_ptr->__value_); size_t __src_hash = hash_function()(__src_ptr->__value_);
__next_pointer __pn = __next_pointer __pn =
__node_insert_multi_prepare(__src_hash, __src_ptr->__value_); __node_insert_multi_prepare(__src_hash, __src_ptr->__value_);
(void)__source.remove(__it++).release(); (void)__source.remove(__it++).release();
__src_ptr->__hash_ = __src_hash; __src_ptr->__hash_ = __src_hash;
__node_insert_multi_perform(__src_ptr, __pn); __node_insert_multi_perform(__src_ptr, __pn);
} }
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
template <class _Tp, class _Hash, class _Equal, class _Alloc> template <class _Tp, class _Hash, class _Equal, class _Alloc>
template <bool _UniqueKeys> template <bool _UniqueKeys>
void void
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __n) __hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __n)
_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
{ {
if (__n == 1) if (__n == 1)
▲ Show 20 Lines • Show All 486 Lines • Show Last 20 Lines

libcxx/include/__iterator/access.h

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
auto auto
end(const _Cp& __c) -> decltype(__c.end()) end(const _Cp& __c) -> decltype(__c.end())
{ {
return __c.end(); return __c.end();
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
auto cbegin(const _Cp& __c) -> decltype(_VSTD::begin(__c)) auto cbegin(const _Cp& __c) -> decltype(_VSTD::begin(__c))
{ {
return _VSTD::begin(__c); return _VSTD::begin(__c);
} }
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

libcxx/include/__iterator/advance.h

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
void advance(_InputIter& __i, _Distance __orig_n) { void advance(_InputIter& __i, _Distance __orig_n) {
typedef typename iterator_traits<_InputIter>::difference_type _Difference; typedef typename iterator_traits<_InputIter>::difference_type _Difference;
_Difference __n = static_cast<_Difference>(_VSTD::__convert_to_integral(__orig_n)); _Difference __n = static_cast<_Difference>(_VSTD::__convert_to_integral(__orig_n));
_LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value, _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
"Attempt to advance(it, n) with negative n on a non-bidirectional iterator"); "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
_VSTD::__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category()); _VSTD::__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
// [range.iter.op.advance] // [range.iter.op.advance]
namespace ranges { namespace ranges {
namespace __advance { namespace __advance {
struct __fn { struct __fn {
private: private:
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines
} // namespace __advance } // namespace __advance
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto advance = __advance::__fn{}; inline constexpr auto advance = __advance::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_ADVANCE_H #endif // _LIBCPP___ITERATOR_ADVANCE_H

libcxx/include/__iterator/back_insert_iterator.h

Show All 30 Lines
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
protected: protected:
_Container* container; _Container* container;
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#else #else
typedef void difference_type; typedef void difference_type;
#endif #endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _Container container_type; typedef _Container container_type;
Show All 26 Lines

libcxx/include/__iterator/bounded_iter.h

Show All 36 Lines
// its range, but it is not possible to dereference it. // its range, but it is not possible to dereference it.
template <class _Iterator, class = __enable_if_t< __is_cpp17_contiguous_iterator<_Iterator>::value > > template <class _Iterator, class = __enable_if_t< __is_cpp17_contiguous_iterator<_Iterator>::value > >
struct __bounded_iter { struct __bounded_iter {
using value_type = typename iterator_traits<_Iterator>::value_type; using value_type = typename iterator_traits<_Iterator>::value_type;
using difference_type = typename iterator_traits<_Iterator>::difference_type; using difference_type = typename iterator_traits<_Iterator>::difference_type;
using pointer = typename iterator_traits<_Iterator>::pointer; using pointer = typename iterator_traits<_Iterator>::pointer;
using reference = typename iterator_traits<_Iterator>::reference; using reference = typename iterator_traits<_Iterator>::reference;
using iterator_category = typename iterator_traits<_Iterator>::iterator_category; using iterator_category = typename iterator_traits<_Iterator>::iterator_category;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
using iterator_concept = contiguous_iterator_tag; using iterator_concept = contiguous_iterator_tag;
#endif #endif
// Create a singular iterator. // Create a singular iterator.
// //
// Such an iterator does not point to any object and is conceptually out of bounds, so it is // Such an iterator does not point to any object and is conceptually out of bounds, so it is
// not dereferenceable. Observing operations like comparison and assignment are valid. // not dereferenceable. Observing operations like comparison and assignment are valid.
_LIBCPP_HIDE_FROM_ABI __bounded_iter() = default; _LIBCPP_HIDE_FROM_ABI __bounded_iter() = default;
▲ Show 20 Lines • Show All 178 Lines • Show Last 20 Lines

libcxx/include/__iterator/common_iterator.h

Show All 29 Lines
#include <variant> #include <variant>
#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 #if _LIBCPP_STD_VER >= 20
template<class _Iter> template<class _Iter>
concept __can_use_postfix_proxy = concept __can_use_postfix_proxy =
constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>> && constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>> &&
move_constructible<iter_value_t<_Iter>>; move_constructible<iter_value_t<_Iter>>;
template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent> template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
requires (!same_as<_Iter, _Sent> && copyable<_Iter>) requires (!same_as<_Iter, _Sent> && copyable<_Iter>)
▲ Show 20 Lines • Show All 222 Lines • ▼ Show 20 Lines using iterator_category = _If<__denotes_forward_iter<_Iter>,
forward_iterator_tag, forward_iterator_tag,
input_iterator_tag>; input_iterator_tag>;
using pointer = typename __arrow_type_or_void<_Iter, _Sent>::type; using pointer = typename __arrow_type_or_void<_Iter, _Sent>::type;
using value_type = iter_value_t<_Iter>; using value_type = iter_value_t<_Iter>;
using difference_type = iter_difference_t<_Iter>; using difference_type = iter_difference_t<_Iter>;
using reference = iter_reference_t<_Iter>; using reference = iter_reference_t<_Iter>;
}; };
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_COMMON_ITERATOR_H #endif // _LIBCPP___ITERATOR_COMMON_ITERATOR_H

libcxx/include/__iterator/concepts.h

Show All 40 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 #if _LIBCPP_STD_VER >= 20
// [iterator.concept.readable] // [iterator.concept.readable]
template<class _In> template<class _In>
concept __indirectly_readable_impl = concept __indirectly_readable_impl =
requires(const _In __i) { requires(const _In __i) {
typename iter_value_t<_In>; typename iter_value_t<_In>;
typename iter_reference_t<_In>; typename iter_reference_t<_In>;
typename iter_rvalue_reference_t<_In>; typename iter_rvalue_reference_t<_In>;
▲ Show 20 Lines • Show All 230 Lines • ▼ Show 20 Linesconcept indirectly_copyable_storable =
indirectly_writable<_Out, const iter_value_t<_In>&&> && indirectly_writable<_Out, const iter_value_t<_In>&&> &&
copyable<iter_value_t<_In>> && copyable<iter_value_t<_In>> &&
constructible_from<iter_value_t<_In>, iter_reference_t<_In>> && constructible_from<iter_value_t<_In>, iter_reference_t<_In>> &&
assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>; assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;
// Note: indirectly_swappable is located in iter_swap.h to prevent a dependency cycle // Note: indirectly_swappable is located in iter_swap.h to prevent a dependency cycle
// (both iter_swap and indirectly_swappable require indirectly_readable). // (both iter_swap and indirectly_swappable require indirectly_readable).
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_CONCEPTS_H #endif // _LIBCPP___ITERATOR_CONCEPTS_H

libcxx/include/__iterator/counted_iterator.h

Show All 30 Lines
#include <compare> #include <compare>
#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 #if _LIBCPP_STD_VER >= 20
template<class> template<class>
struct __counted_iterator_concept {}; struct __counted_iterator_concept {};
template<class _Iter> template<class _Iter>
requires requires { typename _Iter::iterator_concept; } requires requires { typename _Iter::iterator_concept; }
struct __counted_iterator_concept<_Iter> { struct __counted_iterator_concept<_Iter> {
using iterator_concept = typename _Iter::iterator_concept; using iterator_concept = typename _Iter::iterator_concept;
▲ Show 20 Lines • Show All 250 Lines • ▼ Show 20 Lines
template<input_iterator _Iter> template<input_iterator _Iter>
requires same_as<_ITER_TRAITS<_Iter>, iterator_traits<_Iter>> requires same_as<_ITER_TRAITS<_Iter>, iterator_traits<_Iter>>
struct iterator_traits<counted_iterator<_Iter>> : iterator_traits<_Iter> { struct iterator_traits<counted_iterator<_Iter>> : iterator_traits<_Iter> {
using pointer = conditional_t<contiguous_iterator<_Iter>, using pointer = conditional_t<contiguous_iterator<_Iter>,
add_pointer_t<iter_reference_t<_Iter>>, void>; add_pointer_t<iter_reference_t<_Iter>>, void>;
}; };
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_COUNTED_ITERATOR_H #endif // _LIBCPP___ITERATOR_COUNTED_ITERATOR_H

libcxx/include/__iterator/data.h

Show All 14 Lines
#include <initializer_list> #include <initializer_list>
#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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _Cont> constexpr template <class _Cont> constexpr
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
auto data(_Cont& __c) auto data(_Cont& __c)
_NOEXCEPT_(noexcept(__c.data())) _NOEXCEPT_(noexcept(__c.data()))
-> decltype (__c.data()) -> decltype (__c.data())
{ return __c.data(); } { return __c.data(); }
Show All 20 Lines

libcxx/include/__iterator/default_sentinel.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 #if _LIBCPP_STD_VER >= 20
struct default_sentinel_t { }; struct default_sentinel_t { };
inline constexpr default_sentinel_t default_sentinel{}; inline constexpr default_sentinel_t default_sentinel{};
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_DEFAULT_SENTINEL_H #endif // _LIBCPP___ITERATOR_DEFAULT_SENTINEL_H

libcxx/include/__iterator/distance.h

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
template <class _InputIter> template <class _InputIter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_DISTANCE_H #endif // _LIBCPP___ITERATOR_DISTANCE_H

libcxx/include/__iterator/empty.h

Show All 14 Lines
#include <initializer_list> #include <initializer_list>
#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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _Cont> template <class _Cont>
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
constexpr auto empty(const _Cont& __c) constexpr auto empty(const _Cont& __c)
_NOEXCEPT_(noexcept(__c.empty())) _NOEXCEPT_(noexcept(__c.empty()))
-> decltype (__c.empty()) -> decltype (__c.empty())
{ return __c.empty(); } { return __c.empty(); }
template <class _Tp, size_t _Sz> template <class _Tp, size_t _Sz>
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
constexpr bool empty(const _Tp (&)[_Sz]) noexcept { return false; } constexpr bool empty(const _Tp (&)[_Sz]) noexcept { return false; }
template <class _Ep> template <class _Ep>
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
constexpr bool empty(initializer_list<_Ep> __il) noexcept { return __il.size() == 0; } constexpr bool empty(initializer_list<_Ep> __il) noexcept { return __il.size() == 0; }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_EMPTY_H #endif // _LIBCPP___ITERATOR_EMPTY_H

libcxx/include/__iterator/front_insert_iterator.h

Show All 30 Lines
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
protected: protected:
_Container* container; _Container* container;
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#else #else
typedef void difference_type; typedef void difference_type;
#endif #endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _Container container_type; typedef _Container container_type;
Show All 24 Lines

libcxx/include/__iterator/incrementable_traits.h

Show All 20 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 #if _LIBCPP_STD_VER >= 20
// [incrementable.traits] // [incrementable.traits]
template<class> struct incrementable_traits {}; template<class> struct incrementable_traits {};
template<class _Tp> template<class _Tp>
requires is_object_v<_Tp> requires is_object_v<_Tp>
struct incrementable_traits<_Tp*> { struct incrementable_traits<_Tp*> {
using difference_type = ptrdiff_t; using difference_type = ptrdiff_t;
Show All 28 Lines
// Let `RI` be `remove_cvref_t<I>`. The type `iter_difference_t<I>` denotes // Let `RI` be `remove_cvref_t<I>`. The type `iter_difference_t<I>` denotes
// `incrementable_traits<RI>::difference_type` if `iterator_traits<RI>` names a specialization // `incrementable_traits<RI>::difference_type` if `iterator_traits<RI>` names a specialization
// generated from the primary template, and `iterator_traits<RI>::difference_type` otherwise. // generated from the primary template, and `iterator_traits<RI>::difference_type` otherwise.
template <class _Ip> template <class _Ip>
using iter_difference_t = typename conditional_t<__is_primary_template<iterator_traits<remove_cvref_t<_Ip> > >::value, using iter_difference_t = typename conditional_t<__is_primary_template<iterator_traits<remove_cvref_t<_Ip> > >::value,
incrementable_traits<remove_cvref_t<_Ip> >, incrementable_traits<remove_cvref_t<_Ip> >,
iterator_traits<remove_cvref_t<_Ip> > >::difference_type; iterator_traits<remove_cvref_t<_Ip> > >::difference_type;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_INCREMENTABLE_TRAITS_H #endif // _LIBCPP___ITERATOR_INCREMENTABLE_TRAITS_H

libcxx/include/__iterator/indirectly_comparable.h

Show All 15 Lines
#include <__iterator/projected.h> #include <__iterator/projected.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 #if _LIBCPP_STD_VER >= 20
template <class _I1, class _I2, class _Rp, class _P1 = identity, class _P2 = identity> template <class _I1, class _I2, class _Rp, class _P1 = identity, class _P2 = identity>
concept indirectly_comparable = concept indirectly_comparable =
indirect_binary_predicate<_Rp, projected<_I1, _P1>, projected<_I2, _P2>>; indirect_binary_predicate<_Rp, projected<_I1, _P1>, projected<_I2, _P2>>;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_INDIRECTLY_COMPARABLE_H #endif // _LIBCPP___ITERATOR_INDIRECTLY_COMPARABLE_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 #if _LIBCPP_STD_VER >= 20
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
template <class _Container> template <class _Container>
class _LIBCPP_TEMPLATE_VIS insert_iterator class _LIBCPP_TEMPLATE_VIS insert_iterator
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
protected: protected:
_Container* container; _Container* container;
__insert_iterator_iter_t<_Container> iter; __insert_iterator_iter_t<_Container> iter;
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#else #else
typedef void difference_type; typedef void difference_type;
#endif #endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _Container container_type; typedef _Container container_type;
Show All 24 Lines

libcxx/include/__iterator/istream_iterator.h

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linespublic:
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
typedef basic_istream<_CharT,_Traits> istream_type; typedef basic_istream<_CharT,_Traits> istream_type;
private: private:
istream_type* __in_stream_; istream_type* __in_stream_;
_Tp __value_; _Tp __value_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(nullptr), __value_() {} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(nullptr), __value_() {}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI constexpr istream_iterator(default_sentinel_t) : istream_iterator() {} _LIBCPP_HIDE_FROM_ABI constexpr istream_iterator(default_sentinel_t) : istream_iterator() {}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(_VSTD::addressof(__s)) _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(_VSTD::addressof(__s))
{ {
if (!(*__in_stream_ >> __value_)) if (!(*__in_stream_ >> __value_))
__in_stream_ = nullptr; __in_stream_ = nullptr;
} }
_LIBCPP_INLINE_VISIBILITY const _Tp& operator*() const {return __value_;} _LIBCPP_INLINE_VISIBILITY const _Tp& operator*() const {return __value_;}
_LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return _VSTD::addressof((operator*()));} _LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return _VSTD::addressof((operator*()));}
_LIBCPP_INLINE_VISIBILITY istream_iterator& operator++() _LIBCPP_INLINE_VISIBILITY istream_iterator& operator++()
{ {
if (!(*__in_stream_ >> __value_)) if (!(*__in_stream_ >> __value_))
__in_stream_ = nullptr; __in_stream_ = nullptr;
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY istream_iterator operator++(int) _LIBCPP_INLINE_VISIBILITY istream_iterator operator++(int)
{istream_iterator __t(*this); ++(*this); return __t;} {istream_iterator __t(*this); ++(*this); return __t;}
template <class _Up, class _CharU, class _TraitsU, class _DistanceU> template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
friend _LIBCPP_INLINE_VISIBILITY friend _LIBCPP_INLINE_VISIBILITY
bool bool
operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x, operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y); const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istream_iterator& __i, default_sentinel_t) { friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istream_iterator& __i, default_sentinel_t) {
return __i.__in_stream_ == nullptr; return __i.__in_stream_ == nullptr;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
}; };
template <class _Tp, class _CharT, class _Traits, class _Distance> template <class _Tp, class _CharT, class _Traits, class _Distance>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool bool
operator==(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x, operator==(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y) const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
{ {
Show All 17 Lines

libcxx/include/__iterator/istreambuf_iterator.h

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Linesprivate:
bool __test_for_eof() const bool __test_for_eof() const
{ {
if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof())) if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
__sbuf_ = nullptr; __sbuf_ = nullptr;
return __sbuf_ == nullptr; return __sbuf_ == nullptr;
} }
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istreambuf_iterator() _NOEXCEPT : __sbuf_(nullptr) {} _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istreambuf_iterator() _NOEXCEPT : __sbuf_(nullptr) {}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY constexpr istreambuf_iterator(default_sentinel_t) noexcept _LIBCPP_INLINE_VISIBILITY constexpr istreambuf_iterator(default_sentinel_t) noexcept
: istreambuf_iterator() {} : istreambuf_iterator() {}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(istream_type& __s) _NOEXCEPT _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(istream_type& __s) _NOEXCEPT
: __sbuf_(__s.rdbuf()) {} : __sbuf_(__s.rdbuf()) {}
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(streambuf_type* __s) _NOEXCEPT _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(streambuf_type* __s) _NOEXCEPT
: __sbuf_(__s) {} : __sbuf_(__s) {}
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) _NOEXCEPT _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) _NOEXCEPT
: __sbuf_(__p.__sbuf_) {} : __sbuf_(__p.__sbuf_) {}
_LIBCPP_INLINE_VISIBILITY char_type operator*() const _LIBCPP_INLINE_VISIBILITY char_type operator*() const
{return static_cast<char_type>(__sbuf_->sgetc());} {return static_cast<char_type>(__sbuf_->sgetc());}
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++() _LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++()
{ {
__sbuf_->sbumpc(); __sbuf_->sbumpc();
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY __proxy operator++(int) _LIBCPP_INLINE_VISIBILITY __proxy operator++(int)
{ {
return __proxy(__sbuf_->sbumpc(), __sbuf_); return __proxy(__sbuf_->sbumpc(), __sbuf_);
} }
_LIBCPP_INLINE_VISIBILITY bool equal(const istreambuf_iterator& __b) const _LIBCPP_INLINE_VISIBILITY bool equal(const istreambuf_iterator& __b) const
{return __test_for_eof() == __b.__test_for_eof();} {return __test_for_eof() == __b.__test_for_eof();}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istreambuf_iterator& __i, default_sentinel_t) { friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istreambuf_iterator& __i, default_sentinel_t) {
return __i.__test_for_eof(); return __i.__test_for_eof();
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
}; };
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool operator==(const istreambuf_iterator<_CharT,_Traits>& __a, bool operator==(const istreambuf_iterator<_CharT,_Traits>& __a,
const istreambuf_iterator<_CharT,_Traits>& __b) const istreambuf_iterator<_CharT,_Traits>& __b)
{return __a.equal(__b);} {return __a.equal(__b);}
Show All 11 Lines

libcxx/include/__iterator/iter_move.h

Show All 19 Lines
#include <__utility/move.h> #include <__utility/move.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 #if _LIBCPP_STD_VER >= 20
// [iterator.cust.move] // [iterator.cust.move]
namespace ranges { namespace ranges {
namespace __iter_move { namespace __iter_move {
void iter_move(); void iter_move();
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linesinline namespace __cpo {
inline constexpr auto iter_move = __iter_move::__fn{}; inline constexpr auto iter_move = __iter_move::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
template<__dereferenceable _Tp> template<__dereferenceable _Tp>
requires requires(_Tp& __t) { { ranges::iter_move(__t) } -> __can_reference; } requires requires(_Tp& __t) { { ranges::iter_move(__t) } -> __can_reference; }
using iter_rvalue_reference_t = decltype(ranges::iter_move(std::declval<_Tp&>())); using iter_rvalue_reference_t = decltype(ranges::iter_move(std::declval<_Tp&>()));
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_ITER_MOVE_H #endif // _LIBCPP___ITERATOR_ITER_MOVE_H

libcxx/include/__iterator/iter_swap.h

Show All 22 Lines
#include <__utility/move.h> #include <__utility/move.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 #if _LIBCPP_STD_VER >= 20
// [iter.cust.swap] // [iter.cust.swap]
namespace ranges { namespace ranges {
namespace __iter_swap { namespace __iter_swap {
template<class _I1, class _I2> template<class _I1, class _I2>
void iter_swap(_I1, _I2) = delete; void iter_swap(_I1, _I2) = delete;
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Linesconcept indirectly_swappable =
indirectly_readable<_I1> && indirectly_readable<_I2> && indirectly_readable<_I1> && indirectly_readable<_I2> &&
requires(const _I1 __i1, const _I2 __i2) { requires(const _I1 __i1, const _I2 __i2) {
ranges::iter_swap(__i1, __i1); ranges::iter_swap(__i1, __i1);
ranges::iter_swap(__i2, __i2); ranges::iter_swap(__i2, __i2);
ranges::iter_swap(__i1, __i2); ranges::iter_swap(__i1, __i2);
ranges::iter_swap(__i2, __i1); ranges::iter_swap(__i2, __i1);
}; };
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_ITER_SWAP_H #endif // _LIBCPP___ITERATOR_ITER_SWAP_H

libcxx/include/__iterator/iterator_traits.h

Show All 37 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 #if _LIBCPP_STD_VER >= 20
template <class _Tp> template <class _Tp>
using __with_reference = _Tp&; using __with_reference = _Tp&;
template <class _Tp> template <class _Tp>
concept __can_reference = requires { concept __can_reference = requires {
typename __with_reference<_Tp>; typename __with_reference<_Tp>;
}; };
template <class _Tp> template <class _Tp>
concept __dereferenceable = requires(_Tp& __t) { concept __dereferenceable = requires(_Tp& __t) {
{ *__t } -> __can_reference; // not required to be equality-preserving { *__t } -> __can_reference; // not required to be equality-preserving
}; };
// [iterator.traits] // [iterator.traits]
template<__dereferenceable _Tp> template<__dereferenceable _Tp>
using iter_reference_t = decltype(*std::declval<_Tp&>()); using iter_reference_t = decltype(*std::declval<_Tp&>());
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
template <class _Iter> template <class _Iter>
struct _LIBCPP_TEMPLATE_VIS iterator_traits; struct _LIBCPP_TEMPLATE_VIS iterator_traits;
struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {}; struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {}; struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag : public input_iterator_tag {}; struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag : public input_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {}; struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {}; struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {};
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
struct _LIBCPP_TEMPLATE_VIS contiguous_iterator_tag : public random_access_iterator_tag {}; struct _LIBCPP_TEMPLATE_VIS contiguous_iterator_tag : public random_access_iterator_tag {};
#endif #endif
template <class _Iter> template <class _Iter>
struct __iter_traits_cache { struct __iter_traits_cache {
using type = _If< using type = _If<
__is_primary_template<iterator_traits<_Iter> >::value, __is_primary_template<iterator_traits<_Iter> >::value,
_Iter, _Iter,
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
{ {
private: private:
template <class _Up> static false_type __test(...); template <class _Up> static false_type __test(...);
template <class _Up> static true_type __test(typename _Up::iterator_concept* = nullptr); template <class _Up> static true_type __test(typename _Up::iterator_concept* = nullptr);
public: public:
static const bool value = decltype(__test<_Tp>(nullptr))::value; static const bool value = decltype(__test<_Tp>(nullptr))::value;
}; };
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
// The `cpp17-*-iterator` exposition-only concepts have very similar names to the `Cpp17*Iterator` named requirements // The `cpp17-*-iterator` exposition-only concepts have very similar names to the `Cpp17*Iterator` named requirements
// from `[iterator.cpp17]`. To avoid confusion between the two, the exposition-only concepts have been banished to // from `[iterator.cpp17]`. To avoid confusion between the two, the exposition-only concepts have been banished to
// a "detail" namespace indicating they have a niche use-case. // a "detail" namespace indicating they have a niche use-case.
namespace __iterator_traits_detail { namespace __iterator_traits_detail {
template<class _Ip> template<class _Ip>
concept __cpp17_iterator = concept __cpp17_iterator =
requires(_Ip __i) { requires(_Ip __i) {
▲ Show 20 Lines • Show All 207 Lines • ▼ Show 20 Linesstruct __iterator_traits<_Ip> {
using reference = void; using reference = void;
}; };
template<class _Ip> template<class _Ip>
struct iterator_traits : __iterator_traits<_Ip> { struct iterator_traits : __iterator_traits<_Ip> {
using __primary_template = iterator_traits; using __primary_template = iterator_traits;
}; };
#else // _LIBCPP_STD_VER > 17 #else // _LIBCPP_STD_VER >= 20
template <class _Iter, bool> struct __iterator_traits {}; template <class _Iter, bool> struct __iterator_traits {};
template <class _Iter, bool> struct __iterator_traits_impl {}; template <class _Iter, bool> struct __iterator_traits_impl {};
template <class _Iter> template <class _Iter>
struct __iterator_traits_impl<_Iter, true> struct __iterator_traits_impl<_Iter, true>
{ {
Show All 20 Lines
// the client expects instead of failing at compile time. // the client expects instead of failing at compile time.
template <class _Iter> template <class _Iter>
struct _LIBCPP_TEMPLATE_VIS iterator_traits struct _LIBCPP_TEMPLATE_VIS iterator_traits
: __iterator_traits<_Iter, __has_iterator_typedefs<_Iter>::value> { : __iterator_traits<_Iter, __has_iterator_typedefs<_Iter>::value> {
using __primary_template = iterator_traits; using __primary_template = iterator_traits;
}; };
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
template<class _Tp> template<class _Tp>
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
requires is_object_v<_Tp> requires is_object_v<_Tp>
#endif #endif
struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*> struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*>
{ {
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
typedef __remove_cv_t<_Tp> value_type; typedef __remove_cv_t<_Tp> value_type;
typedef _Tp* pointer; typedef _Tp* pointer;
typedef _Tp& reference; typedef _Tp& reference;
typedef random_access_iterator_tag iterator_category; typedef random_access_iterator_tag iterator_category;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
typedef contiguous_iterator_tag iterator_concept; typedef contiguous_iterator_tag iterator_concept;
#endif #endif
}; };
template <class _Tp, class _Up, bool = __has_iterator_category<iterator_traits<_Tp> >::value> template <class _Tp, class _Up, bool = __has_iterator_category<iterator_traits<_Tp> >::value>
struct __has_iterator_category_convertible_to struct __has_iterator_category_convertible_to
: is_convertible<typename iterator_traits<_Tp>::iterator_category, _Up> : is_convertible<typename iterator_traits<_Tp>::iterator_category, _Up>
{}; {};
Show All 23 Lines
// __is_cpp17_contiguous_iterator determines if an iterator is known by // __is_cpp17_contiguous_iterator determines if an iterator is known by
// libc++ to be contiguous, either because it advertises itself as such // libc++ to be contiguous, either because it advertises itself as such
// (in C++20) or because it is a pointer type or a known trivial wrapper // (in C++20) or because it is a pointer type or a known trivial wrapper
// around a (possibly fancy) pointer type, such as __wrap_iter<T*>. // around a (possibly fancy) pointer type, such as __wrap_iter<T*>.
// Such iterators receive special "contiguous" optimizations in // Such iterators receive special "contiguous" optimizations in
// std::copy and std::sort. // std::copy and std::sort.
// //
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Tp> template <class _Tp>
struct __is_cpp17_contiguous_iterator : _Or< struct __is_cpp17_contiguous_iterator : _Or<
__has_iterator_category_convertible_to<_Tp, contiguous_iterator_tag>, __has_iterator_category_convertible_to<_Tp, contiguous_iterator_tag>,
__has_iterator_concept_convertible_to<_Tp, contiguous_iterator_tag> __has_iterator_concept_convertible_to<_Tp, contiguous_iterator_tag>
> {}; > {};
#else #else
template <class _Tp> template <class _Tp>
struct __is_cpp17_contiguous_iterator : false_type {}; struct __is_cpp17_contiguous_iterator : false_type {};
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/include/__iterator/mergeable.h

Show All 16 Lines
#include <__iterator/projected.h> #include <__iterator/projected.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 #if _LIBCPP_STD_VER >= 20
template <class _Input1, class _Input2, class _Output, template <class _Input1, class _Input2, class _Output,
class _Comp = ranges::less, class _Proj1 = identity, class _Proj2 = identity> class _Comp = ranges::less, class _Proj1 = identity, class _Proj2 = identity>
concept mergeable = concept mergeable =
input_iterator<_Input1> && input_iterator<_Input1> &&
input_iterator<_Input2> && input_iterator<_Input2> &&
weakly_incrementable<_Output> && weakly_incrementable<_Output> &&
indirectly_copyable<_Input1, _Output> && indirectly_copyable<_Input1, _Output> &&
indirectly_copyable<_Input2, _Output> && indirectly_copyable<_Input2, _Output> &&
indirect_strict_weak_order<_Comp, projected<_Input1, _Proj1>, projected<_Input2, _Proj2>>; indirect_strict_weak_order<_Comp, projected<_Input1, _Proj1>, projected<_Input2, _Proj2>>;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_MERGEABLE_H #endif // _LIBCPP___ITERATOR_MERGEABLE_H

libcxx/include/__iterator/move_iterator.h

Show All 35 Lines
#include <__utility/move.h> #include <__utility/move.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 #if _LIBCPP_STD_VER >= 20
template<class _Iter, class = void> template<class _Iter, class = void>
struct __move_iter_category_base {}; struct __move_iter_category_base {};
template<class _Iter> template<class _Iter>
requires requires { typename iterator_traits<_Iter>::iterator_category; } requires requires { typename iterator_traits<_Iter>::iterator_category; }
struct __move_iter_category_base<_Iter> { struct __move_iter_category_base<_Iter> {
using iterator_category = _If< using iterator_category = _If<
derived_from<typename iterator_traits<_Iter>::iterator_category, random_access_iterator_tag>, derived_from<typename iterator_traits<_Iter>::iterator_category, random_access_iterator_tag>,
random_access_iterator_tag, random_access_iterator_tag,
typename iterator_traits<_Iter>::iterator_category typename iterator_traits<_Iter>::iterator_category
>; >;
}; };
template<class _Iter, class _Sent> template<class _Iter, class _Sent>
concept __move_iter_comparable = requires { concept __move_iter_comparable = requires {
{ std::declval<const _Iter&>() == std::declval<_Sent>() } -> convertible_to<bool>; { std::declval<const _Iter&>() == std::declval<_Sent>() } -> convertible_to<bool>;
}; };
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
template <class _Iter> template <class _Iter>
class _LIBCPP_TEMPLATE_VIS move_iterator class _LIBCPP_TEMPLATE_VIS move_iterator
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
: public __move_iter_category_base<_Iter> : public __move_iter_category_base<_Iter>
#endif #endif
{ {
public: public:
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
using iterator_type = _Iter; using iterator_type = _Iter;
using iterator_concept = input_iterator_tag; using iterator_concept = input_iterator_tag;
// iterator_category is inherited and not always present // iterator_category is inherited and not always present
using value_type = iter_value_t<_Iter>; using value_type = iter_value_t<_Iter>;
using difference_type = iter_difference_t<_Iter>; using difference_type = iter_difference_t<_Iter>;
using pointer = _Iter; using pointer = _Iter;
using reference = iter_rvalue_reference_t<_Iter>; using reference = iter_rvalue_reference_t<_Iter>;
#else #else
typedef _Iter iterator_type; typedef _Iter iterator_type;
typedef _If< typedef _If<
__is_cpp17_random_access_iterator<_Iter>::value, __is_cpp17_random_access_iterator<_Iter>::value,
random_access_iterator_tag, random_access_iterator_tag,
typename iterator_traits<_Iter>::iterator_category typename iterator_traits<_Iter>::iterator_category
> iterator_category; > iterator_category;
typedef typename iterator_traits<iterator_type>::value_type value_type; typedef typename iterator_traits<iterator_type>::value_type value_type;
typedef typename iterator_traits<iterator_type>::difference_type difference_type; typedef typename iterator_traits<iterator_type>::difference_type difference_type;
typedef iterator_type pointer; typedef iterator_type pointer;
typedef typename iterator_traits<iterator_type>::reference __reference; typedef typename iterator_traits<iterator_type>::reference __reference;
typedef typename conditional< typedef typename conditional<
is_reference<__reference>::value, is_reference<__reference>::value,
__libcpp_remove_reference_t<__reference>&&, __libcpp_remove_reference_t<__reference>&&,
__reference __reference
>::type reference; >::type reference;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {} explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
move_iterator& operator++() { ++__current_; return *this; } move_iterator& operator++() { ++__current_; return *this; }
_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
pointer operator->() const { return __current_; } pointer operator->() const { return __current_; }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
move_iterator() requires is_constructible_v<_Iter> : __current_() {} move_iterator() requires is_constructible_v<_Iter> : __current_() {}
template <class _Up> template <class _Up>
requires (!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter> requires (!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {} move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines#else
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
reference operator*() const { return static_cast<reference>(*__current_); } reference operator*() const { return static_cast<reference>(*__current_); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
reference operator[](difference_type __n) const { return static_cast<reference>(__current_[__n]); } reference operator[](difference_type __n) const { return static_cast<reference>(__current_[__n]); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
move_iterator operator++(int) { move_iterator __tmp(*this); ++__current_; return __tmp; } move_iterator operator++(int) { move_iterator __tmp(*this); ++__current_; return __tmp; }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
move_iterator& operator--() { --__current_; return *this; } move_iterator& operator--() { --__current_; return *this; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
move_iterator operator--(int) { move_iterator __tmp(*this); --__current_; return __tmp; } move_iterator operator--(int) { move_iterator __tmp(*this); --__current_; return __tmp; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
move_iterator operator+(difference_type __n) const { return move_iterator(__current_ + __n); } move_iterator operator+(difference_type __n) const { return move_iterator(__current_ + __n); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
move_iterator& operator+=(difference_type __n) { __current_ += __n; return *this; } move_iterator& operator+=(difference_type __n) { __current_ += __n; return *this; }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
move_iterator operator-(difference_type __n) const { return move_iterator(__current_ - __n); } move_iterator operator-(difference_type __n) const { return move_iterator(__current_ - __n); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
move_iterator& operator-=(difference_type __n) { __current_ -= __n; return *this; } move_iterator& operator-=(difference_type __n) { __current_ -= __n; return *this; }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template<sentinel_for<_Iter> _Sent> template<sentinel_for<_Iter> _Sent>
friend _LIBCPP_HIDE_FROM_ABI constexpr friend _LIBCPP_HIDE_FROM_ABI constexpr
bool operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y) bool operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
requires __move_iter_comparable<_Iter, _Sent> requires __move_iter_comparable<_Iter, _Sent>
{ {
return __x.base() == __y.base(); return __x.base() == __y.base();
} }
Show All 20 Lines#if _LIBCPP_STD_VER >= 20
template<indirectly_swappable<_Iter> _It2> template<indirectly_swappable<_Iter> _It2>
friend _LIBCPP_HIDE_FROM_ABI constexpr friend _LIBCPP_HIDE_FROM_ABI constexpr
void iter_swap(const move_iterator& __x, const move_iterator<_It2>& __y) void iter_swap(const move_iterator& __x, const move_iterator<_It2>& __y)
noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_))) noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
{ {
return ranges::iter_swap(__x.__current_, __y.__current_); return ranges::iter_swap(__x.__current_, __y.__current_);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
private: private:
template<class _It2> friend class move_iterator; template<class _It2> friend class move_iterator;
_Iter __current_; _Iter __current_;
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_iterator); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_iterator);
Show All 36 Lines
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
bool operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) bool operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
{ {
return __x.base() >= __y.base(); return __x.base() >= __y.base();
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2> template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
inline _LIBCPP_HIDE_FROM_ABI constexpr inline _LIBCPP_HIDE_FROM_ABI constexpr
auto operator<=>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) auto operator<=>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-> compare_three_way_result_t<_Iter1, _Iter2> -> compare_three_way_result_t<_Iter1, _Iter2>
{ {
return __x.base() <=> __y.base(); return __x.base() <=> __y.base();
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
auto operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) auto operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-> decltype(__x.base() - __y.base()) -> decltype(__x.base() - __y.base())
{ {
return __x.base() - __y.base(); return __x.base() - __y.base();
} }
#else #else
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename move_iterator<_Iter1>::difference_type typename move_iterator<_Iter1>::difference_type
operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
{ {
return __x.base() - __y.base(); return __x.base() - __y.base();
} }
#endif // !_LIBCPP_CXX03_LANG #endif // !_LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Iter> template <class _Iter>
inline _LIBCPP_HIDE_FROM_ABI constexpr inline _LIBCPP_HIDE_FROM_ABI constexpr
move_iterator<_Iter> operator+(iter_difference_t<_Iter> __n, const move_iterator<_Iter>& __x) move_iterator<_Iter> operator+(iter_difference_t<_Iter> __n, const move_iterator<_Iter>& __x)
requires requires { { __x.base() + __n } -> same_as<_Iter>; } requires requires { { __x.base() + __n } -> same_as<_Iter>; }
{ {
return __x + __n; return __x + __n;
} }
#else #else
template <class _Iter> template <class _Iter>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
move_iterator<_Iter> move_iterator<_Iter>
operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x) operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x)
{ {
return move_iterator<_Iter>(__x.base() + __n); return move_iterator<_Iter>(__x.base() + __n);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
template <class _Iter> template <class _Iter>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
move_iterator<_Iter> move_iterator<_Iter>
make_move_iterator(_Iter __i) make_move_iterator(_Iter __i)
{ {
return move_iterator<_Iter>(std::move(__i)); return move_iterator<_Iter>(std::move(__i));
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_MOVE_ITERATOR_H #endif // _LIBCPP___ITERATOR_MOVE_ITERATOR_H

libcxx/include/__iterator/move_sentinel.h

Show All 15 Lines
#include <__utility/move.h> #include <__utility/move.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 #if _LIBCPP_STD_VER >= 20
template <semiregular _Sent> template <semiregular _Sent>
class _LIBCPP_TEMPLATE_VIS move_sentinel class _LIBCPP_TEMPLATE_VIS move_sentinel
{ {
public: public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
move_sentinel() = default; move_sentinel() = default;
Show All 14 Linespublic:
constexpr _Sent base() const { return __last_; } constexpr _Sent base() const { return __last_; }
private: private:
_Sent __last_ = _Sent(); _Sent __last_ = _Sent();
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_sentinel); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_sentinel);
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_MOVE_SENTINEL_H #endif // _LIBCPP___ITERATOR_MOVE_SENTINEL_H

libcxx/include/__iterator/next.h

Show All 29 Linesinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
next(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) { next(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
_LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value, _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
"Attempt to next(it, n) with negative n on a non-bidirectional iterator"); "Attempt to next(it, n) with negative n on a non-bidirectional iterator");
_VSTD::advance(__x, __n); _VSTD::advance(__x, __n);
return __x; return __x;
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
// [range.iter.op.next] // [range.iter.op.next]
namespace ranges { namespace ranges {
namespace __next { namespace __next {
struct __fn { struct __fn {
template <input_or_output_iterator _Ip> template <input_or_output_iterator _Ip>
Show All 25 Lines
} // namespace __next } // namespace __next
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto next = __next::__fn{}; inline constexpr auto next = __next::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_NEXT_H #endif // _LIBCPP___ITERATOR_NEXT_H

libcxx/include/__iterator/ostream_iterator.h

Show All 28 Lines
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#else #else
typedef void difference_type; typedef void difference_type;
#endif #endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
Show All 26 Lines

libcxx/include/__iterator/ostreambuf_iterator.h

Show All 27 Lines
#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES) #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
: public iterator<output_iterator_tag, void, void, void, void> : public iterator<output_iterator_tag, void, void, void, void>
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#else #else
typedef void difference_type; typedef void difference_type;
#endif #endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
typedef _CharT char_type; typedef _CharT char_type;
typedef _Traits traits_type; typedef _Traits traits_type;
Show All 33 Lines

libcxx/include/__iterator/permutable.h

Show All 14 Lines
#include <__iterator/iter_swap.h> #include <__iterator/iter_swap.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 #if _LIBCPP_STD_VER >= 20
template <class _Iterator> template <class _Iterator>
concept permutable = concept permutable =
forward_iterator<_Iterator> && forward_iterator<_Iterator> &&
indirectly_movable_storable<_Iterator, _Iterator> && indirectly_movable_storable<_Iterator, _Iterator> &&
indirectly_swappable<_Iterator, _Iterator>; indirectly_swappable<_Iterator, _Iterator>;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_PERMUTABLE_H #endif // _LIBCPP___ITERATOR_PERMUTABLE_H

libcxx/include/__iterator/prev.h

Show All 28 Linesinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
typename enable_if<__is_cpp17_input_iterator<_InputIter>::value, _InputIter>::type typename enable_if<__is_cpp17_input_iterator<_InputIter>::value, _InputIter>::type
prev(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) { prev(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
_LIBCPP_ASSERT(__n <= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value, _LIBCPP_ASSERT(__n <= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
"Attempt to prev(it, n) with a positive n on a non-bidirectional iterator"); "Attempt to prev(it, n) with a positive n on a non-bidirectional iterator");
_VSTD::advance(__x, -__n); _VSTD::advance(__x, -__n);
return __x; return __x;
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
// [range.iter.op.prev] // [range.iter.op.prev]
namespace ranges { namespace ranges {
namespace __prev { namespace __prev {
struct __fn { struct __fn {
template <bidirectional_iterator _Ip> template <bidirectional_iterator _Ip>
Show All 19 Lines
} // namespace __prev } // namespace __prev
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto prev = __prev::__fn{}; inline constexpr auto prev = __prev::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_PREV_H #endif // _LIBCPP___ITERATOR_PREV_H

libcxx/include/__iterator/projected.h

Show All 15 Lines
#include <__type_traits/remove_cvref.h> #include <__type_traits/remove_cvref.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 #if _LIBCPP_STD_VER >= 20
template<indirectly_readable _It, indirectly_regular_unary_invocable<_It> _Proj> template<indirectly_readable _It, indirectly_regular_unary_invocable<_It> _Proj>
struct projected { struct projected {
using value_type = remove_cvref_t<indirect_result_t<_Proj&, _It>>; using value_type = remove_cvref_t<indirect_result_t<_Proj&, _It>>;
indirect_result_t<_Proj&, _It> operator*() const; // not defined indirect_result_t<_Proj&, _It> operator*() const; // not defined
}; };
template<weakly_incrementable _It, class _Proj> template<weakly_incrementable _It, class _Proj>
struct incrementable_traits<projected<_It, _Proj>> { struct incrementable_traits<projected<_It, _Proj>> {
using difference_type = iter_difference_t<_It>; using difference_type = iter_difference_t<_It>;
}; };
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_PROJECTED_H #endif // _LIBCPP___ITERATOR_PROJECTED_H

libcxx/include/__iterator/readable_traits.h

Show All 20 Lines
#include <__type_traits/remove_extent.h> #include <__type_traits/remove_extent.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 #if _LIBCPP_STD_VER >= 20
// [readable.traits] // [readable.traits]
template<class> struct __cond_value_type {}; template<class> struct __cond_value_type {};
template<class _Tp> template<class _Tp>
requires is_object_v<_Tp> requires is_object_v<_Tp>
struct __cond_value_type<_Tp> { using value_type = remove_cv_t<_Tp>; }; struct __cond_value_type<_Tp> { using value_type = remove_cv_t<_Tp>; };
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
// Let `RI` be `remove_cvref_t<I>`. The type `iter_value_t<I>` denotes // Let `RI` be `remove_cvref_t<I>`. The type `iter_value_t<I>` denotes
// `indirectly_readable_traits<RI>::value_type` if `iterator_traits<RI>` names a specialization // `indirectly_readable_traits<RI>::value_type` if `iterator_traits<RI>` names a specialization
// generated from the primary template, and `iterator_traits<RI>::value_type` otherwise. // generated from the primary template, and `iterator_traits<RI>::value_type` otherwise.
template <class _Ip> template <class _Ip>
using iter_value_t = typename conditional_t<__is_primary_template<iterator_traits<remove_cvref_t<_Ip> > >::value, using iter_value_t = typename conditional_t<__is_primary_template<iterator_traits<remove_cvref_t<_Ip> > >::value,
indirectly_readable_traits<remove_cvref_t<_Ip> >, indirectly_readable_traits<remove_cvref_t<_Ip> >,
iterator_traits<remove_cvref_t<_Ip> > >::value_type; iterator_traits<remove_cvref_t<_Ip> > >::value_type;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_READABLE_TRAITS_H #endif // _LIBCPP___ITERATOR_READABLE_TRAITS_H

libcxx/include/__iterator/reverse_access.h

Show All 15 Lines
#include <initializer_list> #include <initializer_list>
#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 > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp, size_t _Np> template <class _Tp, size_t _Np>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np]) reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np])
{ {
return reverse_iterator<_Tp*>(__array + _Np); return reverse_iterator<_Tp*>(__array + _Np);
} }
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
template <class _Cp> template <class _Cp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c)) auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c))
{ {
return _VSTD::rend(__c); return _VSTD::rend(__c);
} }
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_REVERSE_ACCESS_H #endif // _LIBCPP___ITERATOR_REVERSE_ACCESS_H

libcxx/include/__iterator/reverse_iterator.h

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
private: private:
#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES #ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
_Iter __t_; // no longer used as of LWG #2360, not removed due to ABI break _Iter __t_; // no longer used as of LWG #2360, not removed due to ABI break
#endif #endif
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
static_assert(__is_cpp17_bidirectional_iterator<_Iter>::value || bidirectional_iterator<_Iter>, static_assert(__is_cpp17_bidirectional_iterator<_Iter>::value || bidirectional_iterator<_Iter>,
"reverse_iterator<It> requires It to be a bidirectional iterator."); "reverse_iterator<It> requires It to be a bidirectional iterator.");
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
protected: protected:
_Iter current; _Iter current;
public: public:
using iterator_type = _Iter; using iterator_type = _Iter;
using iterator_category = _If<__is_cpp17_random_access_iterator<_Iter>::value, using iterator_category = _If<__is_cpp17_random_access_iterator<_Iter>::value,
random_access_iterator_tag, random_access_iterator_tag,
typename iterator_traits<_Iter>::iterator_category>; typename iterator_traits<_Iter>::iterator_category>;
using pointer = typename iterator_traits<_Iter>::pointer; using pointer = typename iterator_traits<_Iter>::pointer;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
using iterator_concept = _If<random_access_iterator<_Iter>, random_access_iterator_tag, bidirectional_iterator_tag>; using iterator_concept = _If<random_access_iterator<_Iter>, random_access_iterator_tag, bidirectional_iterator_tag>;
using value_type = iter_value_t<_Iter>; using value_type = iter_value_t<_Iter>;
using difference_type = iter_difference_t<_Iter>; using difference_type = iter_difference_t<_Iter>;
using reference = iter_reference_t<_Iter>; using reference = iter_reference_t<_Iter>;
#else #else
using value_type = typename iterator_traits<_Iter>::value_type; using value_type = typename iterator_traits<_Iter>::value_type;
using difference_type = typename iterator_traits<_Iter>::difference_type; using difference_type = typename iterator_traits<_Iter>::difference_type;
using reference = typename iterator_traits<_Iter>::reference; using reference = typename iterator_traits<_Iter>::reference;
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
return *this; return *this;
} }
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
_Iter base() const {return current;} _Iter base() const {return current;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reference operator*() const {_Iter __tmp = current; return *--__tmp;} reference operator*() const {_Iter __tmp = current; return *--__tmp;}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr pointer operator->() const constexpr pointer operator->() const
requires is_pointer_v<_Iter> || requires(const _Iter __i) { __i.operator->(); } requires is_pointer_v<_Iter> || requires(const _Iter __i) { __i.operator->(); }
{ {
if constexpr (is_pointer_v<_Iter>) { if constexpr (is_pointer_v<_Iter>) {
return std::prev(current); return std::prev(current);
} else { } else {
return std::prev(current).operator->(); return std::prev(current).operator->();
} }
} }
#else #else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
pointer operator->() const { pointer operator->() const {
return std::addressof(operator*()); return std::addressof(operator*());
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reverse_iterator& operator++() {--current; return *this;} reverse_iterator& operator++() {--current; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;} reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reverse_iterator& operator--() {++current; return *this;} reverse_iterator& operator--() {++current; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;} reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reverse_iterator operator+(difference_type __n) const {return reverse_iterator(current - __n);} reverse_iterator operator+(difference_type __n) const {return reverse_iterator(current - __n);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;} reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reverse_iterator operator-(difference_type __n) const {return reverse_iterator(current + __n);} reverse_iterator operator-(difference_type __n) const {return reverse_iterator(current + __n);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;} reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reference operator[](difference_type __n) const {return *(*this + __n);} reference operator[](difference_type __n) const {return *(*this + __n);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI friend constexpr _LIBCPP_HIDE_FROM_ABI friend constexpr
iter_rvalue_reference_t<_Iter> iter_move(const reverse_iterator& __i) iter_rvalue_reference_t<_Iter> iter_move(const reverse_iterator& __i)
noexcept(is_nothrow_copy_constructible_v<_Iter> && noexcept(is_nothrow_copy_constructible_v<_Iter> &&
noexcept(ranges::iter_move(--std::declval<_Iter&>()))) { noexcept(ranges::iter_move(--std::declval<_Iter&>()))) {
auto __tmp = __i.base(); auto __tmp = __i.base();
return ranges::iter_move(--__tmp); return ranges::iter_move(--__tmp);
} }
template <indirectly_swappable<_Iter> _Iter2> template <indirectly_swappable<_Iter> _Iter2>
_LIBCPP_HIDE_FROM_ABI friend constexpr _LIBCPP_HIDE_FROM_ABI friend constexpr
void iter_swap(const reverse_iterator& __x, const reverse_iterator<_Iter2>& __y) void iter_swap(const reverse_iterator& __x, const reverse_iterator<_Iter2>& __y)
noexcept(is_nothrow_copy_constructible_v<_Iter> && noexcept(is_nothrow_copy_constructible_v<_Iter> &&
is_nothrow_copy_constructible_v<_Iter2> && is_nothrow_copy_constructible_v<_Iter2> &&
noexcept(ranges::iter_swap(--std::declval<_Iter&>(), --std::declval<_Iter2&>()))) { noexcept(ranges::iter_swap(--std::declval<_Iter&>(), --std::declval<_Iter2&>()))) {
auto __xtmp = __x.base(); auto __xtmp = __x.base();
auto __ytmp = __y.base(); auto __ytmp = __y.base();
ranges::iter_swap(--__xtmp, --__ytmp); ranges::iter_swap(--__xtmp, --__ytmp);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
}; };
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
bool bool
operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
requires requires { requires requires {
{ __x.base() == __y.base() } -> convertible_to<bool>; { __x.base() == __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
{ {
return __x.base() == __y.base(); return __x.base() == __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
bool bool
operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
requires requires { requires requires {
{ __x.base() > __y.base() } -> convertible_to<bool>; { __x.base() > __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
{ {
return __x.base() > __y.base(); return __x.base() > __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
bool bool
operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
requires requires { requires requires {
{ __x.base() != __y.base() } -> convertible_to<bool>; { __x.base() != __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
{ {
return __x.base() != __y.base(); return __x.base() != __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
bool bool
operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
requires requires { requires requires {
{ __x.base() < __y.base() } -> convertible_to<bool>; { __x.base() < __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
{ {
return __x.base() < __y.base(); return __x.base() < __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
bool bool
operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
requires requires { requires requires {
{ __x.base() <= __y.base() } -> convertible_to<bool>; { __x.base() <= __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
{ {
return __x.base() <= __y.base(); return __x.base() <= __y.base();
} }
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
bool bool
operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
requires requires { requires requires {
{ __x.base() >= __y.base() } -> convertible_to<bool>; { __x.base() >= __y.base() } -> convertible_to<bool>;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
{ {
return __x.base() >= __y.base(); return __x.base() >= __y.base();
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
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 // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
auto auto
operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
-> decltype(__y.base() - __x.base()) -> decltype(__y.base() - __x.base())
{ {
Show All 12 Lines
template <class _Iter> template <class _Iter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reverse_iterator<_Iter> reverse_iterator<_Iter>
operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x) operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
{ {
return reverse_iterator<_Iter>(__x.base() - __n); return reverse_iterator<_Iter>(__x.base() - __n);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Iter1, class _Iter2> template <class _Iter1, class _Iter2>
requires (!sized_sentinel_for<_Iter1, _Iter2>) requires (!sized_sentinel_for<_Iter1, _Iter2>)
inline constexpr bool disable_sized_sentinel_for<reverse_iterator<_Iter1>, reverse_iterator<_Iter2>> = true; inline constexpr bool disable_sized_sentinel_for<reverse_iterator<_Iter1>, reverse_iterator<_Iter2>> = true;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Iter> template <class _Iter>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
reverse_iterator<_Iter> make_reverse_iterator(_Iter __i) reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
{ {
return reverse_iterator<_Iter>(__i); return reverse_iterator<_Iter>(__i);
} }
#endif #endif
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines return _ReverseWrapper(
_RevIter2<_Iter>(__unwrap_iter_impl<_Iter>::__rewrap(__orig_iter.base().base(), __unwrapped_iter))); _RevIter2<_Iter>(__unwrap_iter_impl<_Iter>::__rewrap(__orig_iter.base().base(), __unwrapped_iter)));
} }
static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _UnwrappedIter __unwrap(_ReverseWrapper __i) _NOEXCEPT { static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _UnwrappedIter __unwrap(_ReverseWrapper __i) _NOEXCEPT {
return __unwrap_iter_impl<_Iter>::__unwrap(__i.base().base()); return __unwrap_iter_impl<_Iter>::__unwrap(__i.base().base());
} }
}; };
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <ranges::bidirectional_range _Range> template <ranges::bidirectional_range _Range>
_LIBCPP_HIDE_FROM_ABI constexpr ranges:: _LIBCPP_HIDE_FROM_ABI constexpr ranges::
subrange<reverse_iterator<ranges::iterator_t<_Range>>, reverse_iterator<ranges::iterator_t<_Range>>> subrange<reverse_iterator<ranges::iterator_t<_Range>>, reverse_iterator<ranges::iterator_t<_Range>>>
__reverse_range(_Range&& __range) { __reverse_range(_Range&& __range) {
auto __first = ranges::begin(__range); auto __first = ranges::begin(__range);
return {std::make_reverse_iterator(ranges::next(__first, ranges::end(__range))), std::make_reverse_iterator(__first)}; return {std::make_reverse_iterator(ranges::next(__first, ranges::end(__range))), std::make_reverse_iterator(__first)};
} }
#endif #endif
template <class _Iter, bool __b> template <class _Iter, bool __b>
struct __unwrap_iter_impl<reverse_iterator<reverse_iterator<_Iter> >, __b> struct __unwrap_iter_impl<reverse_iterator<reverse_iterator<_Iter> >, __b>
: __unwrap_reverse_iter_impl<reverse_iterator, reverse_iterator, _Iter> {}; : __unwrap_reverse_iter_impl<reverse_iterator, reverse_iterator, _Iter> {};
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Iter, bool __b> template <class _Iter, bool __b>
struct __unwrap_iter_impl<reverse_iterator<__unconstrained_reverse_iterator<_Iter>>, __b> struct __unwrap_iter_impl<reverse_iterator<__unconstrained_reverse_iterator<_Iter>>, __b>
: __unwrap_reverse_iter_impl<reverse_iterator, __unconstrained_reverse_iterator, _Iter> {}; : __unwrap_reverse_iter_impl<reverse_iterator, __unconstrained_reverse_iterator, _Iter> {};
template <class _Iter, bool __b> template <class _Iter, bool __b>
struct __unwrap_iter_impl<__unconstrained_reverse_iterator<reverse_iterator<_Iter>>, __b> struct __unwrap_iter_impl<__unconstrained_reverse_iterator<reverse_iterator<_Iter>>, __b>
: __unwrap_reverse_iter_impl<__unconstrained_reverse_iterator, reverse_iterator, _Iter> {}; : __unwrap_reverse_iter_impl<__unconstrained_reverse_iterator, reverse_iterator, _Iter> {};
template <class _Iter, bool __b> template <class _Iter, bool __b>
struct __unwrap_iter_impl<__unconstrained_reverse_iterator<__unconstrained_reverse_iterator<_Iter>>, __b> struct __unwrap_iter_impl<__unconstrained_reverse_iterator<__unconstrained_reverse_iterator<_Iter>>, __b>
: __unwrap_reverse_iter_impl<__unconstrained_reverse_iterator, __unconstrained_reverse_iterator, _Iter> {}; : __unwrap_reverse_iter_impl<__unconstrained_reverse_iterator, __unconstrained_reverse_iterator, _Iter> {};
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_REVERSE_ITERATOR_H #endif // _LIBCPP___ITERATOR_REVERSE_ITERATOR_H

libcxx/include/__iterator/size.h

Show All 15 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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _Cont> template <class _Cont>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr auto size(const _Cont& __c) constexpr auto size(const _Cont& __c)
_NOEXCEPT_(noexcept(__c.size())) _NOEXCEPT_(noexcept(__c.size()))
-> decltype (__c.size()) -> decltype (__c.size())
{ return __c.size(); } { return __c.size(); }
template <class _Tp, size_t _Sz> template <class _Tp, size_t _Sz>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr size_t size(const _Tp (&)[_Sz]) noexcept { return _Sz; } constexpr size_t size(const _Tp (&)[_Sz]) noexcept { return _Sz; }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Cont> template <class _Cont>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr auto ssize(const _Cont& __c) constexpr auto ssize(const _Cont& __c)
_NOEXCEPT_(noexcept(static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size()))) _NOEXCEPT_(noexcept(static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size())))
-> common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>> -> common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>
{ return static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size()); } { return static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size()); }
// GCC complains about the implicit conversion from ptrdiff_t to size_t in // GCC complains about the implicit conversion from ptrdiff_t to size_t in
// the array bound. // the array bound.
_LIBCPP_DIAGNOSTIC_PUSH _LIBCPP_DIAGNOSTIC_PUSH
_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wsign-conversion") _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wsign-conversion")
template <class _Tp, ptrdiff_t _Sz> template <class _Tp, ptrdiff_t _Sz>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr ptrdiff_t ssize(const _Tp (&)[_Sz]) noexcept { return _Sz; } constexpr ptrdiff_t ssize(const _Tp (&)[_Sz]) noexcept { return _Sz; }
_LIBCPP_DIAGNOSTIC_POP _LIBCPP_DIAGNOSTIC_POP
#endif #endif
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_SIZE_H #endif // _LIBCPP___ITERATOR_SIZE_H

libcxx/include/__iterator/sortable.h

Show All 17 Lines
#include <__iterator/projected.h> #include <__iterator/projected.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 #if _LIBCPP_STD_VER >= 20
template <class _Iter, class _Comp = ranges::less, class _Proj = identity> template <class _Iter, class _Comp = ranges::less, class _Proj = identity>
concept sortable = concept sortable =
permutable<_Iter> && permutable<_Iter> &&
indirect_strict_weak_order<_Comp, projected<_Iter, _Proj>>; indirect_strict_weak_order<_Comp, projected<_Iter, _Proj>>;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_SORTABLE_H #endif // _LIBCPP___ITERATOR_SORTABLE_H

libcxx/include/__iterator/unreachable_sentinel.h

Show All 13 Lines
#include <__iterator/concepts.h> #include <__iterator/concepts.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 #if _LIBCPP_STD_VER >= 20
struct unreachable_sentinel_t { struct unreachable_sentinel_t {
template<weakly_incrementable _Iter> template<weakly_incrementable _Iter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
friend constexpr bool operator==(unreachable_sentinel_t, const _Iter&) noexcept { friend constexpr bool operator==(unreachable_sentinel_t, const _Iter&) noexcept {
return false; return false;
} }
}; };
inline constexpr unreachable_sentinel_t unreachable_sentinel{}; inline constexpr unreachable_sentinel_t unreachable_sentinel{};
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_UNREACHABLE_SENTINEL_H #endif // _LIBCPP___ITERATOR_UNREACHABLE_SENTINEL_H

libcxx/include/__iterator/wrap_iter.h

Show All 28 Lines
{ {
public: public:
typedef _Iter iterator_type; typedef _Iter iterator_type;
typedef typename iterator_traits<iterator_type>::value_type value_type; typedef typename iterator_traits<iterator_type>::value_type value_type;
typedef typename iterator_traits<iterator_type>::difference_type difference_type; typedef typename iterator_traits<iterator_type>::difference_type difference_type;
typedef typename iterator_traits<iterator_type>::pointer pointer; typedef typename iterator_traits<iterator_type>::pointer pointer;
typedef typename iterator_traits<iterator_type>::reference reference; typedef typename iterator_traits<iterator_type>::reference reference;
typedef typename iterator_traits<iterator_type>::iterator_category iterator_category; typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
typedef contiguous_iterator_tag iterator_concept; typedef contiguous_iterator_tag iterator_concept;
#endif #endif
private: private:
iterator_type __i_; iterator_type __i_;
public: public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter() _NOEXCEPT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter() _NOEXCEPT
: __i_() : __i_()
▲ Show 20 Lines • Show All 241 Lines • Show Last 20 Lines

libcxx/include/__memory/aligned_alloc.h

Show All 25 Lines
// allocation routines -- if you need to allocate memory inside the library, // allocation routines -- if you need to allocate memory inside the library,
// chances are that you want to use `__libcpp_allocate` instead. // chances are that you want to use `__libcpp_allocate` instead.
// //
// Returns the allocated memory, or `nullptr` on failure. // Returns the allocated memory, or `nullptr` on failure.
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
void* __libcpp_aligned_alloc(std::size_t __alignment, std::size_t __size) { void* __libcpp_aligned_alloc(std::size_t __alignment, std::size_t __size) {
# if defined(_LIBCPP_MSVCRT_LIKE) # if defined(_LIBCPP_MSVCRT_LIKE)
return ::_aligned_malloc(__size, __alignment); return ::_aligned_malloc(__size, __alignment);
# elif _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_C11_ALIGNED_ALLOC) # elif _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_C11_ALIGNED_ALLOC)
// aligned_alloc() requires that __size is a multiple of __alignment, // aligned_alloc() requires that __size is a multiple of __alignment,
// but for C++ [new.delete.general], only states "if the value of an // but for C++ [new.delete.general], only states "if the value of an
// alignment argument passed to any of these functions is not a valid // alignment argument passed to any of these functions is not a valid
// alignment value, the behavior is undefined". // alignment value, the behavior is undefined".
// To handle calls such as ::operator new(1, std::align_val_t(128)), we // To handle calls such as ::operator new(1, std::align_val_t(128)), we
// round __size up to the next multiple of __alignment. // round __size up to the next multiple of __alignment.
size_t __rounded_size = (__size + __alignment - 1) & ~(__alignment - 1); size_t __rounded_size = (__size + __alignment - 1) & ~(__alignment - 1);
// Rounding up could have wrapped around to zero, so we have to add another // Rounding up could have wrapped around to zero, so we have to add another
Show All 24 Lines

libcxx/include/__memory/allocate_at_least.h

Show All 13 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 > 20 #if _LIBCPP_STD_VER >= 23
template <class _Pointer> template <class _Pointer>
struct allocation_result { struct allocation_result {
_Pointer ptr; _Pointer ptr;
size_t count; size_t count;
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(allocation_result); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(allocation_result);
template <class _Alloc> template <class _Alloc>
Show All 19 Lines
}; };
template <class _Alloc> template <class _Alloc>
_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
__allocation_result<typename allocator_traits<_Alloc>::pointer> __allocate_at_least(_Alloc& __alloc, size_t __n) { __allocation_result<typename allocator_traits<_Alloc>::pointer> __allocate_at_least(_Alloc& __alloc, size_t __n) {
return {__alloc.allocate(__n), __n}; return {__alloc.allocate(__n), __n};
} }
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_ALLOCATE_AT_LEAST_H #endif // _LIBCPP___MEMORY_ALLOCATE_AT_LEAST_H

libcxx/include/__memory/allocator.h

Show First 20 Lines • Show All 110 Lines • ▼ Show 20 Lines _Tp* allocate(size_t __n) {
__throw_bad_array_new_length(); __throw_bad_array_new_length();
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} else { } else {
return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp))); return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
} }
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
allocation_result<_Tp*> allocate_at_least(size_t __n) { allocation_result<_Tp*> allocate_at_least(size_t __n) {
return {allocate(__n), __n}; return {allocate(__n), __n};
} }
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
void deallocate(_Tp* __p, size_t __n) _NOEXCEPT { void deallocate(_Tp* __p, size_t __n) _NOEXCEPT {
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines const _Tp* allocate(size_t __n) {
__throw_bad_array_new_length(); __throw_bad_array_new_length();
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
return static_cast<const _Tp*>(::operator new(__n * sizeof(_Tp))); return static_cast<const _Tp*>(::operator new(__n * sizeof(_Tp)));
} else { } else {
return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp))); return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
} }
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
allocation_result<const _Tp*> allocate_at_least(size_t __n) { allocation_result<const _Tp*> allocate_at_least(size_t __n) {
return {allocate(__n), __n}; return {allocate(__n), __n};
} }
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
void deallocate(const _Tp* __p, size_t __n) { void deallocate(const _Tp* __p, size_t __n) {
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

libcxx/include/__memory/allocator_traits.h

Show First 20 Lines • Show All 294 Lines • ▼ Show 20 Lines static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args) {
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
__a.construct(__p, _VSTD::forward<_Args>(__args)...); __a.construct(__p, _VSTD::forward<_Args>(__args)...);
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
} }
template <class _Tp, class... _Args, class = void, class = template <class _Tp, class... _Args, class = void, class =
__enable_if_t<!__has_construct<allocator_type, _Tp*, _Args...>::value> > __enable_if_t<!__has_construct<allocator_type, _Tp*, _Args...>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
static void construct(allocator_type&, _Tp* __p, _Args&&... __args) { static void construct(allocator_type&, _Tp* __p, _Args&&... __args) {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_VSTD::construct_at(__p, _VSTD::forward<_Args>(__args)...); _VSTD::construct_at(__p, _VSTD::forward<_Args>(__args)...);
#else #else
::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...); ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
#endif #endif
} }
template <class _Tp, class = template <class _Tp, class =
__enable_if_t<__has_destroy<allocator_type, _Tp*>::value> > __enable_if_t<__has_destroy<allocator_type, _Tp*>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
static void destroy(allocator_type& __a, _Tp* __p) { static void destroy(allocator_type& __a, _Tp* __p) {
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
__a.destroy(__p); __a.destroy(__p);
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
} }
template <class _Tp, class = void, class = template <class _Tp, class = void, class =
__enable_if_t<!__has_destroy<allocator_type, _Tp*>::value> > __enable_if_t<!__has_destroy<allocator_type, _Tp*>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
static void destroy(allocator_type&, _Tp* __p) { static void destroy(allocator_type&, _Tp* __p) {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_VSTD::destroy_at(__p); _VSTD::destroy_at(__p);
#else #else
__p->~_Tp(); __p->~_Tp();
#endif #endif
} }
template <class _Ap = _Alloc, class = template <class _Ap = _Alloc, class =
__enable_if_t<__has_max_size<const _Ap>::value> > __enable_if_t<__has_max_size<const _Ap>::value> >
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

libcxx/include/__memory/assume_aligned.h

Show All 16 Lines
#include <cstdint> #include <cstdint>
#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 #if _LIBCPP_STD_VER >= 20
template <size_t _Np, class _Tp> template <size_t _Np, class _Tp>
[[nodiscard]] [[nodiscard]]
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr _Tp* assume_aligned(_Tp* __ptr) { constexpr _Tp* assume_aligned(_Tp* __ptr) {
static_assert(_Np != 0 && (_Np & (_Np - 1)) == 0, static_assert(_Np != 0 && (_Np & (_Np - 1)) == 0,
"std::assume_aligned<N>(p) requires N to be a power of two"); "std::assume_aligned<N>(p) requires N to be a power of two");
if (is_constant_evaluated()) { if (is_constant_evaluated()) {
return __ptr; return __ptr;
} else { } else {
_LIBCPP_ASSERT(reinterpret_cast<uintptr_t>(__ptr) % _Np == 0, "Alignment assumption is violated"); _LIBCPP_ASSERT(reinterpret_cast<uintptr_t>(__ptr) % _Np == 0, "Alignment assumption is violated");
return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Np)); return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Np));
} }
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_ASSUME_ALIGNED_H #endif // _LIBCPP___MEMORY_ASSUME_ALIGNED_H

libcxx/include/__memory/concepts.h

Show All 20 Lines
#include <__type_traits/remove_cvref.h> #include <__type_traits/remove_cvref.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
// [special.mem.concepts] // [special.mem.concepts]
// This concept ensures that uninitialized algorithms can construct an object // This concept ensures that uninitialized algorithms can construct an object
// at the address pointed-to by the iterator, which requires an lvalue. // at the address pointed-to by the iterator, which requires an lvalue.
template <class _Ip> template <class _Ip>
Show All 19 Lines
template <class _Rp> template <class _Rp>
concept __nothrow_forward_range = concept __nothrow_forward_range =
__nothrow_input_range<_Rp> && __nothrow_input_range<_Rp> &&
__nothrow_forward_iterator<iterator_t<_Rp>>; __nothrow_forward_iterator<iterator_t<_Rp>>;
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_CONCEPTS_H #endif // _LIBCPP___MEMORY_CONCEPTS_H

libcxx/include/__memory/construct_at.h

Show All 24 Lines
#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
// construct_at // construct_at
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Tp, class... _Args, class = decltype(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))> template <class _Tp, class... _Args, class = decltype(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))>
_LIBCPP_HIDE_FROM_ABI constexpr _Tp* construct_at(_Tp* __location, _Args&&... __args) { _LIBCPP_HIDE_FROM_ABI constexpr _Tp* construct_at(_Tp* __location, _Args&&... __args) {
_LIBCPP_ASSERT(__location != nullptr, "null pointer given to construct_at"); _LIBCPP_ASSERT(__location != nullptr, "null pointer given to construct_at");
return ::new (std::__voidify(*__location)) _Tp(std::forward<_Args>(__args)...); return ::new (std::__voidify(*__location)) _Tp(std::forward<_Args>(__args)...);
} }
#endif #endif
template <class _Tp, class... _Args, class = decltype(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))> template <class _Tp, class... _Args, class = decltype(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp* __construct_at(_Tp* __location, _Args&&... __args) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp* __construct_at(_Tp* __location, _Args&&... __args) {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
return std::construct_at(__location, std::forward<_Args>(__args)...); return std::construct_at(__location, std::forward<_Args>(__args)...);
#else #else
return _LIBCPP_ASSERT(__location != nullptr, "null pointer given to construct_at"), return _LIBCPP_ASSERT(__location != nullptr, "null pointer given to construct_at"),
::new (std::__voidify(*__location)) _Tp(std::forward<_Args>(__args)...); ::new (std::__voidify(*__location)) _Tp(std::forward<_Args>(__args)...);
#endif #endif
} }
// destroy_at // destroy_at
// The internal functions are available regardless of the language version (with the exception of the `__destroy_at` // The internal functions are available regardless of the language version (with the exception of the `__destroy_at`
// taking an array). // taking an array).
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
_ForwardIterator __destroy(_ForwardIterator, _ForwardIterator); _ForwardIterator __destroy(_ForwardIterator, _ForwardIterator);
template <class _Tp, typename enable_if<!is_array<_Tp>::value, int>::type = 0> template <class _Tp, typename enable_if<!is_array<_Tp>::value, int>::type = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
void __destroy_at(_Tp* __loc) { void __destroy_at(_Tp* __loc) {
_LIBCPP_ASSERT(__loc != nullptr, "null pointer given to destroy_at"); _LIBCPP_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
__loc->~_Tp(); __loc->~_Tp();
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Tp, typename enable_if<is_array<_Tp>::value, int>::type = 0> template <class _Tp, typename enable_if<is_array<_Tp>::value, int>::type = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
void __destroy_at(_Tp* __loc) { void __destroy_at(_Tp* __loc) {
_LIBCPP_ASSERT(__loc != nullptr, "null pointer given to destroy_at"); _LIBCPP_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
std::__destroy(std::begin(*__loc), std::end(*__loc)); std::__destroy(std::begin(*__loc), std::end(*__loc));
} }
#endif #endif
Show All 10 Lines
_BidirectionalIterator __reverse_destroy(_BidirectionalIterator __first, _BidirectionalIterator __last) { _BidirectionalIterator __reverse_destroy(_BidirectionalIterator __first, _BidirectionalIterator __last) {
while (__last != __first) { while (__last != __first) {
--__last; --__last;
std::__destroy_at(std::addressof(*__last)); std::__destroy_at(std::addressof(*__last));
} }
return __last; return __last;
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, enable_if_t<!is_array_v<_Tp>, int> = 0> template <class _Tp, enable_if_t<!is_array_v<_Tp>, int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
void destroy_at(_Tp* __loc) { void destroy_at(_Tp* __loc) {
std::__destroy_at(__loc); std::__destroy_at(__loc);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Tp, enable_if_t<is_array_v<_Tp>, int> = 0> template <class _Tp, enable_if_t<is_array_v<_Tp>, int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
void destroy_at(_Tp* __loc) { void destroy_at(_Tp* __loc) {
std::__destroy_at(__loc); std::__destroy_at(__loc);
} }
#endif #endif
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
void destroy(_ForwardIterator __first, _ForwardIterator __last) { void destroy(_ForwardIterator __first, _ForwardIterator __last) {
(void)std::__destroy(std::move(__first), std::move(__last)); (void)std::__destroy(std::move(__first), std::move(__last));
} }
template <class _ForwardIterator, class _Size> template <class _ForwardIterator, class _Size>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
_ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) { _ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) {
for (; __n > 0; (void)++__first, --__n) for (; __n > 0; (void)++__first, --__n)
std::__destroy_at(std::addressof(*__first)); std::__destroy_at(std::addressof(*__first));
return __first; return __first;
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_CONSTRUCT_AT_H #endif // _LIBCPP___MEMORY_CONSTRUCT_AT_H

libcxx/include/__memory/pointer_traits.h

Show First 20 Lines • Show All 217 Lines • ▼ Show 20 Lines
struct __to_address_helper<_Pointer, decltype((void)pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>()))> { struct __to_address_helper<_Pointer, decltype((void)pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>()))> {
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
static decltype(pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>())) static decltype(pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>()))
__call(const _Pointer& __p) _NOEXCEPT { __call(const _Pointer& __p) _NOEXCEPT {
return pointer_traits<_Pointer>::to_address(__p); return pointer_traits<_Pointer>::to_address(__p);
} }
}; };
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Tp> template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY constexpr inline _LIBCPP_INLINE_VISIBILITY constexpr
auto to_address(_Tp *__p) noexcept { auto to_address(_Tp *__p) noexcept {
return _VSTD::__to_address(__p); return _VSTD::__to_address(__p);
} }
template <class _Pointer> template <class _Pointer>
inline _LIBCPP_INLINE_VISIBILITY constexpr inline _LIBCPP_INLINE_VISIBILITY constexpr
auto to_address(const _Pointer& __p) noexcept -> decltype(std::__to_address(__p)) { auto to_address(const _Pointer& __p) noexcept -> decltype(std::__to_address(__p)) {
return _VSTD::__to_address(__p); return _VSTD::__to_address(__p);
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_POINTER_TRAITS_H #endif // _LIBCPP___MEMORY_POINTER_TRAITS_H

libcxx/include/__memory/ranges_construct_at.h

Show All 24 Lines
#include <new> #include <new>
#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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
// construct_at // construct_at
namespace __construct_at { namespace __construct_at {
struct __fn { struct __fn {
template<class _Tp, class... _Args, class = decltype( template<class _Tp, class... _Args, class = decltype(
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
} // namespace __destroy_n } // namespace __destroy_n
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto destroy_n = __destroy_n::__fn{}; inline constexpr auto destroy_n = __destroy_n::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_RANGES_CONSTRUCT_AT_H #endif // _LIBCPP___MEMORY_RANGES_CONSTRUCT_AT_H

libcxx/include/__memory/ranges_uninitialized_algorithms.h

Show All 27 Lines
#include <new> #include <new>
#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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
// uninitialized_default_construct // uninitialized_default_construct
namespace __uninitialized_default_construct { namespace __uninitialized_default_construct {
struct __fn { struct __fn {
▲ Show 20 Lines • Show All 262 Lines • ▼ Show 20 Lines
} // namespace __uninitialized_move_n } // namespace __uninitialized_move_n
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto uninitialized_move_n = __uninitialized_move_n::__fn{}; inline constexpr auto uninitialized_move_n = __uninitialized_move_n::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_RANGES_UNINITIALIZED_ALGORITHMS_H #endif // _LIBCPP___MEMORY_RANGES_UNINITIALIZED_ALGORITHMS_H

libcxx/include/__memory/raw_storage_iterator.h

Show All 33 Lines
#endif #endif
{ {
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
private: private:
_OutputIterator __x_; _OutputIterator __x_;
public: public:
typedef output_iterator_tag iterator_category; typedef output_iterator_tag iterator_category;
typedef void value_type; typedef void value_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
typedef ptrdiff_t difference_type; typedef ptrdiff_t difference_type;
#else #else
typedef void difference_type; typedef void difference_type;
#endif #endif
typedef void pointer; typedef void pointer;
typedef void reference; typedef void reference;
_LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {} _LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {}
Show All 20 Lines

libcxx/include/__memory/shared_ptr.h

Show First 20 Lines • Show All 290 Lines • ▼ Show 20 Lines#endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_Alloc* __get_alloc() _NOEXCEPT { return __storage_.__get_alloc(); } _Alloc* __get_alloc() _NOEXCEPT { return __storage_.__get_alloc(); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_Tp* __get_elem() _NOEXCEPT { return __storage_.__get_elem(); } _Tp* __get_elem() _NOEXCEPT { return __storage_.__get_elem(); }
private: private:
void __on_zero_shared() _NOEXCEPT override { void __on_zero_shared() _NOEXCEPT override {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) { if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
__get_elem()->~_Tp(); __get_elem()->~_Tp();
} else { } else {
using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type; using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
_TpAlloc __tmp(*__get_alloc()); _TpAlloc __tmp(*__get_alloc());
allocator_traits<_TpAlloc>::destroy(__tmp, __get_elem()); allocator_traits<_TpAlloc>::destroy(__tmp, __get_elem());
} }
#else #else
▲ Show 20 Lines • Show All 146 Lines • ▼ Show 20 Lines
#else #else
# define _LIBCPP_SHARED_PTR_TRIVIAL_ABI # define _LIBCPP_SHARED_PTR_TRIVIAL_ABI
#endif #endif
template<class _Tp> template<class _Tp>
class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS shared_ptr class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS shared_ptr
{ {
public: public:
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typedef weak_ptr<_Tp> weak_type; typedef weak_ptr<_Tp> weak_type;
typedef remove_extent_t<_Tp> element_type; typedef remove_extent_t<_Tp> element_type;
#else #else
typedef _Tp element_type; typedef _Tp element_type;
#endif #endif
private: private:
element_type* __ptr_; element_type* __ptr_;
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Lines template <class _Yp, class _Dp, class = __enable_if_t<
!is_lvalue_reference<_Dp>::value && !is_lvalue_reference<_Dp>::value &&
__compatible_with<_Yp, _Tp>::value && __compatible_with<_Yp, _Tp>::value &&
is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value
> > > >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
shared_ptr(unique_ptr<_Yp, _Dp>&& __r) shared_ptr(unique_ptr<_Yp, _Dp>&& __r)
: __ptr_(__r.get()) : __ptr_(__r.get())
{ {
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
if (__ptr_ == nullptr) if (__ptr_ == nullptr)
__cntrl_ = nullptr; __cntrl_ = nullptr;
else else
#endif #endif
{ {
typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer, _Dp, _AllocT> _CntrlBlk; typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer, _Dp, _AllocT> _CntrlBlk;
__cntrl_ = new _CntrlBlk(__r.get(), std::move(__r.get_deleter()), _AllocT()); __cntrl_ = new _CntrlBlk(__r.get(), std::move(__r.get_deleter()), _AllocT());
__enable_weak_this(__r.get(), __r.get()); __enable_weak_this(__r.get(), __r.get());
} }
__r.release(); __r.release();
} }
template <class _Yp, class _Dp, class = void, class = __enable_if_t< template <class _Yp, class _Dp, class = void, class = __enable_if_t<
is_lvalue_reference<_Dp>::value && is_lvalue_reference<_Dp>::value &&
__compatible_with<_Yp, _Tp>::value && __compatible_with<_Yp, _Tp>::value &&
is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value
> > > >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
shared_ptr(unique_ptr<_Yp, _Dp>&& __r) shared_ptr(unique_ptr<_Yp, _Dp>&& __r)
: __ptr_(__r.get()) : __ptr_(__r.get())
{ {
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
if (__ptr_ == nullptr) if (__ptr_ == nullptr)
__cntrl_ = nullptr; __cntrl_ = nullptr;
else else
#endif #endif
{ {
typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer, typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer,
reference_wrapper<__libcpp_remove_reference_t<_Dp> >, reference_wrapper<__libcpp_remove_reference_t<_Dp> >,
▲ Show 20 Lines • Show All 156 Lines • ▼ Show 20 Lines#endif
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
bool __owner_equivalent(const shared_ptr& __p) const bool __owner_equivalent(const shared_ptr& __p) const
{ {
return __cntrl_ == __p.__cntrl_; return __cntrl_ == __p.__cntrl_;
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
__add_lvalue_reference_t<element_type> operator[](ptrdiff_t __i) const __add_lvalue_reference_t<element_type> operator[](ptrdiff_t __i) const
{ {
static_assert(is_array<_Tp>::value, static_assert(is_array<_Tp>::value,
"std::shared_ptr<T>::operator[] is only valid when T is an array type."); "std::shared_ptr<T>::operator[] is only valid when T is an array type.");
return __ptr_[__i]; return __ptr_[__i];
} }
#endif #endif
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Linesprivate:
struct __shared_ptr_default_delete<_Yp[], _Un> struct __shared_ptr_default_delete<_Yp[], _Un>
: default_delete<_Yp[]> : default_delete<_Yp[]>
{ }; { };
template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr; template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr; template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template<class _Tp> template<class _Tp>
shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>; shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
template<class _Tp, class _Dp> template<class _Tp, class _Dp>
shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>; shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>;
#endif #endif
// //
// std::allocate_shared and std::make_shared // std::allocate_shared and std::make_shared
Show All 32 Lines
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> make_shared_for_overwrite() shared_ptr<_Tp> make_shared_for_overwrite()
{ {
return std::allocate_shared_for_overwrite<_Tp>(allocator<_Tp>()); return std::allocate_shared_for_overwrite<_Tp>(allocator<_Tp>());
} }
#endif // _LIBCPP_STD_VER >= 20 #endif // _LIBCPP_STD_VER >= 20
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <size_t _Alignment> template <size_t _Alignment>
struct __sp_aligned_storage { struct __sp_aligned_storage {
alignas(_Alignment) char __storage[_Alignment]; alignas(_Alignment) char __storage[_Alignment];
}; };
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
struct __unbounded_array_control_block; struct __unbounded_array_control_block;
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Linesshared_ptr<_Array> __allocate_shared_bounded_array(const _Alloc& __a, _Arg&& ...__arg)
__allocation_guard<_ControlBlockAlloc> __guard(__a, 1); __allocation_guard<_ControlBlockAlloc> __guard(__a, 1);
_ControlBlock* __control_block = reinterpret_cast<_ControlBlock*>(std::addressof(*__guard.__get())); _ControlBlock* __control_block = reinterpret_cast<_ControlBlock*>(std::addressof(*__guard.__get()));
std::__construct_at(__control_block, __a, std::forward<_Arg>(__arg)...); std::__construct_at(__control_block, __a, std::forward<_Arg>(__arg)...);
__guard.__release_ptr(); __guard.__release_ptr();
return shared_ptr<_Array>::__create_with_control_block(__control_block->__get_data(), __control_block); return shared_ptr<_Array>::__create_with_control_block(__control_block->__get_data(), __control_block);
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
// bounded array variants // bounded array variants
template<class _Tp, class _Alloc, class = __enable_if_t<is_bounded_array<_Tp>::value>> template<class _Tp, class _Alloc, class = __enable_if_t<is_bounded_array<_Tp>::value>>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> allocate_shared(const _Alloc& __a) shared_ptr<_Tp> allocate_shared(const _Alloc& __a)
{ {
return std::__allocate_shared_bounded_array<_Tp>(__a); return std::__allocate_shared_bounded_array<_Tp>(__a);
} }
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
template<class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0> template<class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
shared_ptr<_Tp> make_shared_for_overwrite(size_t __n) shared_ptr<_Tp> make_shared_for_overwrite(size_t __n)
{ {
return std::__allocate_shared_unbounded_array<_Tp>(allocator<__for_overwrite_tag>(), __n); return std::__allocate_shared_unbounded_array<_Tp>(allocator<__for_overwrite_tag>(), __n);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
template<class _Tp, class _Up> template<class _Tp, class _Up>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool bool
operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
{ {
return __x.get() == __y.get(); return __x.get() == __y.get();
} }
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
bool bool
operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
{ {
return !(__x < __y); return !(__x < __y);
} }
#endif // _LIBCPP_STD_VER <= 17 #endif // _LIBCPP_STD_VER <= 17
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template<class _Tp, class _Up> template<class _Tp, class _Up>
_LIBCPP_HIDE_FROM_ABI strong_ordering _LIBCPP_HIDE_FROM_ABI strong_ordering
operator<=>(shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) noexcept operator<=>(shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) noexcept
{ {
return compare_three_way()(__x.get(), __y.get()); return compare_three_way()(__x.get(), __y.get());
} }
#endif #endif
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
bool bool
operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
{ {
return !(nullptr < __x); return !(nullptr < __x);
} }
#endif // _LIBCPP_STD_VER <= 17 #endif // _LIBCPP_STD_VER <= 17
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template<class _Tp> template<class _Tp>
_LIBCPP_HIDE_FROM_ABI strong_ordering _LIBCPP_HIDE_FROM_ABI strong_ordering
operator<=>(shared_ptr<_Tp> const& __x, nullptr_t) noexcept operator<=>(shared_ptr<_Tp> const& __x, nullptr_t) noexcept
{ {
return compare_three_way()(__x.get(), static_cast<typename shared_ptr<_Tp>::element_type*>(nullptr)); return compare_three_way()(__x.get(), static_cast<typename shared_ptr<_Tp>::element_type*>(nullptr));
} }
#endif #endif
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
} }
#endif // _LIBCPP_HAS_NO_RTTI #endif // _LIBCPP_HAS_NO_RTTI
template<class _Tp> template<class _Tp>
class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS weak_ptr class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS weak_ptr
{ {
public: public:
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typedef remove_extent_t<_Tp> element_type; typedef remove_extent_t<_Tp> element_type;
#else #else
typedef _Tp element_type; typedef _Tp element_type;
#endif #endif
private: private:
element_type* __ptr_; element_type* __ptr_;
__shared_weak_count* __cntrl_; __shared_weak_count* __cntrl_;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines template<class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT
{return __cntrl_ < __r.__cntrl_;} {return __cntrl_ < __r.__cntrl_;}
template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr; template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr; template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template<class _Tp> template<class _Tp>
weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>; weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;
#endif #endif
template<class _Tp> template<class _Tp>
inline inline
_LIBCPP_CONSTEXPR _LIBCPP_CONSTEXPR
weak_ptr<_Tp>::weak_ptr() _NOEXCEPT weak_ptr<_Tp>::weak_ptr() _NOEXCEPT
▲ Show 20 Lines • Show All 159 Lines • ▼ Show 20 Lines
{ {
shared_ptr<_Tp> __r; shared_ptr<_Tp> __r;
__r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_; __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;
if (__r.__cntrl_) if (__r.__cntrl_)
__r.__ptr_ = __ptr_; __r.__ptr_ = __ptr_;
return __r; return __r;
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp = void> struct owner_less; template <class _Tp = void> struct owner_less;
#else #else
template <class _Tp> struct owner_less; template <class _Tp> struct owner_less;
#endif #endif
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> > struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> >
Show All 20 Linesstruct _LIBCPP_TEMPLATE_VIS owner_less<weak_ptr<_Tp> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <> template <>
struct _LIBCPP_TEMPLATE_VIS owner_less<void> struct _LIBCPP_TEMPLATE_VIS owner_less<void>
{ {
template <class _Tp, class _Up> template <class _Tp, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT
{return __x.owner_before(__y);} {return __x.owner_before(__y);}
template <class _Tp, class _Up> template <class _Tp, class _Up>
Show All 29 Lines
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
shared_ptr<_Tp> shared_from_this() shared_ptr<_Tp> shared_from_this()
{return shared_ptr<_Tp>(__weak_this_);} {return shared_ptr<_Tp>(__weak_this_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
shared_ptr<_Tp const> shared_from_this() const shared_ptr<_Tp const> shared_from_this() const
{return shared_ptr<const _Tp>(__weak_this_);} {return shared_ptr<const _Tp>(__weak_this_);}
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
weak_ptr<_Tp> weak_from_this() _NOEXCEPT weak_ptr<_Tp> weak_from_this() _NOEXCEPT
{ return __weak_this_; } { return __weak_this_; }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT
{ return __weak_this_; } { return __weak_this_; }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
template <class _Up> friend class shared_ptr; template <class _Up> friend class shared_ptr;
}; };
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> > struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> >
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

libcxx/include/__memory/swap_allocator.h

Show All 17 Lines
#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
template <typename _Alloc> template <typename _Alloc>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __swap_allocator(_Alloc& __a1, _Alloc& __a2, true_type) _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __swap_allocator(_Alloc& __a1, _Alloc& __a2, true_type)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value) _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
#endif #endif
{ {
using _VSTD::swap; using _VSTD::swap;
swap(__a1, __a2); swap(__a1, __a2);
} }
template <typename _Alloc> template <typename _Alloc>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
__swap_allocator(_Alloc&, _Alloc&, false_type) _NOEXCEPT {} __swap_allocator(_Alloc&, _Alloc&, false_type) _NOEXCEPT {}
template <typename _Alloc> template <typename _Alloc>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __swap_allocator(_Alloc& __a1, _Alloc& __a2) inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __swap_allocator(_Alloc& __a1, _Alloc& __a2)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value) _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
#endif #endif
{ {
_VSTD::__swap_allocator( _VSTD::__swap_allocator(
__a1, __a2, integral_constant<bool, allocator_traits<_Alloc>::propagate_on_container_swap::value>()); __a1, __a2, integral_constant<bool, allocator_traits<_Alloc>::propagate_on_container_swap::value>());
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_SWAP_ALLOCATOR_H #endif // _LIBCPP___MEMORY_SWAP_ALLOCATOR_H

libcxx/include/__memory/uninitialized_algorithms.h

Show First 20 Lines • Show All 174 Lines • ▼ Show 20 Lines
template <class _ForwardIterator, class _Size, class _Tp> template <class _ForwardIterator, class _Size, class _Tp>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
_ForwardIterator uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) _ForwardIterator uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
{ {
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
return _VSTD::__uninitialized_fill_n<_ValueType>(__first, __n, __x); return _VSTD::__uninitialized_fill_n<_ValueType>(__first, __n, __x);
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
// uninitialized_default_construct // uninitialized_default_construct
template <class _ValueType, class _ForwardIterator, class _Sentinel> template <class _ValueType, class _ForwardIterator, class _Sentinel>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
_ForwardIterator __uninitialized_default_construct(_ForwardIterator __first, _Sentinel __last) { _ForwardIterator __uninitialized_default_construct(_ForwardIterator __first, _Sentinel __last) {
auto __idx = __first; auto __idx = __first;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
▲ Show 20 Lines • Show All 315 Lines • ▼ Show 20 Lines__uninitialized_allocator_value_construct_n_multidimensional(_Alloc& __alloc, _BidirIter __it, _Size __n) {
// If an exception is thrown, destroy what we have constructed so far in reverse order. // If an exception is thrown, destroy what we have constructed so far in reverse order.
auto __guard = std::__make_exception_guard([&]() { std::__allocator_destroy_multidimensional(__value_alloc, __begin, __it); }); auto __guard = std::__make_exception_guard([&]() { std::__allocator_destroy_multidimensional(__value_alloc, __begin, __it); });
for (; __n != 0; --__n, ++__it) { for (; __n != 0; --__n, ++__it) {
std::__allocator_construct_at_multidimensional(__value_alloc, std::addressof(*__it)); std::__allocator_construct_at_multidimensional(__value_alloc, std::addressof(*__it));
} }
__guard.__complete(); __guard.__complete();
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
// Destroy all elements in [__first, __last) from left to right using allocator destruction. // Destroy all elements in [__first, __last) from left to right using allocator destruction.
template <class _Alloc, class _Iter, class _Sent> template <class _Alloc, class _Iter, class _Sent>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
__allocator_destroy(_Alloc& __alloc, _Iter __first, _Sent __last) { __allocator_destroy(_Alloc& __alloc, _Iter __first, _Sent __last) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
allocator_traits<_Alloc>::destroy(__alloc, std::__to_address(__first)); allocator_traits<_Alloc>::destroy(__alloc, std::__to_address(__first));
} }
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

libcxx/include/__memory/unique_ptr.h

Show First 20 Lines • Show All 550 Lines • ▼ Show 20 Lines
operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);} operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);}
template <class _T1, class _D1, class _T2, class _D2> template <class _T1, class _D1, class _T2, class _D2>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool bool
operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);} operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _T1, class _D1, class _T2, class _D2> template <class _T1, class _D1, class _T2, class _D2>
requires three_way_comparable_with<typename unique_ptr<_T1, _D1>::pointer, requires three_way_comparable_with<typename unique_ptr<_T1, _D1>::pointer,
typename unique_ptr<_T2, _D2>::pointer> typename unique_ptr<_T2, _D2>::pointer>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer, compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer,
typename unique_ptr<_T2, _D2>::pointer> typename unique_ptr<_T2, _D2>::pointer>
operator<=>(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) { operator<=>(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {
return compare_three_way()(__x.get(), __y.get()); return compare_three_way()(__x.get(), __y.get());
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
} }
template <class _T1, class _D1> template <class _T1, class _D1>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x) { operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
return !(nullptr < __x); return !(nullptr < __x);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _T1, class _D1> template <class _T1, class _D1>
requires three_way_comparable< requires three_way_comparable<
typename unique_ptr<_T1, _D1>::pointer> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 typename unique_ptr<_T1, _D1>::pointer> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer> compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer>
operator<=>(const unique_ptr<_T1, _D1>& __x, nullptr_t) { operator<=>(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
return compare_three_way()(__x.get(), static_cast<typename unique_ptr<_T1, _D1>::pointer>(nullptr)); return compare_three_way()(__x.get(), static_cast<typename unique_ptr<_T1, _D1>::pointer>(nullptr));
} }
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template<class _Tp> template<class _Tp>
struct __unique_if struct __unique_if
{ {
typedef unique_ptr<_Tp> __unique_single; typedef unique_ptr<_Tp> __unique_single;
}; };
template<class _Tp> template<class _Tp>
Show All 20 Linesmake_unique(size_t __n) {
typedef __remove_extent_t<_Tp> _Up; typedef __remove_extent_t<_Tp> _Up;
return unique_ptr<_Tp>(new _Up[__n]()); return unique_ptr<_Tp>(new _Up[__n]());
} }
template<class _Tp, class... _Args> template<class _Tp, class... _Args>
typename __unique_if<_Tp>::__unique_array_known_bound typename __unique_if<_Tp>::__unique_array_known_bound
make_unique(_Args&&...) = delete; make_unique(_Args&&...) = delete;
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 typename __unique_if<_Tp>::__unique_single _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 typename __unique_if<_Tp>::__unique_single
make_unique_for_overwrite() { make_unique_for_overwrite() {
return unique_ptr<_Tp>(new _Tp); return unique_ptr<_Tp>(new _Tp);
} }
Show All 38 Lines

libcxx/include/__memory/uses_allocator.h

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
}; };
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
struct _LIBCPP_TEMPLATE_VIS uses_allocator struct _LIBCPP_TEMPLATE_VIS uses_allocator
: public __uses_allocator<_Tp, _Alloc> : public __uses_allocator<_Tp, _Alloc>
{ {
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
inline constexpr size_t uses_allocator_v = uses_allocator<_Tp, _Alloc>::value; inline constexpr size_t uses_allocator_v = uses_allocator<_Tp, _Alloc>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_USES_ALLOCATOR_H #endif // _LIBCPP___MEMORY_USES_ALLOCATOR_H

libcxx/include/__memory/uses_allocator_construction.h

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
__uses_allocator_construction_args(const _Alloc& __alloc, _Up&& __u, _Vp&& __v) noexcept { __uses_allocator_construction_args(const _Alloc& __alloc, _Up&& __u, _Vp&& __v) noexcept {
return std::__uses_allocator_construction_args<_Pair>( return std::__uses_allocator_construction_args<_Pair>(
__alloc, __alloc,
piecewise_construct, piecewise_construct,
std::forward_as_tuple(std::forward<_Up>(__u)), std::forward_as_tuple(std::forward<_Up>(__u)),
std::forward_as_tuple(std::forward<_Vp>(__v))); std::forward_as_tuple(std::forward<_Vp>(__v)));
} }
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0> template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr auto _LIBCPP_HIDE_FROM_ABI constexpr auto
__uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>& __pair) noexcept { __uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>& __pair) noexcept {
return std::__uses_allocator_construction_args<_Pair>( return std::__uses_allocator_construction_args<_Pair>(
__alloc, piecewise_construct, std::forward_as_tuple(__pair.first), std::forward_as_tuple(__pair.second)); __alloc, piecewise_construct, std::forward_as_tuple(__pair.first), std::forward_as_tuple(__pair.second));
} }
# endif # endif
Show All 9 Lines
__uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>&& __pair) noexcept { __uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>&& __pair) noexcept {
return std::__uses_allocator_construction_args<_Pair>( return std::__uses_allocator_construction_args<_Pair>(
__alloc, __alloc,
piecewise_construct, piecewise_construct,
std::forward_as_tuple(std::get<0>(std::move(__pair))), std::forward_as_tuple(std::get<0>(std::move(__pair))),
std::forward_as_tuple(std::get<1>(std::move(__pair)))); std::forward_as_tuple(std::get<1>(std::move(__pair))));
} }
# if _LIBCPP_STD_VER > 20 # if _LIBCPP_STD_VER >= 23
template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0> template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
_LIBCPP_HIDE_FROM_ABI constexpr auto _LIBCPP_HIDE_FROM_ABI constexpr auto
__uses_allocator_construction_args(const _Alloc& __alloc, const pair<_Up, _Vp>&& __pair) noexcept { __uses_allocator_construction_args(const _Alloc& __alloc, const pair<_Up, _Vp>&& __pair) noexcept {
return std::__uses_allocator_construction_args<_Pair>( return std::__uses_allocator_construction_args<_Pair>(
__alloc, __alloc,
piecewise_construct, piecewise_construct,
std::forward_as_tuple(std::get<0>(std::move(__pair))), std::forward_as_tuple(std::get<0>(std::move(__pair))),
std::forward_as_tuple(std::get<1>(std::move(__pair)))); std::forward_as_tuple(std::get<1>(std::move(__pair))));
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

libcxx/include/__memory_resource/memory_resource.h

Show All 10 Lines
#include <__config> #include <__config>
#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
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
// [mem.res.class] // [mem.res.class]
class _LIBCPP_TYPE_VIS memory_resource { class _LIBCPP_TYPE_VIS memory_resource {
Show All 37 Lines
[[__gnu__::__returns_nonnull__]] _LIBCPP_FUNC_VIS memory_resource* set_default_resource(memory_resource*) noexcept; [[__gnu__::__returns_nonnull__]] _LIBCPP_FUNC_VIS memory_resource* set_default_resource(memory_resource*) noexcept;
[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* new_delete_resource() noexcept; [[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* new_delete_resource() noexcept;
[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* null_memory_resource() noexcept; [[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* null_memory_resource() noexcept;
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#endif // _LIBCPP___MEMORY_RESOURCE_MEMORY_RESOURCE_H #endif // _LIBCPP___MEMORY_RESOURCE_MEMORY_RESOURCE_H

libcxx/include/__memory_resource/monotonic_buffer_resource.h

Show All 12 Lines
#include <__memory/addressof.h> #include <__memory/addressof.h>
#include <__memory_resource/memory_resource.h> #include <__memory_resource/memory_resource.h>
#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
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
// [mem.res.monotonic.buffer] // [mem.res.monotonic.buffer]
class _LIBCPP_TYPE_VIS monotonic_buffer_resource : public memory_resource { class _LIBCPP_TYPE_VIS monotonic_buffer_resource : public memory_resource {
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Linesprivate:
__chunk_footer* __chunks_; __chunk_footer* __chunks_;
memory_resource* __res_; memory_resource* __res_;
}; };
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#endif // _LIBCPP___MEMORY_RESOURCE_MONOTONIC_BUFFER_RESOURCE_H #endif // _LIBCPP___MEMORY_RESOURCE_MONOTONIC_BUFFER_RESOURCE_H

libcxx/include/__memory_resource/polymorphic_allocator.h

Show All 20 Lines
#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_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
// [mem.poly.allocator.class] // [mem.poly.allocator.class]
template <class _ValueType template <class _ValueType
▲ Show 20 Lines • Show All 174 Lines • ▼ Show 20 Lines
operator!=(const polymorphic_allocator<_Tp>& __lhs, const polymorphic_allocator<_Up>& __rhs) noexcept { operator!=(const polymorphic_allocator<_Tp>& __lhs, const polymorphic_allocator<_Up>& __rhs) noexcept {
return !(__lhs == __rhs); return !(__lhs == __rhs);
} }
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___MEMORY_RESOURCE_POLYMORPHIC_ALLOCATOR_H #endif // _LIBCPP___MEMORY_RESOURCE_POLYMORPHIC_ALLOCATOR_H

libcxx/include/__memory_resource/pool_options.h

Show All 10 Lines
#include <__config> #include <__config>
#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
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
// [mem.res.pool.options] // [mem.res.pool.options]
struct _LIBCPP_TYPE_VIS pool_options { struct _LIBCPP_TYPE_VIS pool_options {
size_t max_blocks_per_chunk = 0; size_t max_blocks_per_chunk = 0;
size_t largest_required_pool_block = 0; size_t largest_required_pool_block = 0;
}; };
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#endif // _LIBCPP___MEMORY_RESOURCE_POOL_OPTIONS_H #endif // _LIBCPP___MEMORY_RESOURCE_POOL_OPTIONS_H

libcxx/include/__memory_resource/synchronized_pool_resource.h

Show All 16 Lines
#if !defined(_LIBCPP_HAS_NO_THREADS) #if !defined(_LIBCPP_HAS_NO_THREADS)
# include <mutex> # include <mutex>
#endif #endif
#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
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
// [mem.res.pool.overview] // [mem.res.pool.overview]
class _LIBCPP_TYPE_VIS synchronized_pool_resource : public memory_resource { class _LIBCPP_TYPE_VIS synchronized_pool_resource : public memory_resource {
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
# endif # endif
unsynchronized_pool_resource __unsync_; unsynchronized_pool_resource __unsync_;
}; };
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#endif // _LIBCPP___MEMORY_RESOURCE_SYNCHRONIZED_POOL_RESOURCE_H #endif // _LIBCPP___MEMORY_RESOURCE_SYNCHRONIZED_POOL_RESOURCE_H

libcxx/include/__memory_resource/unsynchronized_pool_resource.h

Show All 13 Lines
#include <__memory_resource/pool_options.h> #include <__memory_resource/pool_options.h>
#include <cstddef> #include <cstddef>
#include <cstdint> #include <cstdint>
#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
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
// [mem.res.pool.overview] // [mem.res.pool.overview]
class _LIBCPP_TYPE_VIS unsynchronized_pool_resource : public memory_resource { class _LIBCPP_TYPE_VIS unsynchronized_pool_resource : public memory_resource {
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linesprivate:
int __num_fixed_pools_; int __num_fixed_pools_;
uint32_t __options_max_blocks_per_chunk_; uint32_t __options_max_blocks_per_chunk_;
}; };
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#endif // _LIBCPP___MEMORY_RESOURCE_UNSYNCHRONIZED_POOL_RESOURCE_H #endif // _LIBCPP___MEMORY_RESOURCE_UNSYNCHRONIZED_POOL_RESOURCE_H

libcxx/include/__node_handle

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines
#include <optional> #include <optional>
#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 > 14 #if _LIBCPP_STD_VER >= 17
// Specialized in __tree & __hash_table for their _NodeType. // Specialized in __tree & __hash_table for their _NodeType.
template <class _NodeType, class _Alloc> template <class _NodeType, class _Alloc>
struct __generic_container_node_destructor; struct __generic_container_node_destructor;
template <class _NodeType, class _Alloc, template <class _NodeType, class _Alloc,
template <class, class> class _MapOrSetSpecifics> template <class, class> class _MapOrSetSpecifics>
class _LIBCPP_TEMPLATE_VIS __basic_node_handle class _LIBCPP_TEMPLATE_VIS __basic_node_handle
▲ Show 20 Lines • Show All 160 Lines • ▼ Show 20 Lines
template <class _Iterator, class _NodeType> template <class _Iterator, class _NodeType>
struct _LIBCPP_TEMPLATE_VIS __insert_return_type struct _LIBCPP_TEMPLATE_VIS __insert_return_type
{ {
_Iterator position; _Iterator position;
bool inserted; bool inserted;
_NodeType node; _NodeType node;
}; };
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NODE_HANDLE #endif // _LIBCPP___NODE_HANDLE

libcxx/include/__numeric/accumulate.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _InputIterator, class _Tp> template <class _InputIterator, class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_Tp _Tp
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init) accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
__init = _VSTD::move(__init) + *__first; __init = _VSTD::move(__init) + *__first;
#else #else
__init = __init + *__first; __init = __init + *__first;
#endif #endif
return __init; return __init;
} }
template <class _InputIterator, class _Tp, class _BinaryOperation> template <class _InputIterator, class _Tp, class _BinaryOperation>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_Tp _Tp
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op) accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op)
{ {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
__init = __binary_op(_VSTD::move(__init), *__first); __init = __binary_op(_VSTD::move(__init), *__first);
#else #else
__init = __binary_op(__init, *__first); __init = __binary_op(__init, *__first);
#endif #endif
return __init; return __init;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_ACCUMULATE_H #endif // _LIBCPP___NUMERIC_ACCUMULATE_H

libcxx/include/__numeric/adjacent_difference.h

Show All 26 Lines
{ {
if (__first != __last) if (__first != __last)
{ {
typename iterator_traits<_InputIterator>::value_type __acc(*__first); typename iterator_traits<_InputIterator>::value_type __acc(*__first);
*__result = __acc; *__result = __acc;
for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result) for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
{ {
typename iterator_traits<_InputIterator>::value_type __val(*__first); typename iterator_traits<_InputIterator>::value_type __val(*__first);
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
*__result = __val - _VSTD::move(__acc); *__result = __val - _VSTD::move(__acc);
#else #else
*__result = __val - __acc; *__result = __val - __acc;
#endif #endif
__acc = _VSTD::move(__val); __acc = _VSTD::move(__val);
} }
} }
return __result; return __result;
} }
template <class _InputIterator, class _OutputIterator, class _BinaryOperation> template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_OutputIterator _OutputIterator
adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result, adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
_BinaryOperation __binary_op) _BinaryOperation __binary_op)
{ {
if (__first != __last) if (__first != __last)
{ {
typename iterator_traits<_InputIterator>::value_type __acc(*__first); typename iterator_traits<_InputIterator>::value_type __acc(*__first);
*__result = __acc; *__result = __acc;
for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result) for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
{ {
typename iterator_traits<_InputIterator>::value_type __val(*__first); typename iterator_traits<_InputIterator>::value_type __val(*__first);
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
*__result = __binary_op(__val, _VSTD::move(__acc)); *__result = __binary_op(__val, _VSTD::move(__acc));
#else #else
*__result = __binary_op(__val, __acc); *__result = __binary_op(__val, __acc);
#endif #endif
__acc = _VSTD::move(__val); __acc = _VSTD::move(__val);
} }
} }
return __result; return __result;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_ADJACENT_DIFFERENCE_H #endif // _LIBCPP___NUMERIC_ADJACENT_DIFFERENCE_H

libcxx/include/__numeric/exclusive_scan.h

Show All 14 Lines
#include <__utility/move.h> #include <__utility/move.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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp> template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init, _BinaryOp __b) { exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init, _BinaryOp __b) {
if (__first != __last) { if (__first != __last) {
_Tp __tmp(__b(__init, *__first)); _Tp __tmp(__b(__init, *__first));
while (true) { while (true) {
*__result = _VSTD::move(__init); *__result = _VSTD::move(__init);
Show All 9 Lines
} }
template <class _InputIterator, class _OutputIterator, class _Tp> template <class _InputIterator, class _OutputIterator, class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init) { exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init) {
return _VSTD::exclusive_scan(__first, __last, __result, __init, _VSTD::plus<>()); return _VSTD::exclusive_scan(__first, __last, __result, __init, _VSTD::plus<>());
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_EXCLUSIVE_SCAN_H #endif // _LIBCPP___NUMERIC_EXCLUSIVE_SCAN_H

libcxx/include/__numeric/gcd_lcm.h

Show All 22 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 > 14 #if _LIBCPP_STD_VER >= 17
template <typename _Result, typename _Source, bool _IsSigned = is_signed<_Source>::value> struct __ct_abs; template <typename _Result, typename _Source, bool _IsSigned = is_signed<_Source>::value> struct __ct_abs;
template <typename _Result, typename _Source> template <typename _Result, typename _Source>
struct __ct_abs<_Result, _Source, true> { struct __ct_abs<_Result, _Source, true> {
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
_Result operator()(_Source __t) const noexcept _Result operator()(_Source __t) const noexcept
{ {
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

libcxx/include/__numeric/inclusive_scan.h

Show All 15 Lines
#include <__utility/move.h> #include <__utility/move.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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp> template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOp __b, _Tp __init) { inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOp __b, _Tp __init) {
for (; __first != __last; ++__first, (void)++__result) { for (; __first != __last; ++__first, (void)++__result) {
__init = __b(__init, *__first); __init = __b(__init, *__first);
*__result = __init; *__result = __init;
} }
Show All 15 Lines
template <class _InputIterator, class _OutputIterator> template <class _InputIterator, class _OutputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator inclusive_scan(_InputIterator __first, _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator inclusive_scan(_InputIterator __first,
_InputIterator __last, _InputIterator __last,
_OutputIterator __result) { _OutputIterator __result) {
return _VSTD::inclusive_scan(__first, __last, __result, _VSTD::plus<>()); return _VSTD::inclusive_scan(__first, __last, __result, _VSTD::plus<>());
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_INCLUSIVE_SCAN_H #endif // _LIBCPP___NUMERIC_INCLUSIVE_SCAN_H

libcxx/include/__numeric/inner_product.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _InputIterator1, class _InputIterator2, class _Tp> template <class _InputIterator1, class _InputIterator2, class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_Tp _Tp
inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init) inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init)
{ {
for (; __first1 != __last1; ++__first1, (void) ++__first2) for (; __first1 != __last1; ++__first1, (void) ++__first2)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
__init = _VSTD::move(__init) + *__first1 * *__first2; __init = _VSTD::move(__init) + *__first1 * *__first2;
#else #else
__init = __init + *__first1 * *__first2; __init = __init + *__first1 * *__first2;
#endif #endif
return __init; return __init;
} }
template <class _InputIterator1, class _InputIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2> template <class _InputIterator1, class _InputIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_Tp _Tp
inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
_Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2) _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2)
{ {
for (; __first1 != __last1; ++__first1, (void) ++__first2) for (; __first1 != __last1; ++__first1, (void) ++__first2)
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
__init = __binary_op1(_VSTD::move(__init), __binary_op2(*__first1, *__first2)); __init = __binary_op1(_VSTD::move(__init), __binary_op2(*__first1, *__first2));
#else #else
__init = __binary_op1(__init, __binary_op2(*__first1, *__first2)); __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
#endif #endif
return __init; return __init;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_INNER_PRODUCT_H #endif // _LIBCPP___NUMERIC_INNER_PRODUCT_H

libcxx/include/__numeric/midpoint.h

Show All 27 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 #if _LIBCPP_STD_VER >= 20
template <class _Tp> template <class _Tp>
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
enable_if_t<is_integral_v<_Tp> && !is_same_v<bool, _Tp> && !is_null_pointer_v<_Tp>, _Tp> enable_if_t<is_integral_v<_Tp> && !is_same_v<bool, _Tp> && !is_null_pointer_v<_Tp>, _Tp>
midpoint(_Tp __a, _Tp __b) noexcept midpoint(_Tp __a, _Tp __b) noexcept
_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
{ {
using _Up = make_unsigned_t<_Tp>; using _Up = make_unsigned_t<_Tp>;
constexpr _Up __bitshift = numeric_limits<_Up>::digits - 1; constexpr _Up __bitshift = numeric_limits<_Up>::digits - 1;
Show All 36 Linesmidpoint(_Fp __a, _Fp __b) noexcept
constexpr _Fp __hi = numeric_limits<_Fp>::max()/2; constexpr _Fp __hi = numeric_limits<_Fp>::max()/2;
return std::__fp_abs(__a) <= __hi && std::__fp_abs(__b) <= __hi ? // typical case: overflow is impossible return std::__fp_abs(__a) <= __hi && std::__fp_abs(__b) <= __hi ? // typical case: overflow is impossible
(__a + __b)/2 : // always correctly rounded (__a + __b)/2 : // always correctly rounded
std::__fp_abs(__a) < __lo ? __a + __b/2 : // not safe to halve a std::__fp_abs(__a) < __lo ? __a + __b/2 : // not safe to halve a
std::__fp_abs(__b) < __lo ? __a/2 + __b : // not safe to halve b std::__fp_abs(__b) < __lo ? __a/2 + __b : // not safe to halve b
__a/2 + __b/2; // otherwise correctly rounded __a/2 + __b/2; // otherwise correctly rounded
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___NUMERIC_MIDPOINT_H #endif // _LIBCPP___NUMERIC_MIDPOINT_H

libcxx/include/__numeric/partial_sum.h

Show All 25 Lines
partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result) partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
{ {
if (__first != __last) if (__first != __last)
{ {
typename iterator_traits<_InputIterator>::value_type __t(*__first); typename iterator_traits<_InputIterator>::value_type __t(*__first);
*__result = __t; *__result = __t;
for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result) for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
{ {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
__t = _VSTD::move(__t) + *__first; __t = _VSTD::move(__t) + *__first;
#else #else
__t = __t + *__first; __t = __t + *__first;
#endif #endif
*__result = __t; *__result = __t;
} }
} }
return __result; return __result;
} }
template <class _InputIterator, class _OutputIterator, class _BinaryOperation> template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_OutputIterator _OutputIterator
partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result, partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
_BinaryOperation __binary_op) _BinaryOperation __binary_op)
{ {
if (__first != __last) if (__first != __last)
{ {
typename iterator_traits<_InputIterator>::value_type __t(*__first); typename iterator_traits<_InputIterator>::value_type __t(*__first);
*__result = __t; *__result = __t;
for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result) for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
{ {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
__t = __binary_op(_VSTD::move(__t), *__first); __t = __binary_op(_VSTD::move(__t), *__first);
#else #else
__t = __binary_op(__t, *__first); __t = __binary_op(__t, *__first);
#endif #endif
*__result = __t; *__result = __t;
} }
} }
return __result; return __result;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_PARTIAL_SUM_H #endif // _LIBCPP___NUMERIC_PARTIAL_SUM_H

libcxx/include/__numeric/reduce.h

Show All 14 Lines
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _InputIterator, class _Tp, class _BinaryOp> template <class _InputIterator, class _Tp, class _BinaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp reduce(_InputIterator __first, _InputIterator __last, _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp reduce(_InputIterator __first, _InputIterator __last,
_Tp __init, _BinaryOp __b) { _Tp __init, _BinaryOp __b) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
__init = __b(__init, *__first); __init = __b(__init, *__first);
return __init; return __init;
} }
Show All 16 Lines

libcxx/include/__numeric/transform_exclusive_scan.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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _InputIterator, class _OutputIterator, class _Tp, template <class _InputIterator, class _OutputIterator, class _Tp,
class _BinaryOp, class _UnaryOp> class _BinaryOp, class _UnaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_OutputIterator _OutputIterator
transform_exclusive_scan(_InputIterator __first, _InputIterator __last, transform_exclusive_scan(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Tp __init, _OutputIterator __result, _Tp __init,
_BinaryOp __b, _UnaryOp __u) _BinaryOp __b, _UnaryOp __u)
{ {
if (__first != __last) if (__first != __last)
{ {
_Tp __saved = __init; _Tp __saved = __init;
do do
{ {
__init = __b(__init, __u(*__first)); __init = __b(__init, __u(*__first));
*__result = __saved; *__result = __saved;
__saved = __init; __saved = __init;
++__result; ++__result;
} while (++__first != __last); } while (++__first != __last);
} }
return __result; return __result;
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_TRANSFORM_EXCLUSIVE_SCAN_H #endif // _LIBCPP___NUMERIC_TRANSFORM_EXCLUSIVE_SCAN_H

libcxx/include/__numeric/transform_inclusive_scan.h

Show All 13 Lines
#include <__iterator/iterator_traits.h> #include <__iterator/iterator_traits.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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp> template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_OutputIterator _OutputIterator
transform_inclusive_scan(_InputIterator __first, _InputIterator __last, transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _BinaryOp __b, _UnaryOp __u, _Tp __init) _OutputIterator __result, _BinaryOp __b, _UnaryOp __u, _Tp __init)
{ {
for (; __first != __last; ++__first, (void) ++__result) { for (; __first != __last; ++__first, (void) ++__result) {
Show All 15 Lines if (__first != __last) {
*__result++ = __init; *__result++ = __init;
if (++__first != __last) if (++__first != __last)
return _VSTD::transform_inclusive_scan(__first, __last, __result, __b, __u, __init); return _VSTD::transform_inclusive_scan(__first, __last, __result, __b, __u, __init);
} }
return __result; return __result;
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___NUMERIC_TRANSFORM_INCLUSIVE_SCAN_H #endif // _LIBCPP___NUMERIC_TRANSFORM_INCLUSIVE_SCAN_H

libcxx/include/__numeric/transform_reduce.h

Show All 14 Lines
#include <__utility/move.h> #include <__utility/move.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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp> template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp transform_reduce(_InputIterator __first, _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp transform_reduce(_InputIterator __first,
_InputIterator __last, _Tp __init, _InputIterator __last, _Tp __init,
_BinaryOp __b, _UnaryOp __u) { _BinaryOp __b, _UnaryOp __u) {
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
__init = __b(__init, __u(*__first)); __init = __b(__init, __u(*__first));
return __init; return __init;
} }
Show All 23 Lines

libcxx/include/__random/uniform_random_bit_generator.h

Show All 19 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 #if _LIBCPP_STD_VER >= 20
// [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 #endif // _LIBCPP_STD_VER >= 20
_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/access.h

Show All 23 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template <class _Tp> template <class _Tp>
concept __can_borrow = concept __can_borrow =
is_lvalue_reference_v<_Tp> || enable_borrowed_range<remove_cvref_t<_Tp>>; is_lvalue_reference_v<_Tp> || enable_borrowed_range<remove_cvref_t<_Tp>>;
} // namespace ranges } // namespace ranges
// [range.access.begin] // [range.access.begin]
▲ Show 20 Lines • Show All 177 Lines • ▼ Show 20 Linesnamespace __cend {
}; };
} // namespace __cend } // namespace __cend
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto cend = __cend::__fn{}; inline constexpr auto cend = __cend::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_ACCESS_H #endif // _LIBCPP___RANGES_ACCESS_H

libcxx/include/__ranges/all.h

Show All 23 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 #if _LIBCPP_STD_VER >= 20
namespace ranges::views { namespace ranges::views {
namespace __all { namespace __all {
struct __fn : __range_adaptor_closure<__fn> { struct __fn : __range_adaptor_closure<__fn> {
template<class _Tp> template<class _Tp>
requires ranges::view<decay_t<_Tp>> requires ranges::view<decay_t<_Tp>>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
Show All 31 Linesinline namespace __cpo {
inline constexpr auto all = __all::__fn{}; inline constexpr auto all = __all::__fn{};
} // namespace __cpo } // namespace __cpo
template<ranges::viewable_range _Range> template<ranges::viewable_range _Range>
using all_t = decltype(views::all(std::declval<_Range>())); using all_t = decltype(views::all(std::declval<_Range>()));
} // namespace ranges::views } // namespace ranges::views
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_ALL_H #endif // _LIBCPP___RANGES_ALL_H

libcxx/include/__ranges/common_view.h

Show All 26 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<view _View> template<view _View>
requires (!common_range<_View> && copyable<iterator_t<_View>>) requires (!common_range<_View> && copyable<iterator_t<_View>>)
class common_view : public view_interface<common_view<_View>> { class common_view : public view_interface<common_view<_View>> {
_View __base_ = _View(); _View __base_ = _View();
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
} // namespace __common } // namespace __common
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto common = __common::__fn{}; inline constexpr auto common = __common::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_COMMON_VIEW_H #endif // _LIBCPP___RANGES_COMMON_VIEW_H

libcxx/include/__ranges/concepts.h

Show All 31 Lines
#include <initializer_list> #include <initializer_list>
#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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
// [range.range] // [range.range]
template <class _Tp> template <class _Tp>
concept range = requires(_Tp& __t) { concept range = requires(_Tp& __t) {
ranges::begin(__t); // sometimes equality-preserving ranges::begin(__t); // sometimes equality-preserving
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines concept viewable_range =
range<_Tp> && range<_Tp> &&
((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>) || ((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>) ||
(!view<remove_cvref_t<_Tp>> && (!view<remove_cvref_t<_Tp>> &&
(is_lvalue_reference_v<_Tp> || (is_lvalue_reference_v<_Tp> ||
(movable<remove_reference_t<_Tp>> && !__is_std_initializer_list<remove_cvref_t<_Tp>>)))); (movable<remove_reference_t<_Tp>> && !__is_std_initializer_list<remove_cvref_t<_Tp>>))));
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_CONCEPTS_H #endif // _LIBCPP___RANGES_CONCEPTS_H

libcxx/include/__ranges/copyable_box.h

Show All 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 #if _LIBCPP_STD_VER >= 20
// __copyable_box allows turning a type that is copy-constructible (but maybe not copy-assignable) into // __copyable_box allows turning a type that is copy-constructible (but maybe not copy-assignable) into
// a type that is both copy-constructible and copy-assignable. It does that by introducing an empty state // a type that is both copy-constructible and copy-assignable. It does that by introducing an empty state
// and basically doing destroy-then-copy-construct in the assignment operator. The empty state is necessary // and basically doing destroy-then-copy-construct in the assignment operator. The empty state is necessary
// to handle the case where the copy construction fails after destroying the object. // to handle the case where the copy construction fails after destroying the object.
// //
// In some cases, we can completely avoid the use of an empty state; we provide a specialization of // In some cases, we can completely avoid the use of an empty state; we provide a specialization of
// __copyable_box that does this, see below for the details. // __copyable_box that does this, see below for the details.
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines public:
_LIBCPP_HIDE_FROM_ABI constexpr const _Tp *operator->() const noexcept { return std::addressof(__val_); } _LIBCPP_HIDE_FROM_ABI constexpr const _Tp *operator->() const noexcept { return std::addressof(__val_); }
_LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return std::addressof(__val_); } _LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return std::addressof(__val_); }
_LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return true; } _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return true; }
}; };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_COPYABLE_BOX_H #endif // _LIBCPP___RANGES_COPYABLE_BOX_H

libcxx/include/__ranges/counted.h

Show All 24 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 #if _LIBCPP_STD_VER >= 20
namespace ranges::views { namespace ranges::views {
namespace __counted { namespace __counted {
struct __fn { struct __fn {
template<contiguous_iterator _It> template<contiguous_iterator _It>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
Show All 28 Lines
} // namespace __counted } // namespace __counted
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto counted = __counted::__fn{}; inline constexpr auto counted = __counted::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges::views } // namespace ranges::views
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_COUNTED_H #endif // _LIBCPP___RANGES_COUNTED_H

libcxx/include/__ranges/dangling.h

Show All 15 Lines
#include <__type_traits/conditional.h> #include <__type_traits/conditional.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
struct dangling { struct dangling {
dangling() = default; dangling() = default;
_LIBCPP_HIDE_FROM_ABI constexpr dangling(auto&&...) noexcept {} _LIBCPP_HIDE_FROM_ABI constexpr dangling(auto&&...) noexcept {}
}; };
template <range _Rp> template <range _Rp>
using borrowed_iterator_t = _If<borrowed_range<_Rp>, iterator_t<_Rp>, dangling>; using borrowed_iterator_t = _If<borrowed_range<_Rp>, iterator_t<_Rp>, dangling>;
// borrowed_subrange_t defined in <__ranges/subrange.h> // borrowed_subrange_t defined in <__ranges/subrange.h>
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_DANGLING_H #endif // _LIBCPP___RANGES_DANGLING_H

libcxx/include/__ranges/data.h

Show All 24 Lines
#include <__utility/auto_cast.h> #include <__utility/auto_cast.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 #if _LIBCPP_STD_VER >= 20
// [range.prim.data] // [range.prim.data]
namespace ranges { namespace ranges {
namespace __data { namespace __data {
template <class _Tp> template <class _Tp>
concept __ptr_to_object = is_pointer_v<_Tp> && is_object_v<remove_pointer_t<_Tp>>; concept __ptr_to_object = is_pointer_v<_Tp> && is_object_v<remove_pointer_t<_Tp>>;
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Linesnamespace __cdata {
}; };
} // namespace __cdata } // namespace __cdata
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto cdata = __cdata::__fn{}; inline constexpr auto cdata = __cdata::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_DATA_H #endif // _LIBCPP___RANGES_DATA_H

libcxx/include/__ranges/drop_view.h

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<view _View> template<view _View>
class drop_view class drop_view
: public view_interface<drop_view<_View>> : public view_interface<drop_view<_View>>
{ {
// We cache begin() whenever ranges::next is not guaranteed O(1) to provide an // We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
// amortized O(1) begin() method. If this is an input_range, then we cannot cache // amortized O(1) begin() method. If this is an input_range, then we cannot cache
▲ Show 20 Lines • Show All 235 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto drop = __drop::__fn{}; inline constexpr auto drop = __drop::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___RANGES_DROP_VIEW_H #endif // _LIBCPP___RANGES_DROP_VIEW_H

libcxx/include/__ranges/empty.h

Show All 16 Lines
#include <__ranges/size.h> #include <__ranges/size.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 #if _LIBCPP_STD_VER >= 20
// [range.prim.empty] // [range.prim.empty]
namespace ranges { namespace ranges {
namespace __empty { namespace __empty {
template <class _Tp> template <class _Tp>
concept __member_empty = concept __member_empty =
__workaround_52970<_Tp> && __workaround_52970<_Tp> &&
Show All 36 Linesnamespace __empty {
}; };
} // namespace __empty } // namespace __empty
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto empty = __empty::__fn{}; inline constexpr auto empty = __empty::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_EMPTY_H #endif // _LIBCPP___RANGES_EMPTY_H

libcxx/include/__ranges/empty_view.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<class _Tp> template<class _Tp>
requires is_object_v<_Tp> requires is_object_v<_Tp>
class empty_view : public view_interface<empty_view<_Tp>> { class empty_view : public view_interface<empty_view<_Tp>> {
public: public:
_LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; } _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; }
_LIBCPP_HIDE_FROM_ABI static constexpr _Tp* end() noexcept { return nullptr; } _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* end() noexcept { return nullptr; }
_LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() noexcept { return nullptr; } _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() noexcept { return nullptr; }
_LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 0; } _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 0; }
_LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; } _LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; }
}; };
template<class _Tp> template<class _Tp>
inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true; inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
namespace views { namespace views {
template <class _Tp> template <class _Tp>
inline constexpr empty_view<_Tp> empty{}; inline constexpr empty_view<_Tp> empty{};
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_EMPTY_VIEW_H #endif // _LIBCPP___RANGES_EMPTY_VIEW_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 #if _LIBCPP_STD_VER >= 20
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 #endif // _LIBCPP_STD_VER >= 20
_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/enable_view.h

Show All 17 Lines
#include <__type_traits/remove_cv.h> #include <__type_traits/remove_cv.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
struct view_base { }; struct view_base { };
template<class _Derived> template<class _Derived>
requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>> requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
class view_interface; class view_interface;
template<class _Op, class _Yp> template<class _Op, class _Yp>
requires is_convertible_v<_Op*, view_interface<_Yp>*> requires is_convertible_v<_Op*, view_interface<_Yp>*>
void __is_derived_from_view_interface(const _Op*, const view_interface<_Yp>*); void __is_derived_from_view_interface(const _Op*, const view_interface<_Yp>*);
template <class _Tp> template <class _Tp>
inline constexpr bool enable_view = derived_from<_Tp, view_base> || inline constexpr bool enable_view = derived_from<_Tp, view_base> ||
requires { ranges::__is_derived_from_view_interface((_Tp*)nullptr, (_Tp*)nullptr); }; requires { ranges::__is_derived_from_view_interface((_Tp*)nullptr, (_Tp*)nullptr); };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_ENABLE_VIEW_H #endif // _LIBCPP___RANGES_ENABLE_VIEW_H

libcxx/include/__ranges/filter_view.h

Show All 37 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred> template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
requires view<_View> && is_object_v<_Pred> requires view<_View> && is_object_v<_Pred>
class filter_view : public view_interface<filter_view<_View, _Pred>> { class filter_view : public view_interface<filter_view<_View, _Pred>> {
_LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View(); _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
_LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_; _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
▲ Show 20 Lines • Show All 197 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto filter = __filter::__fn{}; inline constexpr auto filter = __filter::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_FILTER_VIEW_H #endif // _LIBCPP___RANGES_FILTER_VIEW_H

libcxx/include/__ranges/iota_view.h

Show All 34 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<class _Int> template<class _Int>
struct __get_wider_signed { struct __get_wider_signed {
static auto __call() { static auto __call() {
if constexpr (sizeof(_Int) < sizeof(short)) return type_identity<short>{}; if constexpr (sizeof(_Int) < sizeof(short)) return type_identity<short>{};
else if constexpr (sizeof(_Int) < sizeof(int)) return type_identity<int>{}; else if constexpr (sizeof(_Int) < sizeof(int)) return type_identity<int>{};
else if constexpr (sizeof(_Int) < sizeof(long)) return type_identity<long>{}; else if constexpr (sizeof(_Int) < sizeof(long)) return type_identity<long>{};
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Lines
} // namespace __iota } // namespace __iota
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto iota = __iota::__fn{}; inline constexpr auto iota = __iota::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_IOTA_VIEW_H #endif // _LIBCPP___RANGES_IOTA_VIEW_H

libcxx/include/__ranges/join_view.h

Show All 37 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// Note: `join_view` is still marked experimental because there is an ABI-breaking change that affects `join_view` in // Note: `join_view` is still marked experimental because there is an ABI-breaking change that affects `join_view` in
// the pipeline (https://isocpp.org/files/papers/D2770R0.html). // the pipeline (https://isocpp.org/files/papers/D2770R0.html).
// TODO: make `join_view` non-experimental once D2770 is implemented. // TODO: make `join_view` non-experimental once D2770 is implemented.
#if _LIBCPP_STD_VER > 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL) #if _LIBCPP_STD_VER >= 20 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
namespace ranges { namespace ranges {
template<class> template<class>
struct __join_view_iterator_category {}; struct __join_view_iterator_category {};
template<class _View> template<class _View>
requires is_reference_v<range_reference_t<_View>> && requires is_reference_v<range_reference_t<_View>> &&
forward_range<_View> && forward_range<_View> &&
▲ Show 20 Lines • Show All 375 Lines • ▼ Show 20 Linesstruct __segmented_iterator_traits<_JoinViewIterator> {
static constexpr _LIBCPP_HIDE_FROM_ABI _JoinViewIterator static constexpr _LIBCPP_HIDE_FROM_ABI _JoinViewIterator
__compose(__segment_iterator __seg_iter, __local_iterator __local_iter) { __compose(__segment_iterator __seg_iter, __local_iterator __local_iter) {
return _JoinViewIterator( return _JoinViewIterator(
std::move(__seg_iter).__get_data(), std::move(__seg_iter).__get_iter(), std::move(__local_iter)); std::move(__seg_iter).__get_data(), std::move(__seg_iter).__get_iter(), std::move(__local_iter));
} }
}; };
#endif // #if _LIBCPP_STD_VER > 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL) #endif // #if _LIBCPP_STD_VER >= 20 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_JOIN_VIEW_H #endif // _LIBCPP___RANGES_JOIN_VIEW_H

libcxx/include/__ranges/lazy_split_view.h

Show All 39 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template <auto> struct __require_constant; template <auto> struct __require_constant;
template <class _Range> template <class _Range>
concept __tiny_range = concept __tiny_range =
sized_range<_Range> && sized_range<_Range> &&
▲ Show 20 Lines • Show All 396 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto lazy_split = __lazy_split_view::__fn{}; inline constexpr auto lazy_split = __lazy_split_view::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_LAZY_SPLIT_VIEW_H #endif // _LIBCPP___RANGES_LAZY_SPLIT_VIEW_H

libcxx/include/__ranges/non_propagating_cache.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
// __non_propagating_cache is a helper type that allows storing an optional value in it, // __non_propagating_cache is a helper type that allows storing an optional value in it,
// but which does not copy the source's value when it is copy constructed/assigned to, // but which does not copy the source's value when it is copy constructed/assigned to,
// and which resets the source's value when it is moved-from. // and which resets the source's value when it is moved-from.
// //
// This type is used as an implementation detail of some views that need to cache the // This type is used as an implementation detail of some views that need to cache the
// result of `begin()` in order to provide an amortized O(1) begin() method. Typically, // result of `begin()` in order to provide an amortized O(1) begin() method. Typically,
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines public:
constexpr _Tp& __emplace(_Args&& ...__args) { constexpr _Tp& __emplace(_Args&& ...__args) {
return __value_.emplace(__forward_tag{}, std::forward<_Args>(__args)...).__t_; return __value_.emplace(__forward_tag{}, std::forward<_Args>(__args)...).__t_;
} }
}; };
struct __empty_cache { }; struct __empty_cache { };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H #endif // _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H

libcxx/include/__ranges/owning_view.h

Show All 23 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<range _Rp> template<range _Rp>
requires movable<_Rp> && (!__is_std_initializer_list<remove_cvref_t<_Rp>>) requires movable<_Rp> && (!__is_std_initializer_list<remove_cvref_t<_Rp>>)
class owning_view : public view_interface<owning_view<_Rp>> { class owning_view : public view_interface<owning_view<_Rp>> {
_Rp __r_ = _Rp(); _Rp __r_ = _Rp();
public: public:
Show All 30 Linespublic:
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(owning_view); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(owning_view);
template<class _Tp> template<class _Tp>
inline constexpr bool enable_borrowed_range<owning_view<_Tp>> = enable_borrowed_range<_Tp>; inline constexpr bool enable_borrowed_range<owning_view<_Tp>> = enable_borrowed_range<_Tp>;
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_OWNING_VIEW_H #endif // _LIBCPP___RANGES_OWNING_VIEW_H

libcxx/include/__ranges/range_adaptor.h

Show All 22 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 #if _LIBCPP_STD_VER >= 20
// CRTP base that one can derive from in order to be considered a range adaptor closure // CRTP base that one can derive from in order to be considered a range adaptor closure
// by the library. When deriving from this class, a pipe operator will be provided to // by the library. When deriving from this class, a pipe operator will be provided to
// make the following hold: // make the following hold:
// - `x | f` is equivalent to `f(x)` // - `x | f` is equivalent to `f(x)`
// - `f1 | f2` is an adaptor closure `g` such that `g(x)` is equivalent to `f2(f1(x))` // - `f1 | f2` is an adaptor closure `g` such that `g(x)` is equivalent to `f2(f1(x))`
template <class _Tp> template <class _Tp>
struct __range_adaptor_closure; struct __range_adaptor_closure;
Show All 25 Lines template <_RangeAdaptorClosure _Closure, _RangeAdaptorClosure _OtherClosure>
constructible_from<decay_t<_OtherClosure>, _OtherClosure> constructible_from<decay_t<_OtherClosure>, _OtherClosure>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
friend constexpr auto operator|(_Closure&& __c1, _OtherClosure&& __c2) friend constexpr auto operator|(_Closure&& __c1, _OtherClosure&& __c2)
noexcept(is_nothrow_constructible_v<decay_t<_Closure>, _Closure> && noexcept(is_nothrow_constructible_v<decay_t<_Closure>, _Closure> &&
is_nothrow_constructible_v<decay_t<_OtherClosure>, _OtherClosure>) is_nothrow_constructible_v<decay_t<_OtherClosure>, _OtherClosure>)
{ return __range_adaptor_closure_t(std::__compose(std::forward<_OtherClosure>(__c2), std::forward<_Closure>(__c1))); } { return __range_adaptor_closure_t(std::__compose(std::forward<_OtherClosure>(__c2), std::forward<_Closure>(__c1))); }
}; };
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_RANGE_ADAPTOR_H #endif // _LIBCPP___RANGES_RANGE_ADAPTOR_H

libcxx/include/__ranges/rbegin.h

Show All 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 #if _LIBCPP_STD_VER >= 20
// [ranges.access.rbegin] // [ranges.access.rbegin]
namespace ranges { namespace ranges {
namespace __rbegin { namespace __rbegin {
template <class _Tp> template <class _Tp>
concept __member_rbegin = concept __member_rbegin =
__can_borrow<_Tp> && __can_borrow<_Tp> &&
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
}; };
} // namespace __crbegin } // namespace __crbegin
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto crbegin = __crbegin::__fn{}; inline constexpr auto crbegin = __crbegin::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_RBEGIN_H #endif // _LIBCPP___RANGES_RBEGIN_H

libcxx/include/__ranges/ref_view.h

Show All 27 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<range _Range> template<range _Range>
requires is_object_v<_Range> requires is_object_v<_Range>
class ref_view : public view_interface<ref_view<_Range>> { class ref_view : public view_interface<ref_view<_Range>> {
_Range *__range_; _Range *__range_;
static void __fun(_Range&); static void __fun(_Range&);
Show All 31 Linespublic:
template<class _Range> template<class _Range>
ref_view(_Range&) -> ref_view<_Range>; ref_view(_Range&) -> ref_view<_Range>;
template<class _Tp> template<class _Tp>
inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true; inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_REF_VIEW_H #endif // _LIBCPP___RANGES_REF_VIEW_H

libcxx/include/__ranges/rend.h

Show All 21 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 #if _LIBCPP_STD_VER >= 20
// [range.access.rend] // [range.access.rend]
namespace ranges { namespace ranges {
namespace __rend { namespace __rend {
template <class _Tp> template <class _Tp>
concept __member_rend = concept __member_rend =
__can_borrow<_Tp> && __can_borrow<_Tp> &&
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
}; };
} // namespace __crend } // namespace __crend
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto crend = __crend::__fn{}; inline constexpr auto crend = __crend::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_REND_H #endif // _LIBCPP___RANGES_REND_H

libcxx/include/__ranges/reverse_view.h

Show All 28 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<view _View> template<view _View>
requires bidirectional_range<_View> requires bidirectional_range<_View>
class reverse_view : public view_interface<reverse_view<_View>> { class reverse_view : public view_interface<reverse_view<_View>> {
// We cache begin() whenever ranges::next is not guaranteed O(1) to provide an // We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
// amortized O(1) begin() method. // amortized O(1) begin() method.
static constexpr bool _UseCache = !random_access_range<_View> && !common_range<_View>; static constexpr bool _UseCache = !random_access_range<_View> && !common_range<_View>;
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Linesnamespace ranges {
} // namespace __reverse } // namespace __reverse
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto reverse = __reverse::__fn{}; inline constexpr auto reverse = __reverse::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_REVERSE_VIEW_H #endif // _LIBCPP___RANGES_REVERSE_VIEW_H

libcxx/include/__ranges/single_view.h

Show All 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<copy_constructible _Tp> template<copy_constructible _Tp>
requires is_object_v<_Tp> requires is_object_v<_Tp>
class single_view : public view_interface<single_view<_Tp>> { class single_view : public view_interface<single_view<_Tp>> {
__copyable_box<_Tp> __value_; __copyable_box<_Tp> __value_;
public: public:
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto single = __single_view::__fn{}; inline constexpr auto single = __single_view::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_SINGLE_VIEW_H #endif // _LIBCPP___RANGES_SINGLE_VIEW_H

libcxx/include/__ranges/size.h

Show All 24 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<class> template<class>
inline constexpr bool disable_sized_range = false; inline constexpr bool disable_sized_range = false;
} // namespace ranges } // namespace ranges
// [range.prim.size] // [range.prim.size]
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
}; };
} // namespace __ssize } // namespace __ssize
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto ssize = __ssize::__fn{}; inline constexpr auto ssize = __ssize::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_SIZE_H #endif // _LIBCPP___RANGES_SIZE_H

libcxx/include/__ranges/subrange.h

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<class _From, class _To> template<class _From, class _To>
concept __uses_nonqualification_pointer_conversion = concept __uses_nonqualification_pointer_conversion =
is_pointer_v<_From> && is_pointer_v<_To> && is_pointer_v<_From> && is_pointer_v<_To> &&
!convertible_to<remove_pointer_t<_From>(*)[], remove_pointer_t<_To>(*)[]>; !convertible_to<remove_pointer_t<_From>(*)[], remove_pointer_t<_To>(*)[]>;
template<class _From, class _To> template<class _From, class _To>
▲ Show 20 Lines • Show All 219 Lines • ▼ Show 20 Linesstruct tuple_element<0, const ranges::subrange<_Ip, _Sp, _Kp>> {
using type = _Ip; using type = _Ip;
}; };
template<class _Ip, class _Sp, ranges::subrange_kind _Kp> template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
struct tuple_element<1, const ranges::subrange<_Ip, _Sp, _Kp>> { struct tuple_element<1, const ranges::subrange<_Ip, _Sp, _Kp>> {
using type = _Sp; using type = _Sp;
}; };
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_SUBRANGE_H #endif // _LIBCPP___RANGES_SUBRANGE_H

libcxx/include/__ranges/take_view.h

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<view _View> template<view _View>
class take_view : public view_interface<take_view<_View>> { class take_view : public view_interface<take_view<_View>> {
_LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View(); _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
range_difference_t<_View> __count_ = 0; range_difference_t<_View> __count_ = 0;
▲ Show 20 Lines • Show All 268 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto take = __take::__fn{}; inline constexpr auto take = __take::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___RANGES_TAKE_VIEW_H #endif // _LIBCPP___RANGES_TAKE_VIEW_H

libcxx/include/__ranges/transform_view.h

Show All 37 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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<class _Fn, class _View> template<class _Fn, class _View>
concept __regular_invocable_with_range_ref = concept __regular_invocable_with_range_ref =
regular_invocable<_Fn, range_reference_t<_View>>; regular_invocable<_Fn, range_reference_t<_View>>;
template<class _View, class _Fn> template<class _View, class _Fn>
▲ Show 20 Lines • Show All 375 Lines • ▼ Show 20 Lines
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto transform = __transform::__fn{}; inline constexpr auto transform = __transform::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_TRANSFORM_VIEW_H #endif // _LIBCPP___RANGES_TRANSFORM_VIEW_H

libcxx/include/__ranges/view_interface.h

Show All 25 Lines
#include <__type_traits/remove_cv.h> #include <__type_traits/remove_cv.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
template<class _Derived> template<class _Derived>
requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>> requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
class view_interface { class view_interface {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr _Derived& __derived() noexcept { constexpr _Derived& __derived() noexcept {
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 Linespublic:
constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) const constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) const
{ {
return ranges::begin(__derived())[__index]; return ranges::begin(__derived())[__index];
} }
}; };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_VIEW_INTERFACE_H #endif // _LIBCPP___RANGES_VIEW_INTERFACE_H

libcxx/include/__ranges/views.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 #if _LIBCPP_STD_VER >= 20
namespace ranges { namespace ranges {
namespace views { } namespace views { }
} // namespace ranges } // namespace ranges
namespace views = ranges::views; namespace views = ranges::views;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_VIEWS #endif // _LIBCPP___RANGES_VIEWS

libcxx/include/__ranges/zip_view.h

Show All 39 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 > 20 #if _LIBCPP_STD_VER >= 23
namespace ranges { namespace ranges {
template <class... _Ranges> template <class... _Ranges>
concept __zip_is_common = (sizeof...(_Ranges) == 1 && (common_range<_Ranges> && ...)) || concept __zip_is_common = (sizeof...(_Ranges) == 1 && (common_range<_Ranges> && ...)) ||
(!(bidirectional_range<_Ranges> && ...) && (common_range<_Ranges> && ...)) || (!(bidirectional_range<_Ranges> && ...) && (common_range<_Ranges> && ...)) ||
((random_access_range<_Ranges> && ...) && (sized_range<_Ranges> && ...)); ((random_access_range<_Ranges> && ...) && (sized_range<_Ranges> && ...));
▲ Show 20 Lines • Show All 443 Lines • ▼ Show 20 Lines
} // namespace __zip } // namespace __zip
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto zip = __zip::__fn{}; inline constexpr auto zip = __zip::__fn{};
} // namespace __cpo } // namespace __cpo
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___RANGES_ZIP_VIEW_H #endif // _LIBCPP___RANGES_ZIP_VIEW_H

libcxx/include/__string/char_traits.h

Show First 20 Lines • Show All 193 Lines • ▼ Show 20 Lines
template <> template <>
struct _LIBCPP_TEMPLATE_VIS char_traits<char> struct _LIBCPP_TEMPLATE_VIS char_traits<char>
{ {
using char_type = char; using char_type = char;
using int_type = int; using int_type = int;
using off_type = streamoff; using off_type = streamoff;
using pos_type = streampos; using pos_type = streampos;
using state_type = mbstate_t; using state_type = mbstate_t;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
#endif #endif
static inline _LIBCPP_CONSTEXPR_SINCE_CXX17 static inline _LIBCPP_CONSTEXPR_SINCE_CXX17
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;} void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
template <> template <>
struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t> struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
{ {
using char_type = wchar_t; using char_type = wchar_t;
using int_type = wint_t; using int_type = wint_t;
using off_type = streamoff; using off_type = streamoff;
using pos_type = streampos; using pos_type = streampos;
using state_type = mbstate_t; using state_type = mbstate_t;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
#endif #endif
static inline _LIBCPP_CONSTEXPR_SINCE_CXX17 static inline _LIBCPP_CONSTEXPR_SINCE_CXX17
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;} void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
template <> template <>
struct _LIBCPP_TEMPLATE_VIS char_traits<char8_t> struct _LIBCPP_TEMPLATE_VIS char_traits<char8_t>
{ {
using char_type = char8_t; using char_type = char8_t;
using int_type = unsigned int; using int_type = unsigned int;
using off_type = streamoff; using off_type = streamoff;
using pos_type = u8streampos; using pos_type = u8streampos;
using state_type = mbstate_t; using state_type = mbstate_t;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
#endif #endif
static inline constexpr void assign(char_type& __c1, const char_type& __c2) noexcept static inline constexpr void assign(char_type& __c1, const char_type& __c2) noexcept
{__c1 = __c2;} {__c1 = __c2;}
static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept
{return __c1 == __c2;} {return __c1 == __c2;}
static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
template <> template <>
struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t> struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>
{ {
using char_type = char16_t; using char_type = char16_t;
using int_type = uint_least16_t; using int_type = uint_least16_t;
using off_type = streamoff; using off_type = streamoff;
using pos_type = u16streampos; using pos_type = u16streampos;
using state_type = mbstate_t; using state_type = mbstate_t;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
#endif #endif
static inline _LIBCPP_CONSTEXPR_SINCE_CXX17 static inline _LIBCPP_CONSTEXPR_SINCE_CXX17
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;} void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
template <> template <>
struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t> struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t>
{ {
using char_type = char32_t; using char_type = char32_t;
using int_type = uint_least32_t; using int_type = uint_least32_t;
using off_type = streamoff; using off_type = streamoff;
using pos_type = u32streampos; using pos_type = u32streampos;
using state_type = mbstate_t; using state_type = mbstate_t;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
using comparison_category = strong_ordering; using comparison_category = strong_ordering;
#endif #endif
static inline _LIBCPP_CONSTEXPR_SINCE_CXX17 static inline _LIBCPP_CONSTEXPR_SINCE_CXX17
void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;} void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
{return __c1 == __c2;} {return __c1 == __c2;}
static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT static inline _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
▲ Show 20 Lines • Show All 304 Lines • Show Last 20 Lines

libcxx/include/__tree

Show First 20 Lines • Show All 812 Lines • ▼ Show 20 Lines void operator()(pointer __p) _NOEXCEPT
__alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_)); __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
if (__p) if (__p)
__alloc_traits::deallocate(__na_, __p, 1); __alloc_traits::deallocate(__na_, __p, 1);
} }
template <class> friend class __map_node_destructor; template <class> friend class __map_node_destructor;
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _NodeType, class _Alloc> template <class _NodeType, class _Alloc>
struct __generic_container_node_destructor; struct __generic_container_node_destructor;
template <class _Tp, class _VoidPtr, class _Alloc> template <class _Tp, class _VoidPtr, class _Alloc>
struct __generic_container_node_destructor<__tree_node<_Tp, _VoidPtr>, _Alloc> struct __generic_container_node_destructor<__tree_node<_Tp, _VoidPtr>, _Alloc>
: __tree_node_destructor<_Alloc> : __tree_node_destructor<_Alloc>
{ {
using __tree_node_destructor<_Alloc>::__tree_node_destructor; using __tree_node_destructor<_Alloc>::__tree_node_destructor;
}; };
Show All 14 Lines
public: public:
typedef bidirectional_iterator_tag iterator_category; typedef bidirectional_iterator_tag iterator_category;
typedef _Tp value_type; typedef _Tp value_type;
typedef _DiffType difference_type; typedef _DiffType difference_type;
typedef value_type& reference; typedef value_type& reference;
typedef typename _NodeTypes::__node_value_type_pointer pointer; typedef typename _NodeTypes::__node_value_type_pointer pointer;
_LIBCPP_INLINE_VISIBILITY __tree_iterator() _NOEXCEPT _LIBCPP_INLINE_VISIBILITY __tree_iterator() _NOEXCEPT
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
: __ptr_(nullptr) : __ptr_(nullptr)
#endif #endif
{} {}
_LIBCPP_INLINE_VISIBILITY reference operator*() const _LIBCPP_INLINE_VISIBILITY reference operator*() const
{return __get_np()->__value_;} {return __get_np()->__value_;}
_LIBCPP_INLINE_VISIBILITY pointer operator->() const _LIBCPP_INLINE_VISIBILITY pointer operator->() const
{return pointer_traits<pointer>::pointer_to(__get_np()->__value_);} {return pointer_traits<pointer>::pointer_to(__get_np()->__value_);}
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
public: public:
typedef bidirectional_iterator_tag iterator_category; typedef bidirectional_iterator_tag iterator_category;
typedef _Tp value_type; typedef _Tp value_type;
typedef _DiffType difference_type; typedef _DiffType difference_type;
typedef const value_type& reference; typedef const value_type& reference;
typedef typename _NodeTypes::__const_node_value_type_pointer pointer; typedef typename _NodeTypes::__const_node_value_type_pointer pointer;
_LIBCPP_INLINE_VISIBILITY __tree_const_iterator() _NOEXCEPT _LIBCPP_INLINE_VISIBILITY __tree_const_iterator() _NOEXCEPT
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
: __ptr_(nullptr) : __ptr_(nullptr)
#endif #endif
{} {}
private: private:
typedef __tree_iterator<value_type, __node_pointer, difference_type> typedef __tree_iterator<value_type, __node_pointer, difference_type>
__non_const_iterator; __non_const_iterator;
public: public:
▲ Show 20 Lines • Show All 392 Lines • ▼ Show 20 Lines#endif
iterator __node_insert_multi(__node_pointer __nd); iterator __node_insert_multi(__node_pointer __nd);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator __node_insert_multi(const_iterator __p, __node_pointer __nd); iterator __node_insert_multi(const_iterator __p, __node_pointer __nd);
_LIBCPP_INLINE_VISIBILITY iterator _LIBCPP_INLINE_VISIBILITY iterator
__remove_node_pointer(__node_pointer) _NOEXCEPT; __remove_node_pointer(__node_pointer) _NOEXCEPT;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _NodeHandle, class _InsertReturnType> template <class _NodeHandle, class _InsertReturnType>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_InsertReturnType __node_handle_insert_unique(_NodeHandle&&); _InsertReturnType __node_handle_insert_unique(_NodeHandle&&);
template <class _NodeHandle> template <class _NodeHandle>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator __node_handle_insert_unique(const_iterator, _NodeHandle&&); iterator __node_handle_insert_unique(const_iterator, _NodeHandle&&);
template <class _Tree> template <class _Tree>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 917 Lines • ▼ Show 20 Lines__tree<_Tp, _Compare, _Allocator>::__remove_node_pointer(__node_pointer __ptr) _NOEXCEPT
if (__begin_node() == __ptr) if (__begin_node() == __ptr)
__begin_node() = __r.__ptr_; __begin_node() = __r.__ptr_;
--size(); --size();
_VSTD::__tree_remove(__end_node()->__left_, _VSTD::__tree_remove(__end_node()->__left_,
static_cast<__node_base_pointer>(__ptr)); static_cast<__node_base_pointer>(__ptr));
return __r; return __r;
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Compare, class _Allocator> template <class _Tp, class _Compare, class _Allocator>
template <class _NodeHandle, class _InsertReturnType> template <class _NodeHandle, class _InsertReturnType>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_InsertReturnType _InsertReturnType
__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique( __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(
_NodeHandle&& __nh) _NodeHandle&& __nh)
{ {
if (__nh.empty()) if (__nh.empty())
▲ Show 20 Lines • Show All 140 Lines • ▼ Show 20 Lines for (typename _Tree::iterator __i = __source.begin();
__parent, _NodeTypes::__get_key(__src_ptr->__value_)); __parent, _NodeTypes::__get_key(__src_ptr->__value_));
++__i; ++__i;
__source.__remove_node_pointer(__src_ptr); __source.__remove_node_pointer(__src_ptr);
__insert_node_at(__parent, __child, __insert_node_at(__parent, __child,
static_cast<__node_base_pointer>(__src_ptr)); static_cast<__node_base_pointer>(__src_ptr));
} }
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
template <class _Tp, class _Compare, class _Allocator> template <class _Tp, class _Compare, class _Allocator>
typename __tree<_Tp, _Compare, _Allocator>::iterator typename __tree<_Tp, _Compare, _Allocator>::iterator
__tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p) __tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p)
{ {
__node_pointer __np = __p.__get_np(); __node_pointer __np = __p.__get_np();
iterator __r = __remove_node_pointer(__np); iterator __r = __remove_node_pointer(__np);
__node_allocator& __na = __node_alloc(); __node_allocator& __na = __node_alloc();
▲ Show 20 Lines • Show All 325 Lines • Show Last 20 Lines

libcxx/include/__tuple_dir/sfinae_helpers.h

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Linesstruct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
static constexpr bool __enable_explicit() { return false; } static constexpr bool __enable_explicit() { return false; }
template <class ...> template <class ...>
static constexpr bool __enable_implicit() { return false; } static constexpr bool __enable_implicit() { return false; }
template <class ...> template <class ...>
static constexpr bool __enable_assign() { return false; } static constexpr bool __enable_assign() { return false; }
}; };
#endif // !defined(_LIBCPP_CXX03_LANG) #endif // !defined(_LIBCPP_CXX03_LANG)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <bool _CanCopy, bool _CanMove> template <bool _CanCopy, bool _CanMove>
struct __sfinae_ctor_base {}; struct __sfinae_ctor_base {};
template <> template <>
struct __sfinae_ctor_base<false, false> { struct __sfinae_ctor_base<false, false> {
__sfinae_ctor_base() = default; __sfinae_ctor_base() = default;
__sfinae_ctor_base(__sfinae_ctor_base const&) = delete; __sfinae_ctor_base(__sfinae_ctor_base const&) = delete;
__sfinae_ctor_base(__sfinae_ctor_base &&) = delete; __sfinae_ctor_base(__sfinae_ctor_base &&) = delete;
Show All 38 Lines
template <> template <>
struct __sfinae_assign_base<false, true> { struct __sfinae_assign_base<false, true> {
__sfinae_assign_base() = default; __sfinae_assign_base() = default;
__sfinae_assign_base(__sfinae_assign_base const&) = default; __sfinae_assign_base(__sfinae_assign_base const&) = default;
__sfinae_assign_base(__sfinae_assign_base &&) = default; __sfinae_assign_base(__sfinae_assign_base &&) = default;
__sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete; __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
__sfinae_assign_base& operator=(__sfinae_assign_base&&) = default; __sfinae_assign_base& operator=(__sfinae_assign_base&&) = default;
}; };
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TUPLE_SFINAE_HELPERS_H #endif // _LIBCPP___TUPLE_SFINAE_HELPERS_H

libcxx/include/__tuple_dir/tuple_element.h

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
template <size_t _Ip, class ..._Types> template <size_t _Ip, class ..._Types>
struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...> > struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...> >
{ {
static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range"); static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
typedef _LIBCPP_NODEBUG __type_pack_element<_Ip, _Types...> type; typedef _LIBCPP_NODEBUG __type_pack_element<_Ip, _Types...> type;
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <size_t _Ip, class ..._Tp> template <size_t _Ip, class ..._Tp>
using tuple_element_t _LIBCPP_NODEBUG = typename tuple_element <_Ip, _Tp...>::type; using tuple_element_t _LIBCPP_NODEBUG = typename tuple_element <_Ip, _Tp...>::type;
#endif #endif
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TUPLE_TUPLE_ELEMENT_H #endif // _LIBCPP___TUPLE_TUPLE_ELEMENT_H

libcxx/include/__type_traits/add_const.h

Show All 15 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_const { template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_const {
typedef _LIBCPP_NODEBUG const _Tp type; typedef _LIBCPP_NODEBUG const _Tp type;
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using add_const_t = typename add_const<_Tp>::type; template <class _Tp> using add_const_t = typename add_const<_Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_CONST_H #endif // _LIBCPP___TYPE_TRAITS_ADD_CONST_H

libcxx/include/__type_traits/add_cv.h

Show All 15 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_cv { template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_cv {
typedef _LIBCPP_NODEBUG const volatile _Tp type; typedef _LIBCPP_NODEBUG const volatile _Tp type;
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type; template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_CV_H #endif // _LIBCPP___TYPE_TRAITS_ADD_CV_H

libcxx/include/__type_traits/add_lvalue_reference.h

Show All 38 Lines
#endif // __has_builtin(__add_lvalue_reference) #endif // __has_builtin(__add_lvalue_reference)
template <class _Tp> template <class _Tp>
struct add_lvalue_reference { struct add_lvalue_reference {
using type _LIBCPP_NODEBUG = __add_lvalue_reference_t<_Tp>; using type _LIBCPP_NODEBUG = __add_lvalue_reference_t<_Tp>;
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using add_lvalue_reference_t = __add_lvalue_reference_t<_Tp>; template <class _Tp> using add_lvalue_reference_t = __add_lvalue_reference_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_LVALUE_REFERENCE_H #endif // _LIBCPP___TYPE_TRAITS_ADD_LVALUE_REFERENCE_H

libcxx/include/__type_traits/add_pointer.h

Show All 40 Lines
#endif // __has_builtin(__add_pointer) #endif // __has_builtin(__add_pointer)
template <class _Tp> template <class _Tp>
struct add_pointer { struct add_pointer {
using type _LIBCPP_NODEBUG = __add_pointer_t<_Tp>; using type _LIBCPP_NODEBUG = __add_pointer_t<_Tp>;
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using add_pointer_t = __add_pointer_t<_Tp>; template <class _Tp> using add_pointer_t = __add_pointer_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_ADD_POINTER_H

libcxx/include/__type_traits/add_rvalue_reference.h

Show All 38 Lines
#endif // __has_builtin(__add_rvalue_reference) #endif // __has_builtin(__add_rvalue_reference)
template <class _Tp> template <class _Tp>
struct add_rvalue_reference { struct add_rvalue_reference {
using type = __add_rvalue_reference_t<_Tp>; using type = __add_rvalue_reference_t<_Tp>;
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> template <class _Tp>
using add_rvalue_reference_t = __add_rvalue_reference_t<_Tp>; using add_rvalue_reference_t = __add_rvalue_reference_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_RVALUE_REFERENCE_H #endif // _LIBCPP___TYPE_TRAITS_ADD_RVALUE_REFERENCE_H

libcxx/include/__type_traits/add_volatile.h

Show All 15 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_volatile { template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_volatile {
typedef _LIBCPP_NODEBUG volatile _Tp type; typedef _LIBCPP_NODEBUG volatile _Tp type;
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type; template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ADD_VOLATILE_H #endif // _LIBCPP___TYPE_TRAITS_ADD_VOLATILE_H

libcxx/include/__type_traits/aligned_storage.h

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Linesstruct _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_TEMPLATE_VIS aligned_storage
typedef typename __find_pod<__all_types, _Align>::type _Aligner; typedef typename __find_pod<__all_types, _Align>::type _Aligner;
union type union type
{ {
_Aligner __align; _Aligner __align;
unsigned char __data[(_Len + _Align - 1)/_Align * _Align]; unsigned char __data[(_Len + _Align - 1)/_Align * _Align];
}; };
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value> template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
using aligned_storage_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_storage<_Len, _Align>::type; using aligned_storage_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_storage<_Len, _Align>::type;
_LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
#endif #endif
Show All 34 Lines

libcxx/include/__type_traits/aligned_union.h

Show All 40 Lines
{ {
static const size_t alignment_value = __static_max<_LIBCPP_PREFERRED_ALIGNOF(_Type0), static const size_t alignment_value = __static_max<_LIBCPP_PREFERRED_ALIGNOF(_Type0),
_LIBCPP_PREFERRED_ALIGNOF(_Types)...>::value; _LIBCPP_PREFERRED_ALIGNOF(_Types)...>::value;
static const size_t __len = __static_max<_Len, sizeof(_Type0), static const size_t __len = __static_max<_Len, sizeof(_Type0),
sizeof(_Types)...>::value; sizeof(_Types)...>::value;
typedef typename aligned_storage<__len, alignment_value>::type type; typedef typename aligned_storage<__len, alignment_value>::type type;
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <size_t _Len, class... _Types> template <size_t _Len, class... _Types>
using aligned_union_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_union<_Len, _Types...>::type; using aligned_union_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_union<_Len, _Types...>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ALIGNED_UNION_H #endif // _LIBCPP___TYPE_TRAITS_ALIGNED_UNION_H

libcxx/include/__type_traits/alignment_of.h

Show All 16 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS alignment_of template <class _Tp> struct _LIBCPP_TEMPLATE_VIS alignment_of
: public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)> {}; : public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr size_t alignment_of_v = _LIBCPP_ALIGNOF(_Tp); inline constexpr size_t alignment_of_v = _LIBCPP_ALIGNOF(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ALIGNMENT_OF_H #endif // _LIBCPP___TYPE_TRAITS_ALIGNMENT_OF_H

libcxx/include/__type_traits/common_reference.h

Show All 21 Lines
#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
// common_reference // common_reference
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
// 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 ? std::declval<_Xp(&)()>()() : std::declval<_Yp(&)()>()()); decltype(false ? std::declval<_Xp(&)()>()() : std::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 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_COMMON_REFERENCE_H #endif // _LIBCPP___TYPE_TRAITS_COMMON_REFERENCE_H

libcxx/include/__type_traits/common_type.h

Show All 17 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 #if _LIBCPP_STD_VER >= 20
// Let COND_RES(X, Y) be: // Let COND_RES(X, Y) be:
template <class _Tp, class _Up> template <class _Tp, class _Up>
using __cond_type = decltype(false ? std::declval<_Tp>() : std::declval<_Up>()); using __cond_type = decltype(false ? std::declval<_Tp>() : std::declval<_Up>());
template <class _Tp, class _Up, class = void> template <class _Tp, class _Up, class = void>
struct __common_type3 {}; struct __common_type3 {};
// sub-bullet 4 - "if COND_RES(CREF(D1), CREF(D2)) denotes a type..." // sub-bullet 4 - "if COND_RES(CREF(D1), CREF(D2)) denotes a type..."
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
template <class _Tp, class _Up, class _Vp _LIBCPP_OPTIONAL_PACK(class... _Rest)> template <class _Tp, class _Up, class _Vp _LIBCPP_OPTIONAL_PACK(class... _Rest)>
struct _LIBCPP_TEMPLATE_VIS struct _LIBCPP_TEMPLATE_VIS
common_type<_Tp, _Up, _Vp _LIBCPP_OPTIONAL_PACK(_Rest...)> common_type<_Tp, _Up, _Vp _LIBCPP_OPTIONAL_PACK(_Rest...)>
: __common_type_impl< : __common_type_impl<
__common_types<_Tp, _Up, _Vp _LIBCPP_OPTIONAL_PACK(_Rest...)> > {}; __common_types<_Tp, _Up, _Vp _LIBCPP_OPTIONAL_PACK(_Rest...)> > {};
#undef _LIBCPP_OPTIONAL_PACK #undef _LIBCPP_OPTIONAL_PACK
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type; template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_COMMON_TYPE_H #endif // _LIBCPP___TYPE_TRAITS_COMMON_TYPE_H

libcxx/include/__type_traits/conditional.h

Show All 38 Lines
struct _LIBCPP_TEMPLATE_VIS conditional { struct _LIBCPP_TEMPLATE_VIS conditional {
using type _LIBCPP_NODEBUG = _If; using type _LIBCPP_NODEBUG = _If;
}; };
template <class _If, class _Then> template <class _If, class _Then>
struct _LIBCPP_TEMPLATE_VIS conditional<false, _If, _Then> { struct _LIBCPP_TEMPLATE_VIS conditional<false, _If, _Then> {
using type _LIBCPP_NODEBUG = _Then; using type _LIBCPP_NODEBUG = _Then;
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <bool _Bp, class _IfRes, class _ElseRes> template <bool _Bp, class _IfRes, class _ElseRes>
using conditional_t _LIBCPP_NODEBUG = typename conditional<_Bp, _IfRes, _ElseRes>::type; using conditional_t _LIBCPP_NODEBUG = typename conditional<_Bp, _IfRes, _ElseRes>::type;
#endif #endif
// Helper so we can use "conditional_t" in all language versions. // Helper so we can use "conditional_t" in all language versions.
template <bool _Bp, class _If, class _Then> template <bool _Bp, class _If, class _Then>
using __conditional_t _LIBCPP_NODEBUG = typename conditional<_Bp, _If, _Then>::type; using __conditional_t _LIBCPP_NODEBUG = typename conditional<_Bp, _If, _Then>::type;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_CONDITIONAL_H #endif // _LIBCPP___TYPE_TRAITS_CONDITIONAL_H

libcxx/include/__type_traits/conjunction.h

Show All 31 Lines
// _And always performs lazy evaluation of its arguments. // _And always performs lazy evaluation of its arguments.
// //
// However, `_And<_Pred...>` itself will evaluate its result immediately (without having to // However, `_And<_Pred...>` itself will evaluate its result immediately (without having to
// be instantiated) since it is an alias, unlike `conjunction<_Pred...>`, which is a struct. // be instantiated) since it is an alias, unlike `conjunction<_Pred...>`, which is a struct.
// If you want to defer the evaluation of `_And<_Pred...>` itself, use `_Lazy<_And, _Pred...>`. // If you want to defer the evaluation of `_And<_Pred...>` itself, use `_Lazy<_And, _Pred...>`.
template <class... _Pred> template <class... _Pred>
using _And _LIBCPP_NODEBUG = decltype(std::__and_helper<_Pred...>(0)); using _And _LIBCPP_NODEBUG = decltype(std::__and_helper<_Pred...>(0));
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class...> template <class...>
struct conjunction : true_type {}; struct conjunction : true_type {};
template <class _Arg> template <class _Arg>
struct conjunction<_Arg> : _Arg {}; struct conjunction<_Arg> : _Arg {};
template <class _Arg, class... _Args> template <class _Arg, class... _Args>
struct conjunction<_Arg, _Args...> : conditional_t<!bool(_Arg::value), _Arg, conjunction<_Args...>> {}; struct conjunction<_Arg, _Args...> : conditional_t<!bool(_Arg::value), _Arg, conjunction<_Args...>> {};
template <class... _Args> template <class... _Args>
inline constexpr bool conjunction_v = conjunction<_Args...>::value; inline constexpr bool conjunction_v = conjunction<_Args...>::value;
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_CONJUNCTION_H #endif // _LIBCPP___TYPE_TRAITS_CONJUNCTION_H

libcxx/include/__type_traits/decay.h

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
{ {
private: private:
typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp> _Up; typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp> _Up;
public: public:
typedef _LIBCPP_NODEBUG typename __decay<_Up, __libcpp_is_referenceable<_Up>::value>::type type; typedef _LIBCPP_NODEBUG typename __decay<_Up, __libcpp_is_referenceable<_Up>::value>::type type;
}; };
#endif // __has_builtin(__decay) #endif // __has_builtin(__decay)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using decay_t = typename decay<_Tp>::type; template <class _Tp> using decay_t = typename decay<_Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_DECAY_H #endif // _LIBCPP___TYPE_TRAITS_DECAY_H

libcxx/include/__type_traits/disjunction.h

Show All 37 Lines
// //
// However, `_Or<_Pred...>` itself will evaluate its result immediately (without having to // However, `_Or<_Pred...>` itself will evaluate its result immediately (without having to
// be instantiated) since it is an alias, unlike `disjunction<_Pred...>`, which is a struct. // be instantiated) since it is an alias, unlike `disjunction<_Pred...>`, which is a struct.
// If you want to defer the evaluation of `_Or<_Pred...>` itself, use `_Lazy<_Or, _Pred...>` // If you want to defer the evaluation of `_Or<_Pred...>` itself, use `_Lazy<_Or, _Pred...>`
// or `disjunction<_Pred...>` directly. // or `disjunction<_Pred...>` directly.
template <class... _Args> template <class... _Args>
using _Or _LIBCPP_NODEBUG = typename _OrImpl<sizeof...(_Args) != 0>::template _Result<false_type, _Args...>; using _Or _LIBCPP_NODEBUG = typename _OrImpl<sizeof...(_Args) != 0>::template _Result<false_type, _Args...>;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class... _Args> template <class... _Args>
struct disjunction : _Or<_Args...> {}; struct disjunction : _Or<_Args...> {};
template <class... _Args> template <class... _Args>
inline constexpr bool disjunction_v = _Or<_Args...>::value; inline constexpr bool disjunction_v = _Or<_Args...>::value;
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_DISJUNCTION_H #endif // _LIBCPP___TYPE_TRAITS_DISJUNCTION_H

libcxx/include/__type_traits/enable_if.h

Show All 16 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <bool, class _Tp = void> struct _LIBCPP_TEMPLATE_VIS enable_if {}; template <bool, class _Tp = void> struct _LIBCPP_TEMPLATE_VIS enable_if {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS enable_if<true, _Tp> {typedef _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS enable_if<true, _Tp> {typedef _Tp type;};
template <bool _Bp, class _Tp = void> using __enable_if_t _LIBCPP_NODEBUG = typename enable_if<_Bp, _Tp>::type; template <bool _Bp, class _Tp = void> using __enable_if_t _LIBCPP_NODEBUG = typename enable_if<_Bp, _Tp>::type;
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type; template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_ENABLE_IF_H #endif // _LIBCPP___TYPE_TRAITS_ENABLE_IF_H

libcxx/include/__type_traits/extent.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__array_extent) #if __has_builtin(__array_extent)
template<class _Tp, size_t _Dim = 0> template<class _Tp, size_t _Dim = 0>
struct _LIBCPP_TEMPLATE_VIS extent struct _LIBCPP_TEMPLATE_VIS extent
: integral_constant<size_t, __array_extent(_Tp, _Dim)> { }; : integral_constant<size_t, __array_extent(_Tp, _Dim)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, unsigned _Ip = 0> template <class _Tp, unsigned _Ip = 0>
inline constexpr size_t extent_v = __array_extent(_Tp, _Ip); inline constexpr size_t extent_v = __array_extent(_Tp, _Ip);
#endif #endif
#else // __has_builtin(__array_extent) #else // __has_builtin(__array_extent)
template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TEMPLATE_VIS extent template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TEMPLATE_VIS extent
: public integral_constant<size_t, 0> {}; : public integral_constant<size_t, 0> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], 0> template <class _Tp> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], 0>
: public integral_constant<size_t, 0> {}; : public integral_constant<size_t, 0> {};
template <class _Tp, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], _Ip> template <class _Tp, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], _Ip>
: public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {}; : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], 0> template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], 0>
: public integral_constant<size_t, _Np> {}; : public integral_constant<size_t, _Np> {};
template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], _Ip> template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], _Ip>
: public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {}; : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, unsigned _Ip = 0> template <class _Tp, unsigned _Ip = 0>
inline constexpr size_t extent_v = extent<_Tp, _Ip>::value; inline constexpr size_t extent_v = extent<_Tp, _Ip>::value;
#endif #endif
#endif // __has_builtin(__array_extent) #endif // __has_builtin(__array_extent)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_EXTENT_H #endif // _LIBCPP___TYPE_TRAITS_EXTENT_H

libcxx/include/__type_traits/has_unique_object_representation.h

Show All 14 Lines
#include <__type_traits/remove_cv.h> #include <__type_traits/remove_cv.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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_unique_object_representations template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_unique_object_representations
: public integral_constant<bool, : public integral_constant<bool,
__has_unique_object_representations(remove_cv_t<remove_all_extents_t<_Tp>>)> {}; __has_unique_object_representations(remove_cv_t<remove_all_extents_t<_Tp>>)> {};
template <class _Tp> template <class _Tp>
inline constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value; inline constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATION_H #endif // _LIBCPP___TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATION_H

libcxx/include/__type_traits/has_virtual_destructor.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)> {}; : public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Tp); inline constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_HAS_VIRTUAL_DESTRUCTOR_H #endif // _LIBCPP___TYPE_TRAITS_HAS_VIRTUAL_DESTRUCTOR_H

libcxx/include/__type_traits/integral_constant.h

Show All 19 Lines
template <class _Tp, _Tp __v> template <class _Tp, _Tp __v>
struct _LIBCPP_TEMPLATE_VIS integral_constant struct _LIBCPP_TEMPLATE_VIS integral_constant
{ {
static _LIBCPP_CONSTEXPR const _Tp value = __v; static _LIBCPP_CONSTEXPR const _Tp value = __v;
typedef _Tp value_type; typedef _Tp value_type;
typedef integral_constant type; typedef integral_constant type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR operator value_type() const _NOEXCEPT {return value;} _LIBCPP_CONSTEXPR operator value_type() const _NOEXCEPT {return value;}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr value_type operator ()() const _NOEXCEPT {return value;} constexpr value_type operator ()() const _NOEXCEPT {return value;}
#endif #endif
}; };
template <class _Tp, _Tp __v> template <class _Tp, _Tp __v>
_LIBCPP_CONSTEXPR const _Tp integral_constant<_Tp, __v>::value; _LIBCPP_CONSTEXPR const _Tp integral_constant<_Tp, __v>::value;
typedef integral_constant<bool, true> true_type; typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type; typedef integral_constant<bool, false> false_type;
template <bool _Val> template <bool _Val>
using _BoolConstant _LIBCPP_NODEBUG = integral_constant<bool, _Val>; using _BoolConstant _LIBCPP_NODEBUG = integral_constant<bool, _Val>;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <bool __b> template <bool __b>
using bool_constant = integral_constant<bool, __b>; using bool_constant = integral_constant<bool, __b>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_INTEGRAL_CONSTANT_H #endif // _LIBCPP___TYPE_TRAITS_INTEGRAL_CONSTANT_H

libcxx/include/__type_traits/is_abstract.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_abstract template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_abstract
: public integral_constant<bool, __is_abstract(_Tp)> {}; : public integral_constant<bool, __is_abstract(_Tp)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_abstract_v = __is_abstract(_Tp); inline constexpr bool is_abstract_v = __is_abstract(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_ABSTRACT_H #endif // _LIBCPP___TYPE_TRAITS_IS_ABSTRACT_H

libcxx/include/__type_traits/is_aggregate.h

Show All 12 Lines
#include <__type_traits/integral_constant.h> #include <__type_traits/integral_constant.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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
is_aggregate : public integral_constant<bool, __is_aggregate(_Tp)> {}; is_aggregate : public integral_constant<bool, __is_aggregate(_Tp)> {};
template <class _Tp> template <class _Tp>
inline constexpr bool is_aggregate_v = __is_aggregate(_Tp); inline constexpr bool is_aggregate_v = __is_aggregate(_Tp);
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_AGGREGATE_H #endif // _LIBCPP___TYPE_TRAITS_IS_AGGREGATE_H

libcxx/include/__type_traits/is_arithmetic.h

Show All 18 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_arithmetic template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_arithmetic
: public integral_constant<bool, is_integral<_Tp>::value || : public integral_constant<bool, is_integral<_Tp>::value ||
is_floating_point<_Tp>::value> {}; is_floating_point<_Tp>::value> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_ARITHMETIC_H #endif // _LIBCPP___TYPE_TRAITS_IS_ARITHMETIC_H

libcxx/include/__type_traits/is_array.h

Show All 20 Lines
// TODO: Clang incorrectly reports that __is_array is true for T[0]. // TODO: Clang incorrectly reports that __is_array is true for T[0].
// Re-enable the branch once https://llvm.org/PR54705 is fixed. // Re-enable the branch once https://llvm.org/PR54705 is fixed.
#if __has_builtin(__is_array) && 0 #if __has_builtin(__is_array) && 0
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_array : _BoolConstant<__is_array(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_array : _BoolConstant<__is_array(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_array_v = __is_array(_Tp); inline constexpr bool is_array_v = __is_array(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array
: public false_type {}; : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[]> template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[]>
: public true_type {}; : public true_type {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[_Np]> template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[_Np]>
: public true_type {}; : public true_type {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_array_v = is_array<_Tp>::value; inline constexpr bool is_array_v = is_array<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_array) #endif // __has_builtin(__is_array)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_ARRAY_H #endif // _LIBCPP___TYPE_TRAITS_IS_ARRAY_H

libcxx/include/__type_traits/is_assignable.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template<class _Tp, class _Up> template<class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_assignable : _BoolConstant<__is_assignable(_Tp, _Up)> { }; struct _LIBCPP_TEMPLATE_VIS is_assignable : _BoolConstant<__is_assignable(_Tp, _Up)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Arg> template <class _Tp, class _Arg>
inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Arg); inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Arg);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_ASSIGNABLE_H

libcxx/include/__type_traits/is_base_of.h

Show All 16 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Bp, class _Dp> template <class _Bp, class _Dp>
struct _LIBCPP_TEMPLATE_VIS is_base_of struct _LIBCPP_TEMPLATE_VIS is_base_of
: public integral_constant<bool, __is_base_of(_Bp, _Dp)> {}; : public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Bp, class _Dp> template <class _Bp, class _Dp>
inline constexpr bool is_base_of_v = __is_base_of(_Bp, _Dp); inline constexpr bool is_base_of_v = __is_base_of(_Bp, _Dp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_BASE_OF_H #endif // _LIBCPP___TYPE_TRAITS_IS_BASE_OF_H

libcxx/include/__type_traits/is_bounded_array.h

Show All 16 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_bounded_array : false_type {}; template <class> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_bounded_array : false_type {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_bounded_array<_Tp[_Np]> : true_type {}; template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_bounded_array<_Tp[_Np]> : true_type {};
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class> struct _LIBCPP_TEMPLATE_VIS is_bounded_array : false_type {}; template <class> struct _LIBCPP_TEMPLATE_VIS is_bounded_array : false_type {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_bounded_array<_Tp[_Np]> : true_type {}; template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_bounded_array<_Tp[_Np]> : true_type {};
template <class _Tp> template <class _Tp>
inline constexpr inline constexpr
bool is_bounded_array_v = is_bounded_array<_Tp>::value; bool is_bounded_array_v = is_bounded_array<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_BOUNDED_ARRAY_H #endif // _LIBCPP___TYPE_TRAITS_IS_BOUNDED_ARRAY_H

libcxx/include/__type_traits/is_class.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_class template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_class
: public integral_constant<bool, __is_class(_Tp)> {}; : public integral_constant<bool, __is_class(_Tp)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_class_v = __is_class(_Tp); inline constexpr bool is_class_v = __is_class(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_CLASS_H #endif // _LIBCPP___TYPE_TRAITS_IS_CLASS_H

libcxx/include/__type_traits/is_compound.h

Show All 18 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_compound) #if __has_builtin(__is_compound)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_compound : _BoolConstant<__is_compound(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_compound : _BoolConstant<__is_compound(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_compound_v = __is_compound(_Tp); inline constexpr bool is_compound_v = __is_compound(_Tp);
#endif #endif
#else // __has_builtin(__is_compound) #else // __has_builtin(__is_compound)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_compound template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_compound
: public integral_constant<bool, !is_fundamental<_Tp>::value> {}; : public integral_constant<bool, !is_fundamental<_Tp>::value> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_compound_v = is_compound<_Tp>::value; inline constexpr bool is_compound_v = is_compound<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_compound) #endif // __has_builtin(__is_compound)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_COMPOUND_H #endif // _LIBCPP___TYPE_TRAITS_IS_COMPOUND_H

libcxx/include/__type_traits/is_const.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_const) #if __has_builtin(__is_const)
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_const : _BoolConstant<__is_const(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_const : _BoolConstant<__is_const(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_const_v = __is_const(_Tp); inline constexpr bool is_const_v = __is_const(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const : public false_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_const_v = is_const<_Tp>::value; inline constexpr bool is_const_v = is_const<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_const) #endif // __has_builtin(__is_const)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_CONST_H #endif // _LIBCPP___TYPE_TRAITS_IS_CONST_H

libcxx/include/__type_traits/is_constant_evaluated.h

Show All 11 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 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
inline constexpr bool is_constant_evaluated() noexcept { inline constexpr bool is_constant_evaluated() noexcept {
return __builtin_is_constant_evaluated(); return __builtin_is_constant_evaluated();
} }
#endif #endif
_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR
bool __libcpp_is_constant_evaluated() _NOEXCEPT { return __builtin_is_constant_evaluated(); } bool __libcpp_is_constant_evaluated() _NOEXCEPT { return __builtin_is_constant_evaluated(); }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_CONSTANT_EVALUATED_H #endif // _LIBCPP___TYPE_TRAITS_IS_CONSTANT_EVALUATED_H

libcxx/include/__type_traits/is_constructible.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp, class ..._Args> template <class _Tp, class ..._Args>
struct _LIBCPP_TEMPLATE_VIS is_constructible struct _LIBCPP_TEMPLATE_VIS is_constructible
: public integral_constant<bool, __is_constructible(_Tp, _Args...)> : public integral_constant<bool, __is_constructible(_Tp, _Args...)>
{ }; { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class ..._Args> template <class _Tp, class ..._Args>
inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_IS_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_IS_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_convertible.h

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Linestemplate <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible
: public __is_convertible<_T1, _T2> : public __is_convertible<_T1, _T2>
{ {
static const size_t __complete_check1 = __is_convertible_check<_T1>::__v; static const size_t __complete_check1 = __is_convertible_check<_T1>::__v;
static const size_t __complete_check2 = __is_convertible_check<_T2>::__v; static const size_t __complete_check2 = __is_convertible_check<_T2>::__v;
}; };
#endif // __has_builtin(__is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK) #endif // __has_builtin(__is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _From, class _To> template <class _From, class _To>
inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value; inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_CONVERTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_CONVERTIBLE_H

libcxx/include/__type_traits/is_copy_assignable.h

Show All 21 Lines
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_copy_assignable struct _LIBCPP_TEMPLATE_VIS is_copy_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_assignable(__add_lvalue_reference_t<_Tp>, __is_assignable(__add_lvalue_reference_t<_Tp>,
__add_lvalue_reference_t<typename add_const<_Tp>::type>)> {}; __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value; inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_copy_constructible.h

Show All 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_copy_constructible struct _LIBCPP_TEMPLATE_VIS is_copy_constructible
: public integral_constant< : public integral_constant<
bool, bool,
__is_constructible(_Tp, __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {}; __is_constructible(_Tp, __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value; inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_default_constructible.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_default_constructible struct _LIBCPP_TEMPLATE_VIS is_default_constructible
: public integral_constant<bool, __is_constructible(_Tp)> : public integral_constant<bool, __is_constructible(_Tp)>
{}; {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); inline constexpr bool is_default_constructible_v = __is_constructible(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_destructible.h

Show All 21 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_destructible) #if __has_builtin(__is_destructible)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_destructible : _BoolConstant<__is_destructible(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_destructible : _BoolConstant<__is_destructible(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_destructible_v = __is_destructible(_Tp); inline constexpr bool is_destructible_v = __is_destructible(_Tp);
#endif #endif
#else // __has_builtin(__is_destructible) #else // __has_builtin(__is_destructible)
// if it's a reference, return true // if it's a reference, return true
// if it's a function, return false // if it's a function, return false
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
struct is_destructible<_Tp[]> struct is_destructible<_Tp[]>
: public false_type {}; : public false_type {};
template <> template <>
struct is_destructible<void> struct is_destructible<void>
: public false_type {}; : public false_type {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; inline constexpr bool is_destructible_v = is_destructible<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_destructible) #endif // __has_builtin(__is_destructible)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_DESTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_DESTRUCTIBLE_H

libcxx/include/__type_traits/is_empty.h

Show All 16 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_empty struct _LIBCPP_TEMPLATE_VIS is_empty
: public integral_constant<bool, __is_empty(_Tp)> {}; : public integral_constant<bool, __is_empty(_Tp)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_empty_v = __is_empty(_Tp); inline constexpr bool is_empty_v = __is_empty(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_EMPTY_H #endif // _LIBCPP___TYPE_TRAITS_IS_EMPTY_H

libcxx/include/__type_traits/is_enum.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
: public integral_constant<bool, __is_enum(_Tp)> {}; : public integral_constant<bool, __is_enum(_Tp)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_enum_v = __is_enum(_Tp); inline constexpr bool is_enum_v = __is_enum(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_ENUM_H #endif // _LIBCPP___TYPE_TRAITS_IS_ENUM_H

libcxx/include/__type_traits/is_final.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
__libcpp_is_final : public integral_constant<bool, __is_final(_Tp)> {}; __libcpp_is_final : public integral_constant<bool, __is_final(_Tp)> {};
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
is_final : public integral_constant<bool, __is_final(_Tp)> {}; is_final : public integral_constant<bool, __is_final(_Tp)> {};
#endif #endif
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_final_v = __is_final(_Tp); inline constexpr bool is_final_v = __is_final(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_FINAL_H #endif // _LIBCPP___TYPE_TRAITS_IS_FINAL_H

libcxx/include/__type_traits/is_floating_point.h

Show All 21 Lines
template <class _Tp> struct __libcpp_is_floating_point : public false_type {}; template <class _Tp> struct __libcpp_is_floating_point : public false_type {};
template <> struct __libcpp_is_floating_point<float> : public true_type {}; template <> struct __libcpp_is_floating_point<float> : public true_type {};
template <> struct __libcpp_is_floating_point<double> : public true_type {}; template <> struct __libcpp_is_floating_point<double> : public true_type {};
template <> struct __libcpp_is_floating_point<long double> : public true_type {}; template <> struct __libcpp_is_floating_point<long double> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_floating_point template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_floating_point
: public __libcpp_is_floating_point<__remove_cv_t<_Tp> > {}; : public __libcpp_is_floating_point<__remove_cv_t<_Tp> > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_FLOATING_POINT_H #endif // _LIBCPP___TYPE_TRAITS_IS_FLOATING_POINT_H

libcxx/include/__type_traits/is_function.h

Show All 27 Lines
#else #else
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_function struct _LIBCPP_TEMPLATE_VIS is_function
: public integral_constant<bool, !(is_reference<_Tp>::value || is_const<const _Tp>::value)> {}; : public integral_constant<bool, !(is_reference<_Tp>::value || is_const<const _Tp>::value)> {};
#endif // __has_builtin(__is_function) #endif // __has_builtin(__is_function)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_function_v = is_function<_Tp>::value; inline constexpr bool is_function_v = is_function<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_FUNCTIONAL_H #endif // _LIBCPP___TYPE_TRAITS_IS_FUNCTIONAL_H

libcxx/include/__type_traits/is_fundamental.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_fundamental) #if __has_builtin(__is_fundamental)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_fundamental : _BoolConstant<__is_fundamental(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_fundamental : _BoolConstant<__is_fundamental(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_fundamental_v = __is_fundamental(_Tp); inline constexpr bool is_fundamental_v = __is_fundamental(_Tp);
#endif #endif
#else // __has_builtin(__is_fundamental) #else // __has_builtin(__is_fundamental)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fundamental template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fundamental
: public integral_constant<bool, is_void<_Tp>::value || : public integral_constant<bool, is_void<_Tp>::value ||
__is_nullptr_t<_Tp>::value || __is_nullptr_t<_Tp>::value ||
is_arithmetic<_Tp>::value> {}; is_arithmetic<_Tp>::value> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_fundamental) #endif // __has_builtin(__is_fundamental)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_FUNDAMENTAL_H #endif // _LIBCPP___TYPE_TRAITS_IS_FUNDAMENTAL_H

libcxx/include/__type_traits/is_integral.h

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
template <> struct __libcpp_is_integral<__uint128_t> { enum { value = 1 }; }; template <> struct __libcpp_is_integral<__uint128_t> { enum { value = 1 }; };
#endif #endif
#if __has_builtin(__is_integral) #if __has_builtin(__is_integral)
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_integral : _BoolConstant<__is_integral(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_integral : _BoolConstant<__is_integral(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_integral_v = __is_integral(_Tp); inline constexpr bool is_integral_v = __is_integral(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral
: public _BoolConstant<__libcpp_is_integral<__remove_cv_t<_Tp> >::value> {}; : public _BoolConstant<__libcpp_is_integral<__remove_cv_t<_Tp> >::value> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_integral_v = is_integral<_Tp>::value; inline constexpr bool is_integral_v = is_integral<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_integral) #endif // __has_builtin(__is_integral)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_INTEGRAL_H #endif // _LIBCPP___TYPE_TRAITS_IS_INTEGRAL_H

libcxx/include/__type_traits/is_literal_type.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS) #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 is_literal_type template <class _Tp> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 is_literal_type
: public integral_constant<bool, __is_literal_type(_Tp)> : public integral_constant<bool, __is_literal_type(_Tp)>
{}; {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
_LIBCPP_DEPRECATED_IN_CXX17 inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); _LIBCPP_DEPRECATED_IN_CXX17 inline constexpr bool is_literal_type_v = __is_literal_type(_Tp);
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS) #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_LITERAL_TYPE #endif // _LIBCPP___TYPE_TRAITS_IS_LITERAL_TYPE

libcxx/include/__type_traits/is_member_function_pointer.h

Show All 36 Lines
}; };
#if __has_builtin(__is_member_function_pointer) #if __has_builtin(__is_member_function_pointer)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
: _BoolConstant<__is_member_function_pointer(_Tp)> { }; : _BoolConstant<__is_member_function_pointer(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Tp); inline constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Tp);
#endif #endif
#else // __has_builtin(__is_member_function_pointer) #else // __has_builtin(__is_member_function_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
: public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_func > {}; : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_func > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value; inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_member_function_pointer) #endif // __has_builtin(__is_member_function_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H

libcxx/include/__type_traits/is_member_object_pointer.h

Show All 18 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_member_object_pointer) #if __has_builtin(__is_member_object_pointer)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
: _BoolConstant<__is_member_object_pointer(_Tp)> { }; : _BoolConstant<__is_member_object_pointer(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Tp); inline constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Tp);
#endif #endif
#else // __has_builtin(__is_member_object_pointer) #else // __has_builtin(__is_member_object_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
: public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_obj > {}; : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_obj > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value; inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_member_object_pointer) #endif // __has_builtin(__is_member_object_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H

libcxx/include/__type_traits/is_member_pointer.h

Show All 18 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_member_pointer) #if __has_builtin(__is_member_pointer)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_member_pointer : _BoolConstant<__is_member_pointer(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_member_pointer : _BoolConstant<__is_member_pointer(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp); inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp);
#endif #endif
#else // __has_builtin(__is_member_pointer) #else // __has_builtin(__is_member_pointer)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer
: public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_member > {}; : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_member > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_member_pointer) #endif // __has_builtin(__is_member_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_POINTER_H

libcxx/include/__type_traits/is_move_assignable.h

Show All 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_move_assignable struct _LIBCPP_TEMPLATE_VIS is_move_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {}; __is_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value; inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_move_constructible.h

Show All 18 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_move_constructible struct _LIBCPP_TEMPLATE_VIS is_move_constructible
: public integral_constant<bool, __is_constructible(_Tp, __add_rvalue_reference_t<_Tp>)> : public integral_constant<bool, __is_constructible(_Tp, __add_rvalue_reference_t<_Tp>)>
{}; {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value; inline constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_assignable.h

Show All 16 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp, class _Arg> template <class _Tp, class _Arg>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable
: public integral_constant<bool, __is_nothrow_assignable(_Tp, _Arg)> {}; : public integral_constant<bool, __is_nothrow_assignable(_Tp, _Arg)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Arg> template <class _Tp, class _Arg>
inline constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_Tp, _Arg); inline constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_Tp, _Arg);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_ASSIGNABLE_H

libcxx/include/__type_traits/is_nothrow_constructible.h

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp[_Ns]> struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp[_Ns]>
: __libcpp_is_nothrow_constructible<is_constructible<_Tp>::value, is_reference<_Tp>::value, _Tp> : __libcpp_is_nothrow_constructible<is_constructible<_Tp>::value, is_reference<_Tp>::value, _Tp>
{ {
}; };
#endif // __has_builtin(__is_nothrow_constructible) #endif // __has_builtin(__is_nothrow_constructible)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class ..._Args> template <class _Tp, class ..._Args>
inline constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<_Tp, _Args...>::value; inline constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<_Tp, _Args...>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_convertible.h

Show All 18 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 #if _LIBCPP_STD_VER >= 20
template <typename _Tp> template <typename _Tp>
static void __test_noexcept(_Tp) noexcept; static void __test_noexcept(_Tp) noexcept;
template<typename _Fm, typename _To> template<typename _Fm, typename _To>
static bool_constant<noexcept(_VSTD::__test_noexcept<_To>(std::declval<_Fm>()))> static bool_constant<noexcept(_VSTD::__test_noexcept<_To>(std::declval<_Fm>()))>
__is_nothrow_convertible_test(); __is_nothrow_convertible_test();
template <typename _Fm, typename _To> template <typename _Fm, typename _To>
struct __is_nothrow_convertible_helper: decltype(__is_nothrow_convertible_test<_Fm, _To>()) struct __is_nothrow_convertible_helper: decltype(__is_nothrow_convertible_test<_Fm, _To>())
{ }; { };
template <typename _Fm, typename _To> template <typename _Fm, typename _To>
struct is_nothrow_convertible : _Or< struct is_nothrow_convertible : _Or<
_And<is_void<_To>, is_void<_Fm>>, _And<is_void<_To>, is_void<_Fm>>,
_Lazy<_And, is_convertible<_Fm, _To>, __is_nothrow_convertible_helper<_Fm, _To>> _Lazy<_And, is_convertible<_Fm, _To>, __is_nothrow_convertible_helper<_Fm, _To>>
>::type { }; >::type { };
template <typename _Fm, typename _To> template <typename _Fm, typename _To>
inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<_Fm, _To>::value; inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<_Fm, _To>::value;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONVERTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONVERTIBLE_H

libcxx/include/__type_traits/is_nothrow_copy_assignable.h

Show All 22 Lines
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_nothrow_assignable( __is_nothrow_assignable(
__add_lvalue_reference_t<_Tp>, __add_lvalue_reference_t<_Tp>,
__add_lvalue_reference_t<typename add_const<_Tp>::type>)> {}; __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value; inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_nothrow_copy_constructible.h

Show All 32 Lines
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible
: public integral_constant< : public integral_constant<
bool, bool,
__is_nothrow_constructible(_Tp, typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {}; __is_nothrow_constructible(_Tp, typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {};
#endif // _LIBCPP_COMPILER_GCC #endif // _LIBCPP_COMPILER_GCC
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value; inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_default_constructible.h

Show All 16 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_default_constructible template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_default_constructible
: public integral_constant<bool, __is_nothrow_constructible(_Tp)> : public integral_constant<bool, __is_nothrow_constructible(_Tp)>
{}; {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp); inline constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_destructible.h

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Linestemplate <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
: public __libcpp_nothrow_destructor<__remove_all_extents_t<_Tp> > {}; : public __libcpp_nothrow_destructor<__remove_all_extents_t<_Tp> > {};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[]> struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[]>
: public false_type {}; : public false_type {};
#endif #endif
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Tp>::value; inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DESTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DESTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_move_assignable.h

Show All 21 Lines
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_nothrow_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> { __is_nothrow_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value; inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_nothrow_move_constructible.h

Show All 29 Lines
#else // _LIBCPP_COMPILER_GCC #else // _LIBCPP_COMPILER_GCC
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible
: public is_nothrow_constructible<_Tp, __add_rvalue_reference_t<_Tp> > : public is_nothrow_constructible<_Tp, __add_rvalue_reference_t<_Tp> >
{}; {};
#endif // _LIBCPP_COMPILER_GCC #endif // _LIBCPP_COMPILER_GCC
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value; inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_null_pointer.h

Show All 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct __is_nullptr_t_impl : public false_type {}; template <class _Tp> struct __is_nullptr_t_impl : public false_type {};
template <> struct __is_nullptr_t_impl<nullptr_t> : public true_type {}; template <> struct __is_nullptr_t_impl<nullptr_t> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __is_nullptr_t template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __is_nullptr_t
: public __is_nullptr_t_impl<__remove_cv_t<_Tp> > {}; : public __is_nullptr_t_impl<__remove_cv_t<_Tp> > {};
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_null_pointer template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_null_pointer
: public __is_nullptr_t_impl<__remove_cv_t<_Tp> > {}; : public __is_nullptr_t_impl<__remove_cv_t<_Tp> > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
#endif #endif
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_NULL_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_NULL_POINTER_H

libcxx/include/__type_traits/is_object.h

Show All 21 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_object) #if __has_builtin(__is_object)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_object : _BoolConstant<__is_object(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_object : _BoolConstant<__is_object(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_object_v = __is_object(_Tp); inline constexpr bool is_object_v = __is_object(_Tp);
#endif #endif
#else // __has_builtin(__is_object) #else // __has_builtin(__is_object)
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_object template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_object
: public integral_constant<bool, is_scalar<_Tp>::value || : public integral_constant<bool, is_scalar<_Tp>::value ||
is_array<_Tp>::value || is_array<_Tp>::value ||
is_union<_Tp>::value || is_union<_Tp>::value ||
is_class<_Tp>::value > {}; is_class<_Tp>::value > {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_object_v = is_object<_Tp>::value; inline constexpr bool is_object_v = is_object<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_object) #endif // __has_builtin(__is_object)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_OBJECT_H #endif // _LIBCPP___TYPE_TRAITS_IS_OBJECT_H

libcxx/include/__type_traits/is_pod.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod
: public integral_constant<bool, __is_pod(_Tp)> {}; : public integral_constant<bool, __is_pod(_Tp)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_pod_v = __is_pod(_Tp); inline constexpr bool is_pod_v = __is_pod(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_POD_H #endif // _LIBCPP___TYPE_TRAITS_IS_POD_H

libcxx/include/__type_traits/is_pointer.h

Show All 18 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_pointer) #if __has_builtin(__is_pointer)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_pointer : _BoolConstant<__is_pointer(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_pointer : _BoolConstant<__is_pointer(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_pointer_v = __is_pointer(_Tp); inline constexpr bool is_pointer_v = __is_pointer(_Tp);
#endif #endif
#else // __has_builtin(__is_pointer) #else // __has_builtin(__is_pointer)
template <class _Tp> struct __libcpp_is_pointer : public false_type {}; template <class _Tp> struct __libcpp_is_pointer : public false_type {};
template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {}; template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};
template <class _Tp> struct __libcpp_remove_objc_qualifiers { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers { typedef _Tp type; };
#if defined(_LIBCPP_HAS_OBJC_ARC) #if defined(_LIBCPP_HAS_OBJC_ARC)
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __strong> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __strong> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __weak> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __weak> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __autoreleasing> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __autoreleasing> { typedef _Tp type; };
template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __unsafe_unretained> { typedef _Tp type; }; template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __unsafe_unretained> { typedef _Tp type; };
#endif #endif
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pointer template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pointer
: public __libcpp_is_pointer<typename __libcpp_remove_objc_qualifiers<__remove_cv_t<_Tp> >::type> {}; : public __libcpp_is_pointer<typename __libcpp_remove_objc_qualifiers<__remove_cv_t<_Tp> >::type> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_pointer) #endif // __has_builtin(__is_pointer)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_IS_POINTER_H

libcxx/include/__type_traits/is_polymorphic.h

Show All 16 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_polymorphic struct _LIBCPP_TEMPLATE_VIS is_polymorphic
: public integral_constant<bool, __is_polymorphic(_Tp)> {}; : public integral_constant<bool, __is_polymorphic(_Tp)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_POLYMORPHIC_H #endif // _LIBCPP___TYPE_TRAITS_IS_POLYMORPHIC_H

libcxx/include/__type_traits/is_reference.h

Show All 25 Lines
struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> { };
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : _BoolConstant<__is_rvalue_reference(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : _BoolConstant<__is_rvalue_reference(_Tp)> { };
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_reference : _BoolConstant<__is_reference(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_reference : _BoolConstant<__is_reference(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_reference_v = __is_reference(_Tp); inline constexpr bool is_reference_v = __is_reference(_Tp);
template <class _Tp> template <class _Tp>
inline constexpr bool is_lvalue_reference_v = __is_lvalue_reference(_Tp); inline constexpr bool is_lvalue_reference_v = __is_lvalue_reference(_Tp);
template <class _Tp> template <class _Tp>
inline constexpr bool is_rvalue_reference_v = __is_rvalue_reference(_Tp); inline constexpr bool is_rvalue_reference_v = __is_rvalue_reference(_Tp);
#endif #endif
#else // __has_builtin(__is_lvalue_reference) && etc... #else // __has_builtin(__is_lvalue_reference) && etc...
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : public false_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference<_Tp&> : public true_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference<_Tp&> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : public false_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference<_Tp&&> : public true_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference<_Tp&&> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference : public false_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&> : public true_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&> : public true_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&&> : public true_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&&> : public true_type {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_reference_v = is_reference<_Tp>::value; inline constexpr bool is_reference_v = is_reference<_Tp>::value;
template <class _Tp> template <class _Tp>
inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value; inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value;
template <class _Tp> template <class _Tp>
inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value; inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_lvalue_reference) && etc... #endif // __has_builtin(__is_lvalue_reference) && etc...
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_REFERENCE_H #endif // _LIBCPP___TYPE_TRAITS_IS_REFERENCE_H

libcxx/include/__type_traits/is_same.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_same : _BoolConstant<__is_same(_Tp, _Up)> { }; struct _LIBCPP_TEMPLATE_VIS is_same : _BoolConstant<__is_same(_Tp, _Up)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Up> template <class _Tp, class _Up>
inline constexpr bool is_same_v = __is_same(_Tp, _Up); inline constexpr bool is_same_v = __is_same(_Tp, _Up);
#endif #endif
// _IsSame<T,U> has the same effect as is_same<T,U> but instantiates fewer types: // _IsSame<T,U> has the same effect as is_same<T,U> but instantiates fewer types:
// is_same<A,B> and is_same<C,D> are guaranteed to be different types, but // is_same<A,B> and is_same<C,D> are guaranteed to be different types, but
// _IsSame<A,B> and _IsSame<C,D> are the same type (namely, false_type). // _IsSame<A,B> and _IsSame<C,D> are the same type (namely, false_type).
// Neither GCC nor Clang can mangle the __is_same builtin, so _IsSame // Neither GCC nor Clang can mangle the __is_same builtin, so _IsSame
Show All 12 Lines

libcxx/include/__type_traits/is_scalar.h

Show All 22 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_scalar) #if __has_builtin(__is_scalar)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_scalar : _BoolConstant<__is_scalar(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_scalar : _BoolConstant<__is_scalar(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_scalar_v = __is_scalar(_Tp); inline constexpr bool is_scalar_v = __is_scalar(_Tp);
#endif #endif
#else // __has_builtin(__is_scalar) #else // __has_builtin(__is_scalar)
template <class _Tp> struct __is_block : false_type {}; template <class _Tp> struct __is_block : false_type {};
#if defined(_LIBCPP_HAS_EXTENSION_BLOCKS) #if defined(_LIBCPP_HAS_EXTENSION_BLOCKS)
template <class _Rp, class ..._Args> struct __is_block<_Rp (^)(_Args...)> : true_type {}; template <class _Rp, class ..._Args> struct __is_block<_Rp (^)(_Args...)> : true_type {};
#endif #endif
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_scalar template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_scalar
: public integral_constant<bool, is_arithmetic<_Tp>::value || : public integral_constant<bool, is_arithmetic<_Tp>::value ||
is_member_pointer<_Tp>::value || is_member_pointer<_Tp>::value ||
is_pointer<_Tp>::value || is_pointer<_Tp>::value ||
__is_nullptr_t<_Tp>::value || __is_nullptr_t<_Tp>::value ||
__is_block<_Tp>::value || __is_block<_Tp>::value ||
is_enum<_Tp>::value > {}; is_enum<_Tp>::value > {};
template <> struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {}; template <> struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_scalar) #endif // __has_builtin(__is_scalar)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_SCALAR_H #endif // _LIBCPP___TYPE_TRAITS_IS_SCALAR_H

libcxx/include/__type_traits/is_scoped_enum.h

Show All 15 Lines
#include <__type_traits/underlying_type.h> #include <__type_traits/underlying_type.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 > 20 #if _LIBCPP_STD_VER >= 23
template <class _Tp, bool = is_enum_v<_Tp> > template <class _Tp, bool = is_enum_v<_Tp> >
struct __is_scoped_enum_helper : false_type {}; struct __is_scoped_enum_helper : false_type {};
template <class _Tp> template <class _Tp>
struct __is_scoped_enum_helper<_Tp, true> struct __is_scoped_enum_helper<_Tp, true>
: public bool_constant<!is_convertible_v<_Tp, underlying_type_t<_Tp> > > {}; : public bool_constant<!is_convertible_v<_Tp, underlying_type_t<_Tp> > > {};
template <class _Tp> template <class _Tp>
Show All 10 Lines

libcxx/include/__type_traits/is_signed.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_signed) #if __has_builtin(__is_signed)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_signed : _BoolConstant<__is_signed(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_signed : _BoolConstant<__is_signed(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_signed_v = __is_signed(_Tp); inline constexpr bool is_signed_v = __is_signed(_Tp);
#endif #endif
#else // __has_builtin(__is_signed) #else // __has_builtin(__is_signed)
template <class _Tp, bool = is_integral<_Tp>::value> template <class _Tp, bool = is_integral<_Tp>::value>
struct __libcpp_is_signed_impl : public _BoolConstant<(_Tp(-1) < _Tp(0))> {}; struct __libcpp_is_signed_impl : public _BoolConstant<(_Tp(-1) < _Tp(0))> {};
template <class _Tp> template <class _Tp>
struct __libcpp_is_signed_impl<_Tp, false> : public true_type {}; // floating point struct __libcpp_is_signed_impl<_Tp, false> : public true_type {}; // floating point
template <class _Tp, bool = is_arithmetic<_Tp>::value> template <class _Tp, bool = is_arithmetic<_Tp>::value>
struct __libcpp_is_signed : public __libcpp_is_signed_impl<_Tp> {}; struct __libcpp_is_signed : public __libcpp_is_signed_impl<_Tp> {};
template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {}; template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_signed : public __libcpp_is_signed<_Tp> {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_signed : public __libcpp_is_signed<_Tp> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_signed_v = is_signed<_Tp>::value; inline constexpr bool is_signed_v = is_signed<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_signed) #endif // __has_builtin(__is_signed)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_SIGNED_H #endif // _LIBCPP___TYPE_TRAITS_IS_SIGNED_H

libcxx/include/__type_traits/is_specialization.h

Show All 24 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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, template <class...> class _Template> template <class _Tp, template <class...> class _Template>
inline constexpr bool __is_specialization_v = false; // true if and only if _Tp is a specialization of _Template inline constexpr bool __is_specialization_v = false; // true if and only if _Tp is a specialization of _Template
template <template <class...> class _Template, class... _Args> template <template <class...> class _Template, class... _Args>
inline constexpr bool __is_specialization_v<_Template<_Args...>, _Template> = true; inline constexpr bool __is_specialization_v<_Template<_Args...>, _Template> = true;
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_SPECIALIZATION #endif // _LIBCPP___TYPE_TRAITS_IS_SPECIALIZATION

libcxx/include/__type_traits/is_standard_layout.h

Show All 16 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_standard_layout template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_standard_layout
: public integral_constant<bool, __is_standard_layout(_Tp)> : public integral_constant<bool, __is_standard_layout(_Tp)>
{}; {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_STANDARD_LAYOUT_H #endif // _LIBCPP___TYPE_TRAITS_IS_STANDARD_LAYOUT_H

libcxx/include/__type_traits/is_swappable.h

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
}; };
template <class _Tp> template <class _Tp>
struct __is_nothrow_swappable struct __is_nothrow_swappable
: public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp&>::value> : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp&>::value>
{ {
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct _LIBCPP_TEMPLATE_VIS is_swappable_with struct _LIBCPP_TEMPLATE_VIS is_swappable_with
: public integral_constant<bool, __detail::__swappable_with<_Tp, _Up>::value> : public integral_constant<bool, __detail::__swappable_with<_Tp, _Up>::value>
{ {
}; };
template <class _Tp> template <class _Tp>
Show All 33 Lines
inline constexpr bool is_swappable_v = is_swappable<_Tp>::value; inline constexpr bool is_swappable_v = is_swappable<_Tp>::value;
template <class _Tp, class _Up> template <class _Tp, class _Up>
inline constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<_Tp, _Up>::value; inline constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<_Tp, _Up>::value;
template <class _Tp> template <class _Tp>
inline constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value; inline constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value;
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_SWAPPABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_SWAPPABLE_H

libcxx/include/__type_traits/is_trivial.h

Show All 16 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivial template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivial
: public integral_constant<bool, __is_trivial(_Tp)> : public integral_constant<bool, __is_trivial(_Tp)>
{}; {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivial_v = __is_trivial(_Tp); inline constexpr bool is_trivial_v = __is_trivial(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIAL_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIAL_H

libcxx/include/__type_traits/is_trivially_assignable.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp, class _Arg> template <class _Tp, class _Arg>
struct is_trivially_assignable struct is_trivially_assignable
: integral_constant<bool, __is_trivially_assignable(_Tp, _Arg)> : integral_constant<bool, __is_trivially_assignable(_Tp, _Arg)>
{ }; { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class _Arg> template <class _Tp, class _Arg>
inline constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_Tp, _Arg); inline constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_Tp, _Arg);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_ASSIGNABLE_H

libcxx/include/__type_traits/is_trivially_constructible.h

Show All 18 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp, class... _Args> template <class _Tp, class... _Args>
struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible
: integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)> : integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)>
{ {
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp, class... _Args> template <class _Tp, class... _Args>
inline constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Tp, _Args...); inline constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Tp, _Args...);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_copy_assignable.h

Show All 22 Lines
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_trivially_assignable( __is_trivially_assignable(
__add_lvalue_reference_t<_Tp>, __add_lvalue_reference_t<_Tp>,
__add_lvalue_reference_t<typename add_const<_Tp>::type>)> {}; __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value; inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_trivially_copy_constructible.h

Show All 17 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_constructible template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_constructible
: public integral_constant<bool, __is_trivially_constructible(_Tp, __add_lvalue_reference_t<const _Tp>)> : public integral_constant<bool, __is_trivially_constructible(_Tp, __add_lvalue_reference_t<const _Tp>)>
{}; {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Tp>::value; inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_copyable.h

Show All 16 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copyable template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copyable
: public integral_constant<bool, __is_trivially_copyable(_Tp)> : public integral_constant<bool, __is_trivially_copyable(_Tp)>
{}; {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPYABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPYABLE_H

libcxx/include/__type_traits/is_trivially_default_constructible.h

Show All 16 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_default_constructible template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_default_constructible
: public integral_constant<bool, __is_trivially_constructible(_Tp)> : public integral_constant<bool, __is_trivially_constructible(_Tp)>
{}; {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Tp); inline constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_destructible.h

Show All 29 Linestemplate <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
: public integral_constant<bool, is_destructible<_Tp>::value && __has_trivial_destructor(_Tp)> {}; : public integral_constant<bool, is_destructible<_Tp>::value && __has_trivial_destructor(_Tp)> {};
#else #else
#error is_trivially_destructible is not implemented #error is_trivially_destructible is not implemented
#endif // __has_builtin(__is_trivially_destructible) #endif // __has_builtin(__is_trivially_destructible)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Tp>::value; inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DESTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DESTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_move_assignable.h

Show All 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable
: public integral_constant< : public integral_constant<
bool, bool,
__is_trivially_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {}; __is_trivially_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value; inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_trivially_move_constructible.h

Show All 17 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_trivially_move_constructible struct _LIBCPP_TEMPLATE_VIS is_trivially_move_constructible
: public integral_constant<bool, __is_trivially_constructible(_Tp, __add_rvalue_reference_t<_Tp>)> {}; : public integral_constant<bool, __is_trivially_constructible(_Tp, __add_rvalue_reference_t<_Tp>)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Tp>::value; inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE_H #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_unbounded_array.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_unbounded_array : false_type {}; template <class> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_unbounded_array : false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_unbounded_array<_Tp[]> : true_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_unbounded_array<_Tp[]> : true_type {};
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class> struct _LIBCPP_TEMPLATE_VIS is_unbounded_array : false_type {}; template <class> struct _LIBCPP_TEMPLATE_VIS is_unbounded_array : false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unbounded_array<_Tp[]> : true_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unbounded_array<_Tp[]> : true_type {};
template <class _Tp> template <class _Tp>
inline constexpr inline constexpr
bool is_unbounded_array_v = is_unbounded_array<_Tp>::value; bool is_unbounded_array_v = is_unbounded_array<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_UNBOUNDED_ARRAY_H #endif // _LIBCPP___TYPE_TRAITS_IS_UNBOUNDED_ARRAY_H

libcxx/include/__type_traits/is_union.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union
: public integral_constant<bool, __is_union(_Tp)> {}; : public integral_constant<bool, __is_union(_Tp)> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_union_v = __is_union(_Tp); inline constexpr bool is_union_v = __is_union(_Tp);
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_UNION_H #endif // _LIBCPP___TYPE_TRAITS_IS_UNION_H

libcxx/include/__type_traits/is_unsigned.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_unsigned) #if __has_builtin(__is_unsigned)
template<class _Tp> template<class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_unsigned : _BoolConstant<__is_unsigned(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_unsigned : _BoolConstant<__is_unsigned(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_unsigned_v = __is_unsigned(_Tp); inline constexpr bool is_unsigned_v = __is_unsigned(_Tp);
#endif #endif
#else // __has_builtin(__is_unsigned) #else // __has_builtin(__is_unsigned)
template <class _Tp, bool = is_integral<_Tp>::value> template <class _Tp, bool = is_integral<_Tp>::value>
struct __libcpp_is_unsigned_impl : public _BoolConstant<(_Tp(0) < _Tp(-1))> {}; struct __libcpp_is_unsigned_impl : public _BoolConstant<(_Tp(0) < _Tp(-1))> {};
template <class _Tp> template <class _Tp>
struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {}; // floating point struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {}; // floating point
template <class _Tp, bool = is_arithmetic<_Tp>::value> template <class _Tp, bool = is_arithmetic<_Tp>::value>
struct __libcpp_is_unsigned : public __libcpp_is_unsigned_impl<_Tp> {}; struct __libcpp_is_unsigned : public __libcpp_is_unsigned_impl<_Tp> {};
template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {}; template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unsigned : public __libcpp_is_unsigned<_Tp> {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unsigned : public __libcpp_is_unsigned<_Tp> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_unsigned) #endif // __has_builtin(__is_unsigned)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_UNSIGNED_H #endif // _LIBCPP___TYPE_TRAITS_IS_UNSIGNED_H

libcxx/include/__type_traits/is_void.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_void) #if __has_builtin(__is_void)
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_void : _BoolConstant<__is_void(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_void : _BoolConstant<__is_void(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_void_v = __is_void(_Tp); inline constexpr bool is_void_v = __is_void(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void
: public is_same<__remove_cv_t<_Tp>, void> {}; : public is_same<__remove_cv_t<_Tp>, void> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_void_v = is_void<_Tp>::value; inline constexpr bool is_void_v = is_void<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_void) #endif // __has_builtin(__is_void)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_VOID_H #endif // _LIBCPP___TYPE_TRAITS_IS_VOID_H

libcxx/include/__type_traits/is_volatile.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if __has_builtin(__is_volatile) #if __has_builtin(__is_volatile)
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_volatile : _BoolConstant<__is_volatile(_Tp)> { }; struct _LIBCPP_TEMPLATE_VIS is_volatile : _BoolConstant<__is_volatile(_Tp)> { };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_volatile_v = __is_volatile(_Tp); inline constexpr bool is_volatile_v = __is_volatile(_Tp);
#endif #endif
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile : public false_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile : public false_type {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_volatile_v = is_volatile<_Tp>::value; inline constexpr bool is_volatile_v = is_volatile<_Tp>::value;
#endif #endif
#endif // __has_builtin(__is_volatile) #endif // __has_builtin(__is_volatile)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_IS_VOLATILE_H #endif // _LIBCPP___TYPE_TRAITS_IS_VOLATILE_H

libcxx/include/__type_traits/make_32_64_or_128_bit.h

Show All 21 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
/// Helper to promote an integral to smallest 32, 64, or 128 bit representation. /// Helper to promote an integral to smallest 32, 64, or 128 bit representation.
/// ///
/// The restriction is the same as the integral version of to_char. /// The restriction is the same as the integral version of to_char.
template <class _Tp> template <class _Tp>
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
requires (is_signed_v<_Tp> || is_unsigned_v<_Tp> || is_same_v<_Tp, char>) requires (is_signed_v<_Tp> || is_unsigned_v<_Tp> || is_same_v<_Tp, char>)
#endif #endif
using __make_32_64_or_128_bit_t = using __make_32_64_or_128_bit_t =
__copy_unsigned_t<_Tp, __copy_unsigned_t<_Tp,
__conditional_t<sizeof(_Tp) <= sizeof(int32_t), int32_t, __conditional_t<sizeof(_Tp) <= sizeof(int32_t), int32_t,
__conditional_t<sizeof(_Tp) <= sizeof(int64_t), int64_t, __conditional_t<sizeof(_Tp) <= sizeof(int64_t), int64_t,
#ifndef _LIBCPP_HAS_NO_INT128 #ifndef _LIBCPP_HAS_NO_INT128
__conditional_t<sizeof(_Tp) <= sizeof(__int128_t), __int128_t, __conditional_t<sizeof(_Tp) <= sizeof(__int128_t), __int128_t,
Show All 10 Lines

libcxx/include/__type_traits/make_signed.h

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
#endif // __has_builtin(__make_signed) #endif // __has_builtin(__make_signed)
template <class _Tp> template <class _Tp>
struct make_signed { struct make_signed {
using type _LIBCPP_NODEBUG = __make_signed_t<_Tp>; using type _LIBCPP_NODEBUG = __make_signed_t<_Tp>;
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using make_signed_t = __make_signed_t<_Tp>; template <class _Tp> using make_signed_t = __make_signed_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_MAKE_SIGNED_H #endif // _LIBCPP___TYPE_TRAITS_MAKE_SIGNED_H

libcxx/include/__type_traits/make_unsigned.h

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
#endif // __has_builtin(__make_unsigned) #endif // __has_builtin(__make_unsigned)
template <class _Tp> template <class _Tp>
struct make_unsigned { struct make_unsigned {
using type _LIBCPP_NODEBUG = __make_unsigned_t<_Tp>; using type _LIBCPP_NODEBUG = __make_unsigned_t<_Tp>;
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using make_unsigned_t = __make_unsigned_t<_Tp>; template <class _Tp> using make_unsigned_t = __make_unsigned_t<_Tp>;
#endif #endif
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Tp> template <class _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
__make_unsigned_t<_Tp> __to_unsigned_like(_Tp __x) noexcept { __make_unsigned_t<_Tp> __to_unsigned_like(_Tp __x) noexcept {
return static_cast<__make_unsigned_t<_Tp> >(__x); return static_cast<__make_unsigned_t<_Tp> >(__x);
Show All 9 Lines

libcxx/include/__type_traits/negation.h

Show All 15 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Pred> template <class _Pred>
struct _Not : _BoolConstant<!_Pred::value> {}; struct _Not : _BoolConstant<!_Pred::value> {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
struct negation : _Not<_Tp> {}; struct negation : _Not<_Tp> {};
template<class _Tp> template<class _Tp>
inline constexpr bool negation_v = !_Tp::value; inline constexpr bool negation_v = !_Tp::value;
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_NEGATION_H #endif // _LIBCPP___TYPE_TRAITS_NEGATION_H

libcxx/include/__type_traits/noexcept_move_assign_container.h

Show All 17 Lines
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> > template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
struct __noexcept_move_assign_container : public integral_constant<bool, struct __noexcept_move_assign_container : public integral_constant<bool,
_Traits::propagate_on_container_move_assignment::value _Traits::propagate_on_container_move_assignment::value
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
|| _Traits::is_always_equal::value || _Traits::is_always_equal::value
#else #else
&& is_nothrow_move_assignable<_Alloc>::value && is_nothrow_move_assignable<_Alloc>::value
#endif #endif
> {}; > {};
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_NOEXCEPT_MOVE_ASSIGN_CONTAINER_H #endif // _LIBCPP___TYPE_TRAITS_NOEXCEPT_MOVE_ASSIGN_CONTAINER_H

libcxx/include/__type_traits/rank.h

Show All 30 Linestemplate <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank
: public integral_constant<size_t, 0> {}; : public integral_constant<size_t, 0> {};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[]> template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[]>
: public integral_constant<size_t, rank<_Tp>::value + 1> {}; : public integral_constant<size_t, rank<_Tp>::value + 1> {};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[_Np]> template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[_Np]>
: public integral_constant<size_t, rank<_Tp>::value + 1> {}; : public integral_constant<size_t, rank<_Tp>::value + 1> {};
#endif // __has_builtin(__array_rank) #endif // __has_builtin(__array_rank)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr size_t rank_v = rank<_Tp>::value; inline constexpr size_t rank_v = rank<_Tp>::value;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_RANK_H #endif // _LIBCPP___TYPE_TRAITS_RANK_H

libcxx/include/__type_traits/remove_all_extents.h

Show All 32 Linestemplate <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[]>
{typedef typename remove_all_extents<_Tp>::type type;}; {typedef typename remove_all_extents<_Tp>::type type;};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[_Np]> template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[_Np]>
{typedef typename remove_all_extents<_Tp>::type type;}; {typedef typename remove_all_extents<_Tp>::type type;};
template <class _Tp> template <class _Tp>
using __remove_all_extents_t = typename remove_all_extents<_Tp>::type; using __remove_all_extents_t = typename remove_all_extents<_Tp>::type;
#endif // __has_builtin(__remove_all_extents) #endif // __has_builtin(__remove_all_extents)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using remove_all_extents_t = __remove_all_extents_t<_Tp>; template <class _Tp> using remove_all_extents_t = __remove_all_extents_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_ALL_EXTENTS_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_ALL_EXTENTS_H

libcxx/include/__type_traits/remove_const.h

Show All 27 Lines
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const {typedef _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const {typedef _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;};
template <class _Tp> template <class _Tp>
using __remove_const_t = typename remove_const<_Tp>::type; using __remove_const_t = typename remove_const<_Tp>::type;
#endif // __has_builtin(__remove_const) #endif // __has_builtin(__remove_const)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using remove_const_t = __remove_const_t<_Tp>; template <class _Tp> using remove_const_t = __remove_const_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_CONST_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_CONST_H

libcxx/include/__type_traits/remove_cv.h

Show All 29 Lines
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv
{typedef __remove_volatile_t<__remove_const_t<_Tp> > type;}; {typedef __remove_volatile_t<__remove_const_t<_Tp> > type;};
template <class _Tp> template <class _Tp>
using __remove_cv_t = __remove_volatile_t<__remove_const_t<_Tp> >; using __remove_cv_t = __remove_volatile_t<__remove_const_t<_Tp> >;
#endif // __has_builtin(__remove_cv) #endif // __has_builtin(__remove_cv)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using remove_cv_t = __remove_cv_t<_Tp>; template <class _Tp> using remove_cv_t = __remove_cv_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_CV_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_CV_H

libcxx/include/__type_traits/remove_cvref.h

Show All 25 Lines
#else #else
template <class _Tp> template <class _Tp>
using __remove_cvref_t _LIBCPP_NODEBUG = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >; using __remove_cvref_t _LIBCPP_NODEBUG = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >;
#endif // __has_builtin(__remove_cvref) #endif // __has_builtin(__remove_cvref)
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __is_same_uncvref : _IsSame<__remove_cvref_t<_Tp>, __remove_cvref_t<_Up> > {}; struct __is_same_uncvref : _IsSame<__remove_cvref_t<_Tp>, __remove_cvref_t<_Up> > {};
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Tp> template <class _Tp>
struct remove_cvref { struct remove_cvref {
using type _LIBCPP_NODEBUG = __remove_cvref_t<_Tp>; using type _LIBCPP_NODEBUG = __remove_cvref_t<_Tp>;
}; };
template <class _Tp> using remove_cvref_t = __remove_cvref_t<_Tp>; template <class _Tp> using remove_cvref_t = __remove_cvref_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_CVREF_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_CVREF_H

libcxx/include/__type_traits/remove_extent.h

Show All 32 Linestemplate <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[]>
{typedef _Tp type;}; {typedef _Tp type;};
template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[_Np]> template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[_Np]>
{typedef _Tp type;}; {typedef _Tp type;};
template <class _Tp> template <class _Tp>
using __remove_extent_t = typename remove_extent<_Tp>::type; using __remove_extent_t = typename remove_extent<_Tp>::type;
#endif // __has_builtin(__remove_extent) #endif // __has_builtin(__remove_extent)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using remove_extent_t = __remove_extent_t<_Tp>; template <class _Tp> using remove_extent_t = __remove_extent_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_EXTENT_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_EXTENT_H

libcxx/include/__type_traits/remove_pointer.h

Show All 30 Lines
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* volatile> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> template <class _Tp>
using __remove_pointer_t = typename remove_pointer<_Tp>::type; using __remove_pointer_t = typename remove_pointer<_Tp>::type;
#endif // __has_builtin(__remove_pointer) #endif // __has_builtin(__remove_pointer)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using remove_pointer_t = __remove_pointer_t<_Tp>; template <class _Tp> using remove_pointer_t = __remove_pointer_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_POINTER_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_POINTER_H

libcxx/include/__type_traits/remove_reference.h

Show All 29 Lines
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG _Tp type;};
template <class _Tp> template <class _Tp>
using __libcpp_remove_reference_t = typename remove_reference<_Tp>::type; using __libcpp_remove_reference_t = typename remove_reference<_Tp>::type;
#endif // __has_builtin(__remove_reference_t) #endif // __has_builtin(__remove_reference_t)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using remove_reference_t = __libcpp_remove_reference_t<_Tp>; template <class _Tp> using remove_reference_t = __libcpp_remove_reference_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_REFERENCE_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_REFERENCE_H

libcxx/include/__type_traits/remove_volatile.h

Show All 27 Lines
#else #else
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile {typedef _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile {typedef _Tp type;};
template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;}; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
template <class _Tp> template <class _Tp>
using __remove_volatile_t = typename remove_volatile<_Tp>::type; using __remove_volatile_t = typename remove_volatile<_Tp>::type;
#endif // __has_builtin(__remove_volatile) #endif // __has_builtin(__remove_volatile)
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using remove_volatile_t = __remove_volatile_t<_Tp>; template <class _Tp> using remove_volatile_t = __remove_volatile_t<_Tp>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_REMOVE_VOLATILE_H #endif // _LIBCPP___TYPE_TRAITS_REMOVE_VOLATILE_H

libcxx/include/__type_traits/result_of.h

Show All 23 Lines
template <class _Callable> class _LIBCPP_DEPRECATED_IN_CXX17 result_of; template <class _Callable> class _LIBCPP_DEPRECATED_IN_CXX17 result_of;
template <class _Fp, class ..._Args> template <class _Fp, class ..._Args>
class _LIBCPP_TEMPLATE_VIS result_of<_Fp(_Args...)> class _LIBCPP_TEMPLATE_VIS result_of<_Fp(_Args...)>
: public __invoke_of<_Fp, _Args...> : public __invoke_of<_Fp, _Args...>
{ {
}; };
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using result_of_t _LIBCPP_DEPRECATED_IN_CXX17 = typename result_of<_Tp>::type; template <class _Tp> using result_of_t _LIBCPP_DEPRECATED_IN_CXX17 = typename result_of<_Tp>::type;
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS) #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_RESULT_OF_H #endif // _LIBCPP___TYPE_TRAITS_RESULT_OF_H

libcxx/include/__type_traits/type_identity.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct __type_identity { typedef _Tp type; }; struct __type_identity { typedef _Tp type; };
template <class _Tp> template <class _Tp>
using __type_identity_t _LIBCPP_NODEBUG = typename __type_identity<_Tp>::type; using __type_identity_t _LIBCPP_NODEBUG = typename __type_identity<_Tp>::type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template<class _Tp> struct type_identity { typedef _Tp type; }; template<class _Tp> struct type_identity { typedef _Tp type; };
template<class _Tp> using type_identity_t = typename type_identity<_Tp>::type; template<class _Tp> using type_identity_t = typename type_identity<_Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_TYPE_IDENTITY_H #endif // _LIBCPP___TYPE_TRAITS_TYPE_IDENTITY_H

libcxx/include/__type_traits/underlying_type.h

Show All 26 Lines
struct __underlying_type_impl<_Tp, true> struct __underlying_type_impl<_Tp, true>
{ {
typedef __underlying_type(_Tp) type; typedef __underlying_type(_Tp) type;
}; };
template <class _Tp> template <class _Tp>
struct underlying_type : __underlying_type_impl<_Tp, is_enum<_Tp>::value> {}; struct underlying_type : __underlying_type_impl<_Tp, is_enum<_Tp>::value> {};
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type; template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_UNDERLYING_TYPE_H #endif // _LIBCPP___TYPE_TRAITS_UNDERLYING_TYPE_H

libcxx/include/__type_traits/void_t.h

Show All 11 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 > 14 #if _LIBCPP_STD_VER >= 17
template <class...> using void_t = void; template <class...> using void_t = void;
#endif #endif
template <class...> template <class...>
using __void_t = void; using __void_t = void;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___TYPE_TRAITS_VOID_T_H #endif // _LIBCPP___TYPE_TRAITS_VOID_T_H

libcxx/include/__utility/as_const.h

Show All 14 Lines
#include <__utility/move.h> #include <__utility/move.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 > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; } _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }
template <class _Tp> template <class _Tp>
void as_const(const _Tp&&) = delete; void as_const(const _Tp&&) = delete;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_AS_CONST_H #endif // _LIBCPP___UTILITY_AS_CONST_H

libcxx/include/__utility/cmp.h

Show All 22 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 #if _LIBCPP_STD_VER >= 20
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, char16_t, char32_t !_IsSameAsAny<_Tp, bool, char, char16_t, char32_t
#ifndef _LIBCPP_HAS_NO_CHAR8_T #ifndef _LIBCPP_HAS_NO_CHAR8_T
, char8_t , char8_t
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up> template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
bool in_range(_Up __u) noexcept bool in_range(_Up __u) noexcept
{ {
return _VSTD::cmp_less_equal(__u, numeric_limits<_Tp>::max()) && return _VSTD::cmp_less_equal(__u, numeric_limits<_Tp>::max()) &&
_VSTD::cmp_greater_equal(__u, numeric_limits<_Tp>::min()); _VSTD::cmp_greater_equal(__u, numeric_limits<_Tp>::min());
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP___UTILITY_CMP_H #endif // _LIBCPP___UTILITY_CMP_H

libcxx/include/__utility/exchange.h

Show All 15 Lines
#include <__utility/move.h> #include <__utility/move.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 > 11 #if _LIBCPP_STD_VER >= 14
template<class _T1, class _T2 = _T1> template<class _T1, class _T2 = _T1>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
_T1 exchange(_T1& __obj, _T2&& __new_value) _T1 exchange(_T1& __obj, _T2&& __new_value)
noexcept(is_nothrow_move_constructible<_T1>::value && is_nothrow_assignable<_T1&, _T2>::value) noexcept(is_nothrow_move_constructible<_T1>::value && is_nothrow_assignable<_T1&, _T2>::value)
{ {
_T1 __old_value = _VSTD::move(__obj); _T1 __old_value = _VSTD::move(__obj);
__obj = _VSTD::forward<_T2>(__new_value); __obj = _VSTD::forward<_T2>(__new_value);
return __old_value; return __old_value;
} }
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_EXCHANGE_H #endif // _LIBCPP___UTILITY_EXCHANGE_H

libcxx/include/__utility/forward_like.h

Show All 16 Lines
#include <__type_traits/remove_reference.h> #include <__type_traits/remove_reference.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 > 20 #if _LIBCPP_STD_VER >= 23
template <class _Ap, class _Bp> template <class _Ap, class _Bp>
using _CopyConst = _If<is_const_v<_Ap>, const _Bp, _Bp>; using _CopyConst = _If<is_const_v<_Ap>, const _Bp, _Bp>;
template <class _Ap, class _Bp> template <class _Ap, class _Bp>
using _OverrideRef = _If<is_rvalue_reference_v<_Ap>, remove_reference_t<_Bp>&&, _Bp&>; using _OverrideRef = _If<is_rvalue_reference_v<_Ap>, remove_reference_t<_Bp>&&, _Bp&>;
template <class _Ap, class _Bp> template <class _Ap, class _Bp>
using _ForwardLike = _OverrideRef<_Ap&&, _CopyConst<remove_reference_t<_Ap>, remove_reference_t<_Bp>>>; using _ForwardLike = _OverrideRef<_Ap&&, _CopyConst<remove_reference_t<_Ap>, remove_reference_t<_Bp>>>;
template <class _Tp, class _Up> template <class _Tp, class _Up>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto forward_like(_LIBCPP_LIFETIMEBOUND _Up&& __ux) noexcept [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto forward_like(_LIBCPP_LIFETIMEBOUND _Up&& __ux) noexcept
-> _ForwardLike<_Tp, _Up> { -> _ForwardLike<_Tp, _Up> {
return static_cast<_ForwardLike<_Tp, _Up>>(__ux); return static_cast<_ForwardLike<_Tp, _Up>>(__ux);
} }
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_FORWARD_LIKE_H #endif // _LIBCPP___UTILITY_FORWARD_LIKE_H

libcxx/include/__utility/in_place.h

Show All 13 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 > 14 #if _LIBCPP_STD_VER >= 17
struct _LIBCPP_TYPE_VIS in_place_t { struct _LIBCPP_TYPE_VIS in_place_t {
explicit in_place_t() = default; explicit in_place_t() = default;
}; };
inline constexpr in_place_t in_place{}; inline constexpr in_place_t in_place{};
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS in_place_type_t { struct _LIBCPP_TEMPLATE_VIS in_place_type_t {
Show All 16 Lines
using __is_inplace_type = __is_inplace_type_imp<__remove_cvref_t<_Tp>>; using __is_inplace_type = __is_inplace_type_imp<__remove_cvref_t<_Tp>>;
template <class _Tp> struct __is_inplace_index_imp : false_type {}; template <class _Tp> struct __is_inplace_index_imp : false_type {};
template <size_t _Idx> struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {}; template <size_t _Idx> struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {};
template <class _Tp> template <class _Tp>
using __is_inplace_index = __is_inplace_index_imp<__remove_cvref_t<_Tp>>; using __is_inplace_index = __is_inplace_index_imp<__remove_cvref_t<_Tp>>;
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_IN_PLACE_H #endif // _LIBCPP___UTILITY_IN_PLACE_H

libcxx/include/__utility/integer_sequence.h

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Linesusing __make_indices_imp =
__to_tuple_indices<_Sp>; __to_tuple_indices<_Sp>;
#else #else
template <size_t _Ep, size_t _Sp> template <size_t _Ep, size_t _Sp>
using __make_indices_imp = using __make_indices_imp =
typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>; typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>;
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template<class _Tp, _Tp... _Ip> template<class _Tp, _Tp... _Ip>
struct _LIBCPP_TEMPLATE_VIS integer_sequence struct _LIBCPP_TEMPLATE_VIS integer_sequence
{ {
typedef _Tp value_type; typedef _Tp value_type;
static_assert( is_integral<_Tp>::value, static_assert( is_integral<_Tp>::value,
"std::integer_sequence can only be instantiated with an integral type" ); "std::integer_sequence can only be instantiated with an integral type" );
static static
Show All 36 Linestemplate<class _Tp, _Tp _Np>
using make_integer_sequence = __make_integer_sequence<_Tp, _Np>; using make_integer_sequence = __make_integer_sequence<_Tp, _Np>;
template<size_t _Np> template<size_t _Np>
using make_index_sequence = make_integer_sequence<size_t, _Np>; using make_index_sequence = make_integer_sequence<size_t, _Np>;
template<class... _Tp> template<class... _Tp>
using index_sequence_for = make_index_sequence<sizeof...(_Tp)>; using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;
# if _LIBCPP_STD_VER > 17 # if _LIBCPP_STD_VER >= 20
// Executes __func for every element in an index_sequence. // Executes __func for every element in an index_sequence.
template <size_t... _Index, class _Function> template <size_t... _Index, class _Function>
_LIBCPP_HIDE_FROM_ABI constexpr void __for_each_index_sequence(index_sequence<_Index...>, _Function __func) { _LIBCPP_HIDE_FROM_ABI constexpr void __for_each_index_sequence(index_sequence<_Index...>, _Function __func) {
(__func.template operator()<_Index>(), ...); (__func.template operator()<_Index>(), ...);
} }
# endif // _LIBCPP_STD_VER > 17 # endif // _LIBCPP_STD_VER >= 20
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_INTEGER_SEQUENCE_H #endif // _LIBCPP___UTILITY_INTEGER_SEQUENCE_H

libcxx/include/__utility/pair.h

Show First 20 Lines • Show All 411 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_CXX03_LANG
template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
pair(piecewise_construct_t, pair(piecewise_construct_t,
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args, tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
__tuple_indices<_I1...>, __tuple_indices<_I2...>); __tuple_indices<_I1...>, __tuple_indices<_I2...>);
#endif #endif
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template<class _T1, class _T2> template<class _T1, class _T2>
pair(_T1, _T2) -> pair<_T1, _T2>; pair(_T1, _T2) -> pair<_T1, _T2>;
#endif #endif
// [pairs.spec], specialized algorithms // [pairs.spec], specialized algorithms
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
▲ Show 20 Lines • Show All 221 Lines • ▼ Show 20 Lines
template <size_t _Ip, class _T1, class _T2> template <size_t _Ip, class _T1, class _T2>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&& const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
get(const pair<_T1, _T2>&& __p) _NOEXCEPT get(const pair<_T1, _T2>&& __p) _NOEXCEPT
{ {
return __get_pair<_Ip>::get(std::move(__p)); return __get_pair<_Ip>::get(std::move(__p));
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
{ {
return __get_pair<0>::get(__p); return __get_pair<0>::get(__p);
} }
template <class _T1, class _T2> template <class _T1, class _T2>
Show All 40 Lines
template <class _T1, class _T2> template <class _T1, class _T2>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
{ {
return __get_pair<1>::get(std::move(__p)); return __get_pair<1>::get(std::move(__p));
} }
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_PAIR_H #endif // _LIBCPP___UTILITY_PAIR_H

libcxx/include/__utility/to_underlying.h

Show All 21 Lines
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Tp> template <class _Tp>
_LIBCPP_INLINE_VISIBILITY constexpr typename underlying_type<_Tp>::type _LIBCPP_INLINE_VISIBILITY constexpr typename underlying_type<_Tp>::type
__to_underlying(_Tp __val) noexcept { __to_underlying(_Tp __val) noexcept {
return static_cast<typename underlying_type<_Tp>::type>(__val); return static_cast<typename underlying_type<_Tp>::type>(__val);
} }
#endif // !_LIBCPP_CXX03_LANG #endif // !_LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY constexpr underlying_type_t<_Tp> _LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY constexpr underlying_type_t<_Tp>
to_underlying(_Tp __val) noexcept { to_underlying(_Tp __val) noexcept {
return _VSTD::__to_underlying(__val); return _VSTD::__to_underlying(__val);
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_TO_UNDERLYING_H #endif // _LIBCPP___UTILITY_TO_UNDERLYING_H

libcxx/include/__utility/unreachable.h

Show All 17 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline void __libcpp_unreachable() { _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline void __libcpp_unreachable() {
_LIBCPP_ASSERT(false, "std::unreachable() was reached"); _LIBCPP_ASSERT(false, "std::unreachable() was reached");
__builtin_unreachable(); __builtin_unreachable();
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
[[noreturn]] _LIBCPP_HIDE_FROM_ABI inline void unreachable() { __libcpp_unreachable(); } [[noreturn]] _LIBCPP_HIDE_FROM_ABI inline void unreachable() { __libcpp_unreachable(); }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_UNREACHABLE_H #endif // _LIBCPP___UTILITY_UNREACHABLE_H

libcxx/include/__variant/monostate.h

Show All 15 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 > 14 #if _LIBCPP_STD_VER >= 17
struct _LIBCPP_TEMPLATE_VIS monostate {}; struct _LIBCPP_TEMPLATE_VIS monostate {};
_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(monostate, monostate) noexcept { return true; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(monostate, monostate) noexcept { return true; }
# if _LIBCPP_STD_VER > 17 # if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(monostate, monostate) noexcept { _LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(monostate, monostate) noexcept {
return strong_ordering::equal; return strong_ordering::equal;
} }
# else // _LIBCPP_STD_VER > 17 # else // _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(monostate, monostate) noexcept { return false; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(monostate, monostate) noexcept { return false; }
_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(monostate, monostate) noexcept { return false; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(monostate, monostate) noexcept { return false; }
_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(monostate, monostate) noexcept { return false; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(monostate, monostate) noexcept { return false; }
_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(monostate, monostate) noexcept { return true; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(monostate, monostate) noexcept { return true; }
_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(monostate, monostate) noexcept { return true; } _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(monostate, monostate) noexcept { return true; }
# endif // _LIBCPP_STD_VER > 17 # endif // _LIBCPP_STD_VER >= 20
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<monostate> { struct _LIBCPP_TEMPLATE_VIS hash<monostate> {
using argument_type = monostate; using argument_type = monostate;
using result_type = size_t; using result_type = size_t;
inline _LIBCPP_HIDE_FROM_ABI result_type operator()(const argument_type&) const _NOEXCEPT { inline _LIBCPP_HIDE_FROM_ABI result_type operator()(const argument_type&) const _NOEXCEPT {
return 66740831; // return a fundamentally attractive random value. return 66740831; // return a fundamentally attractive random value.
} }
}; };
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___VARIANT_MONOSTATE_H #endif // _LIBCPP___VARIANT_MONOSTATE_H

libcxx/include/any

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
{ {
public: public:
const char* what() const _NOEXCEPT override; const char* what() const _NOEXCEPT override;
}; };
} // namespace std } // namespace std
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
void __throw_bad_any_cast() void __throw_bad_any_cast()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
throw bad_any_cast(); throw bad_any_cast();
#else #else
▲ Show 20 Lines • Show All 564 Lines • ▼ Show 20 Lines
#endif #endif
__any_imp::__get_fallback_typeid<_ValueType>()); __any_imp::__get_fallback_typeid<_ValueType>());
return _VSTD::__pointer_or_func_cast<_ReturnType>( return _VSTD::__pointer_or_func_cast<_ReturnType>(
__p, is_function<_ValueType>{}); __p, is_function<_ValueType>{});
} }
return nullptr; return nullptr;
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
# include <chrono> # include <chrono>
#endif #endif
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
Show All 9 Lines

libcxx/include/array

Show First 20 Lines • Show All 370 Lines • ▼ Show 20 Linesstruct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
const_reference back() const _NOEXCEPT { const_reference back() const _NOEXCEPT {
_LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array"); _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
__libcpp_unreachable(); __libcpp_unreachable();
} }
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template<class _Tp, class... _Args, template<class _Tp, class... _Args,
class = enable_if_t<__all<_IsSame<_Tp, _Args>::value...>::value> class = enable_if_t<__all<_IsSame<_Tp, _Args>::value...>::value>
> >
array(_Tp, _Args...) array(_Tp, _Args...)
-> array<_Tp, 1 + sizeof...(_Args)>; -> array<_Tp, 1 + sizeof...(_Args)>;
#endif #endif
template <class _Tp, size_t _Size> template <class _Tp, size_t _Size>
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
const _Tp&& const _Tp&&
get(const array<_Tp, _Size>&& __a) _NOEXCEPT get(const array<_Tp, _Size>&& __a) _NOEXCEPT
{ {
static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)"); static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)");
return _VSTD::move(__a.__elems_[_Ip]); return _VSTD::move(__a.__elems_[_Ip]);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <typename _Tp, size_t _Size, size_t... _Index> template <typename _Tp, size_t _Size, size_t... _Index>
_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size> _LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>
__to_array_lvalue_impl(_Tp (&__arr)[_Size], index_sequence<_Index...>) { __to_array_lvalue_impl(_Tp (&__arr)[_Size], index_sequence<_Index...>) {
return {{__arr[_Index]...}}; return {{__arr[_Index]...}};
} }
template <typename _Tp, size_t _Size, size_t... _Index> template <typename _Tp, size_t _Size, size_t... _Index>
Show All 22 Lines static_assert(
"[array.creation]/4: to_array does not accept multidimensional arrays."); "[array.creation]/4: to_array does not accept multidimensional arrays.");
static_assert( static_assert(
is_move_constructible_v<_Tp>, is_move_constructible_v<_Tp>,
"[array.creation]/4: to_array requires move constructible elements."); "[array.creation]/4: to_array requires move constructible elements.");
return _VSTD::__to_array_rvalue_impl(_VSTD::move(__arr), return _VSTD::__to_array_rvalue_impl(_VSTD::move(__arr),
make_index_sequence<_Size>()); make_index_sequence<_Size>());
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <algorithm> # include <algorithm>
# include <concepts> # include <concepts>
# include <iterator> # include <iterator>
# include <utility> # include <utility>
#endif #endif
#endif // _LIBCPP_ARRAY #endif // _LIBCPP_ARRAY

libcxx/include/atomic

Show First 20 Lines • Show All 580 Lines • ▼ Show 20 Linesenum __legacy_memory_order {
__mo_acquire, __mo_acquire,
__mo_release, __mo_release,
__mo_acq_rel, __mo_acq_rel,
__mo_seq_cst __mo_seq_cst
}; };
typedef underlying_type<__legacy_memory_order>::type __memory_order_underlying_t; typedef underlying_type<__legacy_memory_order>::type __memory_order_underlying_t;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
enum class memory_order : __memory_order_underlying_t { enum class memory_order : __memory_order_underlying_t {
relaxed = __mo_relaxed, relaxed = __mo_relaxed,
consume = __mo_consume, consume = __mo_consume,
acquire = __mo_acquire, acquire = __mo_acquire,
release = __mo_release, release = __mo_release,
acq_rel = __mo_acq_rel, acq_rel = __mo_acq_rel,
seq_cst = __mo_seq_cst seq_cst = __mo_seq_cst
Show All 12 Linestypedef enum memory_order {
memory_order_relaxed = __mo_relaxed, memory_order_relaxed = __mo_relaxed,
memory_order_consume = __mo_consume, memory_order_consume = __mo_consume,
memory_order_acquire = __mo_acquire, memory_order_acquire = __mo_acquire,
memory_order_release = __mo_release, memory_order_release = __mo_release,
memory_order_acq_rel = __mo_acq_rel, memory_order_acq_rel = __mo_acq_rel,
memory_order_seq_cst = __mo_seq_cst, memory_order_seq_cst = __mo_seq_cst,
} memory_order; } memory_order;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
template <typename _Tp> _LIBCPP_INLINE_VISIBILITY template <typename _Tp> _LIBCPP_INLINE_VISIBILITY
bool __cxx_nonatomic_compare_equal(_Tp const& __lhs, _Tp const& __rhs) { bool __cxx_nonatomic_compare_equal(_Tp const& __lhs, _Tp const& __rhs) {
return _VSTD::memcmp(&__lhs, &__rhs, sizeof(_Tp)) == 0; return _VSTD::memcmp(&__lhs, &__rhs, sizeof(_Tp)) == 0;
} }
static_assert((is_same<underlying_type<memory_order>::type, __memory_order_underlying_t>::value), static_assert((is_same<underlying_type<memory_order>::type, __memory_order_underlying_t>::value),
"unexpected underlying type for std::memory_order"); "unexpected underlying type for std::memory_order");
▲ Show 20 Lines • Show All 976 Lines • ▼ Show 20 Lines _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_one() volatile _NOEXCEPT
{std::__cxx_atomic_notify_one(&__a_);} {std::__cxx_atomic_notify_one(&__a_);}
_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_one() _NOEXCEPT _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_one() _NOEXCEPT
{std::__cxx_atomic_notify_one(&__a_);} {std::__cxx_atomic_notify_one(&__a_);}
_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_all() volatile _NOEXCEPT _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_all() volatile _NOEXCEPT
{std::__cxx_atomic_notify_all(&__a_);} {std::__cxx_atomic_notify_all(&__a_);}
_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_all() _NOEXCEPT _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY void notify_all() _NOEXCEPT
{std::__cxx_atomic_notify_all(&__a_);} {std::__cxx_atomic_notify_all(&__a_);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
__atomic_base() noexcept(is_nothrow_default_constructible_v<_Tp>) : __a_(_Tp()) {} __atomic_base() noexcept(is_nothrow_default_constructible_v<_Tp>) : __a_(_Tp()) {}
#else #else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__atomic_base() _NOEXCEPT = default; __atomic_base() _NOEXCEPT = default;
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
struct atomic struct atomic
: public __atomic_base<_Tp> : public __atomic_base<_Tp>
{ {
typedef __atomic_base<_Tp> __base; typedef __atomic_base<_Tp> __base;
typedef _Tp value_type; typedef _Tp value_type;
typedef value_type difference_type; typedef value_type difference_type;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
atomic() = default; atomic() = default;
#else #else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
atomic() _NOEXCEPT = default; atomic() _NOEXCEPT = default;
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 653 Lines • ▼ Show 20 Lines void notify_one() _NOEXCEPT
{__cxx_atomic_notify_one(&__a_);} {__cxx_atomic_notify_one(&__a_);}
_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
void notify_all() volatile _NOEXCEPT void notify_all() volatile _NOEXCEPT
{__cxx_atomic_notify_all(&__a_);} {__cxx_atomic_notify_all(&__a_);}
_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
void notify_all() _NOEXCEPT void notify_all() _NOEXCEPT
{__cxx_atomic_notify_all(&__a_);} {__cxx_atomic_notify_all(&__a_);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
atomic_flag() _NOEXCEPT : __a_(false) {} atomic_flag() _NOEXCEPT : __a_(false) {}
#else #else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
atomic_flag() _NOEXCEPT = default; atomic_flag() _NOEXCEPT = default;
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
▲ Show 20 Lines • Show All 249 Lines • ▼ Show 20 Lines
#if !defined(_LIBCPP_NO_LOCK_FREE_TYPES) #if !defined(_LIBCPP_NO_LOCK_FREE_TYPES)
typedef atomic<__libcpp_signed_lock_free> atomic_signed_lock_free; typedef atomic<__libcpp_signed_lock_free> atomic_signed_lock_free;
typedef atomic<__libcpp_unsigned_lock_free> atomic_unsigned_lock_free; typedef atomic<__libcpp_unsigned_lock_free> atomic_unsigned_lock_free;
#endif #endif
#define ATOMIC_FLAG_INIT {false} #define ATOMIC_FLAG_INIT {false}
#define ATOMIC_VAR_INIT(__v) {__v} #define ATOMIC_VAR_INIT(__v) {__v}
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) #if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
# if defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 1400 # if defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 1400
# pragma clang deprecated(ATOMIC_VAR_INIT) # pragma clang deprecated(ATOMIC_VAR_INIT)
# endif # endif
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) #endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <cmath> # include <cmath>
# include <compare> # include <compare>
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_ATOMIC #endif // _LIBCPP_ATOMIC

libcxx/include/charconv

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 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 > 14 #if _LIBCPP_STD_VER >= 17
to_chars_result to_chars(char*, char*, bool, int = 10) = delete; to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
from_chars_result from_chars(const char*, const char*, bool, int = 10) = delete; from_chars_result from_chars(const char*, const char*, bool, int = 10) = delete;
namespace __itoa namespace __itoa
{ {
template <typename _Tp, typename = void> template <typename _Tp, typename = void>
▲ Show 20 Lines • Show All 708 Lines • ▼ Show 20 Lines
to_chars_result to_chars(char* __first, char* __last, float __value, chars_format __fmt, int __precision); to_chars_result to_chars(char* __first, char* __last, float __value, chars_format __fmt, int __precision);
_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS
to_chars_result to_chars(char* __first, char* __last, double __value, chars_format __fmt, int __precision); to_chars_result to_chars(char* __first, char* __last, double __value, chars_format __fmt, int __precision);
_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS
to_chars_result to_chars(char* __first, char* __last, long double __value, chars_format __fmt, int __precision); to_chars_result to_chars(char* __first, char* __last, long double __value, chars_format __fmt, int __precision);
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <concepts> # include <concepts>
# include <iosfwd> # include <iosfwd>
#endif #endif
#endif // _LIBCPP_CHARCONV #endif // _LIBCPP_CHARCONV

libcxx/include/chrono

Show First 20 Lines • Show All 769 Lines • ▼ Show 20 Lines
#include <__config> #include <__config>
#include <version> #include <version>
// standard-mandated includes // standard-mandated includes
// [time.syn] // [time.syn]
#include <compare> #include <compare>
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) && _LIBCPP_STD_VER > 17 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) && _LIBCPP_STD_VER >= 20
# include <__chrono/formatter.h> # include <__chrono/formatter.h>
# include <__chrono/ostream.h> # include <__chrono/ostream.h>
# include <__chrono/parser_std_format_spec.h> # include <__chrono/parser_std_format_spec.h>
# include <__chrono/statically_widen.h> # include <__chrono/statically_widen.h>
#endif #endif
#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
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <concepts> # include <concepts>
#endif #endif
#endif // _LIBCPP_CHRONO #endif // _LIBCPP_CHRONO

libcxx/include/cmath

Show First 20 Lines • Show All 538 Lines • ▼ Show 20 Lines
using ::remquol _LIBCPP_USING_IF_EXISTS; using ::remquol _LIBCPP_USING_IF_EXISTS;
using ::rintl _LIBCPP_USING_IF_EXISTS; using ::rintl _LIBCPP_USING_IF_EXISTS;
using ::roundl _LIBCPP_USING_IF_EXISTS; using ::roundl _LIBCPP_USING_IF_EXISTS;
using ::scalblnl _LIBCPP_USING_IF_EXISTS; using ::scalblnl _LIBCPP_USING_IF_EXISTS;
using ::scalbnl _LIBCPP_USING_IF_EXISTS; using ::scalbnl _LIBCPP_USING_IF_EXISTS;
using ::tgammal _LIBCPP_USING_IF_EXISTS; using ::tgammal _LIBCPP_USING_IF_EXISTS;
using ::truncl _LIBCPP_USING_IF_EXISTS; using ::truncl _LIBCPP_USING_IF_EXISTS;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
inline _LIBCPP_INLINE_VISIBILITY float hypot( float __x, float __y, float __z ) { return sqrt(__x*__x + __y*__y + __z*__z); } inline _LIBCPP_INLINE_VISIBILITY float hypot( float __x, float __y, float __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
inline _LIBCPP_INLINE_VISIBILITY double hypot( double __x, double __y, double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); } inline _LIBCPP_INLINE_VISIBILITY double hypot( double __x, double __y, double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double __x, long double __y, long double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); } inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double __x, long double __y, long double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
template <class _A1, class _A2, class _A3> template <class _A1, class _A2, class _A3>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename enable_if_t typename enable_if_t
< <
▲ Show 20 Lines • Show All 222 Lines • ▼ Show 20 Lines while (__exp > 0) {
} }
} }
return __x; return __x;
} }
#endif // !__has_constexpr_builtin(__builtin_scalbln) #endif // !__has_constexpr_builtin(__builtin_scalbln)
return __builtin_scalbn(__x, __exp); return __builtin_scalbn(__x, __exp);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <typename _Fp> template <typename _Fp>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
_Fp __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept { _Fp __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept {
if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0)) if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
return __t * __b + (1 - __t) * __a; return __t * __b + (1 - __t) * __a;
if (__t == 1) return __b; if (__t == 1) return __b;
const _Fp __x = __a + __t * (__b - __a); const _Fp __x = __a + __t * (__b - __a);
Show All 24 Lines
lerp(_A1 __a, _A2 __b, _A3 __t) noexcept lerp(_A1 __a, _A2 __b, _A3 __t) noexcept
{ {
typedef typename __promote<_A1, _A2, _A3>::type __result_type; typedef typename __promote<_A1, _A2, _A3>::type __result_type;
static_assert(!(_IsSame<_A1, __result_type>::value && static_assert(!(_IsSame<_A1, __result_type>::value &&
_IsSame<_A2, __result_type>::value && _IsSame<_A2, __result_type>::value &&
_IsSame<_A3, __result_type>::value)); _IsSame<_A3, __result_type>::value));
return std::__lerp((__result_type)__a, (__result_type)__b, (__result_type)__t); return std::__lerp((__result_type)__a, (__result_type)__b, (__result_type)__t);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_CMATH #endif // _LIBCPP_CMATH

libcxx/include/complex

Show First 20 Lines • Show All 1,516 Lines • ▼ Show 20 Linesoperator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
__s.flags(__os.flags()); __s.flags(__os.flags());
__s.imbue(__os.getloc()); __s.imbue(__os.getloc());
__s.precision(__os.precision()); __s.precision(__os.precision());
__s << '(' << __x.real() << ',' << __x.imag() << ')'; __s << '(' << __x.real() << ',' << __x.imag() << ')';
return __os << __s.str(); return __os << __s.str();
} }
#endif // !_LIBCPP_HAS_NO_LOCALIZATION #endif // !_LIBCPP_HAS_NO_LOCALIZATION
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
// Literal suffix for complex number literals [complex.literals] // Literal suffix for complex number literals [complex.literals]
inline namespace literals inline namespace literals
{ {
inline namespace complex_literals inline namespace complex_literals
{ {
_LIBCPP_HIDE_FROM_ABI constexpr complex<long double> operator""il(long double __im) _LIBCPP_HIDE_FROM_ABI constexpr complex<long double> operator""il(long double __im)
{ {
return { 0.0l, __im }; return { 0.0l, __im };
Show All 35 Lines

libcxx/include/cstddef

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
using ::size_t _LIBCPP_USING_IF_EXISTS; using ::size_t _LIBCPP_USING_IF_EXISTS;
#if !defined(_LIBCPP_CXX03_LANG) #if !defined(_LIBCPP_CXX03_LANG)
using ::max_align_t _LIBCPP_USING_IF_EXISTS; using ::max_align_t _LIBCPP_USING_IF_EXISTS;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
namespace std // purposefully not versioned namespace std // purposefully not versioned
{ {
enum class byte : unsigned char {}; enum class byte : unsigned char {};
_LIBCPP_HIDE_FROM_ABI constexpr byte operator| (byte __lhs, byte __rhs) noexcept _LIBCPP_HIDE_FROM_ABI constexpr byte operator| (byte __lhs, byte __rhs) noexcept
{ {
return static_cast<byte>( return static_cast<byte>(
static_cast<unsigned char>( static_cast<unsigned char>(
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

libcxx/include/cstdlib

Show First 20 Lines • Show All 138 Lines • ▼ Show 20 Lines
using ::mbtowc _LIBCPP_USING_IF_EXISTS; using ::mbtowc _LIBCPP_USING_IF_EXISTS;
using ::wctomb _LIBCPP_USING_IF_EXISTS; using ::wctomb _LIBCPP_USING_IF_EXISTS;
using ::mbstowcs _LIBCPP_USING_IF_EXISTS; using ::mbstowcs _LIBCPP_USING_IF_EXISTS;
using ::wcstombs _LIBCPP_USING_IF_EXISTS; using ::wcstombs _LIBCPP_USING_IF_EXISTS;
#if !defined(_LIBCPP_CXX03_LANG) #if !defined(_LIBCPP_CXX03_LANG)
using ::at_quick_exit _LIBCPP_USING_IF_EXISTS; using ::at_quick_exit _LIBCPP_USING_IF_EXISTS;
using ::quick_exit _LIBCPP_USING_IF_EXISTS; using ::quick_exit _LIBCPP_USING_IF_EXISTS;
#endif #endif
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
using ::aligned_alloc _LIBCPP_USING_IF_EXISTS; using ::aligned_alloc _LIBCPP_USING_IF_EXISTS;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_CSTDLIB #endif // _LIBCPP_CSTDLIB

libcxx/include/ctime

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
using ::clock_t _LIBCPP_USING_IF_EXISTS; using ::clock_t _LIBCPP_USING_IF_EXISTS;
using ::size_t _LIBCPP_USING_IF_EXISTS; using ::size_t _LIBCPP_USING_IF_EXISTS;
using ::time_t _LIBCPP_USING_IF_EXISTS; using ::time_t _LIBCPP_USING_IF_EXISTS;
using ::tm _LIBCPP_USING_IF_EXISTS; using ::tm _LIBCPP_USING_IF_EXISTS;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
using ::timespec _LIBCPP_USING_IF_EXISTS; using ::timespec _LIBCPP_USING_IF_EXISTS;
#endif #endif
using ::clock _LIBCPP_USING_IF_EXISTS; using ::clock _LIBCPP_USING_IF_EXISTS;
using ::difftime _LIBCPP_USING_IF_EXISTS; using ::difftime _LIBCPP_USING_IF_EXISTS;
using ::mktime _LIBCPP_USING_IF_EXISTS; using ::mktime _LIBCPP_USING_IF_EXISTS;
using ::time _LIBCPP_USING_IF_EXISTS; using ::time _LIBCPP_USING_IF_EXISTS;
using ::asctime _LIBCPP_USING_IF_EXISTS; using ::asctime _LIBCPP_USING_IF_EXISTS;
using ::ctime _LIBCPP_USING_IF_EXISTS; using ::ctime _LIBCPP_USING_IF_EXISTS;
using ::gmtime _LIBCPP_USING_IF_EXISTS; using ::gmtime _LIBCPP_USING_IF_EXISTS;
using ::localtime _LIBCPP_USING_IF_EXISTS; using ::localtime _LIBCPP_USING_IF_EXISTS;
using ::strftime _LIBCPP_USING_IF_EXISTS; using ::strftime _LIBCPP_USING_IF_EXISTS;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
using ::timespec_get _LIBCPP_USING_IF_EXISTS; using ::timespec_get _LIBCPP_USING_IF_EXISTS;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_CTIME #endif // _LIBCPP_CTIME

libcxx/include/deque

Show First 20 Lines • Show All 243 Lines • ▼ Show 20 Linesprivate:
static const difference_type __block_size; static const difference_type __block_size;
public: public:
typedef _ValueType value_type; typedef _ValueType value_type;
typedef random_access_iterator_tag iterator_category; typedef random_access_iterator_tag iterator_category;
typedef _Reference reference; typedef _Reference reference;
_LIBCPP_HIDE_FROM_ABI __deque_iterator() _NOEXCEPT _LIBCPP_HIDE_FROM_ABI __deque_iterator() _NOEXCEPT
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
: __m_iter_(nullptr), __ptr_(nullptr) : __m_iter_(nullptr), __ptr_(nullptr)
#endif #endif
{} {}
template <class _Pp, class _Rp, class _MP> template <class _Pp, class _Rp, class _MP>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
__deque_iterator(const __deque_iterator<value_type, _Pp, _Rp, _MP, difference_type, _BS>& __it, __deque_iterator(const __deque_iterator<value_type, _Pp, _Rp, _MP, difference_type, _BS>& __it,
typename enable_if<is_convertible<_Pp, pointer>::value>::type* = 0) _NOEXCEPT typename enable_if<is_convertible<_Pp, pointer>::value>::type* = 0) _NOEXCEPT
▲ Show 20 Lines • Show All 298 Lines • ▼ Show 20 Lines _LIBCPP_HIDE_FROM_ABI ~deque() {
for (; __i != __e; ++__i) for (; __i != __e; ++__i)
__alloc_traits::deallocate(__alloc(), *__i, __block_size); __alloc_traits::deallocate(__alloc(), *__i, __block_size);
} }
_LIBCPP_HIDE_FROM_ABI explicit deque(const allocator_type& __a) _LIBCPP_HIDE_FROM_ABI explicit deque(const allocator_type& __a)
: __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {} : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {}
explicit _LIBCPP_HIDE_FROM_ABI deque(size_type __n); explicit _LIBCPP_HIDE_FROM_ABI deque(size_type __n);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
explicit _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const _Allocator& __a); explicit _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const _Allocator& __a);
#endif #endif
_LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v); _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v);
template <class = __enable_if_t<__is_allocator<_Allocator>::value> > template <class = __enable_if_t<__is_allocator<_Allocator>::value> >
_LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v, const allocator_type& __a) _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v, const allocator_type& __a)
: __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
{ {
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines _LIBCPP_HIDE_FROM_ABI const size_type& __size() const _NOEXCEPT { return __size_.first(); }
reference back() _NOEXCEPT; reference back() _NOEXCEPT;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
const_reference back() const _NOEXCEPT; const_reference back() const _NOEXCEPT;
// 23.2.2.3 modifiers: // 23.2.2.3 modifiers:
_LIBCPP_HIDE_FROM_ABI void push_front(const value_type& __v); _LIBCPP_HIDE_FROM_ABI void push_front(const value_type& __v);
_LIBCPP_HIDE_FROM_ABI void push_back(const value_type& __v); _LIBCPP_HIDE_FROM_ABI void push_back(const value_type& __v);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class... _Args> _LIBCPP_HIDE_FROM_ABI reference emplace_front(_Args&&... __args); template <class... _Args> _LIBCPP_HIDE_FROM_ABI reference emplace_front(_Args&&... __args);
template <class... _Args> _LIBCPP_HIDE_FROM_ABI reference emplace_back (_Args&&... __args); template <class... _Args> _LIBCPP_HIDE_FROM_ABI reference emplace_back (_Args&&... __args);
#else #else
template <class... _Args> _LIBCPP_HIDE_FROM_ABI void emplace_front(_Args&&... __args); template <class... _Args> _LIBCPP_HIDE_FROM_ABI void emplace_front(_Args&&... __args);
template <class... _Args> _LIBCPP_HIDE_FROM_ABI void emplace_back (_Args&&... __args); template <class... _Args> _LIBCPP_HIDE_FROM_ABI void emplace_back (_Args&&... __args);
#endif #endif
template <class... _Args> _LIBCPP_HIDE_FROM_ABI iterator emplace(const_iterator __p, _Args&&... __args); template <class... _Args> _LIBCPP_HIDE_FROM_ABI iterator emplace(const_iterator __p, _Args&&... __args);
▲ Show 20 Lines • Show All 222 Lines • ▼ Show 20 Lines
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
deque<_Tp, _Allocator>::deque(size_type __n) deque<_Tp, _Allocator>::deque(size_type __n)
: __start_(0), __size_(0, __default_init_tag()) : __start_(0), __size_(0, __default_init_tag())
{ {
if (__n > 0) if (__n > 0)
__append(__n); __append(__n);
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
deque<_Tp, _Allocator>::deque(size_type __n, const _Allocator& __a) deque<_Tp, _Allocator>::deque(size_type __n, const _Allocator& __a)
: __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
{ {
if (__n > 0) if (__n > 0)
__append(__n); __append(__n);
} }
#endif #endif
▲ Show 20 Lines • Show All 345 Lines • ▼ Show 20 Lines if (__back_spare() == 0)
__add_back_capacity(); __add_back_capacity();
// __back_spare() >= 1 // __back_spare() >= 1
__alloc_traits::construct(__a, _VSTD::addressof(*end()), _VSTD::move(__v)); __alloc_traits::construct(__a, _VSTD::addressof(*end()), _VSTD::move(__v));
++__size(); ++__size();
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class... _Args> template <class... _Args>
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typename deque<_Tp, _Allocator>::reference typename deque<_Tp, _Allocator>::reference
#else #else
void void
#endif #endif
deque<_Tp, _Allocator>::emplace_back(_Args&&... __args) deque<_Tp, _Allocator>::emplace_back(_Args&&... __args)
{ {
allocator_type& __a = __alloc(); allocator_type& __a = __alloc();
if (__back_spare() == 0) if (__back_spare() == 0)
__add_back_capacity(); __add_back_capacity();
// __back_spare() >= 1 // __back_spare() >= 1
__alloc_traits::construct(__a, _VSTD::addressof(*end()), __alloc_traits::construct(__a, _VSTD::addressof(*end()),
_VSTD::forward<_Args>(__args)...); _VSTD::forward<_Args>(__args)...);
++__size(); ++__size();
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
return *--end(); return *--end();
#endif #endif
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
void void
deque<_Tp, _Allocator>::push_front(value_type&& __v) deque<_Tp, _Allocator>::push_front(value_type&& __v)
{ {
allocator_type& __a = __alloc(); allocator_type& __a = __alloc();
if (__front_spare() == 0) if (__front_spare() == 0)
__add_front_capacity(); __add_front_capacity();
// __front_spare() >= 1 // __front_spare() >= 1
__alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::move(__v)); __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::move(__v));
--__start_; --__start_;
++__size(); ++__size();
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class... _Args> template <class... _Args>
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typename deque<_Tp, _Allocator>::reference typename deque<_Tp, _Allocator>::reference
#else #else
void void
#endif #endif
deque<_Tp, _Allocator>::emplace_front(_Args&&... __args) deque<_Tp, _Allocator>::emplace_front(_Args&&... __args)
{ {
allocator_type& __a = __alloc(); allocator_type& __a = __alloc();
if (__front_spare() == 0) if (__front_spare() == 0)
__add_front_capacity(); __add_front_capacity();
// __front_spare() >= 1 // __front_spare() >= 1
__alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::forward<_Args>(__args)...); __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::forward<_Args>(__args)...);
--__start_; --__start_;
++__size(); ++__size();
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
return *begin(); return *begin();
#endif #endif
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
typename deque<_Tp, _Allocator>::iterator typename deque<_Tp, _Allocator>::iterator
deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v) deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
{ {
▲ Show 20 Lines • Show All 1,011 Lines • ▼ Show 20 Lines
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
void void
swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y) swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Tp, class _Allocator, class _Up> template <class _Tp, class _Allocator, class _Up>
inline _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::size_type inline _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::size_type
erase(deque<_Tp, _Allocator>& __c, const _Up& __v) { erase(deque<_Tp, _Allocator>& __c, const _Up& __v) {
auto __old_size = __c.size(); auto __old_size = __c.size();
__c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end()); __c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end());
return __old_size - __c.size(); return __old_size - __c.size();
} }
template <class _Tp, class _Allocator, class _Predicate> template <class _Tp, class _Allocator, class _Predicate>
inline _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::size_type inline _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::size_type
erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred) { erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred) {
auto __old_size = __c.size(); auto __old_size = __c.size();
__c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end()); __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end());
return __old_size - __c.size(); return __old_size - __c.size();
} }
template <> template <>
inline constexpr bool __format::__enable_insertable<std::deque<char>> = true; inline constexpr bool __format::__enable_insertable<std::deque<char>> = true;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
inline constexpr bool __format::__enable_insertable<std::deque<wchar_t>> = true; inline constexpr bool __format::__enable_insertable<std::deque<wchar_t>> = true;
#endif #endif
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
template <class _ValueT> template <class _ValueT>
using deque = std::deque<_ValueT, polymorphic_allocator<_ValueT>>; using deque = std::deque<_ValueT, polymorphic_allocator<_ValueT>>;
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif #endif
Show All 13 Lines

libcxx/include/experimental/functional

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
# define _LIBCPP_DEPRECATED_BOYER_MOORE_SEARCHER # define _LIBCPP_DEPRECATED_BOYER_MOORE_SEARCHER
# define _LIBCPP_DEPRECATED_BOYER_MOORE_HORSPOOL_SEARCHER # define _LIBCPP_DEPRECATED_BOYER_MOORE_HORSPOOL_SEARCHER
#else #else
# define _LIBCPP_DEPRECATED_DEFAULT_SEARCHER _LIBCPP_DEPRECATED_("std::experimental::default_searcher will be removed in LLVM 17. Use std::default_searcher instead") # define _LIBCPP_DEPRECATED_DEFAULT_SEARCHER _LIBCPP_DEPRECATED_("std::experimental::default_searcher will be removed in LLVM 17. Use std::default_searcher instead")
# define _LIBCPP_DEPRECATED_BOYER_MOORE_SEARCHER _LIBCPP_DEPRECATED_("std::experimental::boyer_moore_searcher will be removed in LLVM 17. Use std::boyer_moore_searcher instead") # define _LIBCPP_DEPRECATED_BOYER_MOORE_SEARCHER _LIBCPP_DEPRECATED_("std::experimental::boyer_moore_searcher will be removed in LLVM 17. Use std::boyer_moore_searcher instead")
# define _LIBCPP_DEPRECATED_BOYER_MOORE_HORSPOOL_SEARCHER _LIBCPP_DEPRECATED_("std::experimental::boyer_moore_horspool_searcher will be removed in LLVM 17. Use std::boyer_moore_horspool_searcher instead") # define _LIBCPP_DEPRECATED_BOYER_MOORE_HORSPOOL_SEARCHER _LIBCPP_DEPRECATED_("std::experimental::boyer_moore_horspool_searcher will be removed in LLVM 17. Use std::boyer_moore_horspool_searcher instead")
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
// default searcher // default searcher
template<class _ForwardIterator, class _BinaryPredicate = equal_to<>> template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
class _LIBCPP_DEPRECATED_DEFAULT_SEARCHER _LIBCPP_TEMPLATE_VIS default_searcher { class _LIBCPP_DEPRECATED_DEFAULT_SEARCHER _LIBCPP_TEMPLATE_VIS default_searcher {
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
default_searcher(_ForwardIterator __f, _ForwardIterator __l, default_searcher(_ForwardIterator __f, _ForwardIterator __l,
_BinaryPredicate __p = _BinaryPredicate()) _BinaryPredicate __p = _BinaryPredicate())
: __first_(__f), __last_(__l), __pred_(__p) {} : __first_(__f), __last_(__l), __pred_(__p) {}
▲ Show 20 Lines • Show All 320 Lines • ▼ Show 20 Lines
_LIBCPP_DEPRECATED_BOYER_MOORE_HORSPOOL_SEARCHER _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_BOYER_MOORE_HORSPOOL_SEARCHER _LIBCPP_INLINE_VISIBILITY
boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate> boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>
make_boyer_moore_horspool_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l, make_boyer_moore_horspool_searcher( _RandomAccessIterator __f, _RandomAccessIterator __l,
_Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ()) _Hash __hf = _Hash(), _BinaryPredicate __p = _BinaryPredicate ())
{ {
return boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p); return boyer_moore_horspool_searcher<_RandomAccessIterator, _Hash, _BinaryPredicate>(__f, __l, __hf, __p);
} }
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
_LIBCPP_END_NAMESPACE_LFTS _LIBCPP_END_NAMESPACE_LFTS
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif /* _LIBCPP_EXPERIMENTAL_FUNCTIONAL */ #endif /* _LIBCPP_EXPERIMENTAL_FUNCTIONAL */

libcxx/include/experimental/iterator

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
#include <experimental/__config> #include <experimental/__config>
#include <iosfwd> // char_traits #include <iosfwd> // char_traits
#include <iterator> #include <iterator>
#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
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_BEGIN_NAMESPACE_LFTS
template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>> template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
class ostream_joiner { class ostream_joiner {
public: public:
typedef _CharT char_type; typedef _CharT char_type;
Show All 35 Lines
template <class _CharT, class _Traits, class _Delim> template <class _CharT, class _Traits, class _Delim>
_LIBCPP_HIDE_FROM_ABI ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits> _LIBCPP_HIDE_FROM_ABI ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>
make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d) make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d)
{ return ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>(__os, _VSTD::forward<_Delim>(__d)); } { return ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>(__os, _VSTD::forward<_Delim>(__d)); }
_LIBCPP_END_NAMESPACE_LFTS _LIBCPP_END_NAMESPACE_LFTS
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_EXPERIMENTAL_ITERATOR #endif // _LIBCPP_EXPERIMENTAL_ITERATOR

libcxx/include/experimental/propagate_const

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Lines
#include <__utility/swap.h> #include <__utility/swap.h>
#include <experimental/__config> #include <experimental/__config>
#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
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2
template <class _Tp> template <class _Tp>
class propagate_const; class propagate_const;
template <class _Up> template <class _Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
▲ Show 20 Lines • Show All 440 Lines • ▼ Show 20 Lines bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
{ {
return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2)); return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
} }
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
#endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST #endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST

libcxx/include/experimental/type_traits

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
} // namespace experimental } // namespace experimental
} // namespace std } // namespace std
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <experimental/__config> #include <experimental/__config>
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
#include <initializer_list> #include <initializer_list>
#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
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
template <class To, template<class...> class _Op, class... _Args> template <class To, template<class...> class _Op, class... _Args>
using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, To>; using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, To>;
template <class To, template<class...> class _Op, class... _Args> template <class To, template<class...> class _Op, class... _Args>
_LIBCPP_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<To, _Op, _Args...>::value; _LIBCPP_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<To, _Op, _Args...>::value;
_LIBCPP_END_NAMESPACE_LFTS _LIBCPP_END_NAMESPACE_LFTS
#endif /* _LIBCPP_STD_VER > 11 */ #endif /* _LIBCPP_STD_VER >= 14 */
#endif /* _LIBCPP_EXPERIMENTAL_TYPE_TRAITS */ #endif /* _LIBCPP_EXPERIMENTAL_TYPE_TRAITS */

libcxx/include/forward_list

Show First 20 Lines • Show All 665 Lines • ▼ Show 20 Linespublic:
typedef const value_type& const_reference; typedef const value_type& const_reference;
typedef typename allocator_traits<allocator_type>::pointer pointer; typedef typename allocator_traits<allocator_type>::pointer pointer;
typedef typename allocator_traits<allocator_type>::const_pointer const_pointer; typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
typedef typename allocator_traits<allocator_type>::size_type size_type; typedef typename allocator_traits<allocator_type>::size_type size_type;
typedef typename allocator_traits<allocator_type>::difference_type difference_type; typedef typename allocator_traits<allocator_type>::difference_type difference_type;
typedef typename base::iterator iterator; typedef typename base::iterator iterator;
typedef typename base::const_iterator const_iterator; typedef typename base::const_iterator const_iterator;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
typedef size_type __remove_return_type; typedef size_type __remove_return_type;
#else #else
typedef void __remove_return_type; typedef void __remove_return_type;
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
forward_list() forward_list()
_NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value) _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
{} // = default; {} // = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit forward_list(const allocator_type& __a); explicit forward_list(const allocator_type& __a);
explicit forward_list(size_type __n); explicit forward_list(size_type __n);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
explicit forward_list(size_type __n, const allocator_type& __a); explicit forward_list(size_type __n, const allocator_type& __a);
#endif #endif
forward_list(size_type __n, const value_type& __v); forward_list(size_type __n, const value_type& __v);
template <class = __enable_if_t<__is_allocator<_Alloc>::value> > template <class = __enable_if_t<__is_allocator<_Alloc>::value> >
forward_list(size_type __n, const value_type& __v, const allocator_type& __a) : base(__a) forward_list(size_type __n, const value_type& __v, const allocator_type& __a) : base(__a)
{ {
insert_after(cbefore_begin(), __n, __v); insert_after(cbefore_begin(), __n, __v);
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Lines#endif // _LIBCPP_CXX03_LANG
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
reference front() {return base::__before_begin()->__next_->__value_;} reference front() {return base::__before_begin()->__next_->__value_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_reference front() const {return base::__before_begin()->__next_->__value_;} const_reference front() const {return base::__before_begin()->__next_->__value_;}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class... _Args> reference emplace_front(_Args&&... __args); template <class... _Args> reference emplace_front(_Args&&... __args);
#else #else
template <class... _Args> void emplace_front(_Args&&... __args); template <class... _Args> void emplace_front(_Args&&... __args);
#endif #endif
void push_front(value_type&& __v); void push_front(value_type&& __v);
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
void push_front(const value_type& __v); void push_front(const value_type& __v);
▲ Show 20 Lines • Show All 123 Lines • ▼ Show 20 Lines if (__n > 0)
__h.reset(__node_traits::allocate(__a, 1)); __h.reset(__node_traits::allocate(__a, 1));
__node_traits::construct(__a, _VSTD::addressof(__h->__value_)); __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
__h->__next_ = nullptr; __h->__next_ = nullptr;
__p->__next_ = __h.release(); __p->__next_ = __h.release();
} }
} }
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
forward_list<_Tp, _Alloc>::forward_list(size_type __n, forward_list<_Tp, _Alloc>::forward_list(size_type __n,
const allocator_type& __base_alloc) const allocator_type& __base_alloc)
: base ( __base_alloc ) : base ( __base_alloc )
{ {
if (__n > 0) if (__n > 0)
{ {
__node_allocator& __a = base::__alloc(); __node_allocator& __a = base::__alloc();
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
void void
forward_list<_Tp, _Alloc>::assign(initializer_list<value_type> __il) forward_list<_Tp, _Alloc>::assign(initializer_list<value_type> __il)
{ {
assign(__il.begin(), __il.end()); assign(__il.begin(), __il.end());
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
template <class... _Args> template <class... _Args>
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typename forward_list<_Tp, _Alloc>::reference typename forward_list<_Tp, _Alloc>::reference
#else #else
void void
#endif #endif
forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args) forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
{ {
__node_allocator& __a = base::__alloc(); __node_allocator& __a = base::__alloc();
typedef __allocator_destructor<__node_allocator> _Dp; typedef __allocator_destructor<__node_allocator> _Dp;
unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1)); unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __node_traits::construct(__a, _VSTD::addressof(__h->__value_),
_VSTD::forward<_Args>(__args)...); _VSTD::forward<_Args>(__args)...);
__h->__next_ = base::__before_begin()->__next_; __h->__next_ = base::__before_begin()->__next_;
base::__before_begin()->__next_ = __h.release(); base::__before_begin()->__next_ = __h.release();
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
return base::__before_begin()->__next_->__value_; return base::__before_begin()->__next_->__value_;
#endif #endif
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
void void
forward_list<_Tp, _Alloc>::push_front(value_type&& __v) forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
{ {
▲ Show 20 Lines • Show All 611 Lines • ▼ Show 20 Lines
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
swap(forward_list<_Tp, _Alloc>& __x, forward_list<_Tp, _Alloc>& __y) swap(forward_list<_Tp, _Alloc>& __x, forward_list<_Tp, _Alloc>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Tp, class _Allocator, class _Predicate> template <class _Tp, class _Allocator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename forward_list<_Tp, _Allocator>::size_type typename forward_list<_Tp, _Allocator>::size_type
erase_if(forward_list<_Tp, _Allocator>& __c, _Predicate __pred) { erase_if(forward_list<_Tp, _Allocator>& __c, _Predicate __pred) {
return __c.remove_if(__pred); return __c.remove_if(__pred);
} }
template <class _Tp, class _Allocator, class _Up> template <class _Tp, class _Allocator, class _Up>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename forward_list<_Tp, _Allocator>::size_type typename forward_list<_Tp, _Allocator>::size_type
erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v) { erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v) {
return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; }); return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; });
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
template <class _ValueT> template <class _ValueT>
using forward_list = std::forward_list<_ValueT, polymorphic_allocator<_ValueT>>; using forward_list = std::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif #endif
Show All 13 Lines

libcxx/include/iomanip

Show First 20 Lines • Show All 618 Lines • ▼ Show 20 Lines
__quoted_proxy<_CharT, _Traits, _Allocator> __quoted_proxy<_CharT, _Traits, _Allocator>
__quoted(basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\')) __quoted(basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
{ {
return __quoted_proxy<_CharT, _Traits, _Allocator>(__s, __delim, __escape); return __quoted_proxy<_CharT, _Traits, _Allocator>(__s, __delim, __escape);
} }
#endif // _LIBCPP_STD_VER >= 11 #endif // _LIBCPP_STD_VER >= 11
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _CharT> template <class _CharT>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
auto quoted(const _CharT *__s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\')) auto quoted(const _CharT *__s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
{ {
const _CharT *__end = __s; const _CharT *__end = __s;
while (*__end) ++__end; while (*__end) ++__end;
return __quoted_output_proxy<_CharT, void>(__s, __end, __delim, __escape); return __quoted_output_proxy<_CharT, void>(__s, __end, __delim, __escape);
Show All 15 Lines
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
auto quoted(basic_string_view<_CharT, _Traits> __sv, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\')) auto quoted(basic_string_view<_CharT, _Traits> __sv, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
{ {
return __quoted_output_proxy<_CharT, _Traits>(__sv.data(), __sv.data() + __sv.size(), __delim, __escape); return __quoted_output_proxy<_CharT, _Traits>(__sv.data(), __sv.data() + __sv.size(), __delim, __escape);
} }
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_IOMANIP #endif // _LIBCPP_IOMANIP

libcxx/include/istream

Show First 20 Lines • Show All 566 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_NO_EXCEPTIONS
} }
} }
#endif #endif
__is.setstate(__state); __is.setstate(__state);
} }
return __is; return __is;
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template<class _CharT, class _Traits, size_t _Np> template<class _CharT, class _Traits, size_t _Np>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _CharT (&__buf)[_Np]) operator>>(basic_istream<_CharT, _Traits>& __is, _CharT (&__buf)[_Np])
{ {
size_t __n = _Np; size_t __n = _Np;
if (__is.width() > 0) if (__is.width() > 0)
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
template<class _Traits> template<class _Traits>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
basic_istream<char, _Traits>& basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __is, signed char* __s) operator>>(basic_istream<char, _Traits>& __is, signed char* __s)
{ {
return __is >> (char*)__s; return __is >> (char*)__s;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c) operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __sen(__is); typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen) if (__sen)
▲ Show 20 Lines • Show All 1,006 Lines • Show Last 20 Lines

libcxx/include/list

Show First 20 Lines • Show All 829 Lines • ▼ Show 20 Linespublic:
typedef typename base::pointer pointer; typedef typename base::pointer pointer;
typedef typename base::const_pointer const_pointer; typedef typename base::const_pointer const_pointer;
typedef typename base::size_type size_type; typedef typename base::size_type size_type;
typedef typename base::difference_type difference_type; typedef typename base::difference_type difference_type;
typedef typename base::iterator iterator; typedef typename base::iterator iterator;
typedef typename base::const_iterator const_iterator; typedef typename base::const_iterator const_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator; typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
typedef size_type __remove_return_type; typedef size_type __remove_return_type;
#else #else
typedef void __remove_return_type; typedef void __remove_return_type;
#endif #endif
static_assert(is_same<allocator_type, __rebind_alloc<allocator_traits<allocator_type>, value_type> >::value, static_assert(is_same<allocator_type, __rebind_alloc<allocator_traits<allocator_type>, value_type> >::value,
"[allocator.requirements] states that rebinding an allocator to the same type should result in the " "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
"original allocator"); "original allocator");
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
list() list()
_NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value) _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
explicit list(const allocator_type& __a) : base(__a) explicit list(const allocator_type& __a) : base(__a)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
} }
explicit list(size_type __n); explicit list(size_type __n);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
explicit list(size_type __n, const allocator_type& __a); explicit list(size_type __n, const allocator_type& __a);
#endif #endif
list(size_type __n, const value_type& __x); list(size_type __n, const value_type& __x);
template <class = __enable_if_t<__is_allocator<_Alloc>::value> > template <class = __enable_if_t<__is_allocator<_Alloc>::value> >
list(size_type __n, const value_type& __x, const allocator_type& __a) : base(__a) list(size_type __n, const value_type& __x, const allocator_type& __a) : base(__a)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
for (; __n > 0; --__n) for (; __n > 0; --__n)
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines const_reference back() const
return base::__end_.__prev_->__as_node()->__value_; return base::__end_.__prev_->__as_node()->__value_;
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
void push_front(value_type&& __x); void push_front(value_type&& __x);
void push_back(value_type&& __x); void push_back(value_type&& __x);
template <class... _Args> template <class... _Args>
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
reference emplace_front(_Args&&... __args); reference emplace_front(_Args&&... __args);
#else #else
void emplace_front(_Args&&... __args); void emplace_front(_Args&&... __args);
#endif #endif
template <class... _Args> template <class... _Args>
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
reference emplace_back(_Args&&... __args); reference emplace_back(_Args&&... __args);
#else #else
void emplace_back(_Args&&... __args); void emplace_back(_Args&&... __args);
#endif #endif
template <class... _Args> template <class... _Args>
iterator emplace(const_iterator __p, _Args&&... __args); iterator emplace(const_iterator __p, _Args&&... __args);
iterator insert(const_iterator __p, value_type&& __x); iterator insert(const_iterator __p, value_type&& __x);
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lineslist<_Tp, _Alloc>::list(size_type __n)
for (; __n > 0; --__n) for (; __n > 0; --__n)
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
emplace_back(); emplace_back();
#else #else
push_back(value_type()); push_back(value_type());
#endif #endif
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : base(__a) list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : base(__a)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
for (; __n > 0; --__n) for (; __n > 0; --__n)
emplace_back(); emplace_back();
} }
#endif #endif
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Lineslist<_Tp, _Alloc>::push_back(value_type&& __x)
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x)); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
__link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link()); __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
++base::__sz(); ++base::__sz();
__hold.release(); __hold.release();
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
template <class... _Args> template <class... _Args>
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typename list<_Tp, _Alloc>::reference typename list<_Tp, _Alloc>::reference
#else #else
void void
#endif #endif
list<_Tp, _Alloc>::emplace_front(_Args&&... __args) list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
{ {
__node_allocator& __na = base::__node_alloc(); __node_allocator& __na = base::__node_alloc();
__hold_pointer __hold = __allocate_node(__na); __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
__link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link()); __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link());
++base::__sz(); ++base::__sz();
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
return __hold.release()->__value_; return __hold.release()->__value_;
#else #else
__hold.release(); __hold.release();
#endif #endif
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
template <class... _Args> template <class... _Args>
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typename list<_Tp, _Alloc>::reference typename list<_Tp, _Alloc>::reference
#else #else
void void
#endif #endif
list<_Tp, _Alloc>::emplace_back(_Args&&... __args) list<_Tp, _Alloc>::emplace_back(_Args&&... __args)
{ {
__node_allocator& __na = base::__node_alloc(); __node_allocator& __na = base::__node_alloc();
__hold_pointer __hold = __allocate_node(__na); __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
__link_pointer __nl = __hold->__as_link(); __link_pointer __nl = __hold->__as_link();
__link_nodes_at_back(__nl, __nl); __link_nodes_at_back(__nl, __nl);
++base::__sz(); ++base::__sz();
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
return __hold.release()->__value_; return __hold.release()->__value_;
#else #else
__hold.release(); __hold.release();
#endif #endif
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
template <class... _Args> template <class... _Args>
▲ Show 20 Lines • Show All 724 Lines • ▼ Show 20 Lines
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y) swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Tp, class _Allocator, class _Predicate> template <class _Tp, class _Allocator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type
erase_if(list<_Tp, _Allocator>& __c, _Predicate __pred) { erase_if(list<_Tp, _Allocator>& __c, _Predicate __pred) {
return __c.remove_if(__pred); return __c.remove_if(__pred);
} }
template <class _Tp, class _Allocator, class _Up> template <class _Tp, class _Allocator, class _Up>
inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type
erase(list<_Tp, _Allocator>& __c, const _Up& __v) { erase(list<_Tp, _Allocator>& __c, const _Up& __v) {
return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; }); return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; });
} }
template <> template <>
inline constexpr bool __format::__enable_insertable<std::list<char>> = true; inline constexpr bool __format::__enable_insertable<std::list<char>> = true;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
inline constexpr bool __format::__enable_insertable<std::list<wchar_t>> = true; inline constexpr bool __format::__enable_insertable<std::list<wchar_t>> = true;
#endif #endif
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
template <class _ValueT> template <class _ValueT>
using list = std::list<_ValueT, polymorphic_allocator<_ValueT>>; using list = std::list<_ValueT, polymorphic_allocator<_ValueT>>;
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif #endif
Show All 13 Lines

libcxx/include/map

Show First 20 Lines • Show All 595 Lines • ▼ Show 20 Lines bool operator()(const _Key& __x, const _CP& __y) const
{return static_cast<const _Compare&>(*this)(__x, __y.__get_value().first);} {return static_cast<const _Compare&>(*this)(__x, __y.__get_value().first);}
void swap(__map_value_compare& __y) void swap(__map_value_compare& __y)
_NOEXCEPT_(__is_nothrow_swappable<_Compare>::value) _NOEXCEPT_(__is_nothrow_swappable<_Compare>::value)
{ {
using _VSTD::swap; using _VSTD::swap;
swap(static_cast<_Compare&>(*this), static_cast<_Compare&>(__y)); swap(static_cast<_Compare&>(*this), static_cast<_Compare&>(__y));
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _K2& __x, const _CP& __y) const bool operator()(const _K2& __x, const _CP& __y) const
{return static_cast<const _Compare&>(*this)(__x, __y.__get_value().first);} {return static_cast<const _Compare&>(*this)(__x, __y.__get_value().first);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _CP& __x, const _K2& __y) const bool operator()(const _CP& __x, const _K2& __y) const
Show All 29 Lines bool operator()(const _Key& __x, const _CP& __y) const
{return __comp_(__x, __y.__get_value().first);} {return __comp_(__x, __y.__get_value().first);}
void swap(__map_value_compare& __y) void swap(__map_value_compare& __y)
_NOEXCEPT_(__is_nothrow_swappable<_Compare>::value) _NOEXCEPT_(__is_nothrow_swappable<_Compare>::value)
{ {
using _VSTD::swap; using _VSTD::swap;
swap(__comp_, __y.__comp_); swap(__comp_, __y.__comp_);
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _K2& __x, const _CP& __y) const bool operator()(const _K2& __x, const _CP& __y) const
{return __comp_(__x, __y.__get_value().first);} {return __comp_(__x, __y.__get_value().first);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _CP& __x, const _K2& __y) const bool operator()(const _CP& __x, const _K2& __y) const
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
private: private:
value_type __cc_; value_type __cc_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
value_type& __get_value() value_type& __get_value()
{ {
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
return *_VSTD::launder(_VSTD::addressof(__cc_)); return *_VSTD::launder(_VSTD::addressof(__cc_));
#else #else
return __cc_; return __cc_;
#endif #endif
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const value_type& __get_value() const const value_type& __get_value() const
{ {
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
return *_VSTD::launder(_VSTD::addressof(__cc_)); return *_VSTD::launder(_VSTD::addressof(__cc_));
#else #else
return __cc_; return __cc_;
#endif #endif
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__nc_ref_pair_type __ref() __nc_ref_pair_type __ref()
▲ Show 20 Lines • Show All 251 Lines • ▼ Show 20 Linespublic:
typedef typename __alloc_traits::const_pointer const_pointer; typedef typename __alloc_traits::const_pointer const_pointer;
typedef typename __alloc_traits::size_type size_type; typedef typename __alloc_traits::size_type size_type;
typedef typename __alloc_traits::difference_type difference_type; typedef typename __alloc_traits::difference_type difference_type;
typedef __map_iterator<typename __base::iterator> iterator; typedef __map_iterator<typename __base::iterator> iterator;
typedef __map_const_iterator<typename __base::const_iterator> const_iterator; typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator; typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typedef __map_node_handle<typename __base::__node, allocator_type> node_type; typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
typedef __insert_return_type<iterator, node_type> insert_return_type; typedef __insert_return_type<iterator, node_type> insert_return_type;
#endif #endif
template <class _Key2, class _Value2, class _Comp2, class _Alloc2> template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS map; friend class _LIBCPP_TEMPLATE_VIS map;
template <class _Key2, class _Value2, class _Comp2, class _Alloc2> template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS multimap; friend class _LIBCPP_TEMPLATE_VIS multimap;
Show All 30 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
map(_InputIterator __f, _InputIterator __l, map(_InputIterator __f, _InputIterator __l,
const key_compare& __comp, const allocator_type& __a) const key_compare& __comp, const allocator_type& __a)
: __tree_(__vc(__comp), typename __base::allocator_type(__a)) : __tree_(__vc(__comp), typename __base::allocator_type(__a))
{ {
insert(__f, __l); insert(__f, __l);
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
map(_InputIterator __f, _InputIterator __l, const allocator_type& __a) map(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
: map(__f, __l, key_compare(), __a) {} : map(__f, __l, key_compare(), __a) {}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
map(const map& __m) map(const map& __m)
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
map(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a) map(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
: __tree_(__vc(__comp), typename __base::allocator_type(__a)) : __tree_(__vc(__comp), typename __base::allocator_type(__a))
{ {
insert(__il.begin(), __il.end()); insert(__il.begin(), __il.end());
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
map(initializer_list<value_type> __il, const allocator_type& __a) map(initializer_list<value_type> __il, const allocator_type& __a)
: map(__il, key_compare(), __a) {} : map(__il, key_compare(), __a) {}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
map& operator=(initializer_list<value_type> __il) map& operator=(initializer_list<value_type> __il)
{ {
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines#endif
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void insert(_InputIterator __f, _InputIterator __l) void insert(_InputIterator __f, _InputIterator __l)
{ {
for (const_iterator __e = cend(); __f != __l; ++__f) for (const_iterator __e = cend(); __f != __l; ++__f)
insert(__e.__i_, *__f); insert(__e.__i_, *__f);
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class... _Args> template <class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args) pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args)
{ {
return __tree_.__emplace_unique_key_args(__k, return __tree_.__emplace_unique_key_args(__k,
_VSTD::piecewise_construct, _VSTD::piecewise_construct,
_VSTD::forward_as_tuple(__k), _VSTD::forward_as_tuple(__k),
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 Lines _LIBCPP_INLINE_VISIBILITY iterator insert_or_assign(const_iterator __h,
__h.__i_, __k, _VSTD::move(__k), _VSTD::forward<_Vp>(__v)); __h.__i_, __k, _VSTD::move(__k), _VSTD::forward<_Vp>(__v));
if (!__inserted) if (!__inserted)
__r->__get_value().second = _VSTD::forward<_Vp>(__v); __r->__get_value().second = _VSTD::forward<_Vp>(__v);
return __r; return __r;
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);} iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(iterator __p) {return __tree_.erase(__p.__i_);} iterator erase(iterator __p) {return __tree_.erase(__p.__i_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) size_type erase(const key_type& __k)
{return __tree_.__erase_unique(__k);} {return __tree_.__erase_unique(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __f, const_iterator __l) iterator erase(const_iterator __f, const_iterator __l)
{return __tree_.erase(__f.__i_, __l.__i_);} {return __tree_.erase(__f.__i_, __l.__i_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void clear() _NOEXCEPT {__tree_.clear();} void clear() _NOEXCEPT {__tree_.clear();}
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
insert_return_type insert(node_type&& __nh) insert_return_type insert(node_type&& __nh)
{ {
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
"node_type with incompatible allocator passed to map::insert()"); "node_type with incompatible allocator passed to map::insert()");
return __tree_.template __node_handle_insert_unique< return __tree_.template __node_handle_insert_unique<
node_type, insert_return_type>(_VSTD::move(__nh)); node_type, insert_return_type>(_VSTD::move(__nh));
} }
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines#endif
void swap(map& __m) void swap(map& __m)
_NOEXCEPT_(__is_nothrow_swappable<__base>::value) _NOEXCEPT_(__is_nothrow_swappable<__base>::value)
{__tree_.swap(__m.__tree_);} {__tree_.swap(__m.__tree_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __tree_.find(__k);} iterator find(const key_type& __k) {return __tree_.find(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __tree_.find(__k);} const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
find(const _K2& __k) {return __tree_.find(__k);} find(const _K2& __k) {return __tree_.find(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
find(const _K2& __k) const {return __tree_.find(__k);} find(const _K2& __k) const {return __tree_.find(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const size_type count(const key_type& __k) const
{return __tree_.__count_unique(__k);} {return __tree_.__count_unique(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, size_type> __enable_if_t<__is_transparent<_Compare, _K2>::value, size_type>
count(const _K2& __k) const {return __tree_.__count_multi(__k);} count(const _K2& __k) const {return __tree_.__count_multi(__k);}
#endif #endif
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const key_type& __k) const {return find(__k) != end();} bool contains(const key_type& __k) const {return find(__k) != end();}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, bool> __enable_if_t<__is_transparent<_Compare, _K2>::value, bool>
contains(const _K2& __k) const { return find(__k) != end(); } contains(const _K2& __k) const { return find(__k) != end(); }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator lower_bound(const key_type& __k) iterator lower_bound(const key_type& __k)
{return __tree_.lower_bound(__k);} {return __tree_.lower_bound(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator lower_bound(const key_type& __k) const const_iterator lower_bound(const key_type& __k) const
{return __tree_.lower_bound(__k);} {return __tree_.lower_bound(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);} lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);} lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator upper_bound(const key_type& __k) iterator upper_bound(const key_type& __k)
{return __tree_.upper_bound(__k);} {return __tree_.upper_bound(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator upper_bound(const key_type& __k) const const_iterator upper_bound(const key_type& __k) const
{return __tree_.upper_bound(__k);} {return __tree_.upper_bound(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);} upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);} upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator,iterator> equal_range(const key_type& __k) pair<iterator,iterator> equal_range(const key_type& __k)
{return __tree_.__equal_range_unique(__k);} {return __tree_.__equal_range_unique(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator,const_iterator> equal_range(const key_type& __k) const pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
{return __tree_.__equal_range_unique(__k);} {return __tree_.__equal_range_unique(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, pair<iterator,iterator>> __enable_if_t<__is_transparent<_Compare, _K2>::value, pair<iterator,iterator>>
equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);} equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, pair<const_iterator,const_iterator>> __enable_if_t<__is_transparent<_Compare, _K2>::value, pair<const_iterator,const_iterator>>
equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);} equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
▲ Show 20 Lines • Show All 192 Lines • ▼ Show 20 Lines
void void
swap(map<_Key, _Tp, _Compare, _Allocator>& __x, swap(map<_Key, _Tp, _Compare, _Allocator>& __x,
map<_Key, _Tp, _Compare, _Allocator>& __y) map<_Key, _Tp, _Compare, _Allocator>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Key, class _Tp, class _Compare, class _Allocator, template <class _Key, class _Tp, class _Compare, class _Allocator,
class _Predicate> class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename map<_Key, _Tp, _Compare, _Allocator>::size_type typename map<_Key, _Tp, _Compare, _Allocator>::size_type
erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred) { erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred) {
return _VSTD::__libcpp_erase_if_container(__c, __pred); return _VSTD::__libcpp_erase_if_container(__c, __pred);
} }
#endif #endif
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Linespublic:
typedef typename __alloc_traits::const_pointer const_pointer; typedef typename __alloc_traits::const_pointer const_pointer;
typedef typename __alloc_traits::size_type size_type; typedef typename __alloc_traits::size_type size_type;
typedef typename __alloc_traits::difference_type difference_type; typedef typename __alloc_traits::difference_type difference_type;
typedef __map_iterator<typename __base::iterator> iterator; typedef __map_iterator<typename __base::iterator> iterator;
typedef __map_const_iterator<typename __base::const_iterator> const_iterator; typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator; typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typedef __map_node_handle<typename __base::__node, allocator_type> node_type; typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
#endif #endif
template <class _Key2, class _Value2, class _Comp2, class _Alloc2> template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS map; friend class _LIBCPP_TEMPLATE_VIS map;
template <class _Key2, class _Value2, class _Comp2, class _Alloc2> template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS multimap; friend class _LIBCPP_TEMPLATE_VIS multimap;
Show All 29 Lines template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multimap(_InputIterator __f, _InputIterator __l, multimap(_InputIterator __f, _InputIterator __l,
const key_compare& __comp, const allocator_type& __a) const key_compare& __comp, const allocator_type& __a)
: __tree_(__vc(__comp), typename __base::allocator_type(__a)) : __tree_(__vc(__comp), typename __base::allocator_type(__a))
{ {
insert(__f, __l); insert(__f, __l);
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multimap(_InputIterator __f, _InputIterator __l, const allocator_type& __a) multimap(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
: multimap(__f, __l, key_compare(), __a) {} : multimap(__f, __l, key_compare(), __a) {}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multimap(const multimap& __m) multimap(const multimap& __m)
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multimap(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a) multimap(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
: __tree_(__vc(__comp), typename __base::allocator_type(__a)) : __tree_(__vc(__comp), typename __base::allocator_type(__a))
{ {
insert(__il.begin(), __il.end()); insert(__il.begin(), __il.end());
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multimap(initializer_list<value_type> __il, const allocator_type& __a) multimap(initializer_list<value_type> __il, const allocator_type& __a)
: multimap(__il, key_compare(), __a) {} : multimap(__il, key_compare(), __a) {}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multimap& operator=(initializer_list<value_type> __il) multimap& operator=(initializer_list<value_type> __il)
{ {
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(iterator __p) {return __tree_.erase(__p.__i_);} iterator erase(iterator __p) {return __tree_.erase(__p.__i_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);} size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __f, const_iterator __l) iterator erase(const_iterator __f, const_iterator __l)
{return __tree_.erase(__f.__i_, __l.__i_);} {return __tree_.erase(__f.__i_, __l.__i_);}
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator insert(node_type&& __nh) iterator insert(node_type&& __nh)
{ {
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
"node_type with incompatible allocator passed to multimap::insert()"); "node_type with incompatible allocator passed to multimap::insert()");
return __tree_.template __node_handle_insert_multi<node_type>( return __tree_.template __node_handle_insert_multi<node_type>(
_VSTD::move(__nh)); _VSTD::move(__nh));
} }
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines#endif
void swap(multimap& __m) void swap(multimap& __m)
_NOEXCEPT_(__is_nothrow_swappable<__base>::value) _NOEXCEPT_(__is_nothrow_swappable<__base>::value)
{__tree_.swap(__m.__tree_);} {__tree_.swap(__m.__tree_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __tree_.find(__k);} iterator find(const key_type& __k) {return __tree_.find(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __tree_.find(__k);} const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
find(const _K2& __k) {return __tree_.find(__k);} find(const _K2& __k) {return __tree_.find(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
find(const _K2& __k) const {return __tree_.find(__k);} find(const _K2& __k) const {return __tree_.find(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const size_type count(const key_type& __k) const
{return __tree_.__count_multi(__k);} {return __tree_.__count_multi(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, size_type> __enable_if_t<__is_transparent<_Compare, _K2>::value, size_type>
count(const _K2& __k) const {return __tree_.__count_multi(__k);} count(const _K2& __k) const {return __tree_.__count_multi(__k);}
#endif #endif
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const key_type& __k) const {return find(__k) != end();} bool contains(const key_type& __k) const {return find(__k) != end();}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, bool> __enable_if_t<__is_transparent<_Compare, _K2>::value, bool>
contains(const _K2& __k) const { return find(__k) != end(); } contains(const _K2& __k) const { return find(__k) != end(); }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator lower_bound(const key_type& __k) iterator lower_bound(const key_type& __k)
{return __tree_.lower_bound(__k);} {return __tree_.lower_bound(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator lower_bound(const key_type& __k) const const_iterator lower_bound(const key_type& __k) const
{return __tree_.lower_bound(__k);} {return __tree_.lower_bound(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);} lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);} lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator upper_bound(const key_type& __k) iterator upper_bound(const key_type& __k)
{return __tree_.upper_bound(__k);} {return __tree_.upper_bound(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator upper_bound(const key_type& __k) const const_iterator upper_bound(const key_type& __k) const
{return __tree_.upper_bound(__k);} {return __tree_.upper_bound(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);} upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator> __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);} upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator,iterator> equal_range(const key_type& __k) pair<iterator,iterator> equal_range(const key_type& __k)
{return __tree_.__equal_range_multi(__k);} {return __tree_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator,const_iterator> equal_range(const key_type& __k) const pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
{return __tree_.__equal_range_multi(__k);} {return __tree_.__equal_range_multi(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, pair<iterator,iterator>> __enable_if_t<__is_transparent<_Compare, _K2>::value, pair<iterator,iterator>>
equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);} equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__enable_if_t<__is_transparent<_Compare, _K2>::value, pair<const_iterator,const_iterator>> __enable_if_t<__is_transparent<_Compare, _K2>::value, pair<const_iterator,const_iterator>>
equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);} equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines
void void
swap(multimap<_Key, _Tp, _Compare, _Allocator>& __x, swap(multimap<_Key, _Tp, _Compare, _Allocator>& __x,
multimap<_Key, _Tp, _Compare, _Allocator>& __y) multimap<_Key, _Tp, _Compare, _Allocator>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Key, class _Tp, class _Compare, class _Allocator, template <class _Key, class _Tp, class _Compare, class _Allocator,
class _Predicate> class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename multimap<_Key, _Tp, _Compare, _Allocator>::size_type typename multimap<_Key, _Tp, _Compare, _Allocator>::size_type
erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c, erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c,
_Predicate __pred) { _Predicate __pred) {
return _VSTD::__libcpp_erase_if_container(__c, __pred); return _VSTD::__libcpp_erase_if_container(__c, __pred);
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
template <class _KeyT, class _ValueT, class _CompareT = std::less<_KeyT>> template <class _KeyT, class _ValueT, class _CompareT = std::less<_KeyT>>
using map = std::map<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>; using map = std::map<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
template <class _KeyT, class _ValueT, class _CompareT = std::less<_KeyT>> template <class _KeyT, class _ValueT, class _CompareT = std::less<_KeyT>>
using multimap = std::multimap<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>; using multimap = std::multimap<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
} // namespace pmr } // namespace pmr
Show All 11 Lines

libcxx/include/mutex

Show First 20 Lines • Show All 461 Lines • ▼ Show 20 Lines
void __unlock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) { void __unlock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
__l0.unlock(); __l0.unlock();
__l1.unlock(); __l1.unlock();
_VSTD::__unlock(__l2, __l3...); _VSTD::__unlock(__l2, __l3...);
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class ..._Mutexes> template <class ..._Mutexes>
class _LIBCPP_TEMPLATE_VIS scoped_lock; class _LIBCPP_TEMPLATE_VIS scoped_lock;
template <> template <>
class _LIBCPP_TEMPLATE_VIS scoped_lock<> { class _LIBCPP_TEMPLATE_VIS scoped_lock<> {
public: public:
explicit scoped_lock() {} explicit scoped_lock() {}
~scoped_lock() = default; ~scoped_lock() = default;
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Linesprivate:
static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& __mt) { static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& __mt) {
_VSTD::__unlock(_VSTD::get<_Indx>(__mt)...); _VSTD::__unlock(_VSTD::get<_Indx>(__mt)...);
} }
_MutexTuple __t_; _MutexTuple __t_;
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scoped_lock); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scoped_lock);
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#endif // !_LIBCPP_HAS_NO_THREADS #endif // !_LIBCPP_HAS_NO_THREADS
struct _LIBCPP_TEMPLATE_VIS once_flag; struct _LIBCPP_TEMPLATE_VIS once_flag;
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template<class _Callable, class... _Args> template<class _Callable, class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 157 Lines • Show Last 20 Lines

libcxx/include/new

Show First 20 Lines • Show All 183 Lines • ▼ Show 20 Lines#if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) && \
!defined(_LIBCPP_ABI_VCRUNTIME) !defined(_LIBCPP_ABI_VCRUNTIME)
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
enum class _LIBCPP_ENUM_VIS align_val_t : size_t { }; enum class _LIBCPP_ENUM_VIS align_val_t : size_t { };
#else #else
enum align_val_t { __zero = 0, __max = (size_t)-1 }; enum align_val_t { __zero = 0, __max = (size_t)-1 };
#endif #endif
#endif #endif
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
// Enable the declaration even if the compiler doesn't support the language // Enable the declaration even if the compiler doesn't support the language
// feature. // feature.
struct destroying_delete_t { struct destroying_delete_t {
explicit destroying_delete_t() = default; explicit destroying_delete_t() = default;
}; };
inline constexpr destroying_delete_t destroying_delete{}; inline constexpr destroying_delete_t destroying_delete{};
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
} // namespace std } // namespace std
#if defined(_LIBCPP_CXX03_LANG) #if defined(_LIBCPP_CXX03_LANG)
#define _THROW_BAD_ALLOC throw(std::bad_alloc) #define _THROW_BAD_ALLOC throw(std::bad_alloc)
#else #else
#define _THROW_BAD_ALLOC #define _THROW_BAD_ALLOC
#endif #endif
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines
_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI
_LIBCPP_CONSTEXPR _Tp* __launder(_Tp* __p) _NOEXCEPT _LIBCPP_CONSTEXPR _Tp* __launder(_Tp* __p) _NOEXCEPT
{ {
static_assert (!(is_function<_Tp>::value), "can't launder functions" ); static_assert (!(is_function<_Tp>::value), "can't launder functions" );
static_assert (!(is_same<void, __remove_cv_t<_Tp> >::value), "can't launder cv-void" ); static_assert (!(is_same<void, __remove_cv_t<_Tp> >::value), "can't launder cv-void" );
return __builtin_launder(__p); return __builtin_launder(__p);
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI
constexpr _Tp* launder(_Tp* __p) noexcept constexpr _Tp* launder(_Tp* __p) noexcept
{ {
return _VSTD::__launder(__p); return _VSTD::__launder(__p);
} }
#endif #endif
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
#if defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE) #if defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
inline constexpr size_t hardware_destructive_interference_size = __GCC_DESTRUCTIVE_SIZE; inline constexpr size_t hardware_destructive_interference_size = __GCC_DESTRUCTIVE_SIZE;
inline constexpr size_t hardware_constructive_interference_size = __GCC_CONSTRUCTIVE_SIZE; inline constexpr size_t hardware_constructive_interference_size = __GCC_CONSTRUCTIVE_SIZE;
#endif // defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE) #endif // defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_NEW #endif // _LIBCPP_NEW

libcxx/include/numbers

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
} }
*/ */
#include <__assert> // all public C++ headers provide the assertion handler #include <__assert> // all public C++ headers provide the assertion handler
#include <__concepts/arithmetic.h> #include <__concepts/arithmetic.h>
#include <__config> #include <__config>
#include <version> #include <version>
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
#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 #endif // _LIBCPP_STD_VER >= 20
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <concepts> # include <concepts>
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_NUMBERS #endif // _LIBCPP_NUMBERS

libcxx/include/optional

Show First 20 Lines • Show All 194 Lines • ▼ Show 20 Lines
public: public:
// Get the key function ~bad_optional_access() into the dylib // Get the key function ~bad_optional_access() into the dylib
~bad_optional_access() _NOEXCEPT override; ~bad_optional_access() _NOEXCEPT override;
const char* what() const _NOEXCEPT override; const char* what() const _NOEXCEPT override;
}; };
} // namespace std } // namespace std
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_NORETURN _LIBCPP_NORETURN
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
void __throw_bad_optional_access() { void __throw_bad_optional_access() {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_NO_EXCEPTIONS
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines constexpr __optional_destruct_base() noexcept
__engaged_(false) {} __engaged_(false) {}
template <class... _Args> template <class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
: __val_(_VSTD::forward<_Args>(__args)...), : __val_(_VSTD::forward<_Args>(__args)...),
__engaged_(true) {} __engaged_(true) {}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _Fp, class... _Args> template <class _Fp, class... _Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
: __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {} : __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept
Show All 25 Lines constexpr __optional_destruct_base() noexcept
__engaged_(false) {} __engaged_(false) {}
template <class... _Args> template <class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args) constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
: __val_(_VSTD::forward<_Args>(__args)...), : __val_(_VSTD::forward<_Args>(__args)...),
__engaged_(true) {} __engaged_(true) {}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _Fp, class... _Args> template <class _Fp, class... _Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
: __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {} : __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept
Show All 39 Lines constexpr const value_type&& __get() const&& noexcept
return _VSTD::move(this->__val_); return _VSTD::move(this->__val_);
} }
template <class... _Args> template <class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_Args&&... __args) _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_Args&&... __args)
{ {
_LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage"); _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_VSTD::construct_at(_VSTD::addressof(this->__val_), _VSTD::forward<_Args>(__args)...); _VSTD::construct_at(_VSTD::addressof(this->__val_), _VSTD::forward<_Args>(__args)...);
#else #else
::new ((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...); ::new ((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...);
#endif #endif
this->__engaged_ = true; this->__engaged_ = true;
} }
template <class _That> template <class _That>
▲ Show 20 Lines • Show All 431 Lines • ▼ Show 20 Lines template <class _Up, enable_if_t<
_CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>() _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>()
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
_LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v) _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v)
{ {
this->__construct_from(_VSTD::move(__v)); this->__construct_from(_VSTD::move(__v));
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template<class _Fp, class... _Args> template<class _Fp, class... _Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr explicit optional(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) constexpr explicit optional(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
: __base(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...) { : __base(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...) {
} }
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 225 Lines • ▼ Show 20 Lines constexpr value_type value_or(_Up&& __v) &&
static_assert(is_move_constructible_v<value_type>, static_assert(is_move_constructible_v<value_type>,
"optional<T>::value_or: T must be move constructible"); "optional<T>::value_or: T must be move constructible");
static_assert(is_convertible_v<_Up, value_type>, static_assert(is_convertible_v<_Up, value_type>,
"optional<T>::value_or: U must be convertible to T"); "optional<T>::value_or: U must be convertible to T");
return this->has_value() ? _VSTD::move(this->__get()) : return this->has_value() ? _VSTD::move(this->__get()) :
static_cast<value_type>(_VSTD::forward<_Up>(__v)); static_cast<value_type>(_VSTD::forward<_Up>(__v));
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template<class _Func> template<class _Func>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
constexpr auto and_then(_Func&& __f) & { constexpr auto and_then(_Func&& __f) & {
using _Up = invoke_result_t<_Func, value_type&>; using _Up = invoke_result_t<_Func, value_type&>;
static_assert(__is_std_optional<remove_cvref_t<_Up>>::value, static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
"Result of f(value()) must be a specialization of std::optional"); "Result of f(value()) must be a specialization of std::optional");
if (*this) if (*this)
return _VSTD::invoke(_VSTD::forward<_Func>(__f), value()); return _VSTD::invoke(_VSTD::forward<_Func>(__f), value());
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Lines#if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr optional or_else(_Func&& __f) && requires is_move_constructible_v<value_type> { constexpr optional or_else(_Func&& __f) && requires is_move_constructible_v<value_type> {
static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>, static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
"Result of f() should be the same type as this optional"); "Result of f() should be the same type as this optional");
if (*this) if (*this)
return _VSTD::move(*this); return _VSTD::move(*this);
return _VSTD::forward<_Func>(__f)(); return _VSTD::forward<_Func>(__f)();
} }
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
using __base::reset; using __base::reset;
}; };
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template<class _Tp> template<class _Tp>
optional(_Tp) -> optional<_Tp>; optional(_Tp) -> optional<_Tp>;
#endif #endif
▲ Show 20 Lines • Show All 384 Lines • ▼ Show 20 Lines#endif
size_t operator()(const optional<_Tp>& __opt) const size_t operator()(const optional<_Tp>& __opt) const
{ {
return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0; return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0;
} }
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <atomic> # include <atomic>
# include <climits> # include <climits>
# include <concepts> # include <concepts>
# include <ctime> # include <ctime>
# include <iterator> # include <iterator>
# include <memory> # include <memory>
# include <ratio> # include <ratio>
# include <tuple> # include <tuple>
# include <typeinfo> # include <typeinfo>
# include <utility> # include <utility>
# include <variant> # include <variant>
#endif #endif
#endif // _LIBCPP_OPTIONAL #endif // _LIBCPP_OPTIONAL

libcxx/include/ostream

Show First 20 Lines • Show All 238 Lines • ▼ Show 20 Linespublic:
basic_ostream& operator<<(unsigned long __n); basic_ostream& operator<<(unsigned long __n);
basic_ostream& operator<<(long long __n); basic_ostream& operator<<(long long __n);
basic_ostream& operator<<(unsigned long long __n); basic_ostream& operator<<(unsigned long long __n);
basic_ostream& operator<<(float __f); basic_ostream& operator<<(float __f);
basic_ostream& operator<<(double __f); basic_ostream& operator<<(double __f);
basic_ostream& operator<<(long double __f); basic_ostream& operator<<(long double __f);
basic_ostream& operator<<(const void* __p); basic_ostream& operator<<(const void* __p);
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
basic_ostream& operator<<(const volatile void* __p) { basic_ostream& operator<<(const volatile void* __p) {
return operator<<(const_cast<const void*>(__p)); return operator<<(const_cast<const void*>(__p));
} }
#endif #endif
basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb); basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
// LWG 2221 - nullptr. This is not backported to older standards modes. // LWG 2221 - nullptr. This is not backported to older standards modes.
// See https://reviews.llvm.org/D127033 for more info on the rationale. // See https://reviews.llvm.org/D127033 for more info on the rationale.
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
basic_ostream& operator<<(nullptr_t) basic_ostream& operator<<(nullptr_t)
{ return *this << "nullptr"; } { return *this << "nullptr"; }
#endif #endif
// 27.7.2.7 Unformatted output: // 27.7.2.7 Unformatted output:
▲ Show 20 Lines • Show All 860 Lines • ▼ Show 20 Lines
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x) operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
{ {
return __os << __x.template to_string<_CharT, _Traits> return __os << __x.template to_string<_CharT, _Traits>
(std::use_facet<ctype<_CharT> >(__os.getloc()).widen('0'), (std::use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
std::use_facet<ctype<_CharT> >(__os.getloc()).widen('1')); std::use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class _Traits> template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete; basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;
template <class _Traits> template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete; basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;
Show All 32 Lines
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete; basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;
template <class _Traits> template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete; basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;
template <class _Traits> template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete; basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>; extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <concepts> # include <concepts>
# include <iterator> # include <iterator>
# include <type_traits> # include <type_traits>
#endif #endif
#endif // _LIBCPP_OSTREAM #endif // _LIBCPP_OSTREAM

libcxx/include/queue

Show First 20 Lines • Show All 272 Lines • ▼ Show 20 Linespublic:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
queue() queue()
_NOEXCEPT_(is_nothrow_default_constructible<container_type>::value) _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
: c() {} : c() {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
queue(const queue& __q) : c(__q.c) {} queue(const queue& __q) : c(__q.c) {}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _InputIterator, template <class _InputIterator,
class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>> class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
queue(_InputIterator __first, _InputIterator __last) : c(__first, __last) {} queue(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
template <class _InputIterator, template <class _InputIterator,
class _Alloc, class _Alloc,
class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void push(const value_type& __v) {c.push_back(__v);} void push(const value_type& __v) {c.push_back(__v);}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void push(value_type&& __v) {c.push_back(_VSTD::move(__v));} void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
template <class... _Args> template <class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
decltype(auto) emplace(_Args&&... __args) decltype(auto) emplace(_Args&&... __args)
{ return c.emplace_back(_VSTD::forward<_Args>(__args)...);} { return c.emplace_back(_VSTD::forward<_Args>(__args)...);}
#else #else
void emplace(_Args&&... __args) void emplace(_Args&&... __args)
{ c.emplace_back(_VSTD::forward<_Args>(__args)...);} { c.emplace_back(_VSTD::forward<_Args>(__args)...);}
#endif #endif
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
Show All 17 Lines#endif // _LIBCPP_CXX03_LANG
template <class _T1, class _C1> template <class _T1, class _C1>
friend friend
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool bool
operator< (const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y); operator< (const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template<class _Container, template<class _Container,
class = enable_if_t<!__is_allocator<_Container>::value> class = enable_if_t<!__is_allocator<_Container>::value>
> >
queue(_Container) queue(_Container)
-> queue<typename _Container::value_type, _Container>; -> queue<typename _Container::value_type, _Container>;
template<class _Container, template<class _Container,
class _Alloc, class _Alloc,
class = enable_if_t<!__is_allocator<_Container>::value>, class = enable_if_t<!__is_allocator<_Container>::value>,
class = enable_if_t<uses_allocator<_Container, _Alloc>::value> class = enable_if_t<uses_allocator<_Container, _Alloc>::value>
> >
queue(_Container, _Alloc) queue(_Container, _Alloc)
-> queue<typename _Container::value_type, _Container>; -> queue<typename _Container::value_type, _Container>;
#endif #endif
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _InputIterator, template <class _InputIterator,
class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>> class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>>
queue(_InputIterator, _InputIterator) queue(_InputIterator, _InputIterator)
-> queue<__iter_value_type<_InputIterator>>; -> queue<__iter_value_type<_InputIterator>>;
template <class _InputIterator, template <class _InputIterator,
class _Alloc, class _Alloc,
class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
▲ Show 20 Lines • Show All 546 Lines • Show Last 20 Lines

libcxx/include/ratio

Show First 20 Lines • Show All 495 Lines • ▼ Show 20 Lines
template <class _R1, class _R2> template <class _R1, class _R2>
struct __ratio_gcd struct __ratio_gcd
{ {
typedef ratio<__static_gcd<_R1::num, _R2::num>::value, typedef ratio<__static_gcd<_R1::num, _R2::num>::value,
__static_lcm<_R1::den, _R2::den>::value> type; __static_lcm<_R1::den, _R2::den>::value> type;
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _R1, class _R2> template <class _R1, class _R2>
inline constexpr bool ratio_equal_v = ratio_equal<_R1, _R2>::value; inline constexpr bool ratio_equal_v = ratio_equal<_R1, _R2>::value;
template <class _R1, class _R2> template <class _R1, class _R2>
inline constexpr bool ratio_not_equal_v = ratio_not_equal<_R1, _R2>::value; inline constexpr bool ratio_not_equal_v = ratio_not_equal<_R1, _R2>::value;
template <class _R1, class _R2> template <class _R1, class _R2>
inline constexpr bool ratio_less_v = ratio_less<_R1, _R2>::value; inline constexpr bool ratio_less_v = ratio_less<_R1, _R2>::value;
Show All 20 Lines

libcxx/include/regex

Show First 20 Lines • Show All 6,208 Lines • ▼ Show 20 Linesregex_search(const basic_string<_CharT, _ST, _SA>& __s,
regex_constants::match_flag_type __flags = regex_constants::match_default) regex_constants::match_flag_type __flags = regex_constants::match_default)
{ {
match_results<const _CharT*> __mc; match_results<const _CharT*> __mc;
bool __r = __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags); bool __r = __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
__m.__assign(__s.begin(), __s.end(), __mc, __flags & regex_constants::__no_update_pos); __m.__assign(__s.begin(), __s.end(), __mc, __flags & regex_constants::__no_update_pos);
return __r; return __r;
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _ST, class _SA, class _Ap, class _Cp, class _Tp> template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
bool bool
regex_search(const basic_string<_Cp, _ST, _SA>&& __s, regex_search(const basic_string<_Cp, _ST, _SA>&& __s,
match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&, match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
const basic_regex<_Cp, _Tp>& __e, const basic_regex<_Cp, _Tp>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default) = delete; regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
#endif #endif
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
regex_match(const basic_string<_CharT, _ST, _SA>& __s, regex_match(const basic_string<_CharT, _ST, _SA>& __s,
match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m, match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e, const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default) regex_constants::match_flag_type __flags = regex_constants::match_default)
{ {
return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags); return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits> template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool bool
regex_match(const basic_string<_CharT, _ST, _SA>&& __s, regex_match(const basic_string<_CharT, _ST, _SA>&& __s,
match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m, match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e, const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default) = delete; regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
#endif #endif
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Linesprivate:
value_type __match_; value_type __match_;
public: public:
regex_iterator(); regex_iterator();
regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re, const regex_type& __re,
regex_constants::match_flag_type __m regex_constants::match_flag_type __m
= regex_constants::match_default); = regex_constants::match_default);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type&& __re, const regex_type&& __re,
regex_constants::match_flag_type __m regex_constants::match_flag_type __m
= regex_constants::match_default) = delete; = regex_constants::match_default) = delete;
#endif #endif
bool operator==(const regex_iterator& __x) const; bool operator==(const regex_iterator& __x) const;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Linesprivate:
vector<int> __subs_; vector<int> __subs_;
public: public:
regex_token_iterator(); regex_token_iterator();
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re, int __submatch = 0, const regex_type& __re, int __submatch = 0,
regex_constants::match_flag_type __m = regex_constants::match_flag_type __m =
regex_constants::match_default); regex_constants::match_default);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type&& __re, int __submatch = 0, const regex_type&& __re, int __submatch = 0,
regex_constants::match_flag_type __m = regex_constants::match_flag_type __m =
regex_constants::match_default) = delete; regex_constants::match_default) = delete;
#endif #endif
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re, const vector<int>& __submatches, const regex_type& __re, const vector<int>& __submatches,
regex_constants::match_flag_type __m = regex_constants::match_flag_type __m =
regex_constants::match_default); regex_constants::match_default);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type&& __re, const vector<int>& __submatches, const regex_type&& __re, const vector<int>& __submatches,
regex_constants::match_flag_type __m = regex_constants::match_flag_type __m =
regex_constants::match_default) = delete; regex_constants::match_default) = delete;
#endif #endif
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type& __re, const regex_type& __re,
initializer_list<int> __submatches, initializer_list<int> __submatches,
regex_constants::match_flag_type __m = regex_constants::match_flag_type __m =
regex_constants::match_default); regex_constants::match_default);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b, regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
const regex_type&& __re, const regex_type&& __re,
initializer_list<int> __submatches, initializer_list<int> __submatches,
regex_constants::match_flag_type __m = regex_constants::match_flag_type __m =
regex_constants::match_default) = delete; regex_constants::match_default) = delete;
#endif #endif
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <size_t _Np> template <size_t _Np>
regex_token_iterator(_BidirectionalIterator __a, regex_token_iterator(_BidirectionalIterator __a,
_BidirectionalIterator __b, _BidirectionalIterator __b,
const regex_type& __re, const regex_type& __re,
const int (&__submatches)[_Np], const int (&__submatches)[_Np],
regex_constants::match_flag_type __m = regex_constants::match_flag_type __m =
regex_constants::match_default); regex_constants::match_default);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <size_t _Np> template <size_t _Np>
regex_token_iterator(_BidirectionalIterator __a, regex_token_iterator(_BidirectionalIterator __a,
_BidirectionalIterator __b, _BidirectionalIterator __b,
const regex_type&& __re, const regex_type&& __re,
const int (&__submatches)[_Np], const int (&__submatches)[_Np],
regex_constants::match_flag_type __m = regex_constants::match_flag_type __m =
regex_constants::match_default) = delete; regex_constants::match_default) = delete;
#endif #endif
▲ Show 20 Lines • Show All 305 Lines • ▼ Show 20 Linesregex_replace(const _CharT* __s,
_VSTD::regex_replace(std::back_inserter(__r), __s, _VSTD::regex_replace(std::back_inserter(__r), __s,
__s + char_traits<_CharT>::length(__s), __e, __s + char_traits<_CharT>::length(__s), __e,
__fmt, __flags); __fmt, __flags);
return __r; return __r;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
template <class _BidirT> template <class _BidirT>
using match_results = std::match_results<_BidirT, polymorphic_allocator<std::sub_match<_BidirT>>>; using match_results = std::match_results<_BidirT, polymorphic_allocator<std::sub_match<_BidirT>>>;
using cmatch = match_results<const char*>; using cmatch = match_results<const char*>;
using smatch = match_results<std::pmr::string::const_iterator>; using smatch = match_results<std::pmr::string::const_iterator>;
Show All 22 Lines

libcxx/include/scoped_allocator

Show First 20 Lines • Show All 672 Lines • ▼ Show 20 Linesprivate:
{ {
using _Tup = tuple<_Args&&..., inner_allocator_type&>; using _Tup = tuple<_Args&&..., inner_allocator_type&>;
return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., inner_allocator()); return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., inner_allocator());
} }
template <class...> friend class __scoped_allocator_storage; template <class...> friend class __scoped_allocator_storage;
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template<class _OuterAlloc, class... _InnerAllocs> template<class _OuterAlloc, class... _InnerAllocs>
scoped_allocator_adaptor(_OuterAlloc, _InnerAllocs...) scoped_allocator_adaptor(_OuterAlloc, _InnerAllocs...)
-> scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>; -> scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>;
#endif #endif
template <class _OuterA1, class _OuterA2> template <class _OuterA1, class _OuterA2>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
bool bool
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/include/set

Show First 20 Lines • Show All 541 Lines • ▼ Show 20 Linespublic:
typedef typename __base::const_pointer const_pointer; typedef typename __base::const_pointer const_pointer;
typedef typename __base::size_type size_type; typedef typename __base::size_type size_type;
typedef typename __base::difference_type difference_type; typedef typename __base::difference_type difference_type;
typedef typename __base::const_iterator iterator; typedef typename __base::const_iterator iterator;
typedef typename __base::const_iterator const_iterator; typedef typename __base::const_iterator const_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator; typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typedef __set_node_handle<typename __base::__node, allocator_type> node_type; typedef __set_node_handle<typename __base::__node, allocator_type> node_type;
typedef __insert_return_type<iterator, node_type> insert_return_type; typedef __insert_return_type<iterator, node_type> insert_return_type;
#endif #endif
template <class _Key2, class _Compare2, class _Alloc2> template <class _Key2, class _Compare2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS set; friend class _LIBCPP_TEMPLATE_VIS set;
template <class _Key2, class _Compare2, class _Alloc2> template <class _Key2, class _Compare2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS multiset; friend class _LIBCPP_TEMPLATE_VIS multiset;
Show All 29 Lines template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
set(_InputIterator __f, _InputIterator __l, const value_compare& __comp, set(_InputIterator __f, _InputIterator __l, const value_compare& __comp,
const allocator_type& __a) const allocator_type& __a)
: __tree_(__comp, __a) : __tree_(__comp, __a)
{ {
insert(__f, __l); insert(__f, __l);
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
set(_InputIterator __f, _InputIterator __l, const allocator_type& __a) set(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
: set(__f, __l, key_compare(), __a) {} : set(__f, __l, key_compare(), __a) {}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
set(const set& __s) set(const set& __s)
Show All 40 Lines#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
set(initializer_list<value_type> __il, const value_compare& __comp, set(initializer_list<value_type> __il, const value_compare& __comp,
const allocator_type& __a) const allocator_type& __a)
: __tree_(__comp, __a) : __tree_(__comp, __a)
{ {
insert(__il.begin(), __il.end()); insert(__il.begin(), __il.end());
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
set(initializer_list<value_type> __il, const allocator_type& __a) set(initializer_list<value_type> __il, const allocator_type& __a)
: set(__il, key_compare(), __a) {} : set(__il, key_compare(), __a) {}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
set& operator=(initializer_list<value_type> __il) set& operator=(initializer_list<value_type> __il)
{ {
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines#endif // _LIBCPP_CXX03_LANG
size_type erase(const key_type& __k) size_type erase(const key_type& __k)
{return __tree_.__erase_unique(__k);} {return __tree_.__erase_unique(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __f, const_iterator __l) iterator erase(const_iterator __f, const_iterator __l)
{return __tree_.erase(__f, __l);} {return __tree_.erase(__f, __l);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void clear() _NOEXCEPT {__tree_.clear();} void clear() _NOEXCEPT {__tree_.clear();}
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
insert_return_type insert(node_type&& __nh) insert_return_type insert(node_type&& __nh)
{ {
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
"node_type with incompatible allocator passed to set::insert()"); "node_type with incompatible allocator passed to set::insert()");
return __tree_.template __node_handle_insert_unique< return __tree_.template __node_handle_insert_unique<
node_type, insert_return_type>(_VSTD::move(__nh)); node_type, insert_return_type>(_VSTD::move(__nh));
} }
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
value_compare value_comp() const {return __tree_.value_comp();} value_compare value_comp() const {return __tree_.value_comp();}
// set operations: // set operations:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __tree_.find(__k);} iterator find(const key_type& __k) {return __tree_.find(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __tree_.find(__k);} const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
find(const _K2& __k) {return __tree_.find(__k);} find(const _K2& __k) {return __tree_.find(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
find(const _K2& __k) const {return __tree_.find(__k);} find(const _K2& __k) const {return __tree_.find(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const size_type count(const key_type& __k) const
{return __tree_.__count_unique(__k);} {return __tree_.__count_unique(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
count(const _K2& __k) const {return __tree_.__count_multi(__k);} count(const _K2& __k) const {return __tree_.__count_multi(__k);}
#endif #endif
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const key_type& __k) const {return find(__k) != end();} bool contains(const key_type& __k) const {return find(__k) != end();}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
contains(const _K2& __k) const { return find(__k) != end(); } contains(const _K2& __k) const { return find(__k) != end(); }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator lower_bound(const key_type& __k) iterator lower_bound(const key_type& __k)
{return __tree_.lower_bound(__k);} {return __tree_.lower_bound(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator lower_bound(const key_type& __k) const const_iterator lower_bound(const key_type& __k) const
{return __tree_.lower_bound(__k);} {return __tree_.lower_bound(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);} lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);} lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator upper_bound(const key_type& __k) iterator upper_bound(const key_type& __k)
{return __tree_.upper_bound(__k);} {return __tree_.upper_bound(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator upper_bound(const key_type& __k) const const_iterator upper_bound(const key_type& __k) const
{return __tree_.upper_bound(__k);} {return __tree_.upper_bound(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);} upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);} upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator,iterator> equal_range(const key_type& __k) pair<iterator,iterator> equal_range(const key_type& __k)
{return __tree_.__equal_range_unique(__k);} {return __tree_.__equal_range_unique(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator,const_iterator> equal_range(const key_type& __k) const pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
{return __tree_.__equal_range_unique(__k);} {return __tree_.__equal_range_unique(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);} equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);} equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines
void void
swap(set<_Key, _Compare, _Allocator>& __x, swap(set<_Key, _Compare, _Allocator>& __x,
set<_Key, _Compare, _Allocator>& __y) set<_Key, _Compare, _Allocator>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Key, class _Compare, class _Allocator, class _Predicate> template <class _Key, class _Compare, class _Allocator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename set<_Key, _Compare, _Allocator>::size_type typename set<_Key, _Compare, _Allocator>::size_type
erase_if(set<_Key, _Compare, _Allocator>& __c, _Predicate __pred) { erase_if(set<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
return _VSTD::__libcpp_erase_if_container(__c, __pred); return _VSTD::__libcpp_erase_if_container(__c, __pred);
} }
#endif #endif
Show All 29 Linespublic:
typedef typename __base::const_pointer const_pointer; typedef typename __base::const_pointer const_pointer;
typedef typename __base::size_type size_type; typedef typename __base::size_type size_type;
typedef typename __base::difference_type difference_type; typedef typename __base::difference_type difference_type;
typedef typename __base::const_iterator iterator; typedef typename __base::const_iterator iterator;
typedef typename __base::const_iterator const_iterator; typedef typename __base::const_iterator const_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator; typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator; typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typedef __set_node_handle<typename __base::__node, allocator_type> node_type; typedef __set_node_handle<typename __base::__node, allocator_type> node_type;
#endif #endif
template <class _Key2, class _Compare2, class _Alloc2> template <class _Key2, class _Compare2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS set; friend class _LIBCPP_TEMPLATE_VIS set;
template <class _Key2, class _Compare2, class _Alloc2> template <class _Key2, class _Compare2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS multiset; friend class _LIBCPP_TEMPLATE_VIS multiset;
Show All 20 Lines template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multiset(_InputIterator __f, _InputIterator __l, multiset(_InputIterator __f, _InputIterator __l,
const value_compare& __comp = value_compare()) const value_compare& __comp = value_compare())
: __tree_(__comp) : __tree_(__comp)
{ {
insert(__f, __l); insert(__f, __l);
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multiset(_InputIterator __f, _InputIterator __l, const allocator_type& __a) multiset(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
: multiset(__f, __l, key_compare(), __a) {} : multiset(__f, __l, key_compare(), __a) {}
#endif #endif
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multiset(initializer_list<value_type> __il, const value_compare& __comp, multiset(initializer_list<value_type> __il, const value_compare& __comp,
const allocator_type& __a) const allocator_type& __a)
: __tree_(__comp, __a) : __tree_(__comp, __a)
{ {
insert(__il.begin(), __il.end()); insert(__il.begin(), __il.end());
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multiset(initializer_list<value_type> __il, const allocator_type& __a) multiset(initializer_list<value_type> __il, const allocator_type& __a)
: multiset(__il, key_compare(), __a) {} : multiset(__il, key_compare(), __a) {}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
multiset& operator=(initializer_list<value_type> __il) multiset& operator=(initializer_list<value_type> __il)
{ {
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);} size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __f, const_iterator __l) iterator erase(const_iterator __f, const_iterator __l)
{return __tree_.erase(__f, __l);} {return __tree_.erase(__f, __l);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void clear() _NOEXCEPT {__tree_.clear();} void clear() _NOEXCEPT {__tree_.clear();}
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator insert(node_type&& __nh) iterator insert(node_type&& __nh)
{ {
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
"node_type with incompatible allocator passed to multiset::insert()"); "node_type with incompatible allocator passed to multiset::insert()");
return __tree_.template __node_handle_insert_multi<node_type>( return __tree_.template __node_handle_insert_multi<node_type>(
_VSTD::move(__nh)); _VSTD::move(__nh));
} }
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
value_compare value_comp() const {return __tree_.value_comp();} value_compare value_comp() const {return __tree_.value_comp();}
// set operations: // set operations:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __tree_.find(__k);} iterator find(const key_type& __k) {return __tree_.find(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __tree_.find(__k);} const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
find(const _K2& __k) {return __tree_.find(__k);} find(const _K2& __k) {return __tree_.find(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
find(const _K2& __k) const {return __tree_.find(__k);} find(const _K2& __k) const {return __tree_.find(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const size_type count(const key_type& __k) const
{return __tree_.__count_multi(__k);} {return __tree_.__count_multi(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
count(const _K2& __k) const {return __tree_.__count_multi(__k);} count(const _K2& __k) const {return __tree_.__count_multi(__k);}
#endif #endif
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const key_type& __k) const {return find(__k) != end();} bool contains(const key_type& __k) const {return find(__k) != end();}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
contains(const _K2& __k) const { return find(__k) != end(); } contains(const _K2& __k) const { return find(__k) != end(); }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator lower_bound(const key_type& __k) iterator lower_bound(const key_type& __k)
{return __tree_.lower_bound(__k);} {return __tree_.lower_bound(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator lower_bound(const key_type& __k) const const_iterator lower_bound(const key_type& __k) const
{return __tree_.lower_bound(__k);} {return __tree_.lower_bound(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);} lower_bound(const _K2& __k) {return __tree_.lower_bound(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);} lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator upper_bound(const key_type& __k) iterator upper_bound(const key_type& __k)
{return __tree_.upper_bound(__k);} {return __tree_.upper_bound(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator upper_bound(const key_type& __k) const const_iterator upper_bound(const key_type& __k) const
{return __tree_.upper_bound(__k);} {return __tree_.upper_bound(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);} upper_bound(const _K2& __k) {return __tree_.upper_bound(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);} upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator,iterator> equal_range(const key_type& __k) pair<iterator,iterator> equal_range(const key_type& __k)
{return __tree_.__equal_range_multi(__k);} {return __tree_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator,const_iterator> equal_range(const key_type& __k) const pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
{return __tree_.__equal_range_multi(__k);} {return __tree_.__equal_range_multi(__k);}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);} equal_range(const _K2& __k) {return __tree_.__equal_range_multi(__k);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);} equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
▲ Show 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
void void
swap(multiset<_Key, _Compare, _Allocator>& __x, swap(multiset<_Key, _Compare, _Allocator>& __x,
multiset<_Key, _Compare, _Allocator>& __y) multiset<_Key, _Compare, _Allocator>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Key, class _Compare, class _Allocator, class _Predicate> template <class _Key, class _Compare, class _Allocator, class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename multiset<_Key, _Compare, _Allocator>::size_type typename multiset<_Key, _Compare, _Allocator>::size_type
erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred) { erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
return _VSTD::__libcpp_erase_if_container(__c, __pred); return _VSTD::__libcpp_erase_if_container(__c, __pred);
} }
#endif #endif
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
template <class _KeyT, class _CompareT = std::less<_KeyT>> template <class _KeyT, class _CompareT = std::less<_KeyT>>
using set = std::set<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>; using set = std::set<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
template <class _KeyT, class _CompareT = std::less<_KeyT>> template <class _KeyT, class _CompareT = std::less<_KeyT>>
using multiset = std::multiset<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>; using multiset = std::multiset<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
} // namespace pmr } // namespace pmr
Show All 10 Lines

libcxx/include/shared_mutex

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 Lines
#include <__availability> #include <__availability>
#include <__config> #include <__config>
#include <version> #include <version>
_LIBCPP_PUSH_MACROS _LIBCPP_PUSH_MACROS
#include <__undef_macros> #include <__undef_macros>
#if _LIBCPP_STD_VER > 11 || defined(_LIBCPP_BUILDING_LIBRARY) #if _LIBCPP_STD_VER >= 14 || defined(_LIBCPP_BUILDING_LIBRARY)
#include <__mutex_base> #include <__mutex_base>
#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
#ifdef _LIBCPP_HAS_NO_THREADS #ifdef _LIBCPP_HAS_NO_THREADS
Show All 29 Lines__shared_mutex_base
bool try_lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_shared_capability(true)); bool try_lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_shared_capability(true));
void unlock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_shared_capability()); void unlock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_shared_capability());
// typedef implementation-defined native_handle_type; // See 30.2.3 // typedef implementation-defined native_handle_type; // See 30.2.3
// native_handle_type native_handle(); // See 30.2.3 // native_handle_type native_handle(); // See 30.2.3
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX shared_mutex class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX shared_mutex
{ {
__shared_mutex_base __base_; __shared_mutex_base __base_;
public: public:
_LIBCPP_INLINE_VISIBILITY shared_mutex() : __base_() {} _LIBCPP_INLINE_VISIBILITY shared_mutex() : __base_() {}
_LIBCPP_INLINE_VISIBILITY ~shared_mutex() = default; _LIBCPP_INLINE_VISIBILITY ~shared_mutex() = default;
shared_mutex(const shared_mutex&) = delete; shared_mutex(const shared_mutex&) = delete;
▲ Show 20 Lines • Show All 308 Lines • ▼ Show 20 Lines
template <class _Mutex> template <class _Mutex>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) _NOEXCEPT swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) _NOEXCEPT
{__x.swap(__y);} {__x.swap(__y);}
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STD_VER > 11 #endif // _LIBCPP_STD_VER >= 14
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_SHARED_MUTEX #endif // _LIBCPP_SHARED_MUTEX

libcxx/include/span

Show First 20 Lines • Show All 160 Lines • ▼ Show 20 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 #if _LIBCPP_STD_VER >= 20
template <class _Tp> template <class _Tp>
struct __is_std_array : false_type {}; struct __is_std_array : false_type {};
template <class _Tp, size_t _Sz> template <class _Tp, size_t _Sz>
struct __is_std_array<array<_Tp, _Sz>> : true_type {}; struct __is_std_array<array<_Tp, _Sz>> : true_type {};
template <class _Tp> template <class _Tp>
▲ Show 20 Lines • Show All 383 Lines • ▼ Show 20 Lines
auto as_bytes(span<_Tp, _Extent> __s) noexcept auto as_bytes(span<_Tp, _Extent> __s) noexcept
{ return __s.__as_bytes(); } { return __s.__as_bytes(); }
template <class _Tp, size_t _Extent> requires(!is_const_v<_Tp>) template <class _Tp, size_t _Extent> requires(!is_const_v<_Tp>)
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept
{ return __s.__as_writable_bytes(); } { return __s.__as_writable_bytes(); }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template<contiguous_iterator _It, class _EndOrSize> template<contiguous_iterator _It, class _EndOrSize>
span(_It, _EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>; span(_It, _EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
template<class _Tp, size_t _Sz> template<class _Tp, size_t _Sz>
span(_Tp (&)[_Sz]) -> span<_Tp, _Sz>; span(_Tp (&)[_Sz]) -> span<_Tp, _Sz>;
template<class _Tp, size_t _Sz> template<class _Tp, size_t _Sz>
span(array<_Tp, _Sz>&) -> span<_Tp, _Sz>; span(array<_Tp, _Sz>&) -> span<_Tp, _Sz>;
template<class _Tp, size_t _Sz> template<class _Tp, size_t _Sz>
span(const array<_Tp, _Sz>&) -> span<const _Tp, _Sz>; span(const array<_Tp, _Sz>&) -> span<const _Tp, _Sz>;
template<ranges::contiguous_range _Range> template<ranges::contiguous_range _Range>
span(_Range&&) -> span<remove_reference_t<ranges::range_reference_t<_Range>>>; span(_Range&&) -> span<remove_reference_t<ranges::range_reference_t<_Range>>>;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <concepts> # include <concepts>
# include <functional> # include <functional>
# include <iterator> # include <iterator>
#endif #endif
#endif // _LIBCPP_SPAN #endif // _LIBCPP_SPAN

libcxx/include/stack

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 Lines template <class _Alloc>
: c(_VSTD::move(__c), __a) {} : c(_VSTD::move(__c), __a) {}
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
stack(stack&& __s, const _Alloc& __a, stack(stack&& __s, const _Alloc& __a,
__enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0) __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
: c(_VSTD::move(__s.c), __a) {} : c(_VSTD::move(__s.c), __a) {}
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _InputIterator, template <class _InputIterator,
class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>> class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
stack(_InputIterator __first, _InputIterator __last) : c(__first, __last) {} stack(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
template <class _InputIterator, template <class _InputIterator,
class _Alloc, class _Alloc,
class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
Show All 14 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void push(const value_type& __v) {c.push_back(__v);} void push(const value_type& __v) {c.push_back(__v);}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void push(value_type&& __v) {c.push_back(_VSTD::move(__v));} void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
template <class... _Args> template <class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
decltype(auto) emplace(_Args&&... __args) decltype(auto) emplace(_Args&&... __args)
{ return c.emplace_back(_VSTD::forward<_Args>(__args)...);} { return c.emplace_back(_VSTD::forward<_Args>(__args)...);}
#else #else
void emplace(_Args&&... __args) void emplace(_Args&&... __args)
{ c.emplace_back(_VSTD::forward<_Args>(__args)...);} { c.emplace_back(_VSTD::forward<_Args>(__args)...);}
#endif #endif
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
Show All 16 Lines#endif // _LIBCPP_CXX03_LANG
operator==(const stack<T1, _C1>& __x, const stack<T1, _C1>& __y); operator==(const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);
template <class T1, class _C1> template <class T1, class _C1>
friend friend
bool bool
operator< (const stack<T1, _C1>& __x, const stack<T1, _C1>& __y); operator< (const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template<class _Container, template<class _Container,
class = enable_if_t<!__is_allocator<_Container>::value> class = enable_if_t<!__is_allocator<_Container>::value>
> >
stack(_Container) stack(_Container)
-> stack<typename _Container::value_type, _Container>; -> stack<typename _Container::value_type, _Container>;
template<class _Container, template<class _Container,
class _Alloc, class _Alloc,
class = enable_if_t<!__is_allocator<_Container>::value>, class = enable_if_t<!__is_allocator<_Container>::value>,
class = enable_if_t<uses_allocator<_Container, _Alloc>::value> class = enable_if_t<uses_allocator<_Container, _Alloc>::value>
> >
stack(_Container, _Alloc) stack(_Container, _Alloc)
-> stack<typename _Container::value_type, _Container>; -> stack<typename _Container::value_type, _Container>;
#endif #endif
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template<class _InputIterator, template<class _InputIterator,
class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>> class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>>
stack(_InputIterator, _InputIterator) stack(_InputIterator, _InputIterator)
-> stack<__iter_value_type<_InputIterator>>; -> stack<__iter_value_type<_InputIterator>>;
template<class _InputIterator, template<class _InputIterator,
class _Alloc, class _Alloc,
class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>, class = __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value>,
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

libcxx/include/stdatomic.h

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 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
#if defined(__cplusplus) && _LIBCPP_STD_VER > 20 #if defined(__cplusplus) && _LIBCPP_STD_VER >= 23
#include <atomic> #include <atomic>
#include <version> #include <version>
#ifdef _Atomic #ifdef _Atomic
# undef _Atomic # undef _Atomic
#endif #endif
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
// Before C++23, we include the next <stdatomic.h> on the path to avoid hijacking // Before C++23, we include the next <stdatomic.h> on the path to avoid hijacking
// the header. We do this because Clang has historically shipped a <stdatomic.h> // the header. We do this because Clang has historically shipped a <stdatomic.h>
// header that would be available in all Standard modes, and we don't want to // header that would be available in all Standard modes, and we don't want to
// break that use case. // break that use case.
# if __has_include_next(<stdatomic.h>) # if __has_include_next(<stdatomic.h>)
# include_next <stdatomic.h> # include_next <stdatomic.h>
# endif # endif
#endif // defined(__cplusplus) && _LIBCPP_STD_VER > 20 #endif // defined(__cplusplus) && _LIBCPP_STD_VER >= 23
#endif // _LIBCPP_STDATOMIC_H #endif // _LIBCPP_STDATOMIC_H

libcxx/include/string

Show First 20 Lines • Show All 880 Lines • ▼ Show 20 Lines _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* __s)
_LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr"); _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
__init(__s, traits_type::length(__s)); __init(__s, traits_type::length(__s));
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> > template <class = __enable_if_t<__is_allocator<_Allocator>::value, nullptr_t> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* __s, const _Allocator& __a); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* __s, const _Allocator& __a);
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
basic_string(nullptr_t) = delete; basic_string(nullptr_t) = delete;
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* __s, size_type __n) _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* __s, size_type __n)
: __r_(__default_init_tag(), __default_init_tag()) { : __r_(__default_init_tag(), __default_init_tag()) {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
__init(__s, __n); __init(__s, __n);
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
basic_string(const _CharT* __s, size_type __n, const _Allocator& __a) basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
: __r_(__default_init_tag(), __a) { : __r_(__default_init_tag(), __a) {
_LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr"); _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
__init(__s, __n); __init(__s, __n);
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(size_type __n, _CharT __c) _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(size_type __n, _CharT __c)
: __r_(__default_init_tag(), __default_init_tag()) { : __r_(__default_init_tag(), __default_init_tag()) {
__init(__n, __c); __init(__n, __c);
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
basic_string(basic_string&& __str, size_type __pos, const _Allocator& __alloc = _Allocator()) basic_string(basic_string&& __str, size_type __pos, const _Allocator& __alloc = _Allocator())
: basic_string(std::move(__str), __pos, npos, __alloc) {} : basic_string(std::move(__str), __pos, npos, __alloc) {}
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
basic_string(basic_string&& __str, size_type __pos, size_type __n, const _Allocator& __alloc = _Allocator()) basic_string(basic_string&& __str, size_type __pos, size_type __n, const _Allocator& __alloc = _Allocator())
: __r_(__default_init_tag(), __alloc) { : __r_(__default_init_tag(), __alloc) {
if (__pos > __str.size()) if (__pos > __str.size())
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Lines _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(basic_string&& __str)
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());} basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
basic_string& operator=(const value_type* __s) {return assign(__s);} basic_string& operator=(const value_type* __s) {return assign(__s);}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
basic_string& operator=(nullptr_t) = delete; basic_string& operator=(nullptr_t) = delete;
#endif #endif
_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(value_type __c); _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(value_type __c);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
iterator begin() _NOEXCEPT iterator begin() _NOEXCEPT
{return __make_iterator(__get_pointer());} {return __make_iterator(__get_pointer());}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type capacity() const _NOEXCEPT {
return (__is_long() ? __get_long_cap() : static_cast<size_type>(__min_cap)) - 1; return (__is_long() ? __get_long_cap() : static_cast<size_type>(__min_cap)) - 1;
} }
_LIBCPP_CONSTEXPR_SINCE_CXX20 void resize(size_type __n, value_type __c); _LIBCPP_CONSTEXPR_SINCE_CXX20 void resize(size_type __n, value_type __c);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void resize(size_type __n) { resize(__n, value_type()); } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void resize(size_type __n) { resize(__n, value_type()); }
_LIBCPP_CONSTEXPR_SINCE_CXX20 void reserve(size_type __requested_capacity); _LIBCPP_CONSTEXPR_SINCE_CXX20 void reserve(size_type __requested_capacity);
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _Op> template <class _Op>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
void resize_and_overwrite(size_type __n, _Op __op) { void resize_and_overwrite(size_type __n, _Op __op) {
__resize_default_init(__n); __resize_default_init(__n);
__erase_to_end(std::move(__op)(data(), _LIBCPP_AUTO_CAST(__n))); __erase_to_end(std::move(__op)(data(), _LIBCPP_AUTO_CAST(__n)));
} }
#endif #endif
▲ Show 20 Lines • Show All 346 Lines • ▼ Show 20 Lines#else
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<allocator_type>::value); __is_nothrow_swappable<allocator_type>::value);
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
const value_type* c_str() const _NOEXCEPT {return data();} const value_type* c_str() const _NOEXCEPT {return data();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
const value_type* data() const _NOEXCEPT {return std::__to_address(__get_pointer());} const value_type* data() const _NOEXCEPT {return std::__to_address(__get_pointer());}
#if _LIBCPP_STD_VER > 14 || defined(_LIBCPP_BUILDING_LIBRARY) #if _LIBCPP_STD_VER >= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
value_type* data() _NOEXCEPT {return std::__to_address(__get_pointer());} value_type* data() _NOEXCEPT {return std::__to_address(__get_pointer());}
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
allocator_type get_allocator() const _NOEXCEPT {return __alloc();} allocator_type get_allocator() const _NOEXCEPT {return __alloc();}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
int int
> >
compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const; compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2=npos) const;
_LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(const value_type* __s) const _NOEXCEPT; _LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(const value_type* __s) const _NOEXCEPT;
_LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(size_type __pos1, size_type __n1, const value_type* __s) const; _LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const; int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const;
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
constexpr _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI
bool starts_with(__self_view __sv) const noexcept bool starts_with(__self_view __sv) const noexcept
{ return __self_view(data(), size()).starts_with(__sv); } { return __self_view(data(), size()).starts_with(__sv); }
constexpr _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI
bool starts_with(value_type __c) const noexcept bool starts_with(value_type __c) const noexcept
{ return !empty() && _Traits::eq(front(), __c); } { return !empty() && _Traits::eq(front(), __c); }
Show All 9 Lines#if _LIBCPP_STD_VER >= 20
bool ends_with(value_type __c) const noexcept bool ends_with(value_type __c) const noexcept
{ return !empty() && _Traits::eq(back(), __c); } { return !empty() && _Traits::eq(back(), __c); }
constexpr _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI
bool ends_with(const value_type* __s) const noexcept bool ends_with(const value_type* __s) const noexcept
{ return ends_with(__self_view(__s)); } { return ends_with(__self_view(__s)); }
#endif #endif
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
constexpr _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI
bool contains(__self_view __sv) const noexcept bool contains(__self_view __sv) const noexcept
{ return __self_view(data(), size()).contains(__sv); } { return __self_view(data(), size()).contains(__sv); }
constexpr _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI
bool contains(value_type __c) const noexcept bool contains(value_type __c) const noexcept
{ return __self_view(data(), size()).contains(__c); } { return __self_view(data(), size()).contains(__c); }
Show All 26 Linesprivate:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
bool __is_long() const _NOEXCEPT { bool __is_long() const _NOEXCEPT {
if (__libcpp_is_constant_evaluated()) if (__libcpp_is_constant_evaluated())
return true; return true;
return __r_.first().__s.__is_long_; return __r_.first().__s.__is_long_;
} }
static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __begin_lifetime(pointer __begin, size_type __n) { static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __begin_lifetime(pointer __begin, size_type __n) {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
for (size_type __i = 0; __i != __n; ++__i) for (size_type __i = 0; __i != __n; ++__i)
std::construct_at(std::addressof(__begin[__i])); std::construct_at(std::addressof(__begin[__i]));
} }
#else #else
(void)__begin; (void)__begin;
(void)__n; (void)__n;
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __default_init() { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __default_init() {
__r_.first() = __rep(); __r_.first() = __rep();
if (__libcpp_is_constant_evaluated()) { if (__libcpp_is_constant_evaluated()) {
size_type __sz = __recommend(0) + 1; size_type __sz = __recommend(0) + 1;
pointer __ptr = __alloc_traits::allocate(__alloc(), __sz); pointer __ptr = __alloc_traits::allocate(__alloc(), __sz);
__begin_lifetime(__ptr, __sz); __begin_lifetime(__ptr, __sz);
▲ Show 20 Lines • Show All 210 Lines • ▼ Show 20 Lines void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT
{} {}
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
void __move_assign(basic_string& __str, false_type) void __move_assign(basic_string& __str, false_type)
_NOEXCEPT_(__alloc_traits::is_always_equal::value); _NOEXCEPT_(__alloc_traits::is_always_equal::value);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
void __move_assign(basic_string& __str, true_type) void __move_assign(basic_string& __str, true_type)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_NOEXCEPT; _NOEXCEPT;
#else #else
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value); _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
#endif #endif
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
void void
▲ Show 20 Lines • Show All 620 Lines • ▼ Show 20 Linesbasic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type)
else else
__move_assign(__str, true_type()); __move_assign(__str, true_type());
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_CONSTEXPR_SINCE_CXX20
void void
basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type) basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
#endif #endif
{ {
if (__is_long()) { if (__is_long()) {
__alloc_traits::deallocate(__alloc(), __get_long_pointer(), __alloc_traits::deallocate(__alloc(), __get_long_pointer(),
__get_long_cap()); __get_long_cap());
▲ Show 20 Lines • Show All 1,438 Lines • ▼ Show 20 Lines
// operator== // operator==
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs); return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs);
#else #else
size_t __lhs_sz = __lhs.size(); size_t __lhs_sz = __lhs.size();
return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(), return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(),
__rhs.data(), __rhs.data(),
__lhs_sz) == 0; __lhs_sz) == 0;
#endif #endif
} }
Show All 33 Lines
#endif // _LIBCPP_STD_VER <= 17 #endif // _LIBCPP_STD_VER <= 17
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
bool bool
operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs, operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT const _CharT* __rhs) _NOEXCEPT
{ {
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs); return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs);
#else #else
typedef basic_string<_CharT, _Traits, _Allocator> _String; typedef basic_string<_CharT, _Traits, _Allocator> _String;
_LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr"); _LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");
size_t __rhs_len = _Traits::length(__rhs); size_t __rhs_len = _Traits::length(__rhs);
if (__rhs_len != __lhs.size()) return false; if (__rhs_len != __lhs.size()) return false;
return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0; return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0;
#endif #endif
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>( _LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>(
const basic_string<_CharT, _Traits, _Allocator>& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) noexcept { const basic_string<_CharT, _Traits, _Allocator>& __rhs) noexcept {
return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs); return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs);
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_HIDE_FROM_ABI constexpr auto _LIBCPP_HIDE_FROM_ABI constexpr auto
operator<=>(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) { operator<=>(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) {
return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs); return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs);
} }
#else // _LIBCPP_STD_VER > 17 #else // _LIBCPP_STD_VER >= 20
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
bool bool
operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return !(__lhs == __rhs); return !(__lhs == __rhs);
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Lines
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
bool bool
operator>=(const _CharT* __lhs, operator>=(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{ {
return !(__lhs < __rhs); return !(__lhs < __rhs);
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
// operator + // operator +
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
basic_string<_CharT, _Traits, _Allocator> basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) const basic_string<_CharT, _Traits, _Allocator>& __rhs)
▲ Show 20 Lines • Show All 257 Lines • ▼ Show 20 Linesgetline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm); basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
template<class _CharT, class _Traits, class _Allocator> template<class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is, getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Allocator>& __str); basic_string<_CharT, _Traits, _Allocator>& __str);
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _CharT, class _Traits, class _Allocator, class _Up> template <class _CharT, class _Traits, class _Allocator, class _Up>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
typename basic_string<_CharT, _Traits, _Allocator>::size_type typename basic_string<_CharT, _Traits, _Allocator>::size_type
erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v) { erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v) {
auto __old_size = __str.size(); auto __old_size = __str.size();
__str.erase(std::remove(__str.begin(), __str.end(), __v), __str.end()); __str.erase(std::remove(__str.begin(), __str.end(), __v), __str.end());
return __old_size - __str.size(); return __old_size - __str.size();
} }
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
{ {
const value_type* __p = std::__to_address(__i->base()) + __n; const value_type* __p = std::__to_address(__i->base()) + __n;
return data() <= __p && __p < data() + size(); return data() <= __p && __p < data() + size();
} }
#endif // _LIBCPP_ENABLE_DEBUG_MODE #endif // _LIBCPP_ENABLE_DEBUG_MODE
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
// Literal suffixes for basic_string [basic.string.literals] // Literal suffixes for basic_string [basic.string.literals]
inline namespace literals inline namespace literals
{ {
inline namespace string_literals inline namespace string_literals
{ {
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
basic_string<char> operator "" s( const char *__str, size_t __len ) basic_string<char> operator "" s( const char *__str, size_t __len )
{ {
Show All 25 Lines#endif
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len ) basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
{ {
return basic_string<char32_t> (__str, __len); return basic_string<char32_t> (__str, __len);
} }
} // namespace string_literals } // namespace string_literals
} // namespace literals } // namespace literals
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <> template <>
inline constexpr bool __format::__enable_insertable<std::basic_string<char>> = true; inline constexpr bool __format::__enable_insertable<std::basic_string<char>> = true;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
inline constexpr bool __format::__enable_insertable<std::basic_string<wchar_t>> = true; inline constexpr bool __format::__enable_insertable<std::basic_string<wchar_t>> = true;
#endif #endif
#endif #endif
Show All 18 Lines

libcxx/include/string_view

Show First 20 Lines • Show All 292 Lines • ▼ Show 20 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default; basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default;
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
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 >= 14
_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 #if _LIBCPP_STD_VER >= 20
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 // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _Range> template <class _Range>
requires ( requires (
!is_same_v<remove_cvref_t<_Range>, basic_string_view> && !is_same_v<remove_cvref_t<_Range>, basic_string_view> &&
ranges::contiguous_range<_Range> && ranges::contiguous_range<_Range> &&
ranges::sized_range<_Range> && ranges::sized_range<_Range> &&
is_same_v<ranges::range_value_t<_Range>, _CharT> && is_same_v<ranges::range_value_t<_Range>, _CharT> &&
!is_convertible_v<_Range, const _CharT*> && !is_convertible_v<_Range, const _CharT*> &&
(!requires(remove_cvref_t<_Range>& __d) { (!requires(remove_cvref_t<_Range>& __d) {
__d.operator _VSTD::basic_string_view<_CharT, _Traits>(); __d.operator _VSTD::basic_string_view<_CharT, _Traits>();
}) && }) &&
(!requires { (!requires {
typename remove_reference_t<_Range>::traits_type; typename remove_reference_t<_Range>::traits_type;
} || is_same_v<typename remove_reference_t<_Range>::traits_type, _Traits>) } || is_same_v<typename remove_reference_t<_Range>::traits_type, _Traits>)
) )
constexpr explicit _LIBCPP_HIDE_FROM_ABI constexpr explicit _LIBCPP_HIDE_FROM_ABI
basic_string_view(_Range&& __r) : __data_(ranges::data(__r)), __size_(ranges::size(__r)) {} basic_string_view(_Range&& __r) : __data_(ranges::data(__r)), __size_(ranges::size(__r)) {}
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
basic_string_view(const _CharT* __s) basic_string_view(const _CharT* __s)
: __data_(__s), __size_(_VSTD::__char_traits_length_checked<_Traits>(__s)) {} : __data_(__s), __size_(_VSTD::__char_traits_length_checked<_Traits>(__s)) {}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
basic_string_view(nullptr_t) = delete; basic_string_view(nullptr_t) = delete;
#endif #endif
// [string.view.iterators], iterators // [string.view.iterators], iterators
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
const_iterator begin() const _NOEXCEPT { return cbegin(); } const_iterator begin() const _NOEXCEPT { return cbegin(); }
_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 338 Lines • ▼ Show 20 Lines#endif
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
{ {
_LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr"); _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
return std::__str_find_last_not_of<value_type, size_type, traits_type, npos> return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
(data(), size(), __s, __pos, traits_type::length(__s)); (data(), size(), __s, __pos, traits_type::length(__s));
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
constexpr _LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY
bool starts_with(basic_string_view __s) const noexcept bool starts_with(basic_string_view __s) const noexcept
{ return size() >= __s.size() && compare(0, __s.size(), __s) == 0; } { return size() >= __s.size() && compare(0, __s.size(), __s) == 0; }
constexpr _LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY
bool starts_with(value_type __c) const noexcept bool starts_with(value_type __c) const noexcept
{ return !empty() && _Traits::eq(front(), __c); } { return !empty() && _Traits::eq(front(), __c); }
Show All 9 Lines#if _LIBCPP_STD_VER >= 20
bool ends_with(value_type __c) const noexcept bool ends_with(value_type __c) const noexcept
{ return !empty() && _Traits::eq(back(), __c); } { return !empty() && _Traits::eq(back(), __c); }
constexpr _LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY
bool ends_with(const value_type* __s) const noexcept bool ends_with(const value_type* __s) const noexcept
{ return ends_with(basic_string_view(__s)); } { return ends_with(basic_string_view(__s)); }
#endif #endif
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
constexpr _LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY
bool contains(basic_string_view __sv) const noexcept bool contains(basic_string_view __sv) const noexcept
{ return find(__sv) != npos; } { return find(__sv) != npos; }
constexpr _LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY
bool contains(value_type __c) const noexcept bool contains(value_type __c) const noexcept
{ return find(__c) != npos; } { return find(__c) != npos; }
constexpr _LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY
bool contains(const value_type* __s) const bool contains(const value_type* __s) const
{ 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_;
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_string_view); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_string_view);
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
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 #endif // _LIBCPP_STD_VER >= 20
// [string.view.deduct] // [string.view.deduct]
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
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 // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
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>>;
#endif #endif
// [string.view.comparison] // [string.view.comparison]
// operator == // operator ==
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
Show All 20 Lines
template<class _CharT, class _Traits, int = 2> template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator==(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs, bool operator==(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
if (__lhs.size() != __rhs.size()) return false; if (__lhs.size() != __rhs.size()) return false;
return __lhs.compare(__rhs) == 0; return __lhs.compare(__rhs) == 0;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
// operator <=> // operator <=>
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI constexpr auto _LIBCPP_HIDE_FROM_ABI constexpr auto
operator<=>(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) noexcept { operator<=>(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) noexcept {
if constexpr (requires { typename _Traits::comparison_category; }) { if constexpr (requires { typename _Traits::comparison_category; }) {
// [string.view]/4 // [string.view]/4
static_assert( static_assert(
__comparison_category<typename _Traits::comparison_category>, __comparison_category<typename _Traits::comparison_category>,
Show All 13 Lines if constexpr (requires { typename _Traits::comparison_category; }) {
__comparison_category<typename _Traits::comparison_category>, __comparison_category<typename _Traits::comparison_category>,
"return type is not a comparison category type"); "return type is not a comparison category type");
return static_cast<typename _Traits::comparison_category>(__lhs.compare(__rhs) <=> 0); return static_cast<typename _Traits::comparison_category>(__lhs.compare(__rhs) <=> 0);
} else { } else {
return static_cast<weak_ordering>(__lhs.compare(__rhs) <=> 0); return static_cast<weak_ordering>(__lhs.compare(__rhs) <=> 0);
} }
} }
#else // _LIBCPP_STD_VER > 17 #else // _LIBCPP_STD_VER >= 20
// operator != // operator !=
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT bool operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
if (__lhs.size() != __rhs.size()) if (__lhs.size() != __rhs.size())
return true; return true;
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Lines
template<class _CharT, class _Traits, int = 2> template<class _CharT, class _Traits, int = 2>
_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
bool operator>=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs, bool operator>=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
{ {
return __lhs.compare(__rhs) >= 0; return __lhs.compare(__rhs) >= 0;
} }
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, operator<<(basic_ostream<_CharT, _Traits>& __os,
basic_string_view<_CharT, _Traits> __str); basic_string_view<_CharT, _Traits> __str);
// [string.view.hash] // [string.view.hash]
template<class _CharT> template<class _CharT>
Show All 19 Lines
template <> template <>
struct hash<basic_string_view<char32_t, char_traits<char32_t> > > : __string_view_hash<char32_t> {}; struct hash<basic_string_view<char32_t, char_traits<char32_t> > > : __string_view_hash<char32_t> {};
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
struct hash<basic_string_view<wchar_t, char_traits<wchar_t> > > : __string_view_hash<wchar_t> {}; struct hash<basic_string_view<wchar_t, char_traits<wchar_t> > > : __string_view_hash<wchar_t> {};
#endif #endif
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
inline namespace literals inline namespace literals
{ {
inline namespace string_view_literals inline namespace string_view_literals
{ {
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
basic_string_view<char> operator "" sv(const char *__str, size_t __len) _NOEXCEPT basic_string_view<char> operator "" sv(const char *__str, size_t __len) _NOEXCEPT
{ {
return basic_string_view<char> (__str, __len); return basic_string_view<char> (__str, __len);
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

libcxx/include/system_error

Show First 20 Lines • Show All 166 Lines • ▼ Show 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// is_error_code_enum // is_error_code_enum
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_error_code_enum struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
: public false_type {}; : public false_type {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value; inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value;
#endif #endif
// is_error_condition_enum // is_error_condition_enum
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
: public false_type {}; : public false_type {};
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
#endif #endif
template <> template <>
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc> struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
: true_type { }; : true_type { };
Show All 28 Lines#endif
virtual error_condition default_error_condition(int __ev) const _NOEXCEPT; virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT; virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT; virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
virtual string message(int __ev) const = 0; virtual string message(int __ev) const = 0;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;} bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
strong_ordering operator<=>(const error_category& __rhs) const noexcept {return compare_three_way()(this, std::addressof(__rhs));} strong_ordering operator<=>(const error_category& __rhs) const noexcept {return compare_three_way()(this, std::addressof(__rhs));}
#else // _LIBCPP_STD_VER > 17 #else // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);} bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;} bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
friend class _LIBCPP_HIDDEN __do_message; friend class _LIBCPP_HIDDEN __do_message;
}; };
class _LIBCPP_HIDDEN __do_message class _LIBCPP_HIDDEN __do_message
: public error_category : public error_category
{ {
public: public:
▲ Show 20 Lines • Show All 296 Lines • Show Last 20 Lines

libcxx/include/tuple

Show First 20 Lines • Show All 859 Lines • ▼ Show 20 Lines template <class ..._Up, class _Alloc, __enable_if_t<
_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t) explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
: __base_(allocator_arg_t(), __a, __t) : __base_(allocator_arg_t(), __a, __t)
{ } { }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
// tuple(tuple<U...>&) constructors (including allocator_arg_t variants) // tuple(tuple<U...>&) constructors (including allocator_arg_t variants)
template <class... _Up, enable_if_t< template <class... _Up, enable_if_t<
_EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr> _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
explicit(!(is_convertible_v<_Up&, _Tp> && ...)) explicit(!(is_convertible_v<_Up&, _Tp> && ...))
tuple(tuple<_Up...>& __t) : __base_(__t) {} tuple(tuple<_Up...>& __t) : __base_(__t) {}
template <class _Alloc, class... _Up, enable_if_t< template <class _Alloc, class... _Up, enable_if_t<
_EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr> _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
explicit(!(is_convertible_v<_Up&, _Tp> && ...)) explicit(!(is_convertible_v<_Up&, _Tp> && ...))
tuple(allocator_arg_t, const _Alloc& __alloc, tuple<_Up...>& __t) : __base_(allocator_arg_t(), __alloc, __t) {} tuple(allocator_arg_t, const _Alloc& __alloc, tuple<_Up...>& __t) : __base_(allocator_arg_t(), __alloc, __t) {}
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
// tuple(tuple<U...>&&) constructors (including allocator_arg_t variants) // tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
template <class ..._Up, __enable_if_t< template <class ..._Up, __enable_if_t<
_And< _And<
_EnableCtorFromUTypesTuple<tuple<_Up...>&&>, _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
is_convertible<_Up, _Tp>... // explicit check is_convertible<_Up, _Tp>... // explicit check
>::value >::value
Show All 33 Lines template <class _Alloc, class ..._Up, __enable_if_t<
_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t) explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
: __base_(allocator_arg_t(), __a, _VSTD::move(__t)) : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
{ } { }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
// tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants) // tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants)
template <class... _Up, enable_if_t< template <class... _Up, enable_if_t<
_EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr> _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
explicit(!(is_convertible_v<const _Up&&, _Tp> && ...)) explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
tuple(const tuple<_Up...>&& __t) : __base_(std::move(__t)) {} tuple(const tuple<_Up...>&& __t) : __base_(std::move(__t)) {}
template <class _Alloc, class... _Up, enable_if_t< template <class _Alloc, class... _Up, enable_if_t<
_EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr> _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
explicit(!(is_convertible_v<const _Up&&, _Tp> && ...)) explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t) tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t)
: __base_(allocator_arg_t(), __alloc, std::move(__t)) {} : __base_(allocator_arg_t(), __alloc, std::move(__t)) {}
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
// tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants) // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
template <template <class...> class Pred, class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple> template <template <class...> class Pred, class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
struct _CtorPredicateFromPair : false_type{}; struct _CtorPredicateFromPair : false_type{};
template <template <class...> class Pred, class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2> template <template <class...> class Pred, class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
struct _CtorPredicateFromPair<Pred, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And< struct _CtorPredicateFromPair<Pred, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And<
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check _Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p) explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
: __base_(allocator_arg_t(), __a, __p) : __base_(allocator_arg_t(), __a, __p)
{ } { }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
// tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants) // tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants)
template <class _U1, class _U2, enable_if_t< template <class _U1, class _U2, enable_if_t<
_EnableCtorFromPair<pair<_U1, _U2>&>::value>* = nullptr> _EnableCtorFromPair<pair<_U1, _U2>&>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value) explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)
tuple(pair<_U1, _U2>& __p) : __base_(__p) {} tuple(pair<_U1, _U2>& __p) : __base_(__p) {}
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
_Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check _Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check
>::value >::value
, int> = 0> , int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p) explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
: __base_(allocator_arg_t(), __a, _VSTD::move(__p)) : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
{ } { }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
// tuple(const pair<U1, U2>&&) constructors (including allocator_arg_t variants) // tuple(const pair<U1, U2>&&) constructors (including allocator_arg_t variants)
template <class _U1, class _U2, enable_if_t< template <class _U1, class _U2, enable_if_t<
_EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr> _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value) explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
tuple(const pair<_U1, _U2>&& __p) : __base_(std::move(__p)) {} tuple(const pair<_U1, _U2>&& __p) : __base_(std::move(__p)) {}
template <class _Alloc, class _U1, class _U2, enable_if_t< template <class _Alloc, class _U1, class _U2, enable_if_t<
_EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr> _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value) explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
tuple(allocator_arg_t, const _Alloc& __alloc, const pair<_U1, _U2>&& __p) tuple(allocator_arg_t, const _Alloc& __alloc, const pair<_U1, _U2>&& __p)
: __base_(allocator_arg_t(), __alloc, std::move(__p)) {} : __base_(allocator_arg_t(), __alloc, std::move(__p)) {}
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
// [tuple.assign] // [tuple.assign]
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple) tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple)
_NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value)) _NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value))
{ {
_VSTD::__memberwise_copy_assign(*this, __tuple, _VSTD::__memberwise_copy_assign(*this, __tuple,
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
const tuple& operator=(tuple const& __tuple) const const tuple& operator=(tuple const& __tuple) const
requires (_And<is_copy_assignable<const _Tp>...>::value) { requires (_And<is_copy_assignable<const _Tp>...>::value) {
std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type()); std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
const tuple& operator=(tuple&& __tuple) const const tuple& operator=(tuple&& __tuple) const
requires (_And<is_assignable<const _Tp&, _Tp>...>::value) { requires (_And<is_assignable<const _Tp&, _Tp>...>::value) {
std::__memberwise_forward_assign(*this, std::__memberwise_forward_assign(*this,
std::move(__tuple), std::move(__tuple),
__tuple_types<_Tp...>(), __tuple_types<_Tp...>(),
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
tuple& operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple) tuple& operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple)
_NOEXCEPT_((_And<is_nothrow_move_assignable<_Tp>...>::value)) _NOEXCEPT_((_And<is_nothrow_move_assignable<_Tp>...>::value))
{ {
_VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple), _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
__tuple_types<_Tp...>(), __tuple_types<_Tp...>(),
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
Show All 27 Lines#endif // _LIBCPP_STD_VER >= 23
{ {
_VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple), _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
__tuple_types<_Up...>(), __tuple_types<_Up...>(),
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class... _UTypes, enable_if_t< template <class... _UTypes, enable_if_t<
_And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>, _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
is_assignable<const _Tp&, const _UTypes&>...>::value>* = nullptr> is_assignable<const _Tp&, const _UTypes&>...>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
const tuple& operator=(const tuple<_UTypes...>& __u) const { const tuple& operator=(const tuple<_UTypes...>& __u) const {
std::__memberwise_copy_assign(*this, std::__memberwise_copy_assign(*this,
__u, __u,
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
template <class... _UTypes, enable_if_t< template <class... _UTypes, enable_if_t<
_And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>, _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
is_assignable<const _Tp&, _UTypes>...>::value>* = nullptr> is_assignable<const _Tp&, _UTypes>...>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
const tuple& operator=(tuple<_UTypes...>&& __u) const { const tuple& operator=(tuple<_UTypes...>&& __u) const {
std::__memberwise_forward_assign(*this, std::__memberwise_forward_assign(*this,
__u, __u,
__tuple_types<_UTypes...>(), __tuple_types<_UTypes...>(),
typename __make_tuple_indices<sizeof...(_Tp)>::type()); typename __make_tuple_indices<sizeof...(_Tp)>::type());
return *this; return *this;
} }
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
template <template<class...> class Pred, bool _Const, template <template<class...> class Pred, bool _Const,
class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple> class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
struct _AssignPredicateFromPair : false_type {}; struct _AssignPredicateFromPair : false_type {};
template <template<class...> class Pred, bool _Const, template <template<class...> class Pred, bool _Const,
class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2> class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
struct _AssignPredicateFromPair<Pred, _Const, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : struct _AssignPredicateFromPair<Pred, _Const, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > :
_And<Pred<__maybe_const<_Const, _Tp1>&, __copy_cvref_t<_Pair, _Up1> >, _And<Pred<__maybe_const<_Const, _Tp1>&, __copy_cvref_t<_Pair, _Up1> >,
Pred<__maybe_const<_Const, _Tp2>&, __copy_cvref_t<_Pair, _Up2> > Pred<__maybe_const<_Const, _Tp2>&, __copy_cvref_t<_Pair, _Up2> >
> {}; > {};
template <bool _Const, class _Pair> template <bool _Const, class _Pair>
struct _EnableAssignFromPair : _AssignPredicateFromPair<is_assignable, _Const, _Pair> {}; struct _EnableAssignFromPair : _AssignPredicateFromPair<is_assignable, _Const, _Pair> {};
template <bool _Const, class _Pair> template <bool _Const, class _Pair>
struct _NothrowAssignFromPair : _AssignPredicateFromPair<is_nothrow_assignable, _Const, _Pair> {}; struct _NothrowAssignFromPair : _AssignPredicateFromPair<is_nothrow_assignable, _Const, _Pair> {};
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _U1, class _U2, enable_if_t< template <class _U1, class _U2, enable_if_t<
_EnableAssignFromPair<true, const pair<_U1, _U2>&>::value>* = nullptr> _EnableAssignFromPair<true, const pair<_U1, _U2>&>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
const tuple& operator=(const pair<_U1, _U2>& __pair) const const tuple& operator=(const pair<_U1, _U2>& __pair) const
noexcept(_NothrowAssignFromPair<true, const pair<_U1, _U2>&>::value) { noexcept(_NothrowAssignFromPair<true, const pair<_U1, _U2>&>::value) {
std::get<0>(*this) = __pair.first; std::get<0>(*this) = __pair.first;
std::get<1>(*this) = __pair.second; std::get<1>(*this) = __pair.second;
return *this; return *this;
} }
template <class _U1, class _U2, enable_if_t< template <class _U1, class _U2, enable_if_t<
_EnableAssignFromPair<true, pair<_U1, _U2>&&>::value>* = nullptr> _EnableAssignFromPair<true, pair<_U1, _U2>&&>::value>* = nullptr>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
const tuple& operator=(pair<_U1, _U2>&& __pair) const const tuple& operator=(pair<_U1, _U2>&& __pair) const
noexcept(_NothrowAssignFromPair<true, pair<_U1, _U2>&&>::value) { noexcept(_NothrowAssignFromPair<true, pair<_U1, _U2>&&>::value) {
std::get<0>(*this) = std::move(__pair.first); std::get<0>(*this) = std::move(__pair.first);
std::get<1>(*this) = std::move(__pair.second); std::get<1>(*this) = std::move(__pair.second);
return *this; return *this;
} }
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
template<class _Up1, class _Up2, __enable_if_t< template<class _Up1, class _Up2, __enable_if_t<
_EnableAssignFromPair<false, pair<_Up1, _Up2> const&>::value _EnableAssignFromPair<false, pair<_Up1, _Up2> const&>::value
,int> = 0> ,int> = 0>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
tuple& operator=(pair<_Up1, _Up2> const& __pair) tuple& operator=(pair<_Up1, _Up2> const& __pair)
_NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2> const&>::value)) _NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2> const&>::value))
{ {
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines tuple& operator=(array<_Up, _Np>&& __array)
return *this; return *this;
} }
// [tuple.swap] // [tuple.swap]
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
{__base_.swap(__t.__base_);} {__base_.swap(__t.__base_);}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
void swap(const tuple& __t) const noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) { void swap(const tuple& __t) const noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) {
__base_.swap(__t.__base_); __base_.swap(__t.__base_);
} }
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
}; };
template <> template <>
class _LIBCPP_TEMPLATE_VIS tuple<> class _LIBCPP_TEMPLATE_VIS tuple<>
{ {
public: public:
_LIBCPP_INLINE_VISIBILITY constexpr _LIBCPP_INLINE_VISIBILITY constexpr
tuple() _NOEXCEPT = default; tuple() _NOEXCEPT = default;
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {} tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
template <class _Alloc> template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {} tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
template <class _Up> template <class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
tuple(array<_Up, 0>) _NOEXCEPT {} tuple(array<_Up, 0>) _NOEXCEPT {}
template <class _Alloc, class _Up> template <class _Alloc, class _Up>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {} tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
void swap(tuple&) _NOEXCEPT {} void swap(tuple&) _NOEXCEPT {}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
_LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {} _LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {}
#endif #endif
}; };
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class... _TTypes, class... _UTypes, template<class> class _TQual, template<class> class _UQual> template <class... _TTypes, class... _UTypes, template<class> class _TQual, template<class> class _UQual>
requires requires { typename tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>; } requires requires { typename tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>; }
struct basic_common_reference<tuple<_TTypes...>, tuple<_UTypes...>, _TQual, _UQual> { struct basic_common_reference<tuple<_TTypes...>, tuple<_UTypes...>, _TQual, _UQual> {
using type = tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>; using type = tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>;
}; };
template <class... _TTypes, class... _UTypes> template <class... _TTypes, class... _UTypes>
requires requires { typename tuple<common_type_t<_TTypes, _UTypes>...>; } requires requires { typename tuple<common_type_t<_TTypes, _UTypes>...>; }
struct common_type<tuple<_TTypes...>, tuple<_UTypes...>> { struct common_type<tuple<_TTypes...>, tuple<_UTypes...>> {
using type = tuple<common_type_t<_TTypes, _UTypes>...>; using type = tuple<common_type_t<_TTypes, _UTypes>...>;
}; };
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class ..._Tp> template <class ..._Tp>
tuple(_Tp...) -> tuple<_Tp...>; tuple(_Tp...) -> tuple<_Tp...>;
template <class _Tp1, class _Tp2> template <class _Tp1, class _Tp2>
tuple(pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>; tuple(pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
template <class _Alloc, class ..._Tp> template <class _Alloc, class ..._Tp>
tuple(allocator_arg_t, _Alloc, _Tp...) -> tuple<_Tp...>; tuple(allocator_arg_t, _Alloc, _Tp...) -> tuple<_Tp...>;
template <class _Alloc, class _Tp1, class _Tp2> template <class _Alloc, class _Tp1, class _Tp2>
tuple(allocator_arg_t, _Alloc, pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>; tuple(allocator_arg_t, _Alloc, pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
template <class _Alloc, class ..._Tp> template <class _Alloc, class ..._Tp>
tuple(allocator_arg_t, _Alloc, tuple<_Tp...>) -> tuple<_Tp...>; tuple(allocator_arg_t, _Alloc, tuple<_Tp...>) -> tuple<_Tp...>;
#endif #endif
template <class ..._Tp> template <class ..._Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
__enable_if_t<__all<__is_swappable<_Tp>::value...>::value, void> __enable_if_t<__all<__is_swappable<_Tp>::value...>::value, void>
swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u) swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
_NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
{__t.swap(__u);} {__t.swap(__u);}
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class... _Tp> template <class... _Tp>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
enable_if_t<__all<is_swappable_v<const _Tp>...>::value, void> enable_if_t<__all<is_swappable_v<const _Tp>...>::value, void>
swap(const tuple<_Tp...>& __lhs, const tuple<_Tp...>& __rhs) swap(const tuple<_Tp...>& __lhs, const tuple<_Tp...>& __rhs)
noexcept(__all<is_nothrow_swappable_v<const _Tp>...>::value) { noexcept(__all<is_nothrow_swappable_v<const _Tp>...>::value) {
__lhs.swap(__rhs); __lhs.swap(__rhs);
} }
#endif #endif
Show All 33 Lines
const typename tuple_element<_Ip, tuple<_Tp...> >::type&& const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
get(const tuple<_Tp...>&& __t) _NOEXCEPT get(const tuple<_Tp...>&& __t) _NOEXCEPT
{ {
typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type; typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
return static_cast<const type&&>( return static_cast<const type&&>(
static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get()); static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
namespace __find_detail { namespace __find_detail {
static constexpr size_t __not_found = static_cast<size_t>(-1); static constexpr size_t __not_found = static_cast<size_t>(-1);
static constexpr size_t __ambiguous = __not_found - 1; static constexpr size_t __ambiguous = __not_found - 1;
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) { constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) {
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 Lines
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
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 #if _LIBCPP_STD_VER >= 20
// 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 #else // _LIBCPP_STD_VER >= 20
template <class ..._Tp, class ..._Up> template <class ..._Tp, class ..._Up>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
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_SINCE_CXX14 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
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 #endif // _LIBCPP_STD_VER >= 20
// 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 142 Lines • ▼ Show 20 Lines
pair<_T1, _T2>::pair(piecewise_construct_t, pair<_T1, _T2>::pair(piecewise_construct_t,
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args, tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
__tuple_indices<_I1...>, __tuple_indices<_I2...>) __tuple_indices<_I1...>, __tuple_indices<_I2...>)
: first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...), : first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...),
second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...) second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
{ {
} }
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
#define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; } #define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
template <class _Fn, class _Tuple, size_t ..._Id> template <class _Fn, class _Tuple, size_t ..._Id>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
constexpr decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t, constexpr decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
Show All 25 Lines
constexpr _Tp make_from_tuple(_Tuple&& __t) constexpr _Tp make_from_tuple(_Tuple&& __t)
_LIBCPP_NOEXCEPT_RETURN( _LIBCPP_NOEXCEPT_RETURN(
_VSTD::__make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t), _VSTD::__make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t),
typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{}) typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
) )
#undef _LIBCPP_NOEXCEPT_RETURN #undef _LIBCPP_NOEXCEPT_RETURN
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
#endif // !defined(_LIBCPP_CXX03_LANG) #endif // !defined(_LIBCPP_CXX03_LANG)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <exception> # include <exception>
# include <iosfwd> # include <iosfwd>
# include <new> # include <new>
# include <type_traits> # include <type_traits>
# include <typeinfo> # include <typeinfo>
# include <utility> # include <utility>
#endif #endif
#endif // _LIBCPP_TUPLE #endif // _LIBCPP_TUPLE

libcxx/include/typeindex

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines#endif
bool operator<=(const type_index& __y) const _NOEXCEPT bool operator<=(const type_index& __y) const _NOEXCEPT
{return !__y.__t_->before(*__t_);} {return !__y.__t_->before(*__t_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator> (const type_index& __y) const _NOEXCEPT bool operator> (const type_index& __y) const _NOEXCEPT
{return __y.__t_->before(*__t_);} {return __y.__t_->before(*__t_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator>=(const type_index& __y) const _NOEXCEPT bool operator>=(const type_index& __y) const _NOEXCEPT
{return !__t_->before(*__y.__t_);} {return !__t_->before(*__y.__t_);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
strong_ordering operator<=>(const type_index& __y) const noexcept { strong_ordering operator<=>(const type_index& __y) const noexcept {
if (*__t_ == *__y.__t_) if (*__t_ == *__y.__t_)
return strong_ordering::equal; return strong_ordering::equal;
if (__t_->before(*__y.__t_)) if (__t_->before(*__y.__t_))
return strong_ordering::less; return strong_ordering::less;
return strong_ordering::greater; return strong_ordering::greater;
} }
Show All 28 Lines

libcxx/include/unordered_map

Show First 20 Lines • Show All 569 Lines • ▼ Show 20 Linespublic:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const _Hash& hash_function() const _NOEXCEPT {return *this;} const _Hash& hash_function() const _NOEXCEPT {return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(const _Cp& __x) const size_t operator()(const _Cp& __x) const
{return static_cast<const _Hash&>(*this)(__x.__get_value().first);} {return static_cast<const _Hash&>(*this)(__x.__get_value().first);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(const _Key& __x) const size_t operator()(const _Key& __x) const
{return static_cast<const _Hash&>(*this)(__x);} {return static_cast<const _Hash&>(*this)(__x);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(const _K2& __x) const size_t operator()(const _K2& __x) const
{return static_cast<const _Hash&>(*this)(__x);} {return static_cast<const _Hash&>(*this)(__x);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void swap(__unordered_map_hasher& __y) void swap(__unordered_map_hasher& __y)
_NOEXCEPT_(__is_nothrow_swappable<_Hash>::value) _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value)
Show All 19 Linespublic:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const _Hash& hash_function() const _NOEXCEPT {return __hash_;} const _Hash& hash_function() const _NOEXCEPT {return __hash_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(const _Cp& __x) const size_t operator()(const _Cp& __x) const
{return __hash_(__x.__get_value().first);} {return __hash_(__x.__get_value().first);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(const _Key& __x) const size_t operator()(const _Key& __x) const
{return __hash_(__x);} {return __hash_(__x);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_t operator()(const _K2& __x) const size_t operator()(const _K2& __x) const
{return __hash_(__x);} {return __hash_(__x);}
#endif #endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void swap(__unordered_map_hasher& __y) void swap(__unordered_map_hasher& __y)
_NOEXCEPT_(__is_nothrow_swappable<_Hash>::value) _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value)
Show All 33 Linespublic:
bool operator()(const _Cp& __x, const _Cp& __y) const bool operator()(const _Cp& __x, const _Cp& __y) const
{return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y.__get_value().first);} {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y.__get_value().first);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Cp& __x, const _Key& __y) const bool operator()(const _Cp& __x, const _Key& __y) const
{return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);} {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Key& __x, const _Cp& __y) const bool operator()(const _Key& __x, const _Cp& __y) const
{return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);} {return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Cp& __x, const _K2& __y) const bool operator()(const _Cp& __x, const _K2& __y) const
{return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);} {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _K2& __x, const _Cp& __y) const bool operator()(const _K2& __x, const _Cp& __y) const
{return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);} {return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);}
Show All 34 Linespublic:
bool operator()(const _Cp& __x, const _Cp& __y) const bool operator()(const _Cp& __x, const _Cp& __y) const
{return __pred_(__x.__get_value().first, __y.__get_value().first);} {return __pred_(__x.__get_value().first, __y.__get_value().first);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Cp& __x, const _Key& __y) const bool operator()(const _Cp& __x, const _Key& __y) const
{return __pred_(__x.__get_value().first, __y);} {return __pred_(__x.__get_value().first, __y);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Key& __x, const _Cp& __y) const bool operator()(const _Key& __x, const _Cp& __y) const
{return __pred_(__x, __y.__get_value().first);} {return __pred_(__x, __y.__get_value().first);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _Cp& __x, const _K2& __y) const bool operator()(const _Cp& __x, const _K2& __y) const
{return __pred_(__x.__get_value().first, __y);} {return __pred_(__x.__get_value().first, __y);}
template <typename _K2> template <typename _K2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool operator()(const _K2& __x, const _Cp& __y) const bool operator()(const _K2& __x, const _Cp& __y) const
{return __pred_(__x, __y.__get_value().first);} {return __pred_(__x, __y.__get_value().first);}
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
private: private:
value_type __cc_; value_type __cc_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
value_type& __get_value() value_type& __get_value()
{ {
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
return *_VSTD::launder(_VSTD::addressof(__cc_)); return *_VSTD::launder(_VSTD::addressof(__cc_));
#else #else
return __cc_; return __cc_;
#endif #endif
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const value_type& __get_value() const const value_type& __get_value() const
{ {
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
return *_VSTD::launder(_VSTD::addressof(__cc_)); return *_VSTD::launder(_VSTD::addressof(__cc_));
#else #else
return __cc_; return __cc_;
#endif #endif
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
__nc_ref_pair_type __ref() __nc_ref_pair_type __ref()
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Linespublic:
typedef typename __table::size_type size_type; typedef typename __table::size_type size_type;
typedef typename __table::difference_type difference_type; typedef typename __table::difference_type difference_type;
typedef __hash_map_iterator<typename __table::iterator> iterator; typedef __hash_map_iterator<typename __table::iterator> iterator;
typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator; typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
typedef __hash_map_iterator<typename __table::local_iterator> local_iterator; typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator; typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typedef __map_node_handle<__node, allocator_type> node_type; typedef __map_node_handle<__node, allocator_type> node_type;
typedef __insert_return_type<iterator, node_type> insert_return_type; typedef __insert_return_type<iterator, node_type> insert_return_type;
#endif #endif
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2> template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_map; friend class _LIBCPP_TEMPLATE_VIS unordered_map;
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2> template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
Show All 31 Lines#ifndef _LIBCPP_CXX03_LANG
unordered_map(unordered_map&& __u, const allocator_type& __a); unordered_map(unordered_map&& __u, const allocator_type& __a);
unordered_map(initializer_list<value_type> __il); unordered_map(initializer_list<value_type> __il);
unordered_map(initializer_list<value_type> __il, size_type __n, unordered_map(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(), const key_equal& __eql = key_equal()); const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
unordered_map(initializer_list<value_type> __il, size_type __n, unordered_map(initializer_list<value_type> __il, size_type __n,
const hasher& __hf, const key_equal& __eql, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a); const allocator_type& __a);
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unordered_map(size_type __n, const allocator_type& __a) unordered_map(size_type __n, const allocator_type& __a)
: unordered_map(__n, hasher(), key_equal(), __a) {} : unordered_map(__n, hasher(), key_equal(), __a) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a) unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a)
: unordered_map(__n, __hf, key_equal(), __a) {} : unordered_map(__n, __hf, key_equal(), __a) {}
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines iterator emplace_hint(const_iterator __p, _Args&&... __args) {
"unordered_map::emplace_hint(const_iterator, args...) called with an iterator not" "unordered_map::emplace_hint(const_iterator, args...) called with an iterator not"
" referring to this unordered_map"); " referring to this unordered_map");
((void)__p); ((void)__p);
return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first; return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template <class... _Args> template <class... _Args>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args) pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args)
{ {
return __table_.__emplace_unique_key_args(__k, piecewise_construct, return __table_.__emplace_unique_key_args(__k, piecewise_construct,
_VSTD::forward_as_tuple(__k), _VSTD::forward_as_tuple(__k),
_VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
} }
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines#if _LIBCPP_STD_VER >= 17
template <class _Vp> template <class _Vp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator insert_or_assign(const_iterator, key_type&& __k, _Vp&& __v) iterator insert_or_assign(const_iterator, key_type&& __k, _Vp&& __v)
{ {
// FIXME: Add debug mode checking for the iterator input // FIXME: Add debug mode checking for the iterator input
return insert_or_assign(_VSTD::move(__k), _VSTD::forward<_Vp>(__v)).first; return insert_or_assign(_VSTD::move(__k), _VSTD::forward<_Vp>(__v)).first;
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);} iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(iterator __p) {return __table_.erase(__p.__i_);} iterator erase(iterator __p) {return __table_.erase(__p.__i_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);} size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __first, const_iterator __last) iterator erase(const_iterator __first, const_iterator __last)
{return __table_.erase(__first.__i_, __last.__i_);} {return __table_.erase(__first.__i_, __last.__i_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void clear() _NOEXCEPT {__table_.clear();} void clear() _NOEXCEPT {__table_.clear();}
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
insert_return_type insert(node_type&& __nh) insert_return_type insert(node_type&& __nh)
{ {
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
"node_type with incompatible allocator passed to unordered_map::insert()"); "node_type with incompatible allocator passed to unordered_map::insert()");
return __table_.template __node_handle_insert_unique< return __table_.template __node_handle_insert_unique<
node_type, insert_return_type>(_VSTD::move(__nh)); node_type, insert_return_type>(_VSTD::move(__nh));
} }
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const key_equal key_eq() const
{return __table_.key_eq().key_eq();} {return __table_.key_eq().key_eq();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);} iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);} const_iterator find(const key_type& __k) const {return __table_.find(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const _K2& __k) {return __table_.find(__k);} iterator find(const _K2& __k) {return __table_.find(__k);}
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const _K2& __k) const {return __table_.find(__k);} const_iterator find(const _K2& __k) const {return __table_.find(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_unique(__k);} size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const _K2& __k) const {return __table_.__count_unique(__k);} size_type count(const _K2& __k) const {return __table_.__count_unique(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const key_type& __k) const {return find(__k) != end();} bool contains(const key_type& __k) const {return find(__k) != end();}
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const _K2& __k) const {return find(__k) != end();} bool contains(const _K2& __k) const {return find(__k) != end();}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k) pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_unique(__k);} {return __table_.__equal_range_unique(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_unique(__k);} {return __table_.__equal_range_unique(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const _K2& __k) pair<iterator, iterator> equal_range(const _K2& __k)
{return __table_.__equal_range_unique(__k);} {return __table_.__equal_range_unique(__k);}
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const _K2& __k) const pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
{return __table_.__equal_range_unique(__k);} {return __table_.__equal_range_unique(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
mapped_type& operator[](const key_type& __k); mapped_type& operator[](const key_type& __k);
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
mapped_type& operator[](key_type&& __k); mapped_type& operator[](key_type&& __k);
#endif #endif
mapped_type& at(const key_type& __k); mapped_type& at(const key_type& __k);
const mapped_type& at(const key_type& __k) const; const mapped_type& at(const key_type& __k) const;
▲ Show 20 Lines • Show All 373 Lines • ▼ Show 20 Lines
void void
swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc, template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
class _Predicate> class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
erase_if(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __c, erase_if(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __c,
_Predicate __pred) { _Predicate __pred) {
return _VSTD::__libcpp_erase_if_container(__c, __pred); return _VSTD::__libcpp_erase_if_container(__c, __pred);
} }
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines public:
typedef typename __table::size_type size_type; typedef typename __table::size_type size_type;
typedef typename __table::difference_type difference_type; typedef typename __table::difference_type difference_type;
typedef __hash_map_iterator<typename __table::iterator> iterator; typedef __hash_map_iterator<typename __table::iterator> iterator;
typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator; typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
typedef __hash_map_iterator<typename __table::local_iterator> local_iterator; typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator; typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typedef __map_node_handle<__node, allocator_type> node_type; typedef __map_node_handle<__node, allocator_type> node_type;
#endif #endif
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2> template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_map; friend class _LIBCPP_TEMPLATE_VIS unordered_map;
template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2> template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_multimap; friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
Show All 31 Lines#ifndef _LIBCPP_CXX03_LANG
unordered_multimap(initializer_list<value_type> __il); unordered_multimap(initializer_list<value_type> __il);
unordered_multimap(initializer_list<value_type> __il, size_type __n, unordered_multimap(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(), const hasher& __hf = hasher(),
const key_equal& __eql = key_equal()); const key_equal& __eql = key_equal());
unordered_multimap(initializer_list<value_type> __il, size_type __n, unordered_multimap(initializer_list<value_type> __il, size_type __n,
const hasher& __hf, const key_equal& __eql, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a); const allocator_type& __a);
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unordered_multimap(size_type __n, const allocator_type& __a) unordered_multimap(size_type __n, const allocator_type& __a)
: unordered_multimap(__n, hasher(), key_equal(), __a) {} : unordered_multimap(__n, hasher(), key_equal(), __a) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a) unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a)
: unordered_multimap(__n, __hf, key_equal(), __a) {} : unordered_multimap(__n, __hf, key_equal(), __a) {}
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 119 Lines • ▼ Show 20 Lines#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);} size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __first, const_iterator __last) iterator erase(const_iterator __first, const_iterator __last)
{return __table_.erase(__first.__i_, __last.__i_);} {return __table_.erase(__first.__i_, __last.__i_);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void clear() _NOEXCEPT {__table_.clear();} void clear() _NOEXCEPT {__table_.clear();}
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator insert(node_type&& __nh) iterator insert(node_type&& __nh)
{ {
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
"node_type with incompatible allocator passed to unordered_multimap::insert()"); "node_type with incompatible allocator passed to unordered_multimap::insert()");
return __table_.template __node_handle_insert_multi<node_type>( return __table_.template __node_handle_insert_multi<node_type>(
_VSTD::move(__nh)); _VSTD::move(__nh));
} }
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const key_equal key_eq() const
{return __table_.key_eq().key_eq();} {return __table_.key_eq().key_eq();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);} iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);} const_iterator find(const key_type& __k) const {return __table_.find(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const _K2& __k) {return __table_.find(__k);} iterator find(const _K2& __k) {return __table_.find(__k);}
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const _K2& __k) const {return __table_.find(__k);} const_iterator find(const _K2& __k) const {return __table_.find(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_multi(__k);} size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const _K2& __k) const {return __table_.__count_multi(__k);} size_type count(const _K2& __k) const {return __table_.__count_multi(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const key_type& __k) const {return find(__k) != end();} bool contains(const key_type& __k) const {return find(__k) != end();}
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const _K2& __k) const {return find(__k) != end();} bool contains(const _K2& __k) const {return find(__k) != end();}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k) pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_multi(__k);} {return __table_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_multi(__k);} {return __table_.__equal_range_multi(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const _K2& __k) pair<iterator, iterator> equal_range(const _K2& __k)
{return __table_.__equal_range_multi(__k);} {return __table_.__equal_range_multi(__k);}
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const _K2& __k) const pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
{return __table_.__equal_range_multi(__k);} {return __table_.__equal_range_multi(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();} size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const _NOEXCEPT size_type max_bucket_count() const _NOEXCEPT
{return __table_.max_bucket_count();} {return __table_.max_bucket_count();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 296 Lines • ▼ Show 20 Lines
void void
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc, template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
class _Predicate> class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
erase_if(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __c, erase_if(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __c,
_Predicate __pred) { _Predicate __pred) {
return _VSTD::__libcpp_erase_if_container(__c, __pred); return _VSTD::__libcpp_erase_if_container(__c, __pred);
} }
Show All 28 Lines
operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
template <class _KeyT, class _ValueT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>> template <class _KeyT, class _ValueT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
using unordered_map = using unordered_map =
std::unordered_map<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>; std::unordered_map<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
template <class _KeyT, class _ValueT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>> template <class _KeyT, class _ValueT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
using unordered_multimap = using unordered_multimap =
Show All 13 Lines

libcxx/include/unordered_set

Show First 20 Lines • Show All 529 Lines • ▼ Show 20 Linespublic:
typedef typename __table::size_type size_type; typedef typename __table::size_type size_type;
typedef typename __table::difference_type difference_type; typedef typename __table::difference_type difference_type;
typedef typename __table::const_iterator iterator; typedef typename __table::const_iterator iterator;
typedef typename __table::const_iterator const_iterator; typedef typename __table::const_iterator const_iterator;
typedef typename __table::const_local_iterator local_iterator; typedef typename __table::const_local_iterator local_iterator;
typedef typename __table::const_local_iterator const_local_iterator; typedef typename __table::const_local_iterator const_local_iterator;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typedef __set_node_handle<typename __table::__node, allocator_type> node_type; typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
typedef __insert_return_type<iterator, node_type> insert_return_type; typedef __insert_return_type<iterator, node_type> insert_return_type;
#endif #endif
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2> template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_set; friend class _LIBCPP_TEMPLATE_VIS unordered_set;
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2> template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_multiset; friend class _LIBCPP_TEMPLATE_VIS unordered_multiset;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unordered_set() unordered_set()
_NOEXCEPT_(is_nothrow_default_constructible<__table>::value) _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
} }
explicit unordered_set(size_type __n, const hasher& __hf = hasher(), explicit unordered_set(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal()); const key_equal& __eql = key_equal());
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
unordered_set(size_type __n, const allocator_type& __a) unordered_set(size_type __n, const allocator_type& __a)
: unordered_set(__n, hasher(), key_equal(), __a) {} : unordered_set(__n, hasher(), key_equal(), __a) {}
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a) unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a)
: unordered_set(__n, __hf, key_equal(), __a) {} : unordered_set(__n, __hf, key_equal(), __a) {}
#endif #endif
unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql, unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a); const allocator_type& __a);
template <class _InputIterator> template <class _InputIterator>
unordered_set(_InputIterator __first, _InputIterator __last); unordered_set(_InputIterator __first, _InputIterator __last);
template <class _InputIterator> template <class _InputIterator>
unordered_set(_InputIterator __first, _InputIterator __last, unordered_set(_InputIterator __first, _InputIterator __last,
size_type __n, const hasher& __hf = hasher(), size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal()); const key_equal& __eql = key_equal());
template <class _InputIterator> template <class _InputIterator>
unordered_set(_InputIterator __first, _InputIterator __last, unordered_set(_InputIterator __first, _InputIterator __last,
size_type __n, const hasher& __hf, const key_equal& __eql, size_type __n, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a); const allocator_type& __a);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _InputIterator> template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
unordered_set(_InputIterator __first, _InputIterator __last, unordered_set(_InputIterator __first, _InputIterator __last,
size_type __n, const allocator_type& __a) size_type __n, const allocator_type& __a)
: unordered_set(__first, __last, __n, hasher(), key_equal(), __a) {} : unordered_set(__first, __last, __n, hasher(), key_equal(), __a) {}
template <class _InputIterator> template <class _InputIterator>
unordered_set(_InputIterator __first, _InputIterator __last, unordered_set(_InputIterator __first, _InputIterator __last,
size_type __n, const hasher& __hf, const allocator_type& __a) size_type __n, const hasher& __hf, const allocator_type& __a)
Show All 10 Lines#ifndef _LIBCPP_CXX03_LANG
unordered_set(unordered_set&& __u, const allocator_type& __a); unordered_set(unordered_set&& __u, const allocator_type& __a);
unordered_set(initializer_list<value_type> __il); unordered_set(initializer_list<value_type> __il);
unordered_set(initializer_list<value_type> __il, size_type __n, unordered_set(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(), const hasher& __hf = hasher(),
const key_equal& __eql = key_equal()); const key_equal& __eql = key_equal());
unordered_set(initializer_list<value_type> __il, size_type __n, unordered_set(initializer_list<value_type> __il, size_type __n,
const hasher& __hf, const key_equal& __eql, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a); const allocator_type& __a);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
unordered_set(initializer_list<value_type> __il, size_type __n, unordered_set(initializer_list<value_type> __il, size_type __n,
const allocator_type& __a) const allocator_type& __a)
: unordered_set(__il, __n, hasher(), key_equal(), __a) {} : unordered_set(__il, __n, hasher(), key_equal(), __a) {}
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
unordered_set(initializer_list<value_type> __il, size_type __n, unordered_set(initializer_list<value_type> __il, size_type __n,
const hasher& __hf, const allocator_type& __a) const hasher& __hf, const allocator_type& __a)
: unordered_set(__il, __n, __hf, key_equal(), __a) {} : unordered_set(__il, __n, __hf, key_equal(), __a) {}
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);} size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator erase(const_iterator __first, const_iterator __last) iterator erase(const_iterator __first, const_iterator __last)
{return __table_.erase(__first, __last);} {return __table_.erase(__first, __last);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void clear() _NOEXCEPT {__table_.clear();} void clear() _NOEXCEPT {__table_.clear();}
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
insert_return_type insert(node_type&& __nh) insert_return_type insert(node_type&& __nh)
{ {
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
"node_type with incompatible allocator passed to unordered_set::insert()"); "node_type with incompatible allocator passed to unordered_set::insert()");
return __table_.template __node_handle_insert_unique< return __table_.template __node_handle_insert_unique<
node_type, insert_return_type>(_VSTD::move(__nh)); node_type, insert_return_type>(_VSTD::move(__nh));
} }
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines#endif
hasher hash_function() const {return __table_.hash_function();} hasher hash_function() const {return __table_.hash_function();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const {return __table_.key_eq();} key_equal key_eq() const {return __table_.key_eq();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);} iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);} const_iterator find(const key_type& __k) const {return __table_.find(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const _K2& __k) {return __table_.find(__k);} iterator find(const _K2& __k) {return __table_.find(__k);}
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const _K2& __k) const {return __table_.find(__k);} const_iterator find(const _K2& __k) const {return __table_.find(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_unique(__k);} size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const _K2& __k) const {return __table_.__count_unique(__k);} size_type count(const _K2& __k) const {return __table_.__count_unique(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const key_type& __k) const {return find(__k) != end();} bool contains(const key_type& __k) const {return find(__k) != end();}
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const _K2& __k) const {return find(__k) != end();} bool contains(const _K2& __k) const {return find(__k) != end();}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k) pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_unique(__k);} {return __table_.__equal_range_unique(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_unique(__k);} {return __table_.__equal_range_unique(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const _K2& __k) pair<iterator, iterator> equal_range(const _K2& __k)
{return __table_.__equal_range_unique(__k);} {return __table_.__equal_range_unique(__k);}
template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const _K2& __k) const pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
{return __table_.__equal_range_unique(__k);} {return __table_.__equal_range_unique(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();} size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();} size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);} size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
▲ Show 20 Lines • Show All 275 Lines • ▼ Show 20 Lines
void void
swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Value, class _Hash, class _Pred, class _Alloc, template <class _Value, class _Hash, class _Pred, class _Alloc,
class _Predicate> class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename unordered_set<_Value, _Hash, _Pred, _Alloc>::size_type typename unordered_set<_Value, _Hash, _Pred, _Alloc>::size_type
erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c, erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c,
_Predicate __pred) { _Predicate __pred) {
return _VSTD::__libcpp_erase_if_container(__c, __pred); return _VSTD::__libcpp_erase_if_container(__c, __pred);
} }
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linespublic:
typedef typename __table::size_type size_type; typedef typename __table::size_type size_type;
typedef typename __table::difference_type difference_type; typedef typename __table::difference_type difference_type;
typedef typename __table::const_iterator iterator; typedef typename __table::const_iterator iterator;
typedef typename __table::const_iterator const_iterator; typedef typename __table::const_iterator const_iterator;
typedef typename __table::const_local_iterator local_iterator; typedef typename __table::const_local_iterator local_iterator;
typedef typename __table::const_local_iterator const_local_iterator; typedef typename __table::const_local_iterator const_local_iterator;
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typedef __set_node_handle<typename __table::__node, allocator_type> node_type; typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
#endif #endif
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2> template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_set; friend class _LIBCPP_TEMPLATE_VIS unordered_set;
template <class _Value2, class _Hash2, class _Pred2, class _Alloc2> template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
friend class _LIBCPP_TEMPLATE_VIS unordered_multiset; friend class _LIBCPP_TEMPLATE_VIS unordered_multiset;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
unordered_multiset() unordered_multiset()
_NOEXCEPT_(is_nothrow_default_constructible<__table>::value) _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
{ {
_VSTD::__debug_db_insert_c(this); _VSTD::__debug_db_insert_c(this);
} }
explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(), explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal()); const key_equal& __eql = key_equal());
unordered_multiset(size_type __n, const hasher& __hf, unordered_multiset(size_type __n, const hasher& __hf,
const key_equal& __eql, const allocator_type& __a); const key_equal& __eql, const allocator_type& __a);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
unordered_multiset(size_type __n, const allocator_type& __a) unordered_multiset(size_type __n, const allocator_type& __a)
: unordered_multiset(__n, hasher(), key_equal(), __a) {} : unordered_multiset(__n, hasher(), key_equal(), __a) {}
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a) unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a)
: unordered_multiset(__n, __hf, key_equal(), __a) {} : unordered_multiset(__n, __hf, key_equal(), __a) {}
#endif #endif
template <class _InputIterator> template <class _InputIterator>
unordered_multiset(_InputIterator __first, _InputIterator __last); unordered_multiset(_InputIterator __first, _InputIterator __last);
template <class _InputIterator> template <class _InputIterator>
unordered_multiset(_InputIterator __first, _InputIterator __last, unordered_multiset(_InputIterator __first, _InputIterator __last,
size_type __n, const hasher& __hf = hasher(), size_type __n, const hasher& __hf = hasher(),
const key_equal& __eql = key_equal()); const key_equal& __eql = key_equal());
template <class _InputIterator> template <class _InputIterator>
unordered_multiset(_InputIterator __first, _InputIterator __last, unordered_multiset(_InputIterator __first, _InputIterator __last,
size_type __n , const hasher& __hf, size_type __n , const hasher& __hf,
const key_equal& __eql, const allocator_type& __a); const key_equal& __eql, const allocator_type& __a);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _InputIterator> template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
unordered_multiset(_InputIterator __first, _InputIterator __last, unordered_multiset(_InputIterator __first, _InputIterator __last,
size_type __n, const allocator_type& __a) size_type __n, const allocator_type& __a)
: unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) {} : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) {}
template <class _InputIterator> template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
unordered_multiset(_InputIterator __first, _InputIterator __last, unordered_multiset(_InputIterator __first, _InputIterator __last,
Show All 11 Lines#ifndef _LIBCPP_CXX03_LANG
unordered_multiset(unordered_multiset&& __u, const allocator_type& __a); unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
unordered_multiset(initializer_list<value_type> __il); unordered_multiset(initializer_list<value_type> __il);
unordered_multiset(initializer_list<value_type> __il, size_type __n, unordered_multiset(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(), const hasher& __hf = hasher(),
const key_equal& __eql = key_equal()); const key_equal& __eql = key_equal());
unordered_multiset(initializer_list<value_type> __il, size_type __n, unordered_multiset(initializer_list<value_type> __il, size_type __n,
const hasher& __hf, const key_equal& __eql, const hasher& __hf, const key_equal& __eql,
const allocator_type& __a); const allocator_type& __a);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
unordered_multiset(initializer_list<value_type> __il, size_type __n, const allocator_type& __a) unordered_multiset(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
: unordered_multiset(__il, __n, hasher(), key_equal(), __a) {} : unordered_multiset(__il, __n, hasher(), key_equal(), __a) {}
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a) unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
: unordered_multiset(__il, __n, __hf, key_equal(), __a) {} : unordered_multiset(__il, __n, __hf, key_equal(), __a) {}
#endif #endif
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, const value_type& __x) iterator insert(const_iterator __p, const value_type& __x)
{return __table_.__insert_multi(__p, __x);} {return __table_.__insert_multi(__p, __x);}
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void insert(_InputIterator __first, _InputIterator __last); void insert(_InputIterator __first, _InputIterator __last);
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator insert(node_type&& __nh) iterator insert(node_type&& __nh)
{ {
_LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(), _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
"node_type with incompatible allocator passed to unordered_multiset::insert()"); "node_type with incompatible allocator passed to unordered_multiset::insert()");
return __table_.template __node_handle_insert_multi<node_type>( return __table_.template __node_handle_insert_multi<node_type>(
_VSTD::move(__nh)); _VSTD::move(__nh));
} }
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines#endif
hasher hash_function() const {return __table_.hash_function();} hasher hash_function() const {return __table_.hash_function();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
key_equal key_eq() const {return __table_.key_eq();} key_equal key_eq() const {return __table_.key_eq();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const key_type& __k) {return __table_.find(__k);} iterator find(const key_type& __k) {return __table_.find(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const key_type& __k) const {return __table_.find(__k);} const_iterator find(const key_type& __k) const {return __table_.find(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
iterator find(const _K2& __k) {return __table_.find(__k);} iterator find(const _K2& __k) {return __table_.find(__k);}
template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const_iterator find(const _K2& __k) const {return __table_.find(__k);} const_iterator find(const _K2& __k) const {return __table_.find(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const key_type& __k) const {return __table_.__count_multi(__k);} size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type count(const _K2& __k) const {return __table_.__count_multi(__k);} size_type count(const _K2& __k) const {return __table_.__count_multi(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const key_type& __k) const {return find(__k) != end();} bool contains(const key_type& __k) const {return find(__k) != end();}
template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
bool contains(const _K2& __k) const {return find(__k) != end();} bool contains(const _K2& __k) const {return find(__k) != end();}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const key_type& __k) pair<iterator, iterator> equal_range(const key_type& __k)
{return __table_.__equal_range_multi(__k);} {return __table_.__equal_range_multi(__k);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const key_type& __k) const pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
{return __table_.__equal_range_multi(__k);} {return __table_.__equal_range_multi(__k);}
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<iterator, iterator> equal_range(const _K2& __k) pair<iterator, iterator> equal_range(const _K2& __k)
{return __table_.__equal_range_multi(__k);} {return __table_.__equal_range_multi(__k);}
template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr> template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
pair<const_iterator, const_iterator> equal_range(const _K2& __k) const pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
{return __table_.__equal_range_multi(__k);} {return __table_.__equal_range_multi(__k);}
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();} size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();} size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);} size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
▲ Show 20 Lines • Show All 275 Lines • ▼ Show 20 Lines
void void
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Value, class _Hash, class _Pred, class _Alloc, template <class _Value, class _Hash, class _Pred, class _Alloc,
class _Predicate> class _Predicate>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::size_type typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::size_type
erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c, erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c,
_Predicate __pred) { _Predicate __pred) {
return _VSTD::__libcpp_erase_if_container(__c, __pred); return _VSTD::__libcpp_erase_if_container(__c, __pred);
} }
Show All 28 Lines
operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
{ {
return !(__x == __y); return !(__x == __y);
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>> template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
using unordered_set = std::unordered_set<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>; using unordered_set = std::unordered_set<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>> template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
using unordered_multiset = std::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>; using unordered_multiset = std::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
} // namespace pmr } // namespace pmr
Show All 10 Lines

libcxx/include/valarray

Show First 20 Lines • Show All 1,098 Lines • ▼ Show 20 Linesprivate:
const _Up* const _Up*
end(const valarray<_Up>& __v); end(const valarray<_Up>& __v);
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
void __clear(size_t __capacity); void __clear(size_t __capacity);
valarray& __assign_range(const value_type* __f, const value_type* __l); valarray& __assign_range(const value_type* __f, const value_type* __l);
}; };
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
template<class _Tp, size_t _Size> template<class _Tp, size_t _Size>
valarray(const _Tp(&)[_Size], size_t) -> valarray<_Tp>; valarray(const _Tp(&)[_Size], size_t) -> valarray<_Tp>;
#endif #endif
extern template _LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t); extern template _LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t);
template <class _Op, class _Tp> template <class _Op, class _Tp>
struct _UnaryOp<_Op, valarray<_Tp> > struct _UnaryOp<_Op, valarray<_Tp> >
▲ Show 20 Lines • Show All 3,826 Lines • Show Last 20 Lines

libcxx/include/variant

Show First 20 Lines • Show All 260 Lines • ▼ Show 20 Lines
public: public:
const char* what() const _NOEXCEPT override; const char* what() const _NOEXCEPT override;
}; };
} // namespace std } // namespace std
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
// Light N-dimensional array of function pointers. Used in place of std::array to avoid // Light N-dimensional array of function pointers. Used in place of std::array to avoid
// adding a dependency. // adding a dependency.
template<class _Tp, size_t _Size> template<class _Tp, size_t _Size>
struct __farray { struct __farray {
static_assert(_Size > 0, "N-dimensional array should never be empty in std::visit"); static_assert(_Size > 0, "N-dimensional array should never be empty in std::visit");
_Tp __buf_[_Size] = {}; _Tp __buf_[_Size] = {};
▲ Show 20 Lines • Show All 377 Lines • ▼ Show 20 Linesstruct __variant {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr decltype(auto) __visit_value(_Visitor&& __visitor, static constexpr decltype(auto) __visit_value(_Visitor&& __visitor,
_Vs&&... __vs) { _Vs&&... __vs) {
return __visit_alt( return __visit_alt(
__make_value_visitor(_VSTD::forward<_Visitor>(__visitor)), __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
_VSTD::forward<_Vs>(__vs)...); _VSTD::forward<_Vs>(__vs)...);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Rp, class _Visitor, class... _Vs> template <class _Rp, class _Visitor, class... _Vs>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr _Rp __visit_value(_Visitor&& __visitor, static constexpr _Rp __visit_value(_Visitor&& __visitor,
_Vs&&... __vs) { _Vs&&... __vs) {
return __visit_alt( return __visit_alt(
__make_value_visitor<_Rp>(_VSTD::forward<_Visitor>(__visitor)), __make_value_visitor<_Rp>(_VSTD::forward<_Visitor>(__visitor)),
_VSTD::forward<_Vs>(__vs)...); _VSTD::forward<_Vs>(__vs)...);
} }
Show All 15 Lines constexpr decltype(auto) operator()(_Alts&&... __alts) const {
_Visitor, _Visitor,
decltype((_VSTD::forward<_Alts>(__alts).__value))...>(); decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
return _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor), return _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor),
_VSTD::forward<_Alts>(__alts).__value...); _VSTD::forward<_Alts>(__alts).__value...);
} }
_Visitor&& __visitor; _Visitor&& __visitor;
}; };
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Rp, class _Visitor> template <class _Rp, class _Visitor>
struct __value_visitor_return_type { struct __value_visitor_return_type {
template <class... _Alts> template <class... _Alts>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr _Rp operator()(_Alts&&... __alts) const { constexpr _Rp operator()(_Alts&&... __alts) const {
__std_visit_exhaustive_visitor_check< __std_visit_exhaustive_visitor_check<
_Visitor, _Visitor,
decltype((_VSTD::forward<_Alts>(__alts).__value))...>(); decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
Show All 12 Lines
#endif #endif
template <class _Visitor> template <class _Visitor>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr auto __make_value_visitor(_Visitor&& __visitor) { static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)}; return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)};
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Rp, class _Visitor> template <class _Rp, class _Visitor>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
static constexpr auto __make_value_visitor(_Visitor&& __visitor) { static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
return __value_visitor_return_type<_Rp, _Visitor>{_VSTD::forward<_Visitor>(__visitor)}; return __value_visitor_return_type<_Rp, _Visitor>{_VSTD::forward<_Visitor>(__visitor)};
} }
#endif #endif
}; };
▲ Show 20 Lines • Show All 914 Lines • ▼ Show 20 Lines
constexpr bool operator==(const variant<_Types...>& __lhs, constexpr bool operator==(const variant<_Types...>& __lhs,
const variant<_Types...>& __rhs) { const variant<_Types...>& __rhs) {
using __variant_detail::__visitation::__variant; using __variant_detail::__visitation::__variant;
if (__lhs.index() != __rhs.index()) return false; if (__lhs.index() != __rhs.index()) return false;
if (__lhs.valueless_by_exception()) return true; if (__lhs.valueless_by_exception()) return true;
return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<equal_to<>>{}, __lhs, __rhs); return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<equal_to<>>{}, __lhs, __rhs);
} }
# if _LIBCPP_STD_VER > 17 # if _LIBCPP_STD_VER >= 20
template <class... _Types> requires (three_way_comparable<_Types> && ...) template <class... _Types> requires (three_way_comparable<_Types> && ...)
_LIBCPP_HIDE_FROM_ABI constexpr common_comparison_category_t<compare_three_way_result_t<_Types>...> _LIBCPP_HIDE_FROM_ABI constexpr common_comparison_category_t<compare_three_way_result_t<_Types>...>
operator<=>(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { operator<=>(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
using __variant_detail::__visitation::__variant; using __variant_detail::__visitation::__variant;
using __result_t = common_comparison_category_t<compare_three_way_result_t<_Types>...>; using __result_t = common_comparison_category_t<compare_three_way_result_t<_Types>...>;
if (__lhs.valueless_by_exception() && __rhs.valueless_by_exception()) if (__lhs.valueless_by_exception() && __rhs.valueless_by_exception())
return strong_ordering::equal; return strong_ordering::equal;
if (__lhs.valueless_by_exception()) if (__lhs.valueless_by_exception())
return strong_ordering::less; return strong_ordering::less;
if (__rhs.valueless_by_exception()) if (__rhs.valueless_by_exception())
return strong_ordering::greater; return strong_ordering::greater;
if (auto __c = __lhs.index() <=> __rhs.index(); __c != 0) if (auto __c = __lhs.index() <=> __rhs.index(); __c != 0)
return __c; return __c;
auto __three_way = []<class _Type>(const _Type& __v, const _Type& __w) -> __result_t { return __v <=> __w; }; auto __three_way = []<class _Type>(const _Type& __v, const _Type& __w) -> __result_t { return __v <=> __w; };
return __variant::__visit_value_at(__lhs.index(), __three_way, __lhs, __rhs); return __variant::__visit_value_at(__lhs.index(), __three_way, __lhs, __rhs);
} }
# endif // _LIBCPP_STD_VER > 17 # endif // _LIBCPP_STD_VER >= 20
template <class... _Types> template <class... _Types>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr bool operator!=(const variant<_Types...>& __lhs, constexpr bool operator!=(const variant<_Types...>& __lhs,
const variant<_Types...>& __rhs) { const variant<_Types...>& __rhs) {
using __variant_detail::__visitation::__variant; using __variant_detail::__visitation::__variant;
if (__lhs.index() != __rhs.index()) return true; if (__lhs.index() != __rhs.index()) return true;
if (__lhs.valueless_by_exception()) return false; if (__lhs.valueless_by_exception()) return false;
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
constexpr decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) { constexpr decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) {
using __variant_detail::__visitation::__variant; using __variant_detail::__visitation::__variant;
_VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...); _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...);
return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor), return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
_VSTD::forward<_Vs>(__vs)...); _VSTD::forward<_Vs>(__vs)...);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template < template <
class _Rp, class _Visitor, class... _Vs, class _Rp, class _Visitor, class... _Vs,
typename = void_t<decltype(_VSTD::__as_variant(std::declval<_Vs>()))...> > typename = void_t<decltype(_VSTD::__as_variant(std::declval<_Vs>()))...> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
constexpr _Rp visit(_Visitor&& __visitor, _Vs&&... __vs) { constexpr _Rp visit(_Visitor&& __visitor, _Vs&&... __vs) {
using __variant_detail::__visitation::__variant; using __variant_detail::__visitation::__variant;
_VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...); _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...);
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
} }
template <class _Tp, class... _Types> template <class _Tp, class... _Types>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr auto&& __unchecked_get(variant<_Types...>& __v) noexcept { constexpr auto&& __unchecked_get(variant<_Types...>& __v) noexcept {
return std::__unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v); return std::__unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
} }
#endif // _LIBCPP_STD_VER > 14 #endif // _LIBCPP_STD_VER >= 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
# include <type_traits> # include <type_traits>
# include <typeinfo> # include <typeinfo>
# include <utility> # include <utility>
#endif #endif
#endif // _LIBCPP_VARIANT #endif // _LIBCPP_VARIANT

libcxx/include/vector

Show First 20 Lines • Show All 383 Lines • ▼ Show 20 Lines
#else #else
_NOEXCEPT _NOEXCEPT
#endif #endif
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
} }
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit vector(size_type __n); _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit vector(size_type __n);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit vector(size_type __n, const allocator_type& __a); _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit vector(size_type __n, const allocator_type& __a);
#endif #endif
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector(size_type __n, const value_type& __x); _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector(size_type __n, const value_type& __x);
template <class = __enable_if_t<__is_allocator<_Allocator>::value> > template <class = __enable_if_t<__is_allocator<_Allocator>::value> >
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
vector(size_type __n, const value_type& __x, const allocator_type& __a) vector(size_type __n, const value_type& __x, const allocator_type& __a)
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
vector& operator=(initializer_list<value_type> __il) vector& operator=(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end()); return *this;} {assign(__il.begin(), __il.end()); return *this;}
#endif // !_LIBCPP_CXX03_LANG #endif // !_LIBCPP_CXX03_LANG
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
vector(vector&& __x) vector(vector&& __x)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
noexcept; noexcept;
#else #else
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
#endif #endif
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
vector(vector&& __x, const __type_identity_t<allocator_type>& __a); vector(vector&& __x, const __type_identity_t<allocator_type>& __a);
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines const value_type* data() const _NOEXCEPT
{return std::__to_address(this->__begin_);} {return std::__to_address(this->__begin_);}
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void push_back(const_reference __x); _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void push_back(const_reference __x);
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __x); _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __x);
template <class... _Args> template <class... _Args>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
reference emplace_back(_Args&&... __args); reference emplace_back(_Args&&... __args);
#else #else
void emplace_back(_Args&&... __args); void emplace_back(_Args&&... __args);
#endif #endif
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
void pop_back(); void pop_back();
▲ Show 20 Lines • Show All 472 Lines • ▼ Show 20 Linesvector<_Tp, _Allocator>::vector(size_type __n)
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__n); __construct_at_end(__n);
} }
__guard.__complete(); __guard.__complete();
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
vector<_Tp, _Allocator>::vector(size_type __n, const allocator_type& __a) vector<_Tp, _Allocator>::vector(size_type __n, const allocator_type& __a)
: __end_cap_(nullptr, __a) : __end_cap_(nullptr, __a)
{ {
auto __guard = std::__make_exception_guard(__destroy_vector(*this)); auto __guard = std::__make_exception_guard(__destroy_vector(*this));
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
if (__n > 0) if (__n > 0)
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Linesvector<_Tp, _Allocator>::vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
} }
__guard.__complete(); __guard.__complete();
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
vector<_Tp, _Allocator>::vector(vector&& __x) vector<_Tp, _Allocator>::vector(vector&& __x)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
noexcept noexcept
#else #else
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
#endif #endif
: __end_cap_(nullptr, std::move(__x.__alloc())) : __end_cap_(nullptr, std::move(__x.__alloc()))
{ {
std::__debug_db_insert_c(this); std::__debug_db_insert_c(this);
std::__debug_db_swap(this, std::addressof(__x)); std::__debug_db_swap(this, std::addressof(__x));
▲ Show 20 Lines • Show All 355 Lines • ▼ Show 20 Lines// __v.emplace_back(std::forward<_Args>(__args)...);
__v.__end_++; __v.__end_++;
__swap_out_circular_buffer(__v); __swap_out_circular_buffer(__v);
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class... _Args> template <class... _Args>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
inline inline
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
typename vector<_Tp, _Allocator>::reference typename vector<_Tp, _Allocator>::reference
#else #else
void void
#endif #endif
vector<_Tp, _Allocator>::emplace_back(_Args&&... __args) vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
{ {
if (this->__end_ < this->__end_cap()) if (this->__end_ < this->__end_cap())
{ {
__construct_one_at_end(std::forward<_Args>(__args)...); __construct_one_at_end(std::forward<_Args>(__args)...);
} }
else else
__emplace_back_slow_path(std::forward<_Args>(__args)...); __emplace_back_slow_path(std::forward<_Args>(__args)...);
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
return this->back(); return this->back();
#endif #endif
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
inline inline
void void
▲ Show 20 Lines • Show All 505 Lines • ▼ Show 20 Lines class __destroy_vector {
private: private:
vector& __vec_; vector& __vec_;
}; };
public: public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~vector() { __destroy_vector(*this)(); } _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~vector() { __destroy_vector(*this)(); }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n, const allocator_type& __a); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n, const allocator_type& __a);
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(size_type __n, const value_type& __v); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(size_type __n, const value_type& __v);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(size_type __n, const value_type& __v, const allocator_type& __a); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(size_type __n, const value_type& __v, const allocator_type& __a);
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_InputIterator __first, _InputIterator __last, _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_InputIterator __first, _InputIterator __last,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type* = 0); typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type* = 0);
template <class _InputIterator> template <class _InputIterator>
Show All 17 Lines#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
vector& operator=(initializer_list<value_type> __il) vector& operator=(initializer_list<value_type> __il)
{assign(__il.begin(), __il.end()); return *this;} {assign(__il.begin(), __il.end()); return *this;}
#endif // !_LIBCPP_CXX03_LANG #endif // !_LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
vector(vector&& __v) vector(vector&& __v)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
noexcept; noexcept;
#else #else
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value); _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(vector&& __v, const __type_identity_t<allocator_type>& __a); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(vector&& __v, const __type_identity_t<allocator_type>& __a);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
vector& operator=(vector&& __v) vector& operator=(vector&& __v)
_NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)); _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines#endif
_LIBCPP_HIDE_FROM_ABI const_reference at(size_type __n) const; _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __n) const;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference front() {return __make_ref(0);} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference front() {return __make_ref(0);}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference front() const {return __make_ref(0);} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference front() const {return __make_ref(0);}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference back() {return __make_ref(__size_ - 1);} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference back() {return __make_ref(__size_ - 1);}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference back() const {return __make_ref(__size_ - 1);} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference back() const {return __make_ref(__size_ - 1);}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void push_back(const value_type& __x); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void push_back(const value_type& __x);
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class... _Args> template <class... _Args>
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference emplace_back(_Args&&... __args) _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference emplace_back(_Args&&... __args)
#else #else
_LIBCPP_HIDE_FROM_ABI void emplace_back(_Args&&... __args) _LIBCPP_HIDE_FROM_ABI void emplace_back(_Args&&... __args)
#endif #endif
{ {
push_back ( value_type ( std::forward<_Args>(__args)... )); push_back ( value_type ( std::forward<_Args>(__args)... ));
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
return this->back(); return this->back();
#endif #endif
} }
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void pop_back() {--__size_;} _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void pop_back() {--__size_;}
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class... _Args> template <class... _Args>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator emplace(const_iterator __position, _Args&&... __args) _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator emplace(const_iterator __position, _Args&&... __args)
{ return insert ( __position, value_type ( std::forward<_Args>(__args)... )); } { return insert ( __position, value_type ( std::forward<_Args>(__args)... )); }
#endif #endif
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __position, const value_type& __x); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __position, const value_type& __x);
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __position, size_type __n, const value_type& __x); _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __position, size_type __n, const value_type& __x);
template <class _InputIterator> template <class _InputIterator>
▲ Show 20 Lines • Show All 262 Lines • ▼ Show 20 Lines
{ {
if (__n > 0) if (__n > 0)
{ {
__vallocate(__n); __vallocate(__n);
__construct_at_end(__n, false); __construct_at_end(__n, false);
} }
} }
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
vector<bool, _Allocator>::vector(size_type __n, const allocator_type& __a) vector<bool, _Allocator>::vector(size_type __n, const allocator_type& __a)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, static_cast<__storage_allocator>(__a)) __cap_alloc_(0, static_cast<__storage_allocator>(__a))
{ {
if (__n > 0) if (__n > 0)
▲ Show 20 Lines • Show All 205 Lines • ▼ Show 20 Lines if (this != std::addressof(__v))
} }
__size_ = __v.__size_; __size_ = __v.__size_;
} }
return *this; return *this;
} }
template <class _Allocator> template <class _Allocator>
inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(vector&& __v) inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(vector&& __v)
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_NOEXCEPT _NOEXCEPT
#else #else
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value) _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
#endif #endif
: __begin_(__v.__begin_), : __begin_(__v.__begin_),
__size_(__v.__size_), __size_(__v.__size_),
__cap_alloc_(std::move(__v.__cap_alloc_)) { __cap_alloc_(std::move(__v.__cap_alloc_)) {
__v.__begin_ = nullptr; __v.__begin_ = nullptr;
▲ Show 20 Lines • Show All 504 Lines • ▼ Show 20 Lines
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
void void
swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y) swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
{ {
__x.swap(__y); __x.swap(__y);
} }
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
template <class _Tp, class _Allocator, class _Up> template <class _Tp, class _Allocator, class _Up>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::size_type inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::size_type
erase(vector<_Tp, _Allocator>& __c, const _Up& __v) { erase(vector<_Tp, _Allocator>& __c, const _Up& __v) {
auto __old_size = __c.size(); auto __old_size = __c.size();
__c.erase(std::remove(__c.begin(), __c.end(), __v), __c.end()); __c.erase(std::remove(__c.begin(), __c.end(), __v), __c.end());
return __old_size - __c.size(); return __old_size - __c.size();
} }
Show All 9 Lines
template <> template <>
inline constexpr bool __format::__enable_insertable<vector<char>> = true; inline constexpr bool __format::__enable_insertable<vector<char>> = true;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <> template <>
inline constexpr bool __format::__enable_insertable<vector<wchar_t>> = true; inline constexpr bool __format::__enable_insertable<vector<wchar_t>> = true;
#endif #endif
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER >= 20
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
template <class _Tp, class CharT> template <class _Tp, class CharT>
// Since is-vector-bool-reference is only used once it's inlined here. // Since is-vector-bool-reference is only used once it's inlined here.
requires same_as<typename _Tp::__container, vector<bool, typename _Tp::__container::allocator_type>> requires same_as<typename _Tp::__container, vector<bool, typename _Tp::__container::allocator_type>>
struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<_Tp, CharT> { struct _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT formatter<_Tp, CharT> {
private: private:
formatter<bool, CharT> __underlying_; formatter<bool, CharT> __underlying_;
public: public:
template <class _ParseContext> template <class _ParseContext>
_LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) { _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
return __underlying_.parse(__ctx); return __underlying_.parse(__ctx);
} }
template <class _FormatContext> template <class _FormatContext>
_LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const _Tp& __ref, _FormatContext& __ctx) const { _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const _Tp& __ref, _FormatContext& __ctx) const {
return __underlying_.format(__ref, __ctx); return __underlying_.format(__ref, __ctx);
} }
}; };
#endif // _LIBCPP_STD_VER > 20 #endif // _LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace pmr { namespace pmr {
template <class _ValueT> template <class _ValueT>
using vector = std::vector<_ValueT, polymorphic_allocator<_ValueT>>; using vector = std::vector<_ValueT, polymorphic_allocator<_ValueT>>;
} // namespace pmr } // namespace pmr
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif #endif
Show All 11 Lines

libcxx/include/version

Show First 20 Lines • Show All 202 Lines • ▼ Show 20 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
// clang-format off // clang-format off
#if _LIBCPP_STD_VER > 11 #if _LIBCPP_STD_VER >= 14
# define __cpp_lib_chrono_udls 201304L # define __cpp_lib_chrono_udls 201304L
# define __cpp_lib_complex_udls 201309L # define __cpp_lib_complex_udls 201309L
# define __cpp_lib_exchange_function 201304L # define __cpp_lib_exchange_function 201304L
# define __cpp_lib_generic_associative_lookup 201304L # define __cpp_lib_generic_associative_lookup 201304L
# define __cpp_lib_integer_sequence 201304L # define __cpp_lib_integer_sequence 201304L
# define __cpp_lib_integral_constant_callable 201304L # define __cpp_lib_integral_constant_callable 201304L
# define __cpp_lib_is_final 201402L # define __cpp_lib_is_final 201402L
# define __cpp_lib_is_null_pointer 201309L # define __cpp_lib_is_null_pointer 201309L
# define __cpp_lib_make_reverse_iterator 201402L # define __cpp_lib_make_reverse_iterator 201402L
# define __cpp_lib_make_unique 201304L # define __cpp_lib_make_unique 201304L
# define __cpp_lib_null_iterators 201304L # define __cpp_lib_null_iterators 201304L
# define __cpp_lib_quoted_string_io 201304L # define __cpp_lib_quoted_string_io 201304L
# define __cpp_lib_result_of_sfinae 201210L # define __cpp_lib_result_of_sfinae 201210L
# define __cpp_lib_robust_nonmodifying_seq_ops 201304L # define __cpp_lib_robust_nonmodifying_seq_ops 201304L
# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex) # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex)
# define __cpp_lib_shared_timed_mutex 201402L # define __cpp_lib_shared_timed_mutex 201402L
# endif # endif
# define __cpp_lib_string_udls 201304L # define __cpp_lib_string_udls 201304L
# define __cpp_lib_transformation_trait_aliases 201304L # define __cpp_lib_transformation_trait_aliases 201304L
# define __cpp_lib_transparent_operators 201210L # define __cpp_lib_transparent_operators 201210L
# define __cpp_lib_tuple_element_t 201402L # define __cpp_lib_tuple_element_t 201402L
# define __cpp_lib_tuples_by_type 201304L # define __cpp_lib_tuples_by_type 201304L
#endif #endif
#if _LIBCPP_STD_VER > 14 #if _LIBCPP_STD_VER >= 17
# define __cpp_lib_addressof_constexpr 201603L # define __cpp_lib_addressof_constexpr 201603L
# define __cpp_lib_allocator_traits_is_always_equal 201411L # define __cpp_lib_allocator_traits_is_always_equal 201411L
# define __cpp_lib_any 201606L # define __cpp_lib_any 201606L
# define __cpp_lib_apply 201603L # define __cpp_lib_apply 201603L
# define __cpp_lib_array_constexpr 201603L # define __cpp_lib_array_constexpr 201603L
# define __cpp_lib_as_const 201510L # define __cpp_lib_as_const 201510L
# define __cpp_lib_atomic_is_always_lock_free 201603L # define __cpp_lib_atomic_is_always_lock_free 201603L
# define __cpp_lib_bool_constant 201505L # define __cpp_lib_bool_constant 201505L
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
# define __cpp_lib_transparent_operators 201510L # define __cpp_lib_transparent_operators 201510L
# define __cpp_lib_type_trait_variable_templates 201510L # define __cpp_lib_type_trait_variable_templates 201510L
# define __cpp_lib_uncaught_exceptions 201411L # define __cpp_lib_uncaught_exceptions 201411L
# define __cpp_lib_unordered_map_try_emplace 201411L # define __cpp_lib_unordered_map_try_emplace 201411L
# define __cpp_lib_variant 202102L # define __cpp_lib_variant 202102L
# define __cpp_lib_void_t 201411L # define __cpp_lib_void_t 201411L
#endif #endif
#if _LIBCPP_STD_VER > 17 #if _LIBCPP_STD_VER >= 20
# undef __cpp_lib_array_constexpr # undef __cpp_lib_array_constexpr
# define __cpp_lib_array_constexpr 201811L # define __cpp_lib_array_constexpr 201811L
# define __cpp_lib_assume_aligned 201811L # define __cpp_lib_assume_aligned 201811L
# define __cpp_lib_atomic_flag_test 201907L # define __cpp_lib_atomic_flag_test 201907L
// # define __cpp_lib_atomic_float 201711L // # define __cpp_lib_atomic_float 201711L
# define __cpp_lib_atomic_lock_free_type_aliases 201907L # define __cpp_lib_atomic_lock_free_type_aliases 201907L
// # define __cpp_lib_atomic_ref 201806L // # define __cpp_lib_atomic_ref 201806L
// # define __cpp_lib_atomic_shared_ptr 201711L // # define __cpp_lib_atomic_shared_ptr 201711L
Show All 20 Lines
# define __cpp_lib_constexpr_memory 201811L # define __cpp_lib_constexpr_memory 201811L
# define __cpp_lib_constexpr_numeric 201911L # define __cpp_lib_constexpr_numeric 201911L
# define __cpp_lib_constexpr_string 201907L # define __cpp_lib_constexpr_string 201907L
# define __cpp_lib_constexpr_string_view 201811L # define __cpp_lib_constexpr_string_view 201811L
# define __cpp_lib_constexpr_tuple 201811L # define __cpp_lib_constexpr_tuple 201811L
# define __cpp_lib_constexpr_utility 201811L # define __cpp_lib_constexpr_utility 201811L
# define __cpp_lib_constexpr_vector 201907L # define __cpp_lib_constexpr_vector 201907L
# define __cpp_lib_coroutine 201902L # define __cpp_lib_coroutine 201902L
# if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L # if _LIBCPP_STD_VER >= 20 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
# define __cpp_lib_destroying_delete 201806L # define __cpp_lib_destroying_delete 201806L
# endif # endif
# define __cpp_lib_endian 201907L # define __cpp_lib_endian 201907L
# define __cpp_lib_erase_if 202002L # define __cpp_lib_erase_if 202002L
# undef __cpp_lib_execution # undef __cpp_lib_execution
// # define __cpp_lib_execution 201902L // # define __cpp_lib_execution 201902L
# if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT) # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_format) && !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
// # define __cpp_lib_format 202106L // # define __cpp_lib_format 202106L
Show All 35 Lines
// # define __cpp_lib_syncbuf 201803L // # define __cpp_lib_syncbuf 201803L
// # define __cpp_lib_three_way_comparison 201907L // # define __cpp_lib_three_way_comparison 201907L
# define __cpp_lib_to_address 201711L # define __cpp_lib_to_address 201711L
# define __cpp_lib_to_array 201907L # define __cpp_lib_to_array 201907L
# define __cpp_lib_type_identity 201806L # define __cpp_lib_type_identity 201806L
# define __cpp_lib_unwrap_ref 201811L # define __cpp_lib_unwrap_ref 201811L
#endif #endif
#if _LIBCPP_STD_VER > 20 #if _LIBCPP_STD_VER >= 23
# define __cpp_lib_adaptor_iterator_pair_constructor 202106L # define __cpp_lib_adaptor_iterator_pair_constructor 202106L
# define __cpp_lib_allocate_at_least 202106L # define __cpp_lib_allocate_at_least 202106L
// # define __cpp_lib_associative_heterogeneous_erasure 202110L // # define __cpp_lib_associative_heterogeneous_erasure 202110L
// # define __cpp_lib_bind_back 202202L // # define __cpp_lib_bind_back 202202L
# define __cpp_lib_byteswap 202110L # define __cpp_lib_byteswap 202110L
# define __cpp_lib_constexpr_bitset 202207L # define __cpp_lib_constexpr_bitset 202207L
# define __cpp_lib_constexpr_charconv 202207L # define __cpp_lib_constexpr_charconv 202207L
// # define __cpp_lib_constexpr_cmath 202202L // # define __cpp_lib_constexpr_cmath 202202L
Show All 32 Lines

libcxx/utils/generate_escaped_output_table.py

Show First 20 Lines • Show All 222 Lines • ▼ Show 20 Lines
#include <cstdint> #include <cstdint>
#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 > 20 #if _LIBCPP_STD_VER >= 23
namespace __escaped_output_table {{ namespace __escaped_output_table {{
{content} {content}
}} // namespace __escaped_output_table }} // namespace __escaped_output_table
#endif //_LIBCPP_STD_VER > 20 #endif //_LIBCPP_STD_VER >= 23
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_ESCAPED_OUTPUT_TABLE_H""" #endif // _LIBCPP___FORMAT_ESCAPED_OUTPUT_TABLE_H"""
def property_ranges_to_table(ranges: list[PropertyRange]) -> list[Entry]: def property_ranges_to_table(ranges: list[PropertyRange]) -> list[Entry]:
result = list[Entry]() result = list[Entry]()
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

libcxx/utils/generate_extended_grapheme_cluster_table.py

Show First 20 Lines • Show All 216 Lines • ▼ Show 20 Lines
#include <cstdint> #include <cstdint>
#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 #if _LIBCPP_STD_VER >= 20
namespace __extended_grapheme_custer_property_boundary {{ namespace __extended_grapheme_custer_property_boundary {{
{content} {content}
}} // namespace __extended_grapheme_custer_property_boundary }} // namespace __extended_grapheme_custer_property_boundary
#endif //_LIBCPP_STD_VER > 17 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_EXTENDED_GRAPHEME_CLUSTER_TABLE_H""" #endif // _LIBCPP___FORMAT_EXTENDED_GRAPHEME_CLUSTER_TABLE_H"""
def property_ranges_to_table( def property_ranges_to_table(
ranges: list[PropertyRange], props: list[str] ranges: list[PropertyRange], props: list[str]
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

libcxx/utils/generate_feature_test_macro_components.py

Show First 20 Lines • Show All 277 Lines • ▼ Show 20 Linesfeature_test_macros = [ add_version_header(x) for x in [
}, { }, {
"name": "__cpp_lib_coroutine", "name": "__cpp_lib_coroutine",
"values": { "c++20": 201902 }, "values": { "c++20": 201902 },
"headers": ["coroutine"], "headers": ["coroutine"],
}, { }, {
"name": "__cpp_lib_destroying_delete", "name": "__cpp_lib_destroying_delete",
"values": { "c++20": 201806 }, "values": { "c++20": 201806 },
"headers": ["new"], "headers": ["new"],
"test_suite_guard": "TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L", "test_suite_guard": "TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L",
jloserUnsubmitted
Not Done
ReplyInline Actions

Out of curiosity, did we decide (or should we) to do the same for TEST_STD_VER? It seems slightly out of place seeing it use >. WDYT?

jloser: Out of curiosity, did we decide (or should we) to do the same for `TEST_STD_VER`? It seems…
ldionneUnsubmitted
Not Done
ReplyInline Actions

I agree, however that touches even more files. Let's do it separately if at all.

ldionne: I agree, however that touches even more files. Let's do it separately if at all.
"libcxx_guard": "_LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L", "libcxx_guard": "_LIBCPP_STD_VER >= 20 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L",
}, { }, {
"name": "__cpp_lib_enable_shared_from_this", "name": "__cpp_lib_enable_shared_from_this",
"values": { "c++17": 201603 }, "values": { "c++17": 201603 },
"headers": ["memory"], "headers": ["memory"],
}, { }, {
"name": "__cpp_lib_endian", "name": "__cpp_lib_endian",
"values": { "c++20": 201907 }, "values": { "c++20": 201907 },
"headers": ["bit"], "headers": ["bit"],
▲ Show 20 Lines • Show All 572 Lines • ▼ Show 20 Lines if 'unimplemented' in tc.keys():
line = "// " + line line = "// " + line
result += line result += line
result += "\n" result += "\n"
if 'test_suite_guard' in tc.keys(): if 'test_suite_guard' in tc.keys():
result += "# endif\n" result += "# endif\n"
return result.strip() return result.strip()
def produce_macros_definitions(): def produce_macros_definitions():
macro_definition_template = """#if _LIBCPP_STD_VER > {previous_std_number} macro_definition_template = """#if _LIBCPP_STD_VER >= {std_number}
{macro_definition} {macro_definition}
#endif""" #endif"""
macros_definitions = [] macros_definitions = []
previous_std_number = '11'
for std in get_std_dialects(): for std in get_std_dialects():
macros_definitions.append( macros_definitions.append(
macro_definition_template.format(previous_std_number=previous_std_number, macro_definition_template.format(std_number=get_std_number(std).replace('2b', '23'),
macro_definition=produce_macros_definition_for_std(std))) macro_definition=produce_macros_definition_for_std(std)))
previous_std_number = get_std_number(std)
return '\n\n'.join(macros_definitions) return '\n\n'.join(macros_definitions)
def chunks(l, n): def chunks(l, n):
"""Yield successive n-sized chunks from l.""" """Yield successive n-sized chunks from l."""
for i in range(0, len(l), n): for i in range(0, len(l), n):
yield l[i:i + n] yield l[i:i + n]
▲ Show 20 Lines • Show All 328 Lines • Show Last 20 Lines