This is an archive of the discontinued LLVM Phabricator instance.

Differential D118507

[libc++] Merge _LIBCPP_HAS_NO_RANGES into _LIBCPP_HAS_NO_CONCEPTS. NFC
ClosedPublic

Authored by • Quuxplusone on Jan 28 2022, 1:00 PM.

Details

Reviewers
ldionne
philnik
Mordante
var-const
jloser
Group Reviewers
Restricted Project
Commits
rG2eb2ff2a02a3: [libc++] Merge _LIBCPP_HAS_NO_RANGES into _LIBCPP_HAS_NO_CONCEPTS. NFC.
Summary
The macro that opts out of `std::ranges::` functionality is called
`_LIBCPP_HAS_NO_INCOMPLETE_RANGES`, and is unrelated to this macro
which is specifically about _compiler_ support for the _syntax_.

The only non-mechanical diff here is in `<__config>`.

Diff Detail

Event Timeline

• Quuxplusone requested review of this revision.Jan 28 2022, 1:00 PM
• Quuxplusone created this revision.
Herald added 1 blocking reviewer(s): Restricted Project. · View Herald TranscriptJan 28 2022, 1:00 PM
Herald added a subscriber: libcxx-commits. · View Herald Transcript
• Quuxplusone added inline comments.Jan 28 2022, 1:07 PM
libcxx/include/__filesystem/directory_iterator.h
136

@ldionne: Here's an example of something that should probably be guarded under _LIBCPP_HAS_NO_INCOMPLETE_RANGES (instead of _LIBCPP_HAS_NO_CONCEPTS).

libcxx/include/string_view
726

@ldionne: Some or all of these deduction guides should probably be guarded under _LIBCPP_HAS_NO_INCOMPLETE_RANGES, since ranges::contiguous_range (line 727) won't even exist if libc++ isn't providing Ranges facilities.

libcxx/test/support/test_macros.h
246–248

The testing story is a little messed up, but perhaps this should be guarded under #if TEST_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES). (It's unclear what the purpose of this macro is right now. Compare to the other places in libcxx/test/ that have diffs in this PR.)

• Quuxplusone mentioned this in D117961: [libc++] Fix LWG3589 "The const lvalue reference overload of get for subrange...".Jan 28 2022, 4:34 PM
jloser accepted this revision.Jan 28 2022, 5:33 PM

LGTM! Thanks for cleaning this up.

I'd be in favor of a patch that guards the enable_view for directory_iterator and recursive_directory_iterator with _LIBCPP_HAS_NO_INCOMPLETE_RANGES instead as you pointed out.

libcxx/include/__filesystem/directory_iterator.h
136

Agreed. I added these IIRC, but copied the #ifdef check from somewhere else likely but never chased down the differences between concepts/ranges checks. I'd be fine if you change this to _LIBCPP_HAS_NO_INCOMPLETE_RANGES.

libcxx/include/__filesystem/recursive_directory_iterator.h
167

Let's also guard this with _LIBCPP_HAS_NO_INCOMPLETE_RANGES as in the directory_iterator case.

Mordante added inline comments.Jan 29 2022, 4:46 AM
libcxx/include/__config
882

How about keeping this and test it for _LIBCPP_HAS_NO_INCOMPLETE_RANGES too? Wouldn't that solve our problem with not testing _LIBCPP_HAS_NO_INCOMPLETE_RANGES everywhere. Of course that would mean we keep both _LIBCPP_HAS_NO_CONCEPTS and _LIBCPP_HAS_NO_RANGES.

Note that adding _LIBCPP_HAS_NO_INCOMPLETE_RANGES was a kind of hurried last minute fix for the LLVM 13 release, but in hindsight updating this part of the __config sounds like a good idea.

• Quuxplusone added inline comments.Jan 29 2022, 8:31 AM
libcxx/include/__config
882

I'm not sure I understand, but maybe I do.
We have two orthogonal criteria for #if'ing stuff out right now:

  • Does it (perhaps transitively) depend on the compiler's support for C++20 concept/requires syntax?
  • Does it (perhaps transitively) depend on the vendor's commitment to std::ranges support in the library?

I claim that the former should be called _LIBCPP_HAS_NO_CONCEPTS and the latter should be called _LIBCPP_HAS_NO_INCOMPLETE_RANGES. IIUC, you're saying that it would cause less churn if we also introduced

#if defined(_LIBCPP_HAS_NO_CONCEPTS) || defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 #define _LIBCPP_HAS_NO_RANGES
#endif

So then most of the places guarded by _LIBCPP_HAS_NO_RANGES today would be correct; and probably some of them are wrong, but maybe it would be easier to audit for those (few?) places.

Is that the right idea?

It also occurs to me that it would aid understanding if we renamed s/_LIBCPP_HAS_NO_RANGES/_LIBCPP_HAS_NO_RANGES_NAMESPACE/. That makes it clearer the exact scope we're talking about (more than <ranges>, all of std::ranges; but not including the One Ranges Proposal stuff that lies outside std::ranges, such as std::forward_iterator.) Do we agree on that scope, and if so, do we agree on the renaming?

• Quuxplusone added inline comments.Jan 29 2022, 9:30 AM
libcxx/include/__config
882

Actually, what I suggested won't work.

std::forward_iterator depends on std::weakly_incrementable depends on std::movable depends on std::swappable depends on ranges::swap. So there is effectively no way to snip out just namespace ranges without snipping all of the standard concepts as well.

@Mordante: Does this change your suggested approach?

Mordante added inline comments.Jan 30 2022, 6:08 AM
libcxx/include/__config
882

Your previous example was indeed what I suggested. It's unfortunate that this doesn't work, since this basically means it's not possible for vendors to completely opt-out of ranges. Which was the original intention of _LIBCPP_HAS_NO_INCOMPLETE_RANGES. I wonder how useful _LIBCPP_HAS_NO_INCOMPLETE_RANGES is now it's not a proper guard anymore.

Looking at our ranges implementation status there are still quite a number of not implemented papers. I'm not familiar enough with ranges to know whether or not these papers introduce API/ABI-incompatability. So I'm not sure whether we can just remove _LIBCPP_HAS_NO_INCOMPLETE_RANGES or need to guard the unguarded places.

So I prefer to defer the decision of the way forward to @ldionne.

ldionne accepted this revision.Jan 31 2022, 8:48 AM

IMO this looks fine as-is. This is just removing an additional spelling of _LIBCPP_HAS_NO_CONCEPTS by folding it into _LIBCPP_HAS_NO_CONCEPTS. Furthermore, all of these _LIBCPP_HAS_NO_CONCEPTS will be changed to _LIBCPP_STD_VER > 17 as soon as I manage to drop support for a slightly older AppleClang.

Yes, we do have places that are not guarded by _LIBCPP_HAS_NO_INCOMPLETE_RANGES , and we should fix those separately.

Also, personally, I would keep _LIBCPP_HAS_NO_INCOMPLETE_RANGES its own separate macro and use it directly, because we'll mass-remove it as soon as we are sufficiently confident about the stability of <ranges>.

libcxx/include/__filesystem/directory_iterator.h
136

100% agreed, let's fix this.

This revision is now accepted and ready to land.Jan 31 2022, 8:48 AM
This revision was landed with ongoing or failed builds.Jan 31 2022, 9:11 AM
Closed by commit rG2eb2ff2a02a3: [libc++] Merge _LIBCPP_HAS_NO_RANGES into _LIBCPP_HAS_NO_CONCEPTS. NFC. (authored by • arthur.j.odwyer). · Explain Why
This revision was automatically updated to reflect the committed changes.
• arthur.j.odwyer added a commit: rG2eb2ff2a02a3: [libc++] Merge _LIBCPP_HAS_NO_RANGES into _LIBCPP_HAS_NO_CONCEPTS. NFC..

Revision Contents

PathSize
libcxx/
include/
__algorithm/
4 lines
4 lines
4 lines
6 lines
__filesystem/
2 lines
2 lines
__functional/
4 lines
__iterator/
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
4 lines
12 lines
4 lines
4 lines
4 lines
4 lines
4 lines
__memory/
4 lines
4 lines
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
18 lines
12 lines
test/
std/
input.output/
filesystems/
class.path/
path.itr/
2 lines
support/
2 lines
2 lines

Diff 404566

libcxx/include/__algorithm/in_in_out_result.h

Show All 10 Lines
#define _LIBCPP___ALGORITHM_IN_IN_OUT_RESULT_H #define _LIBCPP___ALGORITHM_IN_IN_OUT_RESULT_H
#include <__concepts/convertible_to.h> #include <__concepts/convertible_to.h>
#include <__config> #include <__config>
#include <__utility/move.h> #include <__utility/move.h>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_HAS_NO_RANGES #ifndef _LIBCPP_HAS_NO_CONCEPTS
namespace ranges { namespace ranges {
template <class _I1, class _I2, class _O1> template <class _I1, class _I2, class _O1>
struct in_in_out_result { struct in_in_out_result {
[[no_unique_address]] _I1 in1; [[no_unique_address]] _I1 in1;
[[no_unique_address]] _I2 in2; [[no_unique_address]] _I2 in2;
[[no_unique_address]] _O1 out; [[no_unique_address]] _O1 out;
template <class _II1, class _II2, class _OO1> template <class _II1, class _II2, class _OO1>
requires convertible_to<const _I1&, _II1> && convertible_to<const _I2&, _II2> && convertible_to<const _O1&, _OO1> requires convertible_to<const _I1&, _II1> && convertible_to<const _I2&, _II2> && convertible_to<const _O1&, _OO1>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
operator in_in_out_result<_II1, _II2, _OO1>() const& { operator in_in_out_result<_II1, _II2, _OO1>() const& {
return {in1, in2, out}; return {in1, in2, out};
} }
template <class _II1, class _II2, class _OO1> template <class _II1, class _II2, class _OO1>
requires convertible_to<_I1, _II1> && convertible_to<_I2, _II2> && convertible_to<_O1, _OO1> requires convertible_to<_I1, _II1> && convertible_to<_I2, _II2> && convertible_to<_O1, _OO1>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
operator in_in_out_result<_II1, _II2, _OO1>() && { operator in_in_out_result<_II1, _II2, _OO1>() && {
return {_VSTD::move(in1), _VSTD::move(in2), _VSTD::move(out)}; return {_VSTD::move(in1), _VSTD::move(in2), _VSTD::move(out)};
} }
}; };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_HAS_NO_RANGES #endif // _LIBCPP_HAS_NO_CONCEPTS
_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_in_result.h

Show All 10 Lines
#define _LIBCPP___ALGORITHM_IN_IN_RESULT_H #define _LIBCPP___ALGORITHM_IN_IN_RESULT_H
#include <__concepts/convertible_to.h> #include <__concepts/convertible_to.h>
#include <__config> #include <__config>
#include <__utility/move.h> #include <__utility/move.h>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_HAS_NO_RANGES #ifndef _LIBCPP_HAS_NO_CONCEPTS
namespace ranges { namespace ranges {
template <class _I1, class _I2> template <class _I1, class _I2>
struct in_in_result { struct in_in_result {
[[no_unique_address]] _I1 in1; [[no_unique_address]] _I1 in1;
[[no_unique_address]] _I2 in2; [[no_unique_address]] _I2 in2;
template <class _II1, class _II2> template <class _II1, class _II2>
requires convertible_to<const _I1&, _II1> && convertible_to<const _I2&, _II2> requires convertible_to<const _I1&, _II1> && convertible_to<const _I2&, _II2>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
operator in_in_result<_II1, _II2>() const & { operator in_in_result<_II1, _II2>() const & {
return {in1, in2}; return {in1, in2};
} }
template <class _II1, class _II2> template <class _II1, class _II2>
requires convertible_to<_I1, _II1> && convertible_to<_I2, _II2> requires convertible_to<_I1, _II1> && convertible_to<_I2, _II2>
_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_HIDE_FROM_ABI constexpr
operator in_in_result<_II1, _II2>() && { return {_VSTD::move(in1), _VSTD::move(in2)}; } operator in_in_result<_II1, _II2>() && { return {_VSTD::move(in1), _VSTD::move(in2)}; }
}; };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_HAS_NO_RANGES #endif // _LIBCPP_HAS_NO_CONCEPTS
_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_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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace ranges { namespace ranges {
template<class _InputIterator, class _OutputIterator> template<class _InputIterator, class _OutputIterator>
struct in_out_result { struct in_out_result {
[[no_unique_address]] _InputIterator in; [[no_unique_address]] _InputIterator in;
[[no_unique_address]] _OutputIterator out; [[no_unique_address]] _OutputIterator out;
template <class _InputIterator2, class _OutputIterator2> template <class _InputIterator2, class _OutputIterator2>
requires convertible_to<const _InputIterator&, _InputIterator2> && convertible_to<const _OutputIterator&, requires convertible_to<const _InputIterator&, _InputIterator2> && convertible_to<const _OutputIterator&,
_OutputIterator2> _OutputIterator2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr operator in_out_result<_InputIterator2, _OutputIterator2>() const & { constexpr operator in_out_result<_InputIterator2, _OutputIterator2>() const & {
return {in, out}; return {in, out};
} }
template <class _InputIterator2, class _OutputIterator2> template <class _InputIterator2, class _OutputIterator2>
requires convertible_to<_InputIterator, _InputIterator2> && convertible_to<_OutputIterator, _OutputIterator2> requires convertible_to<_InputIterator, _InputIterator2> && convertible_to<_OutputIterator, _OutputIterator2>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr operator in_out_result<_InputIterator2, _OutputIterator2>() && { constexpr operator in_out_result<_InputIterator2, _OutputIterator2>() && {
return {_VSTD::move(in), _VSTD::move(out)}; return {_VSTD::move(in), _VSTD::move(out)};
} }
}; };
} // namespace ranges } // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ALGORITHM_IN_OUT_RESULT_H #endif // _LIBCPP___ALGORITHM_IN_OUT_RESULT_H

libcxx/include/__config

Show First 20 Lines • Show All 869 Lines • ▼ Show 20 Lines
#endif #endif
#ifndef __cpp_consteval #ifndef __cpp_consteval
# define _LIBCPP_CONSTEVAL _LIBCPP_CONSTEXPR # define _LIBCPP_CONSTEVAL _LIBCPP_CONSTEXPR
#else #else
# define _LIBCPP_CONSTEVAL consteval # define _LIBCPP_CONSTEVAL consteval
#endif #endif
#if !defined(__cpp_concepts) || __cpp_concepts < 201907L #if _LIBCPP_STD_VER <= 17 || !defined(__cpp_concepts) || __cpp_concepts < 201907L
#define _LIBCPP_HAS_NO_CONCEPTS #define _LIBCPP_HAS_NO_CONCEPTS
#endif #endif
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_HAS_NO_CONCEPTS)
MordanteUnsubmitted
Not Done
ReplyInline Actions

How about keeping this and test it for _LIBCPP_HAS_NO_INCOMPLETE_RANGES too? Wouldn't that solve our problem with not testing _LIBCPP_HAS_NO_INCOMPLETE_RANGES everywhere. Of course that would mean we keep both _LIBCPP_HAS_NO_CONCEPTS and _LIBCPP_HAS_NO_RANGES.

Note that adding _LIBCPP_HAS_NO_INCOMPLETE_RANGES was a kind of hurried last minute fix for the LLVM 13 release, but in hindsight updating this part of the __config sounds like a good idea.

Mordante: How about keeping this and test it for `_LIBCPP_HAS_NO_INCOMPLETE_RANGES` too? Wouldn't that…
QuuxplusoneAuthorUnsubmitted
Done
ReplyInline Actions

I'm not sure I understand, but maybe I do.
We have two orthogonal criteria for #if'ing stuff out right now:

  • Does it (perhaps transitively) depend on the compiler's support for C++20 concept/requires syntax?
  • Does it (perhaps transitively) depend on the vendor's commitment to std::ranges support in the library?

I claim that the former should be called _LIBCPP_HAS_NO_CONCEPTS and the latter should be called _LIBCPP_HAS_NO_INCOMPLETE_RANGES. IIUC, you're saying that it would cause less churn if we also introduced

#if defined(_LIBCPP_HAS_NO_CONCEPTS) || defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
 #define _LIBCPP_HAS_NO_RANGES
#endif

So then most of the places guarded by _LIBCPP_HAS_NO_RANGES today would be correct; and probably some of them are wrong, but maybe it would be easier to audit for those (few?) places.

Is that the right idea?

It also occurs to me that it would aid understanding if we renamed s/_LIBCPP_HAS_NO_RANGES/_LIBCPP_HAS_NO_RANGES_NAMESPACE/. That makes it clearer the exact scope we're talking about (more than <ranges>, all of std::ranges; but not including the One Ranges Proposal stuff that lies outside std::ranges, such as std::forward_iterator.) Do we agree on that scope, and if so, do we agree on the renaming?

Quuxplusone: I'm not sure I understand, but maybe I do. We have two orthogonal criteria for `#if`'ing stuff…
QuuxplusoneAuthorUnsubmitted
Done
ReplyInline Actions

Actually, what I suggested won't work.

std::forward_iterator depends on std::weakly_incrementable depends on std::movable depends on std::swappable depends on ranges::swap. So there is effectively no way to snip out just namespace ranges without snipping all of the standard concepts as well.

@Mordante: Does this change your suggested approach?

Quuxplusone: Actually, what I suggested won't work. `std::forward_iterator` depends on `std…
MordanteUnsubmitted
Not Done
ReplyInline Actions

Your previous example was indeed what I suggested. It's unfortunate that this doesn't work, since this basically means it's not possible for vendors to completely opt-out of ranges. Which was the original intention of _LIBCPP_HAS_NO_INCOMPLETE_RANGES. I wonder how useful _LIBCPP_HAS_NO_INCOMPLETE_RANGES is now it's not a proper guard anymore.

Looking at our ranges implementation status there are still quite a number of not implemented papers. I'm not familiar enough with ranges to know whether or not these papers introduce API/ABI-incompatability. So I'm not sure whether we can just remove _LIBCPP_HAS_NO_INCOMPLETE_RANGES or need to guard the unguarded places.

So I prefer to defer the decision of the way forward to @ldionne.

Mordante: Your previous example was indeed what I suggested. It's unfortunate that this doesn't work…
#define _LIBCPP_HAS_NO_RANGES
#endif
#ifdef __GNUC__ #ifdef __GNUC__
# define _LIBCPP_NOALIAS __attribute__((__malloc__)) # define _LIBCPP_NOALIAS __attribute__((__malloc__))
#else #else
# define _LIBCPP_NOALIAS # define _LIBCPP_NOALIAS
#endif #endif
#if __has_attribute(using_if_exists) #if __has_attribute(using_if_exists)
# define _LIBCPP_USING_IF_EXISTS __attribute__((using_if_exists)) # define _LIBCPP_USING_IF_EXISTS __attribute__((using_if_exists))
▲ Show 20 Lines • Show All 544 Lines • Show Last 20 Lines

libcxx/include/__filesystem/directory_iterator.h

Show First 20 Lines • Show All 127 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
QuuxplusoneAuthorUnsubmitted
Done
ReplyInline Actions

@ldionne: Here's an example of something that should probably be guarded under _LIBCPP_HAS_NO_INCOMPLETE_RANGES (instead of _LIBCPP_HAS_NO_CONCEPTS).

Quuxplusone: @ldionne: Here's an example of something that should probably be guarded under…
jloserUnsubmitted
Not Done
ReplyInline Actions

Agreed. I added these IIRC, but copied the #ifdef check from somewhere else likely but never chased down the differences between concepts/ranges checks. I'd be fine if you change this to _LIBCPP_HAS_NO_INCOMPLETE_RANGES.

jloser: Agreed. I added these IIRC, but copied the `#ifdef` check from somewhere else likely but never…
ldionneUnsubmitted
Done
ReplyInline Actions

100% agreed, let's fix this.

ldionne: 100% agreed, let's fix this.
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 #endif
#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 158 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
jloserUnsubmitted
Not Done
ReplyInline Actions

Let's also guard this with _LIBCPP_HAS_NO_INCOMPLETE_RANGES as in the directory_iterator case.

jloser: Let's also guard this with `_LIBCPP_HAS_NO_INCOMPLETE_RANGES` as in the `directory_iterator`…
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 #endif
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#endif // _LIBCPP___FILESYSTEM_RECURSIVE_DIRECTORY_ITERATOR_H #endif // _LIBCPP___FILESYSTEM_RECURSIVE_DIRECTORY_ITERATOR_H

libcxx/include/__functional/ranges_operations.h

Show All 14 Lines
#include <utility> #include <utility>
#if !defined(_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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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)))) {
return _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u); return _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u);
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines [[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))))) {
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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FUNCTIONAL_RANGES_OPERATIONS_H #endif // _LIBCPP___FUNCTIONAL_RANGES_OPERATIONS_H

libcxx/include/__iterator/advance.h

Show First 20 Lines • Show All 58 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [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 111 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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_ADVANCE_H #endif // _LIBCPP___ITERATOR_ADVANCE_H

libcxx/include/__iterator/common_iterator.h

Show All 21 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 232 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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [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 214 Lines • ▼ Show 20 Linesconcept indirectly_movable_storable =
indirectly_writable<_Out, iter_value_t<_In>> && indirectly_writable<_Out, iter_value_t<_In>> &&
movable<iter_value_t<_In>> && movable<iter_value_t<_In>> &&
constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>> && constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>> &&
assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>; assignable_from<iter_value_t<_In>&, iter_rvalue_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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 249 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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_COUNTED_ITERATOR_H #endif // _LIBCPP___ITERATOR_COUNTED_ITERATOR_H

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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
struct default_sentinel_t { }; struct default_sentinel_t { };
inline constexpr default_sentinel_t default_sentinel{}; inline constexpr default_sentinel_t default_sentinel{};
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_DEFAULT_SENTINEL_H #endif // _LIBCPP___ITERATOR_DEFAULT_SENTINEL_H

libcxx/include/__iterator/incrementable_traits.h

Show All 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 11 Lines
#include <__config> #include <__config>
#include <__functional/identity.h> #include <__functional/identity.h>
#include <__iterator/concepts.h> #include <__iterator/concepts.h>
#include <__iterator/projected.h> #include <__iterator/projected.h>
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#ifndef _LIBCPP_HAS_NO_RANGES #ifndef _LIBCPP_HAS_NO_CONCEPTS
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_HAS_NO_RANGES #endif // _LIBCPP_HAS_NO_CONCEPTS
_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 && !defined(_LIBCPP_HAS_NO_RANGES) #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _Container> template <class _Container>
using __insert_iterator_iter_t = ranges::iterator_t<_Container>; using __insert_iterator_iter_t = ranges::iterator_t<_Container>;
#else #else
template <class _Container> template <class _Container>
using __insert_iterator_iter_t = typename _Container::iterator; using __insert_iterator_iter_t = typename _Container::iterator;
#endif #endif
_LIBCPP_SUPPRESS_DEPRECATED_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

libcxx/include/__iterator/iter_move.h

Show All 17 Lines
#include <utility> #include <utility>
#if !defined(_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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [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 44 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) } -> __referenceable; } requires requires(_Tp& __t) { { ranges::iter_move(__t) } -> __referenceable; }
using iter_rvalue_reference_t = decltype(ranges::iter_move(declval<_Tp&>())); using iter_rvalue_reference_t = decltype(ranges::iter_move(declval<_Tp&>()));
#endif // !_LIBCPP_HAS_NO_RANGES #endif // !_LIBCPP_HAS_NO_CONCEPTS
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [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 55 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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _Tp> template <class _Tp>
using __with_reference = _Tp&; using __with_reference = _Tp&;
template <class _Tp> template <class _Tp>
concept __referenceable = requires { concept __referenceable = 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 } -> __referenceable; // not required to be equality-preserving { *__t } -> __referenceable; // not required to be equality-preserving
}; };
// [iterator.traits] // [iterator.traits]
template<__dereferenceable _Tp> template<__dereferenceable _Tp>
using iter_reference_t = decltype(*declval<_Tp&>()); using iter_reference_t = decltype(*declval<_Tp&>());
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 {};
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
private: private:
struct __two {char __lx; char __lxx;}; struct __two {char __lx; char __lxx;};
template <class _Up> static __two __test(...); template <class _Up> static __two __test(...);
template <class _Up> static char __test(typename _Up::iterator_concept* = nullptr); template <class _Up> static char __test(typename _Up::iterator_concept* = nullptr);
public: public:
static const bool value = sizeof(__test<_Tp>(nullptr)) == 1; static const bool value = sizeof(__test<_Tp>(nullptr)) == 1;
}; };
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// The `cpp17-*-iterator` exposition-only concepts are easily confused with the Cpp17*Iterator tables, // The `cpp17-*-iterator` exposition-only concepts are easily confused with the Cpp17*Iterator tables,
// so they've been banished to a namespace that makes it obvious they have a niche use-case. // so they've been banished to a namespace that makes it obvious 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) {
{ *__i } -> __referenceable; { *__i } -> __referenceable;
▲ Show 20 Lines • Show All 206 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 // !defined(_LIBCPP_HAS_NO_RANGES) #else // !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
template<class _Tp> template<class _Tp>
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 typename remove_cv<_Tp>::type value_type; typedef typename remove_cv<_Tp>::type value_type;
typedef _Tp* pointer; typedef _Tp* pointer;
typedef _Tp& reference; typedef _Tp& reference;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

libcxx/include/__iterator/next.h

Show All 29 Linesinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [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 27 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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_NEXT_H #endif // _LIBCPP___ITERATOR_NEXT_H

libcxx/include/__iterator/prev.h

Show All 28 Linesinline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [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 20 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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_READABLE_TRAITS_H #endif // _LIBCPP___ITERATOR_READABLE_TRAITS_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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___ITERATOR_UNREACHABLE_SENTINEL_H #endif // _LIBCPP___ITERATOR_UNREACHABLE_SENTINEL_H

libcxx/include/__memory/concepts.h

Show All 19 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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>
concept __nothrow_input_iterator = concept __nothrow_input_iterator =
Show All 17 Linesconcept __nothrow_forward_iterator =
__nothrow_sentinel_for<_Ip, _Ip>; __nothrow_sentinel_for<_Ip, _Ip>;
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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_CONCEPTS_H #endif // _LIBCPP___MEMORY_CONCEPTS_H

libcxx/include/__memory/ranges_construct_at.h

Show All 23 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace ranges { namespace ranges {
// uninitialized_default_construct // uninitialized_default_construct
namespace __uninitialized_default_construct { namespace __uninitialized_default_construct {
struct __fn { struct __fn {
template <__nothrow_forward_iterator _ForwardIterator, template <__nothrow_forward_iterator _ForwardIterator,
▲ Show 20 Lines • Show All 260 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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___MEMORY_RANGES_UNINITIALIZED_ALGORITHMS_H #endif // _LIBCPP___MEMORY_RANGES_UNINITIALIZED_ALGORITHMS_H

libcxx/include/__ranges/access.h

Show All 19 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 171 Lines • ▼ Show 20 Linesnamespace __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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 30 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(declval<_Range>())); using all_t = decltype(views::all(declval<_Range>()));
} // namespace ranges::views } // namespace ranges::views
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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
} }
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto common = __common::__fn{}; inline constexpr auto common = __common::__fn{};
} }
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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
ranges::end(__t); ranges::end(__t);
}; };
▲ Show 20 Lines • Show All 84 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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// __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 _VSTD::addressof(__val_); } _LIBCPP_HIDE_FROM_ABI constexpr const _Tp *operator->() const noexcept { return _VSTD::addressof(__val_); }
_LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return _VSTD::addressof(__val_); } _LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return _VSTD::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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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> #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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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_HAS_NO_RANGES #endif // !_LIBCPP_HAS_NO_CONCEPTS
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [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 {
}; };
} }
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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 All 25 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 72 Lines • ▼ Show 20 Linespublic:
template<class _Range> template<class _Range>
drop_view(_Range&&, range_difference_t<_Range>) -> drop_view<views::all_t<_Range>>; drop_view(_Range&&, range_difference_t<_Range>) -> drop_view<views::all_t<_Range>>;
template<class _Tp> template<class _Tp>
inline constexpr bool enable_borrowed_range<drop_view<_Tp>> = enable_borrowed_range<_Tp>; inline constexpr bool enable_borrowed_range<drop_view<_Tp>> = enable_borrowed_range<_Tp>;
} // namespace ranges } // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_DROP_VIEW_H #endif // _LIBCPP___RANGES_DROP_VIEW_H

libcxx/include/__ranges/empty.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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// [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 {
}; };
} }
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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 ranges } // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 && !defined(_LIBCPP_HAS_NO_RANGES) #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace ranges namespace ranges
{ {
// [range.range], ranges // [range.range], ranges
template <class> template <class>
inline constexpr bool enable_borrowed_range = false; inline constexpr bool enable_borrowed_range = false;
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES) #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_ENABLE_BORROWED_RANGE_H #endif // _LIBCPP___RANGES_ENABLE_BORROWED_RANGE_H

libcxx/include/__ranges/enable_view.h

Show All 14 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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_HAS_NO_RANGES #endif // !_LIBCPP_HAS_NO_CONCEPTS
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_ENABLE_VIEW_H #endif // _LIBCPP___RANGES_ENABLE_VIEW_H

libcxx/include/__ranges/iota_view.h

Show All 33 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 345 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 views } // namespace views
} // namespace ranges } // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 296 Lines • ▼ Show 20 Linesnamespace ranges {
template<class _Range> template<class _Range>
explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>; explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
} // namespace ranges } // namespace ranges
#undef _CONSTEXPR_TERNARY #undef _CONSTEXPR_TERNARY
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_JOIN_VIEW_H #endif // _LIBCPP___RANGES_JOIN_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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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{}, _VSTD::forward<_Args>(__args)...).__t_; return __value_.emplace(__forward_tag{}, _VSTD::forward<_Args>(__args)...).__t_;
} }
}; };
struct __empty_cache { }; struct __empty_cache { };
} // namespace ranges } // namespace ranges
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES) #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H #endif // _LIBCPP___RANGES_NON_PROPAGATING_CACHE_H

libcxx/include/__ranges/owning_view.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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 29 Lines _LIBCPP_HIDE_FROM_ABI constexpr auto data() const requires contiguous_range<const _Rp>
{ return ranges::data(__r_); } { return ranges::data(__r_); }
}; };
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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 19 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// 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 24 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(_VSTD::__compose(_VSTD::forward<_OtherClosure>(__c2), _VSTD::forward<_Closure>(__c1))); } { return __range_adaptor_closure_t(_VSTD::__compose(_VSTD::forward<_OtherClosure>(__c2), _VSTD::forward<_Closure>(__c1))); }
}; };
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_RANGE_ADAPTOR_H #endif // _LIBCPP___RANGES_RANGE_ADAPTOR_H

libcxx/include/__ranges/ref_view.h

Show All 25 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_REF_VIEW_H #endif // _LIBCPP___RANGES_REF_VIEW_H

libcxx/include/__ranges/reverse_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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 {
} }
inline namespace __cpo { inline namespace __cpo {
inline constexpr auto reverse = __reverse::__fn{}; inline constexpr auto reverse = __reverse::__fn{};
} }
} // namespace views } // namespace views
} // namespace ranges } // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 All 33 Lines public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr const _Tp* data() const noexcept { return __value_.operator->(); } constexpr const _Tp* data() const noexcept { return __value_.operator->(); }
}; };
template<class _Tp> template<class _Tp>
single_view(_Tp) -> single_view<_Tp>; single_view(_Tp) -> single_view<_Tp>;
} // namespace ranges } // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace ranges { namespace ranges {
template<class> template<class>
inline constexpr bool disable_sized_range = false; inline constexpr bool disable_sized_range = false;
} }
// [range.prim.size] // [range.prim.size]
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Linesnamespace __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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_SIZE_H #endif // _LIBCPP___RANGES_SIZE_H

libcxx/include/__ranges/subrange.h

Show All 30 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 229 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 // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 All 28 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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>> {
[[no_unique_address]] _View __base_ = _View(); [[no_unique_address]] _View __base_ = _View();
range_difference_t<_View> __count_ = 0; range_difference_t<_View> __count_ = 0;
template<bool> class __sentinel; template<bool> class __sentinel;
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Linespublic:
template<class _Range> template<class _Range>
take_view(_Range&&, range_difference_t<_Range>) -> take_view<views::all_t<_Range>>; take_view(_Range&&, range_difference_t<_Range>) -> take_view<views::all_t<_Range>>;
template<class _Tp> template<class _Tp>
inline constexpr bool enable_borrowed_range<take_view<_Tp>> = enable_borrowed_range<_Tp>; inline constexpr bool enable_borrowed_range<take_view<_Tp>> = enable_borrowed_range<_Tp>;
} // namespace ranges } // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 36 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 views } // namespace views
} // namespace ranges } // namespace ranges
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_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 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 !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace ranges { namespace ranges {
template<class _Tp> template<class _Tp>
concept __can_empty = requires(_Tp __t) { ranges::empty(__t); }; concept __can_empty = requires(_Tp __t) { ranges::empty(__t); };
template<class _Tp> template<class _Tp>
void __implicitly_convert_to(type_identity_t<_Tp>) noexcept; void __implicitly_convert_to(type_identity_t<_Tp>) noexcept;
▲ Show 20 Lines • Show All 144 Lines • ▼ Show 20 Lines constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) const
noexcept(noexcept(ranges::begin(__derived())[__index])) noexcept(noexcept(ranges::begin(__derived())[__index]))
{ {
return ranges::begin(__derived())[__index]; return ranges::begin(__derived())[__index];
} }
}; };
} }
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___RANGES_VIEW_INTERFACE_H #endif // _LIBCPP___RANGES_VIEW_INTERFACE_H

libcxx/include/ranges

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Lines
#include <type_traits> #include <type_traits>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header #pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES) #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
namespace views = ranges::views; namespace views = ranges::views;
#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES) #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES) #endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
#endif // _LIBCPP_RANGES #endif // _LIBCPP_RANGES

libcxx/include/span

Show First 20 Lines • Show All 164 Lines • ▼ Show 20 Lines
struct __is_std_array<array<_Tp, _Sz>> : true_type {}; struct __is_std_array<array<_Tp, _Sz>> : true_type {};
template <class _Tp> template <class _Tp>
struct __is_std_span : false_type {}; struct __is_std_span : false_type {};
template <class _Tp, size_t _Sz> template <class _Tp, size_t _Sz>
struct __is_std_span<span<_Tp, _Sz>> : true_type {}; struct __is_std_span<span<_Tp, _Sz>> : true_type {};
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _Range, class _ElementType> template <class _Range, class _ElementType>
concept __span_compatible_range = concept __span_compatible_range =
ranges::contiguous_range<_Range> && ranges::contiguous_range<_Range> &&
ranges::sized_range<_Range> && ranges::sized_range<_Range> &&
(ranges::borrowed_range<_Range> || is_const_v<_ElementType>) && (ranges::borrowed_range<_Range> || is_const_v<_ElementType>) &&
!__is_std_span<remove_cvref_t<_Range>>::value && !__is_std_span<remove_cvref_t<_Range>>::value &&
!__is_std_array<remove_cvref_t<_Range>>::value && !__is_std_array<remove_cvref_t<_Range>>::value &&
!is_array_v<remove_cvref_t<_Range>> && !is_array_v<remove_cvref_t<_Range>> &&
Show All 23 Lines
// [span.cons], span constructors, copy, assignment, and destructor // [span.cons], span constructors, copy, assignment, and destructor
template <size_t _Sz = _Extent, enable_if_t<_Sz == 0, nullptr_t> = nullptr> template <size_t _Sz = _Extent, enable_if_t<_Sz == 0, nullptr_t> = nullptr>
_LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr} {} _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr} {}
constexpr span (const span&) noexcept = default; constexpr span (const span&) noexcept = default;
constexpr span& operator=(const span&) noexcept = default; constexpr span& operator=(const span&) noexcept = default;
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _It, template <class _It,
enable_if_t<contiguous_iterator<_It> && enable_if_t<contiguous_iterator<_It> &&
is_convertible_v<remove_reference_t<iter_reference_t<_It>>(*)[], element_type (*)[]>, is_convertible_v<remove_reference_t<iter_reference_t<_It>>(*)[], element_type (*)[]>,
nullptr_t> = nullptr> nullptr_t> = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr explicit span(_It __first, size_type __count) constexpr explicit span(_It __first, size_type __count)
: __data{_VSTD::to_address(__first)} { : __data{_VSTD::to_address(__first)} {
(void)__count; (void)__count;
Show All 21 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr span(array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {} constexpr span(array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {}
template <class _OtherElementType, template <class _OtherElementType,
enable_if_t<is_convertible_v<const _OtherElementType(*)[], element_type (*)[]>, nullptr_t> = nullptr> enable_if_t<is_convertible_v<const _OtherElementType(*)[], element_type (*)[]>, nullptr_t> = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr span(const array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {} constexpr span(const array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {}
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <__span_compatible_range<element_type> _Range> template <__span_compatible_range<element_type> _Range>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr explicit span(_Range&& __r) : __data{ranges::data(__r)} { constexpr explicit span(_Range&& __r) : __data{ranges::data(__r)} {
_LIBCPP_ASSERT(ranges::size(__r) == _Extent, "size mismatch in span's constructor (range)"); _LIBCPP_ASSERT(ranges::size(__r) == _Extent, "size mismatch in span's constructor (range)");
} }
#endif #endif
template <class _OtherElementType> template <class _OtherElementType>
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Lines#endif
static constexpr size_type extent = dynamic_extent; static constexpr size_type extent = dynamic_extent;
// [span.cons], span constructors, copy, assignment, and destructor // [span.cons], span constructors, copy, assignment, and destructor
_LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}, __size{0} {} _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}, __size{0} {}
constexpr span (const span&) noexcept = default; constexpr span (const span&) noexcept = default;
constexpr span& operator=(const span&) noexcept = default; constexpr span& operator=(const span&) noexcept = default;
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _It, template <class _It,
enable_if_t<contiguous_iterator<_It> && enable_if_t<contiguous_iterator<_It> &&
is_convertible_v<remove_reference_t<iter_reference_t<_It> > (*)[], element_type (*)[]>, is_convertible_v<remove_reference_t<iter_reference_t<_It> > (*)[], element_type (*)[]>,
nullptr_t> = nullptr> nullptr_t> = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr span(_It __first, size_type __count) constexpr span(_It __first, size_type __count)
: __data{_VSTD::to_address(__first)}, __size{__count} {} : __data{_VSTD::to_address(__first)}, __size{__count} {}
Show All 16 Lines#endif
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr span(array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {} constexpr span(array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}
template <class _OtherElementType, size_t _Sz, template <class _OtherElementType, size_t _Sz,
enable_if_t<is_convertible_v<const _OtherElementType(*)[], element_type (*)[]>, nullptr_t> = nullptr> enable_if_t<is_convertible_v<const _OtherElementType(*)[], element_type (*)[]>, nullptr_t> = nullptr>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr span(const array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {} constexpr span(const array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <__span_compatible_range<element_type> _Range> template <__span_compatible_range<element_type> _Range>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr span(_Range&& __r) : __data(ranges::data(__r)), __size{ranges::size(__r)} {} constexpr span(_Range&& __r) : __data(ranges::data(__r)), __size{ranges::size(__r)} {}
# endif # endif
template <class _OtherElementType, size_t _OtherExtent> template <class _OtherElementType, size_t _OtherExtent>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
constexpr span(const span<_OtherElementType, _OtherExtent>& __other, constexpr span(const span<_OtherElementType, _OtherExtent>& __other,
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines// [span.iter], span iterator support
_LIBCPP_INLINE_VISIBILITY span<byte, dynamic_extent> __as_writable_bytes() const noexcept _LIBCPP_INLINE_VISIBILITY span<byte, dynamic_extent> __as_writable_bytes() const noexcept
{ return {reinterpret_cast<byte *>(data()), size_bytes()}; } { return {reinterpret_cast<byte *>(data()), size_bytes()}; }
private: private:
pointer __data; pointer __data;
size_type __size; size_type __size;
}; };
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
template <class _Tp, size_t _Extent> template <class _Tp, size_t _Extent>
inline constexpr bool ranges::enable_borrowed_range<span<_Tp, _Extent> > = true; inline constexpr bool ranges::enable_borrowed_range<span<_Tp, _Extent> > = true;
template <class _ElementType, size_t _Extent> template <class _ElementType, size_t _Extent>
inline constexpr bool ranges::enable_view<span<_ElementType, _Extent>> = true; inline constexpr bool ranges::enable_view<span<_ElementType, _Extent>> = true;
#endif // !defined(_LIBCPP_HAS_NO_RANGES) #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
// as_bytes & as_writable_bytes // as_bytes & as_writable_bytes
template <class _Tp, size_t _Extent> template <class _Tp, size_t _Extent>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
auto as_bytes(span<_Tp, _Extent> __s) noexcept auto as_bytes(span<_Tp, _Extent> __s) noexcept
-> decltype(__s.__as_bytes()) -> decltype(__s.__as_bytes())
{ return __s.__as_bytes(); } { return __s.__as_bytes(); }
template <class _Tp, size_t _Extent> template <class _Tp, size_t _Extent>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept
-> enable_if_t<!is_const_v<_Tp>, decltype(__s.__as_writable_bytes())> -> enable_if_t<!is_const_v<_Tp>, decltype(__s.__as_writable_bytes())>
{ return __s.__as_writable_bytes(); } { return __s.__as_writable_bytes(); }
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
// Deduction guides // Deduction guides
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 #endif
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>;
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
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 #endif
#endif // _LIBCPP_STD_VER > 17 #endif // _LIBCPP_STD_VER > 17
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS
#endif // _LIBCPP_SPAN #endif // _LIBCPP_SPAN

libcxx/include/string_view

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

@ldionne: Some or all of these deduction guides should probably be guarded under _LIBCPP_HAS_NO_INCOMPLETE_RANGES, since ranges::contiguous_range (line 727) won't even exist if libc++ isn't providing Ranges facilities.

Quuxplusone: @ldionne: Some or all of these deduction guides should probably be guarded under…
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_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

libcxx/test/std/input.output/filesystems/class.path/path.itr/iterator.pass.cpp

Show All 25 Lines
#include "test_macros.h" #include "test_macros.h"
#include "filesystem_test_helper.h" #include "filesystem_test_helper.h"
void checkIteratorConcepts() { void checkIteratorConcepts() {
using namespace fs; using namespace fs;
using It = path::iterator; using It = path::iterator;
using Traits = std::iterator_traits<It>; using Traits = std::iterator_traits<It>;
ASSERT_SAME_TYPE(path::const_iterator, It); ASSERT_SAME_TYPE(path::const_iterator, It);
#if TEST_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES) #if TEST_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
static_assert(std::bidirectional_iterator<It>); static_assert(std::bidirectional_iterator<It>);
#endif #endif
ASSERT_SAME_TYPE(Traits::value_type, path); ASSERT_SAME_TYPE(Traits::value_type, path);
LIBCPP_STATIC_ASSERT(std::is_same<Traits::iterator_category, std::input_iterator_tag>::value, ""); LIBCPP_STATIC_ASSERT(std::is_same<Traits::iterator_category, std::input_iterator_tag>::value, "");
LIBCPP_STATIC_ASSERT(std::is_same<Traits::pointer, path const*>::value, ""); LIBCPP_STATIC_ASSERT(std::is_same<Traits::pointer, path const*>::value, "");
LIBCPP_STATIC_ASSERT(std::is_same<Traits::reference, path>::value, ""); LIBCPP_STATIC_ASSERT(std::is_same<Traits::reference, path>::value, "");
{ {
It it; It it;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/test/support/test_macros.h

Show First 20 Lines • Show All 237 Lines • ▼ Show 20 Lines
#else #else
#define LIBCPP_ASSERT(...) static_assert(true, "") #define LIBCPP_ASSERT(...) static_assert(true, "")
#define LIBCPP_STATIC_ASSERT(...) static_assert(true, "") #define LIBCPP_STATIC_ASSERT(...) static_assert(true, "")
#define LIBCPP_ASSERT_NOEXCEPT(...) static_assert(true, "") #define LIBCPP_ASSERT_NOEXCEPT(...) static_assert(true, "")
#define LIBCPP_ASSERT_NOT_NOEXCEPT(...) static_assert(true, "") #define LIBCPP_ASSERT_NOT_NOEXCEPT(...) static_assert(true, "")
#define LIBCPP_ONLY(...) static_assert(true, "") #define LIBCPP_ONLY(...) static_assert(true, "")
#endif #endif
#if !defined(_LIBCPP_HAS_NO_RANGES) #if !defined(_LIBCPP_HAS_NO_CONCEPTS)
#define TEST_SUPPORTS_RANGES #define TEST_SUPPORTS_RANGES
#endif #endif
QuuxplusoneAuthorUnsubmitted
Done
ReplyInline Actions

The testing story is a little messed up, but perhaps this should be guarded under #if TEST_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES). (It's unclear what the purpose of this macro is right now. Compare to the other places in libcxx/test/ that have diffs in this PR.)

Quuxplusone: The testing story is a little messed up, but //perhaps// this should be guarded under `#if…
#define TEST_IGNORE_NODISCARD (void) #define TEST_IGNORE_NODISCARD (void)
namespace test_macros_detail { namespace test_macros_detail {
template <class T, class U> template <class T, class U>
struct is_same { enum { value = 0};} ; struct is_same { enum { value = 0};} ;
template <class T> template <class T>
struct is_same<T, T> { enum {value = 1}; }; struct is_same<T, T> { enum {value = 1}; };
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

libcxx/test/support/test_range.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LIBCXX_TEST_SUPPORT_TEST_RANGE_H #ifndef LIBCXX_TEST_SUPPORT_TEST_RANGE_H
#define LIBCXX_TEST_SUPPORT_TEST_RANGE_H #define LIBCXX_TEST_SUPPORT_TEST_RANGE_H
#include <iterator> #include <iterator>
#include <ranges> #include <ranges>
#include "test_iterators.h" #include "test_iterators.h"
#ifdef _LIBCPP_HAS_NO_RANGES #ifdef _LIBCPP_HAS_NO_CONCEPTS
#error "test/support/test_range.h" can only be included in builds supporting ranges #error "test/support/test_range.h" can only be included in builds supporting ranges
#endif #endif
struct sentinel { struct sentinel {
bool operator==(std::input_or_output_iterator auto const&) const; bool operator==(std::input_or_output_iterator auto const&) const;
}; };
template <template <class...> class I> template <template <class...> class I>
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines