This is an archive of the discontinued LLVM Phabricator instance.

Differential D101242

[libcxx][nfc] prefixes test type `input_iterator` with `cpp17_`
ClosedPublic

Authored by cjdb on Apr 24 2021, 2:40 PM.

Details

Reviewers
ldionne
zoecarver
Mordante
• Quuxplusone
Group Reviewers
Restricted Project
Commits
rG773ae4412468: [libcxx][nfc] prefixes test type `input_iterator` with `cpp17_`
Summary

C++20 revised the definition of what it means to be an iterator. While
all _Cpp17InputIterators_ satisfy std::input_iterator, the reverse
isn't true. D100271 introduces a new test adaptor to accommodate this
new definition (cpp20_input_iterator).

In order to help readers immediately distinguish which input iterator
adaptor is _Cpp17InputIterator_, the current input_iterator adaptor
has been prefixed with cpp17_.

Diff Detail

Event Timeline

cjdb created this revision.Apr 24 2021, 2:40 PM
Herald added subscribers: wenlei, arphaman. · View Herald TranscriptApr 24 2021, 2:40 PM
cjdb requested review of this revision.Apr 24 2021, 2:40 PM
Herald added a project: Restricted Project. · View Herald TranscriptApr 24 2021, 2:40 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
• Quuxplusone resigned from this revision.Apr 24 2021, 3:12 PM
• Quuxplusone added a subscriber: • Quuxplusone.

It seems like literally all this does is make the test iterators' names longer and more tedious, so I personally don't think we should accept this patch.

cjdb updated this revision to Diff 340317.Apr 24 2021, 5:10 PM
cjdb edited the summary of this revision. (Show Details)

benchmark file was not updated (tooling only considered files in libcxx/test/)

Harbormaster completed remote builds in B100779: Diff 340315.Apr 24 2021, 7:26 PM
Harbormaster completed remote builds in B100781: Diff 340317.Apr 24 2021, 10:08 PM
Mordante added a comment.Apr 25 2021, 4:38 AM

I had a short look at the patch. I also wonder whether this is the direction we want to go.
For reviewing, I assume this is all basically a search and replace? Or are there more changes?

libcxx/test/support/test_iterators.h
1

The new C++20 style iterators will they also be put in this file or will they get their own header. If the latter then maybe rename this file to test_legacy_iterator.h.

cjdb mentioned this in D100271: [libcxx][iterator][ranges] adds `input_iterator` and `input_range`.Apr 26 2021, 9:51 AM
cjdb added a comment.Apr 26 2021, 9:59 AM
In D101242#2715229, @Mordante wrote:

I had a short look at the patch. I also wonder whether this is the direction we want to go.

The intention of this patch is to optimise for the reader, not the writer. I don't want any contributors or reviewers to question whether input_iterator means legacy input iterator or C++20 input iterator.

For reviewing, I assume this is all basically a search and replace? Or are there more changes?

Should be a 100% search and replace with one file renamed too (input_iterator.h -> legacy_input_iterator.h).

libcxx/test/support/test_iterators.h
1

My intention was to add them here and guard them with a ranges support macro. C++20 ranges may want to test both in certain circumstances.

ldionne requested changes to this revision.Apr 26 2021, 10:03 AM

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

One other option would be to call those cpp17_XXXXX_iterator instead. That way, if we introduce new iterator concepts eventually in the future, we can call the current ones cpp20_XXXXX_iterator instead of being stuck with a naming problem. WDYT?

I also agree with @Mordante , if we're going to rename the header in the future, we might just as well rename it now. If there's no plans to rename the header, then this LGTM.

Requesting changes for discussion.

This revision now requires changes to proceed.Apr 26 2021, 10:03 AM
• Quuxplusone added a comment.Apr 26 2021, 10:04 AM

The intention of this patch is to optimise for the reader, not the writer.

As a reader myself, I explicitly state that this patch does not optimize for my preferences when reading code. It makes the code actively harder to read.

cjdb added a subscriber: tcanens.Apr 26 2021, 10:10 AM
In D101242#2717210, @ldionne wrote:

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

One other option would be to call those cpp17_XXXXX_iterator instead. That way, if we introduce new iterator concepts eventually in the future, we can call the current ones cpp20_XXXXX_iterator instead of being stuck with a naming problem. WDYT?

I have grave objections to cpp17 as a prefix (I even raised that in LWG once). It's weird see a C++11 test to have a cpp17_XXXX_iterator. I'm pretty sure that's why @tcanens pushed so strongly for LegacyXXXXIterator on cppreference too.

I also agree with @Mordante , if we're going to rename the header in the future, we might just as well rename it now. If there's no plans to rename the header, then this LGTM.

No plans to rename the header, but I could be talked into it.

ldionne added a comment.Apr 26 2021, 10:14 AM
In D101242#2717210, @ldionne wrote:

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

@cjdb Are the other iterator concepts also different between C++20 and C++17? It's true for input iterators, but is it also the case for e.g. forward iterator? I think that should influence what we do here.

cjdb added a comment.Apr 26 2021, 10:23 AM
In D101242#2717230, @ldionne wrote:
In D101242#2717210, @ldionne wrote:

I agree this is making names longer and I dislike that. However, I think being able to distinguish between an archetype for a C++20 input_iterator and a pre-concepts InputIterator archetype is useful and necessary in the test suite, since those two concepts are different (see note about equality comparable https://en.cppreference.com/w/cpp/iterator/input_iterator).

@cjdb Are the other iterator concepts also different between C++20 and C++17? It's true for input iterators, but is it also the case for e.g. forward iterator? I think that should influence what we do here.

Contrast:

tl;dr yes. At minimum, the iterator tags are now mandatory.

Mordante added a comment.Apr 26 2021, 11:34 AM
In D101242#2717221, @cjdb wrote:
In D101242#2717210, @ldionne wrote:

One other option would be to call those cpp17_XXXXX_iterator instead. That way, if we introduce new iterator concepts eventually in the future, we can call the current ones cpp20_XXXXX_iterator instead of being stuck with a naming problem. WDYT?

I have grave objections to cpp17 as a prefix (I even raised that in LWG once). It's weird see a C++11 test to have a cpp17_XXXX_iterator. I'm pretty sure that's why @tcanens pushed so strongly for LegacyXXXXIterator on cppreference too.

I'm not too fond of the name Legacy. Unless I'm mistaken the standard uses Cpp17 for these iterators. So that would be my preference.

I also agree with @Mordante , if we're going to rename the header in the future, we might just as well rename it now. If there's no plans to rename the header, then this LGTM.

No plans to rename the header, but I could be talked into it.

I have a strong opinion about the renaming of the header. Just wanted to make sure there wouldn't be a second update in the near future.

• Quuxplusone requested changes to this revision.Apr 26 2021, 11:36 AM
• Quuxplusone added inline comments.
libcxx/test/support/test_iterators.h
64

@cjdb wrote:

tl;dr yes. At minimum, the iterator tags are now mandatory.

The existing iterators already have tags, though. So that's not a concern for us.

I suggested to Louis in chat but will put here for the record: If the main concern of this patch is to make sure we have a test iterator which is a "non-comparable input iterator" (comparable only to its sentinel type, but not to itself), then I suggest you leave everything the way it is in main but then add the new C++20-only, sentinel-comparison-only test iterator, like this:

#if TEST_STD_VER >= 20
template<class It>
class incomparable_input_iterator {
    // This is an input iterator according to C++>=20, but not according to C++<=17.
    // It is comparable with its sentinel type, but not with its own type.
    [...mostly the same stuff as the regular input iterator test type...]
public:
    struct sentinel {
        constexpr explicit sentinel(It it) : it_(it) {}
    };
    friend constexpr bool operator==(const incomparable_input_iterator& x, const sentinel& y)
        {return x.it_ == y.it_;}
};
#endif

This probably belongs right above contiguous_iterator, circa line 315, because we intend it to be new in C++20.

cjdb added inline comments.Apr 26 2021, 12:06 PM
libcxx/test/support/test_iterators.h
64

If the main concern of this patch is to make sure we have a test iterator which is a "non-comparable input iterator" (comparable only to its sentinel type, but not to itself)

This isn't the only difference between Cpp17InputIterator and std::input_iterator.

I suggest you leave everything the way it is in main but then add the new C++20-only, sentinel-comparison-only test iterator

That leaves ambiguity as to whether or not input_iterator refers to a Cpp17InputIterator or is a strict std::input_iterator. It needs to be renamed to clear up that ambiguity.

• Quuxplusone added inline comments.Apr 26 2021, 12:38 PM
libcxx/test/support/test_iterators.h
64

This isn't the only difference

Obligatory "What are the differences you care about, then?"
No two things in the world are ever exactly the same. That doesn't mean we make libc++ PRs about it. :)

cjdb added inline comments.Apr 26 2021, 1:28 PM
libcxx/test/support/test_iterators.h
64

The most salient difference is that C++20 input iterators need not be copyable. I expected that this would be fresh in your mind, since you've recently reviewed D100271, which is why I didn't mention it.

cjdb updated this revision to Diff 340647.Apr 26 2021, 2:20 PM
cjdb retitled this revision from [libcxx][nfc] renames test iterator types to `legacy_*_iterator` to [libcxx][nfc] prefixes test type `input_iterator` with `cpp17_`.
cjdb edited the summary of this revision. (Show Details)
  • reverts legacy_forward_iterator (and stronger)
  • replaces legacy prefix with cpp17
  • revises commit message to reflect drastic changes
• Quuxplusone added inline comments.Apr 26 2021, 2:40 PM
libcxx/test/support/test_iterators.h
64

So basically the intent of D101242-plus-D100271 is to introduce moveonly_input_iterator (and moveonly_output_iterator) while leaving everything else the same? I would approve of that direction.

But I notice that D100271 doesn't introduce a sentinel with which its new iterator type could be compared. It probably should include a sentinel, in order to make the new iterator type more useful with C++20 algorithms like std::ranges::copy. Still, I'm a little leery of introducing too many knobs. We probably don't want all four of a "copyable, comparable iterator" (i.e. the existing input_iterator/output_iterator) and a "move-only, comparable iterator" and a "copyable, sentineled iterator" and a "move-only, sentineled iterator"; but I'm still not sure what we do want.

(Fortunately, std::forward_iterator and higher all require std::regular, which means "copyable and comparable"; so the above combinatorial explosion applies only to input iterators and output iterators.)

cjdb added inline comments.Apr 26 2021, 4:20 PM
libcxx/test/support/test_iterators.h
64

So basically the intent of D101242-plus-D100271 is to introduce moveonly_input_iterator (and moveonly_output_iterator) while leaving everything else the same? I would approve of that direction.

That + prefixing current input_iterator with cpp17_ (or copyable_, which is more descriptive, but longer).

But I notice that D100271 doesn't introduce a sentinel with which its new iterator type could be compared. It probably should include a sentinel, in order to make the new iterator type more useful with C++20 algorithms like std::ranges::copy.

The patch has no need for a sentinel, so it's not added. I think it'd be a good idea for us to think about what the new sentinel type should do, and add it either with the first algorithm or as a follow-up patch to D100271 (it certainly shouldn't be blocking).

Still, I'm a little leery of introducing too many knobs. We probably don't want all four of a "copyable, comparable iterator" (i.e. the existing input_iterator/output_iterator) and a "move-only, comparable iterator" and a "copyable, sentineled iterator" and a "move-only, sentineled iterator"; but I'm still not sure what we do want.

Yeah, that's a bad idea. My intention is for the new, move-only input iterator is for it to be a completely minimal interface (i.e. move-only, not a self-sentinel).

Harbormaster completed remote builds in B101023: Diff 340647.Apr 26 2021, 11:27 PM
ldionne accepted this revision.Apr 27 2021, 12:21 PM

Reached agreement with @cjdb offline about using cpp17_input_iterator here and cpp20_input_iterator for the new thing introduced by D100271.

LGTM but please add a one-line comment saying This is the InputIterator concept as described prior to C++20 or something along those lines.

Mordante accepted this revision.Apr 28 2021, 10:18 AM
In D101242#2720585, @ldionne wrote:

Reached agreement with @cjdb offline about using cpp17_input_iterator here and cpp20_input_iterator for the new thing introduced by D100271.

Nice!
LGTM.

ldionne added a comment.Apr 30 2021, 2:22 PM

Can we apply the feedback and land this? Sorry to be pushy, but this is a large change (in terms of touched lines) and I'd like to get it in ASAP.

cjdb updated this revision to Diff 342043.Apr 30 2021, 2:31 PM

adds a comment explaining what cpp17_input_iterator represents

Harbormaster completed remote builds in B102022: Diff 342043.Apr 30 2021, 3:41 PM
cjdb updated this revision to Diff 342101.Apr 30 2021, 6:46 PM

rebases to fix CI

Harbormaster completed remote builds in B102068: Diff 342101.Apr 30 2021, 7:01 PM
cjdb updated this revision to Diff 342112.Apr 30 2021, 8:49 PM

tries to get CI working once more

• Quuxplusone added inline comments.Apr 30 2021, 8:55 PM
libcxx/benchmarks/filesystem.bench.cpp
69 ↗(On Diff #342112)

This legacy_ should also be cpp17_, right? (I think a git grep would help here.)

cjdb updated this revision to Diff 342115.Apr 30 2021, 9:38 PM

fixes benchmark

libcxx/benchmarks/filesystem.bench.cpp
69 ↗(On Diff #342112)

Thanks! TIL about git grep.

Harbormaster completed remote builds in B102074: Diff 342112.Apr 30 2021, 10:22 PM
Harbormaster completed remote builds in B102077: Diff 342115.May 1 2021, 12:37 AM
This revision was not accepted when it landed; it landed in state Needs Review.May 1 2021, 10:03 PM
Closed by commit rG773ae4412468: [libcxx][nfc] prefixes test type `input_iterator` with `cpp17_` (authored by cjdb). · Explain Why
This revision was automatically updated to reflect the committed changes.
cjdb added a commit: rG773ae4412468: [libcxx][nfc] prefixes test type `input_iterator` with `cpp17_`.

Large Diff

This large diff affects 373 files. Files without inline comments have been collapsed. Expand All Files

Revision Contents

PathSize
libcxx/
test/
libcxx/
containers/
sequences/
list/
list.modifiers/
4 lines
vector/
2 lines
input.output/
filesystems/
class.path/
path.req/
4 lines
iterators/
4 lines
10 lines
2 lines
6 lines
62 lines
strings/
8 lines
8 lines
std/
algorithms/
alg.modifying.operations/
alg.copy/
74 lines
32 lines
62 lines
62 lines
alg.fill/
12 lines
12 lines
alg.generate/
6 lines
6 lines
alg.move/
232 lines
100 lines
alg.partitions/
24 lines
8 lines
4 lines
48 lines
6 lines
alg.random.sample/
2 lines
30 lines
4 lines
alg.random.shuffle/
2 lines
2 lines
alg.remove/
12 lines
46 lines
52 lines
12 lines
alg.replace/
6 lines
52 lines
52 lines
6 lines
alg.reverse/
8 lines
28 lines
alg.rotate/
18 lines
28 lines
alg.shift/
24 lines
24 lines
alg.swap/
72 lines
alg.transform/
342 lines
62 lines
alg.unique/
12 lines
52 lines
52 lines
12 lines
alg.nonmodifying/
alg.adjacent.find/
18 lines
18 lines
alg.all_of/
16 lines
alg.any_of/
24 lines
alg.count/
12 lines
12 lines
alg.equal/
64 lines
64 lines
alg.find.end/
24 lines
24 lines
alg.find.first.of/
46 lines
46 lines
alg.find/
8 lines
10 lines
10 lines
alg.foreach/
2 lines
4 lines
alg.is_permutation/
628 lines
682 lines
alg.none_of/
24 lines
alg.search/
24 lines
6 lines
6 lines
18 lines
mismatch/
8 lines
8 lines
alg.sorting/
alg.heap.operations/
is.heap/
2 lines
2 lines
2 lines
2 lines
make.heap/
8 lines
8 lines
pop.heap/
8 lines
8 lines
push.heap/
8 lines
8 lines
sort.heap/
8 lines
8 lines
alg.binary.search/
binary.search/
6 lines
6 lines
equal.range/
6 lines
6 lines
lower.bound/
6 lines
6 lines
upper.bound/
6 lines
6 lines
alg.lex.comparison/
48 lines
48 lines
alg.merge/
8 lines
8 lines
22 lines
22 lines
alg.min.max/
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
2 lines
alg.nth.element/
8 lines
8 lines
alg.permutation.generators/
8 lines
8 lines
8 lines
8 lines
alg.set.operations/
includes/
56 lines
56 lines
set.difference/
22 lines
22 lines
set.intersection/
22 lines
22 lines
set.symmetric.difference/
22 lines
22 lines
set.union/
22 lines
22 lines
alg.sort/
is.sorted/
6 lines
6 lines
6 lines
6 lines
partial.sort.copy/
24 lines
24 lines
partial.sort/
8 lines
8 lines
sort/
56 lines
56 lines
containers/
associative/
map/
map.modifiers/
4 lines
multimap/
multimap.modifiers/
4 lines
multiset/
8 lines
multiset.cons/
8 lines
4 lines
4 lines
set/
8 lines
set.cons/
8 lines
4 lines
4 lines
sequences/
deque/
deque.cons/
6 lines
12 lines
20 lines
deque.modifiers/
10 lines
deque.special/
6 lines
4 lines
4 lines
4 lines
forwardlist/
forwardlist.cons/
8 lines
4 lines
4 lines
forwardlist.modifiers/
4 lines
list/
list.cons/
36 lines
vector.bool/
16 lines
16 lines
24 lines
vector/
vector.cons/
4 lines
50 lines
36 lines
vector.modifiers/
34 lines
unord/
unord.map/
unord.map.cnstr/
8 lines
4 lines
4 lines
4 lines
6 lines
unord.map.modifiers/
4 lines
unord.multimap/
unord.multimap.cnstr/
8 lines
4 lines
4 lines
4 lines
6 lines
unord.multimap.modifiers/
4 lines
unord.multiset/
4 lines
unord.multiset.cnstr/
8 lines
4 lines
4 lines
4 lines
4 lines
unord.set/
4 lines
unord.set.cnstr/
8 lines
4 lines
4 lines
4 lines
4 lines
experimental/
func/
func.searchers/
func.searchers.boyer_moore/
4 lines
4 lines
4 lines
4 lines
func.searchers.boyer_moore_horspool/
4 lines
4 lines
4 lines
4 lines
func.searchers.default/
18 lines
18 lines
func.searchers.default.creation/
18 lines
18 lines
iterator/
ostream.joiner/
ostream.joiner.ops/
24 lines
input.output/
filesystems/
class.path/
path.member/
8 lines
path.assign/
10 lines
8 lines
path.construct/
8 lines
iterators/
iterator.primitives/
iterator.operations/
20 lines
8 lines
20 lines
14 lines
iterator.traits/
10 lines
8 lines
iterator.requirements/
iterator.concepts/
iterator.concept.iterator/
38 lines
predef.iterators/
move.iterators/
move.iter.ops/
move.iter.nonmember/
8 lines
2 lines
2 lines
move.iter.op.+/
2 lines
move.iter.op.+=/
2 lines
move.iter.op.-/
2 lines
move.iter.op.-=/
2 lines
move.iter.op.comp/
16 lines
6 lines
6 lines
6 lines
6 lines
16 lines
move.iter.op.const/
8 lines
8 lines
8 lines
move.iter.op.decr/
4 lines
4 lines
move.iter.op.incr/
10 lines
8 lines
move.iter.op.index/
2 lines
move.iter.op=/
8 lines
move.iterator/
18 lines
reverse.iterators/
reverse.iter.ops/
reverse.iter.cons/
4 lines
4 lines
4 lines
reverse.iter.make/
4 lines
reverse.iter.op!=/
8 lines
reverse.iter.op++/
4 lines
4 lines
reverse.iter.op+/
2 lines
reverse.iter.op+=/
2 lines
reverse.iter.op--/
4 lines
4 lines
reverse.iter.op-/
2 lines
reverse.iter.op-=/
2 lines
reverse.iter.op=/
4 lines
reverse.iter.op==/
8 lines
reverse.iter.opdiff/
6 lines
reverse.iter.opgt/
6 lines
reverse.iter.opgt=/
6 lines
reverse.iter.opindex/
2 lines
reverse.iter.oplt/
6 lines
reverse.iter.oplt=/
6 lines
reverse.iter.opsum/
2 lines
reverse.iterator/
12 lines
localization/
locale.categories/
category.monetary/
locale.money.get/
locale.money.get.members/
116 lines
116 lines
116 lines
116 lines
116 lines
category.numeric/
locale.num.get/
facet.num.get.members/
86 lines
110 lines
86 lines
230 lines
116 lines
32 lines
14 lines
20 lines
20 lines
20 lines
20 lines
38 lines
category.time/
locale.time.get.byname/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
locale.time.get/
locale.time.get.members/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
numerics/
numeric.ops/
accumulate/
8 lines
8 lines
adjacent.difference/
52 lines
52 lines
exclusive.scan/
8 lines
8 lines
inclusive.scan/
8 lines
8 lines
8 lines
inner.product/
48 lines
56 lines
numeric.iota/
6 lines
partial.sum/
46 lines
52 lines
reduce/
8 lines
8 lines
8 lines
transform.exclusive.scan/
8 lines
transform.inclusive.scan/
8 lines
8 lines
transform.reduce/
8 lines
38 lines
38 lines
re/
re.alg/
re.alg.match/
8 lines
8 lines
8 lines
8 lines
re.alg.replace/
12 lines
12 lines
re.alg.search/
8 lines
8 lines
8 lines
8 lines
re.regex/
re.regex.assign/
4 lines
re.regex.construct/
2 lines
2 lines
re.traits/
4 lines
2 lines
4 lines
4 lines
strings/
basic.string/
legacy_input_iterator.h
input_iterator.h
14 lines
string.cons/
4 lines
34 lines
2 lines
2 lines
2 lines
string.modifiers/
string_append/
68 lines
string_assign/
66 lines
string_insert/
82 lines
string_replace/
2 lines
utilities/
function.objects/
func.search/
func.search.bm/
4 lines
4 lines
4 lines
4 lines
func.search.bmh/
4 lines
4 lines
4 lines
4 lines
func.search.default/
36 lines
36 lines
memory/
specialized.algorithms/
specialized.destroy/
2 lines
4 lines
uninitialized.construct.default/
6 lines
6 lines
uninitialized.construct.value/
6 lines
6 lines
uninitialized.move/
6 lines
6 lines
support/
184 lines

Diff 340315

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp

libcxx/test/libcxx/containers/sequences/vector/asan.pass.cpp

libcxx/test/libcxx/input.output/filesystems/class.path/path.req/is_pathable.pass.cpp

libcxx/test/libcxx/iterators/advance.debug1.pass.cpp

libcxx/test/libcxx/iterators/contiguous_iterators.pass.cpp

libcxx/test/libcxx/iterators/next.debug1.pass.cpp

libcxx/test/libcxx/iterators/prev.debug1.pass.cpp

libcxx/test/libcxx/iterators/trivial_iterators.pass.cpp

libcxx/test/libcxx/strings/iterators.exceptions.pass.cpp

libcxx/test/libcxx/strings/iterators.noexcept.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_backward.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy_n.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.generate/generate_n.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/move_backward.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_point.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.partitions/stable_partition.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.fail.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.sample/sample.stable.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle_rand.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_copy_if.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.remove/remove_if.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_copy_if.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.replace/replace_if.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.rotate/rotate_copy.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.shift/shift_left.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.shift/shift_right.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.swap/swap_ranges.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_copy_pred.pass.cpp

libcxx/test/std/algorithms/alg.modifying.operations/alg.unique/unique_pred.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.adjacent.find/adjacent_find_pred.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.all_of/all_of.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.any_of/any_of.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count_if.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find_if_not.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/for_each_n.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.foreach/test.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.none_of/none_of.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_n_pred.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/alg.search/search_pred.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp

libcxx/test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/is.heap/is_heap_until_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/make.heap/make_heap_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/pop.heap/pop_heap_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/push.heap/push_heap_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.heap.operations/sort.heap/sort_heap_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.binary.search/binary.search/binary_search_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.binary.search/equal.range/equal_range_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.binary.search/lower.bound/lower_bound_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.binary.search/upper.bound/upper_bound_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.merge/merge.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.merge/merge_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.min.max/max_element_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.min.max/min_element_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.min.max/minmax_element_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.min.max/requires_forward_iterator.fail.cpp

libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.nth.element/nth_element_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/next_permutation_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.permutation.generators/prev_permutation_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/includes/includes_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.difference/set_difference_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.intersection/set_intersection_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.symmetric.difference/set_symmetric_difference_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.set.operations/set.union/set_union_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/is_sorted_until_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/partial_sort_copy_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort/partial_sort_comp.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr.pass.cpp

libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort_constexpr_comp.pass.cpp

libcxx/test/std/containers/associative/map/map.modifiers/insert_iter_iter.pass.cpp

libcxx/test/std/containers/associative/multimap/multimap.modifiers/insert_iter_iter.pass.cpp

libcxx/test/std/containers/associative/multiset/insert_iter_iter.pass.cpp

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter.pass.cpp

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_alloc.pass.cpp

libcxx/test/std/containers/associative/multiset/multiset.cons/iter_iter_comp.pass.cpp

libcxx/test/std/containers/associative/set/insert_iter_iter.pass.cpp

libcxx/test/std/containers/associative/set/set.cons/iter_iter.pass.cpp

libcxx/test/std/containers/associative/set/set.cons/iter_iter_alloc.pass.cpp

libcxx/test/std/containers/associative/set/set.cons/iter_iter_comp.pass.cpp

libcxx/test/std/containers/sequences/deque/deque.cons/assign_iter_iter.pass.cpp

libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter.pass.cpp

libcxx/test/std/containers/sequences/deque/deque.cons/iter_iter_alloc.pass.cpp

libcxx/test/std/containers/sequences/deque/deque.modifiers/insert_iter_iter.pass.cpp

libcxx/test/std/containers/sequences/deque/deque.special/copy.pass.cpp

libcxx/test/std/containers/sequences/deque/deque.special/copy_backward.pass.cpp

libcxx/test/std/containers/sequences/deque/deque.special/move.pass.cpp

libcxx/test/std/containers/sequences/deque/deque.special/move_backward.pass.cpp

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/assign_range.pass.cpp

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range.pass.cpp

libcxx/test/std/containers/sequences/forwardlist/forwardlist.cons/range_alloc.pass.cpp

libcxx/test/std/containers/sequences/forwardlist/forwardlist.modifiers/insert_after_range.pass.cpp

libcxx/test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp

libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter.pass.cpp

libcxx/test/std/containers/sequences/vector.bool/construct_iter_iter_alloc.pass.cpp

libcxx/test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp

libcxx/test/std/containers/sequences/vector/vector.cons/assign_iter_iter.pass.cpp

libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp

libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter_alloc.pass.cpp

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range.pass.cpp

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size.pass.cpp

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash.pass.cpp

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal.pass.cpp

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/range_size_hash_equal_allocator.pass.cpp

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_range.pass.cpp

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range.pass.cpp

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size.pass.cpp

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash.pass.cpp

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal.pass.cpp

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/range_size_hash_equal_allocator.pass.cpp

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_range.pass.cpp

libcxx/test/std/containers/unord/unord.multiset/insert_range.pass.cpp

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range.pass.cpp

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size.pass.cpp

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash.pass.cpp

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal.pass.cpp

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/range_size_hash_equal_allocator.pass.cpp

libcxx/test/std/containers/unord/unord.set/insert_range.pass.cpp

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range.pass.cpp

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size.pass.cpp

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash.pass.cpp

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal.pass.cpp

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/range_size_hash_equal_allocator.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/default.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/hash.pred.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore/pred.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/default.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/hash.pred.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.boyer_moore_horspool/pred.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.default/default.pred.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pass.cpp

libcxx/test/std/experimental/func/func.searchers/func.searchers.default/func.searchers.default.creation/make_default_searcher.pred.pass.cpp

libcxx/test/std/experimental/iterator/ostream.joiner/ostream.joiner.ops/ostream_joiner.op.assign.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.pass.cpp

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp

libcxx/test/std/iterators/iterator.primitives/iterator.operations/advance.pass.cpp

libcxx/test/std/iterators/iterator.primitives/iterator.operations/distance.pass.cpp

libcxx/test/std/iterators/iterator.primitives/iterator.operations/next.pass.cpp

libcxx/test/std/iterators/iterator.primitives/iterator.operations/prev.pass.cpp

libcxx/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

libcxx/test/std/iterators/iterator.primitives/iterator.traits/iter_reference_t.compile.pass.cpp

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.iterator/input_or_output_iterator.compile.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/make_move_iterator.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/minus.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.nonmember/plus.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+/difference_type.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.+=/difference_type.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-/difference_type.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.-=/difference_type.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_eq.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gt.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_gte.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lt.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_lte.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.comp/op_neq.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/convert.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/default.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.const/iter.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/post.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.decr/pre.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/post.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.incr/pre.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op.index/difference_type.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iter.ops/move.iter.op=/move_iterator.pass.cpp

libcxx/test/std/iterators/predef.iterators/move.iterators/move.iterator/types.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/default.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/iter.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.cons/reverse_iterator.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.make/make_reverse_iterator.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op!=/test.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/post.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op++/pre.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+/difference_type.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op+=/difference_type.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/post.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op--/pre.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-/difference_type.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op-=/difference_type.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op=/reverse_iterator.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.op==/test.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opdiff/test.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt/test.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opgt=/test.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opindex/difference_type.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt/test.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.oplt=/test.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iter.ops/reverse.iter.opsum/difference_type.pass.cpp

libcxx/test/std/iterators/predef.iterators/reverse.iterators/reverse.iterator/types.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_en_US.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_fr_FR.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_ru_RU.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_long_double_zh_CN.pass.cpp

libcxx/test/std/localization/locale.categories/category.monetary/locale.money.get/locale.money.get.members/get_string_en_US.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_bool.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_double.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_long.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_pointer.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_int.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_long_long.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_unsigned_short.pass.cpp

libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/test_neg_one.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/date_order_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_date_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_monthname_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_one_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_time_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_weekday_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get.byname/get_year_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/date_order.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_date_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_many.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_monthname_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_one.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_time_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_weekday_wide.pass.cpp

libcxx/test/std/localization/locale.categories/category.time/locale.time.get/locale.time.get.members/get_year.pass.cpp

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate_op.pass.cpp

libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference.pass.cpp

libcxx/test/std/numerics/numeric.ops/adjacent.difference/adjacent_difference_op.pass.cpp

libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp

libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp

libcxx/test/std/numerics/numeric.ops/inner.product/inner_product.pass.cpp

libcxx/test/std/numerics/numeric.ops/inner.product/inner_product_comp.pass.cpp

libcxx/test/std/numerics/numeric.ops/numeric.iota/iota.pass.cpp

libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum.pass.cpp

libcxx/test/std/numerics/numeric.ops/partial.sum/partial_sum_op.pass.cpp

libcxx/test/std/numerics/numeric.ops/reduce/reduce.pass.cpp

libcxx/test/std/numerics/numeric.ops/reduce/reduce_init.pass.cpp

libcxx/test/std/numerics/numeric.ops/reduce/reduce_init_op.pass.cpp

libcxx/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp

libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp

libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_init_bop_uop.pass.cpp

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init.pass.cpp

libcxx/test/std/numerics/numeric.ops/transform.reduce/transform_reduce_iter_iter_iter_init_op_op.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/awk.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/basic.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/ecma.pass.cpp

libcxx/test/std/re/re.alg/re.alg.match/extended.pass.cpp

libcxx/test/std/re/re.alg/re.alg.replace/test1.pass.cpp

libcxx/test/std/re/re.alg/re.alg.replace/test2.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/awk.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/basic.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/ecma.pass.cpp

libcxx/test/std/re/re.alg/re.alg.search/extended.pass.cpp

libcxx/test/std/re/re.regex/re.regex.assign/assign_iter_iter_flag.pass.cpp

libcxx/test/std/re/re.regex/re.regex.construct/iter_iter.pass.cpp

libcxx/test/std/re/re.regex/re.regex.construct/iter_iter_flg.pass.cpp

libcxx/test/std/re/re.traits/lookup_classname.pass.cpp

libcxx/test/std/re/re.traits/lookup_collatename.pass.cpp

libcxx/test/std/re/re.traits/transform.pass.cpp

libcxx/test/std/re/re.traits/transform_primary.pass.cpp

libcxx/test/std/strings/basic.string/input_iterator.h

libcxx/test/std/strings/basic.string/legacy_input_iterator.h

libcxx/test/std/strings/basic.string/string.cons/implicit_deduction_guides.pass.cpp

libcxx/test/std/strings/basic.string/string.cons/iter_alloc.pass.cpp

libcxx/test/std/strings/basic.string/string.cons/iter_alloc_deduction.pass.cpp

libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp

libcxx/test/std/strings/basic.string/string.cons/string_view_size_size_deduction.pass.cpp

libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

libcxx/test/std/utilities/function.objects/func.search/func.search.bm/default.pass.cpp

libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pass.cpp

libcxx/test/std/utilities/function.objects/func.search/func.search.bm/hash.pred.pass.cpp

libcxx/test/std/utilities/function.objects/func.search/func.search.bm/pred.pass.cpp

libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/default.pass.cpp

libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pass.cpp

libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/hash.pred.pass.cpp

libcxx/test/std/utilities/function.objects/func.search/func.search.bmh/pred.pass.cpp

libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pass.cpp

libcxx/test/std/utilities/function.objects/func.search/func.search.default/default.pred.pass.cpp

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy.pass.cpp

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct.pass.cpp

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.default/uninitialized_default_construct_n.pass.cpp

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct.pass.cpp

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.construct.value/uninitialized_value_construct_n.pass.cpp

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move.pass.cpp

libcxx/test/std/utilities/memory/specialized.algorithms/uninitialized.move/uninitialized_move_n.pass.cpp

libcxx/test/support/test_iterators.h

//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
MordanteUnsubmitted
Not Done
ReplyInline Actions

The new C++20 style iterators will they also be put in this file or will they get their own header. If the latter then maybe rename this file to test_legacy_iterator.h.

Mordante: The new C++20 style iterators will they also be put in this file or will they get their own…
cjdbAuthorUnsubmitted
Done
ReplyInline Actions

My intention was to add them here and guard them with a ranges support macro. C++20 ranges may want to test both in certain circumstances.

cjdb: My intention was to add them here and guard them with a ranges support macro. C++20 ranges may…
// //
// 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 ITERATORS_H #ifndef ITERATORS_H
Show All 39 Lines TEST_CONSTEXPR_CXX14 output_iterator operator++(int)
{output_iterator tmp(*this); ++(*this); return tmp;} {output_iterator tmp(*this); ++(*this); return tmp;}
template <class T> template <class T>
void operator,(T const &) DELETE_FUNCTION; void operator,(T const &) DELETE_FUNCTION;
}; };
template <class It, template <class It,
class ItTraits = It> class ItTraits = It>
class input_iterator class legacy_input_iterator
{ {
typedef std::iterator_traits<ItTraits> Traits; typedef std::iterator_traits<ItTraits> Traits;
It it_; It it_;
template <class U, class T> friend class input_iterator; template <class U, class T> friend class legacy_input_iterator;
public: public:
typedef std::input_iterator_tag iterator_category; typedef std::input_iterator_tag iterator_category;
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

@cjdb wrote:

tl;dr yes. At minimum, the iterator tags are now mandatory.

The existing iterators already have tags, though. So that's not a concern for us.

I suggested to Louis in chat but will put here for the record: If the main concern of this patch is to make sure we have a test iterator which is a "non-comparable input iterator" (comparable only to its sentinel type, but not to itself), then I suggest you leave everything the way it is in main but then add the new C++20-only, sentinel-comparison-only test iterator, like this:

#if TEST_STD_VER >= 20
template<class It>
class incomparable_input_iterator {
    // This is an input iterator according to C++>=20, but not according to C++<=17.
    // It is comparable with its sentinel type, but not with its own type.
    [...mostly the same stuff as the regular input iterator test type...]
public:
    struct sentinel {
        constexpr explicit sentinel(It it) : it_(it) {}
    };
    friend constexpr bool operator==(const incomparable_input_iterator& x, const sentinel& y)
        {return x.it_ == y.it_;}
};
#endif

This probably belongs right above contiguous_iterator, circa line 315, because we intend it to be new in C++20.

Quuxplusone: @cjdb wrote: > tl;dr yes. At minimum, the iterator tags are now mandatory. The existing…
cjdbAuthorUnsubmitted
Done
ReplyInline Actions

If the main concern of this patch is to make sure we have a test iterator which is a "non-comparable input iterator" (comparable only to its sentinel type, but not to itself)

This isn't the only difference between Cpp17InputIterator and std::input_iterator.

I suggest you leave everything the way it is in main but then add the new C++20-only, sentinel-comparison-only test iterator

That leaves ambiguity as to whether or not input_iterator refers to a Cpp17InputIterator or is a strict std::input_iterator. It needs to be renamed to clear up that ambiguity.

cjdb: > If the main concern of this patch is to make sure we have a test iterator which is a "non…
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

This isn't the only difference

Obligatory "What are the differences you care about, then?"
No two things in the world are ever exactly the same. That doesn't mean we make libc++ PRs about it. :)

Quuxplusone: > This isn't the only difference Obligatory "What are the differences you care about, then?"…
cjdbAuthorUnsubmitted
Done
ReplyInline Actions

The most salient difference is that C++20 input iterators need not be copyable. I expected that this would be fresh in your mind, since you've recently reviewed D100271, which is why I didn't mention it.

cjdb: The most salient difference is that C++20 input iterators need not be copyable. I expected that…
QuuxplusoneUnsubmitted
Not Done
ReplyInline Actions

So basically the intent of D101242-plus-D100271 is to introduce moveonly_input_iterator (and moveonly_output_iterator) while leaving everything else the same? I would approve of that direction.

But I notice that D100271 doesn't introduce a sentinel with which its new iterator type could be compared. It probably should include a sentinel, in order to make the new iterator type more useful with C++20 algorithms like std::ranges::copy. Still, I'm a little leery of introducing too many knobs. We probably don't want all four of a "copyable, comparable iterator" (i.e. the existing input_iterator/output_iterator) and a "move-only, comparable iterator" and a "copyable, sentineled iterator" and a "move-only, sentineled iterator"; but I'm still not sure what we do want.

(Fortunately, std::forward_iterator and higher all require std::regular, which means "copyable and comparable"; so the above combinatorial explosion applies only to input iterators and output iterators.)

Quuxplusone: So basically the intent of D101242-plus-D100271 is to introduce `moveonly_input_iterator` (and…
cjdbAuthorUnsubmitted
Done
ReplyInline Actions

So basically the intent of D101242-plus-D100271 is to introduce moveonly_input_iterator (and moveonly_output_iterator) while leaving everything else the same? I would approve of that direction.

That + prefixing current input_iterator with cpp17_ (or copyable_, which is more descriptive, but longer).

But I notice that D100271 doesn't introduce a sentinel with which its new iterator type could be compared. It probably should include a sentinel, in order to make the new iterator type more useful with C++20 algorithms like std::ranges::copy.

The patch has no need for a sentinel, so it's not added. I think it'd be a good idea for us to think about what the new sentinel type should do, and add it either with the first algorithm or as a follow-up patch to D100271 (it certainly shouldn't be blocking).

Still, I'm a little leery of introducing too many knobs. We probably don't want all four of a "copyable, comparable iterator" (i.e. the existing input_iterator/output_iterator) and a "move-only, comparable iterator" and a "copyable, sentineled iterator" and a "move-only, sentineled iterator"; but I'm still not sure what we do want.

Yeah, that's a bad idea. My intention is for the new, move-only input iterator is for it to be a completely minimal interface (i.e. move-only, not a self-sentinel).

cjdb: > So basically the intent of D101242-plus-D100271 is to introduce `moveonly_input_iterator`…
typedef typename Traits::value_type value_type; typedef typename Traits::value_type value_type;
typedef typename Traits::difference_type difference_type; typedef typename Traits::difference_type difference_type;
typedef It pointer; typedef It pointer;
typedef typename Traits::reference reference; typedef typename Traits::reference reference;
TEST_CONSTEXPR_CXX14 It base() const {return it_;} TEST_CONSTEXPR_CXX14 It base() const {return it_;}
TEST_CONSTEXPR_CXX14 input_iterator() : it_() {} TEST_CONSTEXPR_CXX14 legacy_input_iterator() : it_() {}
explicit TEST_CONSTEXPR_CXX14 input_iterator(It it) : it_(it) {} explicit TEST_CONSTEXPR_CXX14 legacy_input_iterator(It it) : it_(it) {}
template <class U, class T> template <class U, class T>
TEST_CONSTEXPR_CXX14 input_iterator(const input_iterator<U, T>& u) :it_(u.it_) {} TEST_CONSTEXPR_CXX14 legacy_input_iterator(const legacy_input_iterator<U, T>& u) :it_(u.it_) {}
TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;} TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;} TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
TEST_CONSTEXPR_CXX14 input_iterator& operator++() {++it_; return *this;} TEST_CONSTEXPR_CXX14 legacy_input_iterator& operator++() {++it_; return *this;}
TEST_CONSTEXPR_CXX14 input_iterator operator++(int) TEST_CONSTEXPR_CXX14 legacy_input_iterator operator++(int)
{input_iterator tmp(*this); ++(*this); return tmp;} {legacy_input_iterator tmp(*this); ++(*this); return tmp;}
friend TEST_CONSTEXPR_CXX14 bool operator==(const input_iterator& x, const input_iterator& y) friend TEST_CONSTEXPR_CXX14 bool operator==(const legacy_input_iterator& x, const legacy_input_iterator& y)
{return x.it_ == y.it_;} {return x.it_ == y.it_;}
friend TEST_CONSTEXPR_CXX14 bool operator!=(const input_iterator& x, const input_iterator& y) friend TEST_CONSTEXPR_CXX14 bool operator!=(const legacy_input_iterator& x, const legacy_input_iterator& y)
{return !(x == y);} {return !(x == y);}
template <class T> template <class T>
void operator,(T const &) DELETE_FUNCTION; void operator,(T const &) DELETE_FUNCTION;
}; };
template <class T, class TV, class U, class UV> template <class T, class TV, class U, class UV>
inline inline
bool bool
operator==(const input_iterator<T, TV>& x, const input_iterator<U, UV>& y) operator==(const legacy_input_iterator<T, TV>& x, const legacy_input_iterator<U, UV>& y)
{ {
return x.base() == y.base(); return x.base() == y.base();
} }
template <class T, class TV, class U, class UV> template <class T, class TV, class U, class UV>
inline inline
bool bool
operator!=(const input_iterator<T, TV>& x, const input_iterator<U, UV>& y) operator!=(const legacy_input_iterator<T, TV>& x, const legacy_input_iterator<U, UV>& y)
{ {
return !(x == y); return !(x == y);
} }
template <class It> template <class It>
class forward_iterator class legacy_forward_iterator
{ {
It it_; It it_;
template <class U> friend class forward_iterator; template <class U> friend class legacy_forward_iterator;
public: public:
typedef std::forward_iterator_tag iterator_category; typedef std::forward_iterator_tag iterator_category;
typedef typename std::iterator_traits<It>::value_type value_type; typedef typename std::iterator_traits<It>::value_type value_type;
typedef typename std::iterator_traits<It>::difference_type difference_type; typedef typename std::iterator_traits<It>::difference_type difference_type;
typedef It pointer; typedef It pointer;
typedef typename std::iterator_traits<It>::reference reference; typedef typename std::iterator_traits<It>::reference reference;
TEST_CONSTEXPR_CXX14 It base() const {return it_;} TEST_CONSTEXPR_CXX14 It base() const {return it_;}
TEST_CONSTEXPR_CXX14 forward_iterator() : it_() {} TEST_CONSTEXPR_CXX14 legacy_forward_iterator() : it_() {}
explicit TEST_CONSTEXPR_CXX14 forward_iterator(It it) : it_(it) {} explicit TEST_CONSTEXPR_CXX14 legacy_forward_iterator(It it) : it_(it) {}
template <class U> template <class U>
TEST_CONSTEXPR_CXX14 forward_iterator(const forward_iterator<U>& u) :it_(u.it_) {} TEST_CONSTEXPR_CXX14 legacy_forward_iterator(const legacy_forward_iterator<U>& u) :it_(u.it_) {}
TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;} TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;} TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
TEST_CONSTEXPR_CXX14 forward_iterator& operator++() {++it_; return *this;} TEST_CONSTEXPR_CXX14 legacy_forward_iterator& operator++() {++it_; return *this;}
TEST_CONSTEXPR_CXX14 forward_iterator operator++(int) TEST_CONSTEXPR_CXX14 legacy_forward_iterator operator++(int)
{forward_iterator tmp(*this); ++(*this); return tmp;} {legacy_forward_iterator tmp(*this); ++(*this); return tmp;}
friend TEST_CONSTEXPR_CXX14 bool operator==(const forward_iterator& x, const forward_iterator& y) friend TEST_CONSTEXPR_CXX14 bool operator==(const legacy_forward_iterator& x, const legacy_forward_iterator& y)
{return x.it_ == y.it_;} {return x.it_ == y.it_;}
friend TEST_CONSTEXPR_CXX14 bool operator!=(const forward_iterator& x, const forward_iterator& y) friend TEST_CONSTEXPR_CXX14 bool operator!=(const legacy_forward_iterator& x, const legacy_forward_iterator& y)
{return !(x == y);} {return !(x == y);}
template <class T> template <class T>
void operator,(T const &) DELETE_FUNCTION; void operator,(T const &) DELETE_FUNCTION;
}; };
template <class T, class U> template <class T, class U>
inline inline
bool TEST_CONSTEXPR_CXX14 bool TEST_CONSTEXPR_CXX14
operator==(const forward_iterator<T>& x, const forward_iterator<U>& y) operator==(const legacy_forward_iterator<T>& x, const legacy_forward_iterator<U>& y)
{ {
return x.base() == y.base(); return x.base() == y.base();
} }
template <class T, class U> template <class T, class U>
inline inline
bool TEST_CONSTEXPR_CXX14 bool TEST_CONSTEXPR_CXX14
operator!=(const forward_iterator<T>& x, const forward_iterator<U>& y) operator!=(const legacy_forward_iterator<T>& x, const legacy_forward_iterator<U>& y)
{ {
return !(x == y); return !(x == y);
} }
template <class It> template <class It>
class bidirectional_iterator class legacy_bidirectional_iterator
{ {
It it_; It it_;
template <class U> friend class bidirectional_iterator; template <class U> friend class legacy_bidirectional_iterator;
public: public:
typedef std::bidirectional_iterator_tag iterator_category; typedef std::bidirectional_iterator_tag iterator_category;
typedef typename std::iterator_traits<It>::value_type value_type; typedef typename std::iterator_traits<It>::value_type value_type;
typedef typename std::iterator_traits<It>::difference_type difference_type; typedef typename std::iterator_traits<It>::difference_type difference_type;
typedef It pointer; typedef It pointer;
typedef typename std::iterator_traits<It>::reference reference; typedef typename std::iterator_traits<It>::reference reference;
TEST_CONSTEXPR_CXX14 It base() const {return it_;} TEST_CONSTEXPR_CXX14 It base() const {return it_;}
TEST_CONSTEXPR_CXX14 bidirectional_iterator() : it_() {} TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator() : it_() {}
explicit TEST_CONSTEXPR_CXX14 bidirectional_iterator(It it) : it_(it) {} explicit TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator(It it) : it_(it) {}
template <class U> template <class U>
TEST_CONSTEXPR_CXX14 bidirectional_iterator(const bidirectional_iterator<U>& u) :it_(u.it_) {} TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator(const legacy_bidirectional_iterator<U>& u) :it_(u.it_) {}
TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;} TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;} TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
TEST_CONSTEXPR_CXX14 bidirectional_iterator& operator++() {++it_; return *this;} TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator& operator++() {++it_; return *this;}
TEST_CONSTEXPR_CXX14 bidirectional_iterator operator++(int) TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator operator++(int)
{bidirectional_iterator tmp(*this); ++(*this); return tmp;} {legacy_bidirectional_iterator tmp(*this); ++(*this); return tmp;}
TEST_CONSTEXPR_CXX14 bidirectional_iterator& operator--() {--it_; return *this;} TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator& operator--() {--it_; return *this;}
TEST_CONSTEXPR_CXX14 bidirectional_iterator operator--(int) TEST_CONSTEXPR_CXX14 legacy_bidirectional_iterator operator--(int)
{bidirectional_iterator tmp(*this); --(*this); return tmp;} {legacy_bidirectional_iterator tmp(*this); --(*this); return tmp;}
template <class T> template <class T>
void operator,(T const &) DELETE_FUNCTION; void operator,(T const &) DELETE_FUNCTION;
}; };
template <class T, class U> template <class T, class U>
inline inline
bool TEST_CONSTEXPR_CXX14 bool TEST_CONSTEXPR_CXX14
operator==(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y) operator==(const legacy_bidirectional_iterator<T>& x, const legacy_bidirectional_iterator<U>& y)
{ {
return x.base() == y.base(); return x.base() == y.base();
} }
template <class T, class U> template <class T, class U>
inline inline
bool TEST_CONSTEXPR_CXX14 bool TEST_CONSTEXPR_CXX14
operator!=(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y) operator!=(const legacy_bidirectional_iterator<T>& x, const legacy_bidirectional_iterator<U>& y)
{ {
return !(x == y); return !(x == y);
} }
template <class It> template <class It>
class random_access_iterator class legacy_random_access_iterator
{ {
It it_; It it_;
template <class U> friend class random_access_iterator; template <class U> friend class legacy_random_access_iterator;
public: public:
typedef std::random_access_iterator_tag iterator_category; typedef std::random_access_iterator_tag iterator_category;
typedef typename std::iterator_traits<It>::value_type value_type; typedef typename std::iterator_traits<It>::value_type value_type;
typedef typename std::iterator_traits<It>::difference_type difference_type; typedef typename std::iterator_traits<It>::difference_type difference_type;
typedef It pointer; typedef It pointer;
typedef typename std::iterator_traits<It>::reference reference; typedef typename std::iterator_traits<It>::reference reference;
TEST_CONSTEXPR_CXX14 It base() const {return it_;} TEST_CONSTEXPR_CXX14 It base() const {return it_;}
TEST_CONSTEXPR_CXX14 random_access_iterator() : it_() {} TEST_CONSTEXPR_CXX14 legacy_random_access_iterator() : it_() {}
explicit TEST_CONSTEXPR_CXX14 random_access_iterator(It it) : it_(it) {} explicit TEST_CONSTEXPR_CXX14 legacy_random_access_iterator(It it) : it_(it) {}
template <class U> template <class U>
TEST_CONSTEXPR_CXX14 random_access_iterator(const random_access_iterator<U>& u) :it_(u.it_) {} TEST_CONSTEXPR_CXX14 legacy_random_access_iterator(const legacy_random_access_iterator<U>& u) :it_(u.it_) {}
TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;} TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;} TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
TEST_CONSTEXPR_CXX14 random_access_iterator& operator++() {++it_; return *this;} TEST_CONSTEXPR_CXX14 legacy_random_access_iterator& operator++() {++it_; return *this;}
TEST_CONSTEXPR_CXX14 random_access_iterator operator++(int) TEST_CONSTEXPR_CXX14 legacy_random_access_iterator operator++(int)
{random_access_iterator tmp(*this); ++(*this); return tmp;} {legacy_random_access_iterator tmp(*this); ++(*this); return tmp;}
TEST_CONSTEXPR_CXX14 random_access_iterator& operator--() {--it_; return *this;} TEST_CONSTEXPR_CXX14 legacy_random_access_iterator& operator--() {--it_; return *this;}
TEST_CONSTEXPR_CXX14 random_access_iterator operator--(int) TEST_CONSTEXPR_CXX14 legacy_random_access_iterator operator--(int)
{random_access_iterator tmp(*this); --(*this); return tmp;} {legacy_random_access_iterator tmp(*this); --(*this); return tmp;}
TEST_CONSTEXPR_CXX14 random_access_iterator& operator+=(difference_type n) {it_ += n; return *this;} TEST_CONSTEXPR_CXX14 legacy_random_access_iterator& operator+=(difference_type n) {it_ += n; return *this;}
TEST_CONSTEXPR_CXX14 random_access_iterator operator+(difference_type n) const TEST_CONSTEXPR_CXX14 legacy_random_access_iterator operator+(difference_type n) const
{random_access_iterator tmp(*this); tmp += n; return tmp;} {legacy_random_access_iterator tmp(*this); tmp += n; return tmp;}
friend TEST_CONSTEXPR_CXX14 random_access_iterator operator+(difference_type n, random_access_iterator x) friend TEST_CONSTEXPR_CXX14 legacy_random_access_iterator operator+(difference_type n, legacy_random_access_iterator x)
{x += n; return x;} {x += n; return x;}
TEST_CONSTEXPR_CXX14 random_access_iterator& operator-=(difference_type n) {return *this += -n;} TEST_CONSTEXPR_CXX14 legacy_random_access_iterator& operator-=(difference_type n) {return *this += -n;}
TEST_CONSTEXPR_CXX14 random_access_iterator operator-(difference_type n) const TEST_CONSTEXPR_CXX14 legacy_random_access_iterator operator-(difference_type n) const
{random_access_iterator tmp(*this); tmp -= n; return tmp;} {legacy_random_access_iterator tmp(*this); tmp -= n; return tmp;}
TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];} TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];}
template <class T> template <class T>
void operator,(T const &) DELETE_FUNCTION; void operator,(T const &) DELETE_FUNCTION;
}; };
template <class T, class U> template <class T, class U>
inline inline
bool TEST_CONSTEXPR_CXX14 bool TEST_CONSTEXPR_CXX14
operator==(const random_access_iterator<T>& x, const random_access_iterator<U>& y) operator==(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
{ {
return x.base() == y.base(); return x.base() == y.base();
} }
template <class T, class U> template <class T, class U>
inline inline
bool TEST_CONSTEXPR_CXX14 bool TEST_CONSTEXPR_CXX14
operator!=(const random_access_iterator<T>& x, const random_access_iterator<U>& y) operator!=(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
{ {
return !(x == y); return !(x == y);
} }
template <class T, class U> template <class T, class U>
inline inline
bool TEST_CONSTEXPR_CXX14 bool TEST_CONSTEXPR_CXX14
operator<(const random_access_iterator<T>& x, const random_access_iterator<U>& y) operator<(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
{ {
return x.base() < y.base(); return x.base() < y.base();
} }
template <class T, class U> template <class T, class U>
inline inline
bool TEST_CONSTEXPR_CXX14 bool TEST_CONSTEXPR_CXX14
operator<=(const random_access_iterator<T>& x, const random_access_iterator<U>& y) operator<=(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
{ {
return !(y < x); return !(y < x);
} }
template <class T, class U> template <class T, class U>
inline inline
bool TEST_CONSTEXPR_CXX14 bool TEST_CONSTEXPR_CXX14
operator>(const random_access_iterator<T>& x, const random_access_iterator<U>& y) operator>(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
{ {
return y < x; return y < x;
} }
template <class T, class U> template <class T, class U>
inline inline
bool TEST_CONSTEXPR_CXX14 bool TEST_CONSTEXPR_CXX14
operator>=(const random_access_iterator<T>& x, const random_access_iterator<U>& y) operator>=(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
{ {
return !(x < y); return !(x < y);
} }
template <class T, class U> template <class T, class U>
inline TEST_CONSTEXPR_CXX14 inline TEST_CONSTEXPR_CXX14
typename std::iterator_traits<T>::difference_type typename std::iterator_traits<T>::difference_type
operator-(const random_access_iterator<T>& x, const random_access_iterator<U>& y) operator-(const legacy_random_access_iterator<T>& x, const legacy_random_access_iterator<U>& y)
{ {
return x.base() - y.base(); return x.base() - y.base();
} }
#if TEST_STD_VER >= 20 #if TEST_STD_VER >= 20
template <class It> template <class It>
class contiguous_iterator class legacy_contiguous_iterator
{ {
static_assert(std::is_pointer_v<It>, "Things probably break in this case"); static_assert(std::is_pointer_v<It>, "Things probably break in this case");
It it_; It it_;
template <class U> friend class contiguous_iterator; template <class U> friend class legacy_contiguous_iterator;
public: public:
typedef std::contiguous_iterator_tag iterator_category; typedef std::contiguous_iterator_tag iterator_category;
typedef typename std::iterator_traits<It>::value_type value_type; typedef typename std::iterator_traits<It>::value_type value_type;
typedef typename std::iterator_traits<It>::difference_type difference_type; typedef typename std::iterator_traits<It>::difference_type difference_type;
typedef It pointer; typedef It pointer;
typedef typename std::iterator_traits<It>::reference reference; typedef typename std::iterator_traits<It>::reference reference;
typedef typename std::remove_pointer<It>::type element_type; typedef typename std::remove_pointer<It>::type element_type;
TEST_CONSTEXPR_CXX14 It base() const {return it_;} TEST_CONSTEXPR_CXX14 It base() const {return it_;}
TEST_CONSTEXPR_CXX14 contiguous_iterator() : it_() {} TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator() : it_() {}
explicit TEST_CONSTEXPR_CXX14 contiguous_iterator(It it) : it_(it) {} explicit TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator(It it) : it_(it) {}
template <class U> template <class U>
TEST_CONSTEXPR_CXX14 contiguous_iterator(const contiguous_iterator<U>& u) : it_(u.it_) {} TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator(const legacy_contiguous_iterator<U>& u) : it_(u.it_) {}
TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;} TEST_CONSTEXPR_CXX14 reference operator*() const {return *it_;}
TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;} TEST_CONSTEXPR_CXX14 pointer operator->() const {return it_;}
TEST_CONSTEXPR_CXX14 contiguous_iterator& operator++() {++it_; return *this;} TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator& operator++() {++it_; return *this;}
TEST_CONSTEXPR_CXX14 contiguous_iterator operator++(int) TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator operator++(int)
{contiguous_iterator tmp(*this); ++(*this); return tmp;} {legacy_contiguous_iterator tmp(*this); ++(*this); return tmp;}
TEST_CONSTEXPR_CXX14 contiguous_iterator& operator--() {--it_; return *this;} TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator& operator--() {--it_; return *this;}
TEST_CONSTEXPR_CXX14 contiguous_iterator operator--(int) TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator operator--(int)
{contiguous_iterator tmp(*this); --(*this); return tmp;} {legacy_contiguous_iterator tmp(*this); --(*this); return tmp;}
TEST_CONSTEXPR_CXX14 contiguous_iterator& operator+=(difference_type n) {it_ += n; return *this;} TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator& operator+=(difference_type n) {it_ += n; return *this;}
TEST_CONSTEXPR_CXX14 contiguous_iterator operator+(difference_type n) const TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator operator+(difference_type n) const
{contiguous_iterator tmp(*this); tmp += n; return tmp;} {legacy_contiguous_iterator tmp(*this); tmp += n; return tmp;}
friend TEST_CONSTEXPR_CXX14 contiguous_iterator operator+(difference_type n, contiguous_iterator x) friend TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator operator+(difference_type n, legacy_contiguous_iterator x)
{x += n; return x;} {x += n; return x;}
TEST_CONSTEXPR_CXX14 contiguous_iterator& operator-=(difference_type n) {return *this += -n;} TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator& operator-=(difference_type n) {return *this += -n;}
TEST_CONSTEXPR_CXX14 contiguous_iterator operator-(difference_type n) const TEST_CONSTEXPR_CXX14 legacy_contiguous_iterator operator-(difference_type n) const
{contiguous_iterator tmp(*this); tmp -= n; return tmp;} {legacy_contiguous_iterator tmp(*this); tmp -= n; return tmp;}
TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];} TEST_CONSTEXPR_CXX14 reference operator[](difference_type n) const {return it_[n];}
template <class T> template <class T>
void operator,(T const &) DELETE_FUNCTION; void operator,(T const &) DELETE_FUNCTION;
friend TEST_CONSTEXPR_CXX14 friend TEST_CONSTEXPR_CXX14
difference_type operator-(const contiguous_iterator& x, const contiguous_iterator& y) { difference_type operator-(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
return x.base() - y.base(); return x.base() - y.base();
} }
friend TEST_CONSTEXPR_CXX14 friend TEST_CONSTEXPR_CXX14
difference_type operator<(const contiguous_iterator& x, const contiguous_iterator& y) { difference_type operator<(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
return x.base() < y.base(); return x.base() < y.base();
} }
friend TEST_CONSTEXPR_CXX14 friend TEST_CONSTEXPR_CXX14
difference_type operator>(const contiguous_iterator& x, const contiguous_iterator& y) { difference_type operator>(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
return x.base() > y.base(); return x.base() > y.base();
} }
friend TEST_CONSTEXPR_CXX14 friend TEST_CONSTEXPR_CXX14
difference_type operator<=(const contiguous_iterator& x, const contiguous_iterator& y) { difference_type operator<=(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
return x.base() <= y.base(); return x.base() <= y.base();
} }
friend TEST_CONSTEXPR_CXX14 friend TEST_CONSTEXPR_CXX14
difference_type operator>=(const contiguous_iterator& x, const contiguous_iterator& y) { difference_type operator>=(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
return x.base() >= y.base(); return x.base() >= y.base();
} }
friend TEST_CONSTEXPR_CXX14 friend TEST_CONSTEXPR_CXX14
difference_type operator==(const contiguous_iterator& x, const contiguous_iterator& y) { difference_type operator==(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
return x.base() == y.base(); return x.base() == y.base();
} }
friend TEST_CONSTEXPR_CXX14 friend TEST_CONSTEXPR_CXX14
difference_type operator!=(const contiguous_iterator& x, const contiguous_iterator& y) { difference_type operator!=(const legacy_contiguous_iterator& x, const legacy_contiguous_iterator& y) {
return x.base() != y.base(); return x.base() != y.base();
} }
}; };
#endif #endif
template <class Iter> template <class Iter>
inline TEST_CONSTEXPR_CXX14 Iter base(output_iterator<Iter> i) { return i.base(); } inline TEST_CONSTEXPR_CXX14 Iter base(output_iterator<Iter> i) { return i.base(); }
template <class Iter> template <class Iter>
inline TEST_CONSTEXPR_CXX14 Iter base(input_iterator<Iter> i) { return i.base(); } inline TEST_CONSTEXPR_CXX14 Iter base(legacy_input_iterator<Iter> i) { return i.base(); }
template <class Iter> template <class Iter>
inline TEST_CONSTEXPR_CXX14 Iter base(forward_iterator<Iter> i) { return i.base(); } inline TEST_CONSTEXPR_CXX14 Iter base(legacy_forward_iterator<Iter> i) { return i.base(); }
template <class Iter> template <class Iter>
inline TEST_CONSTEXPR_CXX14 Iter base(bidirectional_iterator<Iter> i) { return i.base(); } inline TEST_CONSTEXPR_CXX14 Iter base(legacy_bidirectional_iterator<Iter> i) { return i.base(); }
template <class Iter> template <class Iter>
inline TEST_CONSTEXPR_CXX14 Iter base(random_access_iterator<Iter> i) { return i.base(); } inline TEST_CONSTEXPR_CXX14 Iter base(legacy_random_access_iterator<Iter> i) { return i.base(); }
#if TEST_STD_VER >= 20 #if TEST_STD_VER >= 20
template <class Iter> template <class Iter>
inline TEST_CONSTEXPR_CXX14 Iter base(contiguous_iterator<Iter> i) { return i.base(); } inline TEST_CONSTEXPR_CXX14 Iter base(legacy_contiguous_iterator<Iter> i) { return i.base(); }
#endif #endif
template <class Iter> // everything else template <class Iter> // everything else
inline TEST_CONSTEXPR_CXX14 Iter base(Iter i) { return i; } inline TEST_CONSTEXPR_CXX14 Iter base(Iter i) { return i; }
template <typename T> template <typename T>
struct ThrowingIterator { struct ThrowingIterator {
typedef std::bidirectional_iterator_tag iterator_category; typedef std::bidirectional_iterator_tag iterator_category;
▲ Show 20 Lines • Show All 217 Lines • Show Last 20 Lines