blob: 929cc164384eb4a7e89758f319033d6ef5c60386 [file] [log] [blame]
Howard Hinnantc51e1022010-05-11 19:42:16 +00001// -*- C++ -*-
2//===-------------------------- iterator ----------------------------------===//
3//
Chandler Carruthd2012102019-01-19 10:56:40 +00004// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Howard Hinnantc51e1022010-05-11 19:42:16 +00007//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_ITERATOR
11#define _LIBCPP_ITERATOR
12
13/*
14 iterator synopsis
15
Christopher Di Bella490fe402021-03-23 03:55:52 +000016#include <concepts>
17
Howard Hinnantc51e1022010-05-11 19:42:16 +000018namespace std
19{
Christopher Di Bellae00eebc2021-03-23 20:48:41 +000020template<class> struct incrementable_traits; // since C++20
Christopher Di Bellaa3a10062021-04-20 18:56:08 +000021template<class T>
22 using iter_difference_t = see below; // since C++20
23
Christopher Di Bellae00eebc2021-03-23 20:48:41 +000024template<class> struct indirectly_readable_traits; // since C++20
Christopher Di Bellaa3a10062021-04-20 18:56:08 +000025template<class T>
26 using iter_value_t = see below; // since C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000027
28template<class Iterator>
zoecarver9f1e2972021-04-20 08:50:11 -040029struct iterator_traits;
Howard Hinnantc51e1022010-05-11 19:42:16 +000030
31template<class T>
zoecarver9f1e2972021-04-20 08:50:11 -040032 requires is_object_v<T> // since C++20
33struct iterator_traits<T*>;
Howard Hinnantc51e1022010-05-11 19:42:16 +000034
Christopher Di Bella875636f2021-04-04 05:12:46 +000035template<dereferenceable T>
36 using iter_reference_t = decltype(*declval<T&>());
37
Louis Dionneca989a52021-04-20 14:40:43 -040038namespace ranges::inline unspecified {
39 inline constexpr unspecified iter_move = unspecified; // since C++20, nodiscard as an extension
40}}
41
42template<dereferenceable T>
43 requires ...
44using iter_rvalue_reference_t = decltype(ranges::iter_move(declval<T&>())); // since C++20
45
Louis Dionne463afb82021-04-22 11:05:30 -040046// [iterator.concepts], iterator concepts
47// [iterator.concept.readable], concept indirectly_readable
48template<class In>
Louis Dionne170a03c2021-04-28 15:02:08 -040049 concept indirectly_readable = see below; // since C++20
50
51template<indirectly_readable T>
52 using iter_common_reference_t =
53 common_reference_t<iter_reference_t<T>, iter_value_t<T>&>; // since C++20
Louis Dionne463afb82021-04-22 11:05:30 -040054
55// [iterator.concept.writable], concept indirectly_writable
56template<class Out, class T>
57 concept indirectly_writable = see below; // since C++20
58
Mark de Wever6639f422021-04-26 17:53:20 +020059// [iterator.concept.winc], concept weakly_incrementable
Christopher Di Bella54ffc182021-04-23 18:22:55 -070060template<class I>
61 concept weakly_incrementable = see below; // since C++20
62
63// [iterator.concept.inc], concept incrementable
64template<class I>
65 concept incrementable = see below; // since C++20
66
Mark de Wever6639f422021-04-26 17:53:20 +020067// [iterator.concept.iterator], concept input_or_output_iterator
Christopher Di Bella0ef52282021-04-09 02:10:32 +000068 template<class I>
69 concept input_or_output_iterator = see below; // since C++20
70
Mark de Wever6639f422021-04-26 17:53:20 +020071// [iterator.concept.sentinel], concept sentinel_for
Christopher Di Bella0ef52282021-04-09 02:10:32 +000072template<class S, class I>
73 concept sentinel_for = see below; // since C++20
74
zoecarver11391bc2021-04-26 09:35:47 -070075// [iterator.concept.sizedsentinel], concept sized_sentinel_for
76template<class S, class I>
77 inline constexpr bool disable_sized_sentinel_for = false;
78
79template<class S, class I>
80 concept sized_sentinel_for = see below;
81
Christopher Di Bella8250c632021-04-11 19:04:52 +000082// [iterator.concept.input], concept input_iterator
83template<class I>
84 concept input_iterator = see below; // since C++20
85
Christopher Di Bella8f1370d2021-04-11 22:11:03 +000086// [iterator.concept.forward], concept forward_iterator
87template<class I>
88 concept forward_iterator = see below; // since C++20
89
Christopher Di Bella10a31472021-04-12 01:16:45 +000090// [iterator.concept.bidir], concept bidirectional_iterator
91template<class I>
92 concept bidirectional_iterator = see below; // since C++20
93
zoecarver21da57e2021-04-23 17:11:44 -070094// [iterator.concept.random.access], concept random_access_iterator
95template<class I>
96 concept random_access_iterator = see below; // since C++20
97
Louis Dionne170a03c2021-04-28 15:02:08 -040098// [indirectcallable]
99// [indirectcallable.indirectinvocable]
100template<class F, class I>
101 concept indirectly_unary_invocable = see below; // since C++20
102
103template<class F, class I>
104 concept indirectly_regular_unary_invocable = see below; // since C++20
105
106template<class F, class I>
107 concept indirect_unary_predicate = see below; // since C++20
108
109template<class F, class I1, class I2>
110 concept indirect_binary_predicate = see below; // since C++20
111
112template<class F, class I1, class I2 = I1>
113 concept indirect_equivalence_relation = see below; // since C++20
114
115template<class F, class I1, class I2 = I1>
116 concept indirect_strict_weak_order = see below; // since C++20
117
118template<class F, class... Is>
119 using indirect_result_t = see below; // since C++20
120
121// [projected], projected
122template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
123 struct projected; // since C++20
124
125template<weakly_incrementable I, indirectly_regular_unary_invocable<I> Proj>
126 struct incrementable_traits<projected<I, Proj>>; // since C++20
127
zoecarver7e38f802021-05-17 10:30:12 -0700128// [alg.req.ind.move], concept indirectly_movable
129template<class In, class Out>
130 concept indirectly_movable = see below; // since C++20
131
132template<class In, class Out>
133 concept indirectly_movable_storable = see below; // since C++20
134
Howard Hinnantc51e1022010-05-11 19:42:16 +0000135template<class Category, class T, class Distance = ptrdiff_t,
136 class Pointer = T*, class Reference = T&>
Louis Dionne8762e2b2021-05-25 18:15:58 -0400137struct iterator // deprecated in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000138{
139 typedef T value_type;
140 typedef Distance difference_type;
141 typedef Pointer pointer;
142 typedef Reference reference;
143 typedef Category iterator_category;
144};
145
146struct input_iterator_tag {};
147struct output_iterator_tag {};
148struct forward_iterator_tag : public input_iterator_tag {};
149struct bidirectional_iterator_tag : public forward_iterator_tag {};
150struct random_access_iterator_tag : public bidirectional_iterator_tag {};
151
Marshall Clow75468e72017-05-17 18:51:36 +0000152// 27.4.3, iterator operations
Louis Dionne45768662020-06-08 16:16:01 -0400153template <class InputIterator, class Distance> // constexpr in C++17
154 constexpr void advance(InputIterator& i, Distance n);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000155
Marshall Clow75468e72017-05-17 18:51:36 +0000156template <class InputIterator> // constexpr in C++17
157 constexpr typename iterator_traits<InputIterator>::difference_type
158 distance(InputIterator first, InputIterator last);
159
160template <class InputIterator> // constexpr in C++17
161 constexpr InputIterator next(InputIterator x,
162typename iterator_traits<InputIterator>::difference_type n = 1);
163
164template <class BidirectionalIterator> // constexpr in C++17
165 constexpr BidirectionalIterator prev(BidirectionalIterator x,
Louis Dionne173f29e2019-05-29 16:01:36 +0000166 typename iterator_traits<BidirectionalIterator>::difference_type n = 1);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000167
Christopher Di Bellac6ead652021-05-05 07:14:08 +0000168// [range.iter.ops], range iterator operations
169namespace ranges {
170 // [range.iter.op.advance], ranges::advance
171 template<input_or_output_iterator I>
172 constexpr void advance(I& i, iter_difference_t<I> n); // since C++20
173 template<input_or_output_iterator I, sentinel_for<I> S>
174 constexpr void advance(I& i, S bound); // since C++20
175 template<input_or_output_iterator I, sentinel_for<I> S>
176 constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound); // since C++20
177}
178
Howard Hinnantc51e1022010-05-11 19:42:16 +0000179template <class Iterator>
180class reverse_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400181 : public iterator<typename iterator_traits<Iterator>::iterator_category, // until C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000182 typename iterator_traits<Iterator>::value_type,
183 typename iterator_traits<Iterator>::difference_type,
184 typename iterator_traits<Iterator>::pointer,
185 typename iterator_traits<Iterator>::reference>
186{
187protected:
188 Iterator current;
189public:
190 typedef Iterator iterator_type;
191 typedef typename iterator_traits<Iterator>::difference_type difference_type;
192 typedef typename iterator_traits<Iterator>::reference reference;
193 typedef typename iterator_traits<Iterator>::pointer pointer;
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000194
Marshall Clow5ace5542016-10-19 15:12:50 +0000195 constexpr reverse_iterator();
196 constexpr explicit reverse_iterator(Iterator x);
197 template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
198 template <class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u);
199 constexpr Iterator base() const;
200 constexpr reference operator*() const;
201 constexpr pointer operator->() const;
202 constexpr reverse_iterator& operator++();
203 constexpr reverse_iterator operator++(int);
204 constexpr reverse_iterator& operator--();
205 constexpr reverse_iterator operator--(int);
206 constexpr reverse_iterator operator+ (difference_type n) const;
207 constexpr reverse_iterator& operator+=(difference_type n);
208 constexpr reverse_iterator operator- (difference_type n) const;
209 constexpr reverse_iterator& operator-=(difference_type n);
210 constexpr reference operator[](difference_type n) const;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000211};
212
213template <class Iterator1, class Iterator2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000214constexpr bool // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000215operator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
216
217template <class Iterator1, class Iterator2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000218constexpr bool // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000219operator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
220
221template <class Iterator1, class Iterator2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000222constexpr bool // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000223operator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
224
225template <class Iterator1, class Iterator2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000226constexpr bool // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000227operator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
228
229template <class Iterator1, class Iterator2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000230constexpr bool // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000231operator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
232
233template <class Iterator1, class Iterator2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000234constexpr bool // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000235operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
236
237template <class Iterator1, class Iterator2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000238constexpr auto
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000239operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y)
Marshall Clow5ace5542016-10-19 15:12:50 +0000240-> decltype(__y.base() - __x.base()); // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000241
242template <class Iterator>
Marshall Clow5ace5542016-10-19 15:12:50 +0000243constexpr reverse_iterator<Iterator>
Louis Dionne173f29e2019-05-29 16:01:36 +0000244operator+(typename reverse_iterator<Iterator>::difference_type n,
Marshall Clow5ace5542016-10-19 15:12:50 +0000245 const reverse_iterator<Iterator>& x); // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000246
Marshall Clow5ace5542016-10-19 15:12:50 +0000247template <class Iterator>
248constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17
Marshall Clow6dbbdc92014-03-03 01:24:04 +0000249
Howard Hinnantc51e1022010-05-11 19:42:16 +0000250template <class Container>
251class back_insert_iterator
Louis Dionne3402c3c2021-05-27 12:56:12 -0400252 : public iterator<output_iterator_tag, void, void, void, void> // until C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000253{
254protected:
255 Container* container;
256public:
257 typedef Container container_type;
258 typedef void value_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400259 typedef void difference_type; // until C++20
260 typedef ptrdiff_t difference_type; // since C++20
Eric Fiselier9aeea872016-06-30 04:40:50 +0000261 typedef void reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000262 typedef void pointer;
263
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500264 explicit back_insert_iterator(Container& x); // constexpr in C++20
265 back_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20
266 back_insert_iterator& operator*(); // constexpr in C++20
267 back_insert_iterator& operator++(); // constexpr in C++20
268 back_insert_iterator operator++(int); // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000269};
270
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500271template <class Container> back_insert_iterator<Container> back_inserter(Container& x); // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000272
273template <class Container>
274class front_insert_iterator
Louis Dionne3402c3c2021-05-27 12:56:12 -0400275 : public iterator<output_iterator_tag, void, void, void, void> // until C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000276{
277protected:
278 Container* container;
279public:
280 typedef Container container_type;
281 typedef void value_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400282 typedef void difference_type; // until C++20
283 typedef ptrdiff_t difference_type; // since C++20
Eric Fiselier9aeea872016-06-30 04:40:50 +0000284 typedef void reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000285 typedef void pointer;
286
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500287 explicit front_insert_iterator(Container& x); // constexpr in C++20
288 front_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20
289 front_insert_iterator& operator*(); // constexpr in C++20
290 front_insert_iterator& operator++(); // constexpr in C++20
291 front_insert_iterator operator++(int); // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000292};
293
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500294template <class Container> front_insert_iterator<Container> front_inserter(Container& x); // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000295
296template <class Container>
297class insert_iterator
Louis Dionne3402c3c2021-05-27 12:56:12 -0400298 : public iterator<output_iterator_tag, void, void, void, void> // until C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000299{
300protected:
301 Container* container;
302 typename Container::iterator iter;
303public:
304 typedef Container container_type;
305 typedef void value_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400306 typedef void difference_type; // until C++20
307 typedef ptrdiff_t difference_type; // since C++20
Eric Fiselier9aeea872016-06-30 04:40:50 +0000308 typedef void reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000309 typedef void pointer;
310
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500311 insert_iterator(Container& x, typename Container::iterator i); // constexpr in C++20
312 insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20
313 insert_iterator& operator*(); // constexpr in C++20
314 insert_iterator& operator++(); // constexpr in C++20
315 insert_iterator& operator++(int); // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000316};
317
318template <class Container, class Iterator>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500319insert_iterator<Container> inserter(Container& x, Iterator i); // constexpr in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000320
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000321template <class Iterator>
322class move_iterator {
323public:
324 typedef Iterator iterator_type;
325 typedef typename iterator_traits<Iterator>::difference_type difference_type;
326 typedef Iterator pointer;
327 typedef typename iterator_traits<Iterator>::value_type value_type;
328 typedef typename iterator_traits<Iterator>::iterator_category iterator_category;
329 typedef value_type&& reference;
Louis Dionne173f29e2019-05-29 16:01:36 +0000330
Marshall Clowb5f99122016-11-02 15:30:26 +0000331 constexpr move_iterator(); // all the constexprs are in C++17
332 constexpr explicit move_iterator(Iterator i);
333 template <class U>
334 constexpr move_iterator(const move_iterator<U>& u);
335 template <class U>
336 constexpr move_iterator& operator=(const move_iterator<U>& u);
337 constexpr iterator_type base() const;
338 constexpr reference operator*() const;
339 constexpr pointer operator->() const;
340 constexpr move_iterator& operator++();
341 constexpr move_iterator operator++(int);
342 constexpr move_iterator& operator--();
343 constexpr move_iterator operator--(int);
Louis Dionne173f29e2019-05-29 16:01:36 +0000344 constexpr move_iterator operator+(difference_type n) const;
345 constexpr move_iterator& operator+=(difference_type n);
346 constexpr move_iterator operator-(difference_type n) const;
347 constexpr move_iterator& operator-=(difference_type n);
Marshall Clowb5f99122016-11-02 15:30:26 +0000348 constexpr unspecified operator[](difference_type n) const;
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000349private:
350 Iterator current; // exposition only
351};
352
353template <class Iterator1, class Iterator2>
Marshall Clowb5f99122016-11-02 15:30:26 +0000354constexpr bool // constexpr in C++17
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000355operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
356
357template <class Iterator1, class Iterator2>
Marshall Clowb5f99122016-11-02 15:30:26 +0000358constexpr bool // constexpr in C++17
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000359operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
360
361template <class Iterator1, class Iterator2>
Marshall Clowb5f99122016-11-02 15:30:26 +0000362constexpr bool // constexpr in C++17
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000363operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
364
365template <class Iterator1, class Iterator2>
Marshall Clowb5f99122016-11-02 15:30:26 +0000366constexpr bool // constexpr in C++17
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000367operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
368
369template <class Iterator1, class Iterator2>
Marshall Clowb5f99122016-11-02 15:30:26 +0000370constexpr bool // constexpr in C++17
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000371operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
372
373template <class Iterator1, class Iterator2>
Marshall Clowb5f99122016-11-02 15:30:26 +0000374constexpr bool // constexpr in C++17
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000375operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
376
377template <class Iterator1, class Iterator2>
Marshall Clowb5f99122016-11-02 15:30:26 +0000378constexpr auto // constexpr in C++17
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000379operator-(const move_iterator<Iterator1>& x,
380 const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
381
382template <class Iterator>
Marshall Clowb5f99122016-11-02 15:30:26 +0000383constexpr move_iterator<Iterator> operator+( // constexpr in C++17
Louis Dionne173f29e2019-05-29 16:01:36 +0000384 typename move_iterator<Iterator>::difference_type n,
Marshall Clowb5f99122016-11-02 15:30:26 +0000385 const move_iterator<Iterator>& x);
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000386
Marshall Clowb5f99122016-11-02 15:30:26 +0000387template <class Iterator> // constexpr in C++17
388constexpr move_iterator<Iterator> make_move_iterator(const Iterator& i);
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000389
zoecarver63f13202021-06-01 12:55:33 -0700390// [default.sentinel], default sentinel
391struct default_sentinel_t;
392inline constexpr default_sentinel_t default_sentinel{};
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000393
Howard Hinnantc51e1022010-05-11 19:42:16 +0000394template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t>
395class istream_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400396 : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000397{
398public:
Louis Dionne3402c3c2021-05-27 12:56:12 -0400399 typedef input_iterator_tag iterator_category;
400 typedef T value_type;
401 typedef Distance difference_type;
402 typedef const T* pointer;
403 typedef const T& reference;
404
405 typedef charT char_type;
406 typedef traits traits_type;
407 typedef basic_istream<charT, traits> istream_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000408
Marshall Clow0735e4e2015-04-16 21:36:54 +0000409 constexpr istream_iterator();
Howard Hinnantc51e1022010-05-11 19:42:16 +0000410 istream_iterator(istream_type& s);
411 istream_iterator(const istream_iterator& x);
412 ~istream_iterator();
413
414 const T& operator*() const;
415 const T* operator->() const;
416 istream_iterator& operator++();
417 istream_iterator operator++(int);
418};
419
420template <class T, class charT, class traits, class Distance>
421bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
422 const istream_iterator<T,charT,traits,Distance>& y);
423template <class T, class charT, class traits, class Distance>
424bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
425 const istream_iterator<T,charT,traits,Distance>& y);
426
427template <class T, class charT = char, class traits = char_traits<charT> >
428class ostream_iterator
Louis Dionne3402c3c2021-05-27 12:56:12 -0400429 : public iterator<output_iterator_tag, void, void, void, void> // until C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000430{
431public:
Louis Dionne3402c3c2021-05-27 12:56:12 -0400432 typedef output_iterator_tag iterator_category;
433 typedef void value_type;
434 typedef void difference_type; // until C++20
435 typedef ptrdiff_t difference_type; // since C++20
436 typedef void pointer;
437 typedef void reference;
438
Howard Hinnantc51e1022010-05-11 19:42:16 +0000439 typedef charT char_type;
440 typedef traits traits_type;
441 typedef basic_ostream<charT,traits> ostream_type;
442
443 ostream_iterator(ostream_type& s);
444 ostream_iterator(ostream_type& s, const charT* delimiter);
445 ostream_iterator(const ostream_iterator& x);
446 ~ostream_iterator();
447 ostream_iterator& operator=(const T& value);
448
449 ostream_iterator& operator*();
450 ostream_iterator& operator++();
451 ostream_iterator& operator++(int);
452};
453
454template<class charT, class traits = char_traits<charT> >
455class istreambuf_iterator
Louis Dionne3402c3c2021-05-27 12:56:12 -0400456 : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000457{
458public:
Louis Dionne3402c3c2021-05-27 12:56:12 -0400459 typedef input_iterator_tag iterator_category;
460 typedef charT value_type;
461 typedef traits::off_type difference_type;
462 typedef unspecified pointer;
463 typedef charT reference;
464
465 typedef charT char_type;
466 typedef traits traits_type;
467 typedef traits::int_type int_type;
468 typedef basic_streambuf<charT, traits> streambuf_type;
469 typedef basic_istream<charT, traits> istream_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000470
Howard Hinnant011138d2012-07-20 19:36:34 +0000471 istreambuf_iterator() noexcept;
472 istreambuf_iterator(istream_type& s) noexcept;
473 istreambuf_iterator(streambuf_type* s) noexcept;
474 istreambuf_iterator(a-private-type) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000475
476 charT operator*() const;
477 pointer operator->() const;
478 istreambuf_iterator& operator++();
479 a-private-type operator++(int);
480
481 bool equal(const istreambuf_iterator& b) const;
482};
483
484template <class charT, class traits>
485bool operator==(const istreambuf_iterator<charT,traits>& a,
486 const istreambuf_iterator<charT,traits>& b);
487template <class charT, class traits>
488bool operator!=(const istreambuf_iterator<charT,traits>& a,
489 const istreambuf_iterator<charT,traits>& b);
490
491template <class charT, class traits = char_traits<charT> >
492class ostreambuf_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400493 : public iterator<output_iterator_tag, void, void, void, void> // until C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000494{
495public:
Louis Dionne3402c3c2021-05-27 12:56:12 -0400496 typedef output_iterator_tag iterator_category;
497 typedef void value_type;
498 typedef void difference_type; // until C++20
499 typedef ptrdiff_t difference_type; // since C++20
500 typedef void pointer;
501 typedef void reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000502
Louis Dionne3402c3c2021-05-27 12:56:12 -0400503 typedef charT char_type;
504 typedef traits traits_type;
505 typedef basic_streambuf<charT, traits> streambuf_type;
506 typedef basic_ostream<charT, traits> ostream_type;
507
Howard Hinnant011138d2012-07-20 19:36:34 +0000508 ostreambuf_iterator(ostream_type& s) noexcept;
509 ostreambuf_iterator(streambuf_type* s) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000510 ostreambuf_iterator& operator=(charT c);
511 ostreambuf_iterator& operator*();
512 ostreambuf_iterator& operator++();
513 ostreambuf_iterator& operator++(int);
Howard Hinnant011138d2012-07-20 19:36:34 +0000514 bool failed() const noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000515};
516
Marshall Clow99ba0022017-01-04 17:58:17 +0000517template <class C> constexpr auto begin(C& c) -> decltype(c.begin());
518template <class C> constexpr auto begin(const C& c) -> decltype(c.begin());
519template <class C> constexpr auto end(C& c) -> decltype(c.end());
520template <class C> constexpr auto end(const C& c) -> decltype(c.end());
521template <class T, size_t N> constexpr T* begin(T (&array)[N]);
522template <class T, size_t N> constexpr T* end(T (&array)[N]);
Howard Hinnantc51e1022010-05-11 19:42:16 +0000523
Marshall Clow99ba0022017-01-04 17:58:17 +0000524template <class C> auto constexpr cbegin(const C& c) -> decltype(std::begin(c)); // C++14
525template <class C> auto constexpr cend(const C& c) -> decltype(std::end(c)); // C++14
526template <class C> auto constexpr rbegin(C& c) -> decltype(c.rbegin()); // C++14
527template <class C> auto constexpr rbegin(const C& c) -> decltype(c.rbegin()); // C++14
528template <class C> auto constexpr rend(C& c) -> decltype(c.rend()); // C++14
529template <class C> constexpr auto rend(const C& c) -> decltype(c.rend()); // C++14
530template <class E> reverse_iterator<const E*> constexpr rbegin(initializer_list<E> il); // C++14
531template <class E> reverse_iterator<const E*> constexpr rend(initializer_list<E> il); // C++14
532template <class T, size_t N> reverse_iterator<T*> constexpr rbegin(T (&array)[N]); // C++14
533template <class T, size_t N> reverse_iterator<T*> constexpr rend(T (&array)[N]); // C++14
534template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); // C++14
535template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c)); // C++14
Marshall Clowb278e9c2013-08-30 01:17:07 +0000536
Marshall Clowef357272014-11-19 19:43:23 +0000537// 24.8, container access:
538template <class C> constexpr auto size(const C& c) -> decltype(c.size()); // C++17
539template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17
Marshall Clow3c5363e2019-02-27 02:58:56 +0000540
541template <class C> constexpr auto ssize(const C& c)
Arthur O'Dwyer2fc9b5d2021-04-17 17:03:20 -0400542 -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>; // C++20
Marshall Clow3c5363e2019-02-27 02:58:56 +0000543template <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20
544
Marshall Clowef357272014-11-19 19:43:23 +0000545template <class C> constexpr auto empty(const C& c) -> decltype(c.empty()); // C++17
546template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept; // C++17
547template <class E> constexpr bool empty(initializer_list<E> il) noexcept; // C++17
548template <class C> constexpr auto data(C& c) -> decltype(c.data()); // C++17
549template <class C> constexpr auto data(const C& c) -> decltype(c.data()); // C++17
550template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept; // C++17
551template <class E> constexpr const E* data(initializer_list<E> il) noexcept; // C++17
552
Howard Hinnantc51e1022010-05-11 19:42:16 +0000553} // std
554
555*/
556
557#include <__config>
Arthur O'Dwyera2f99ee2021-04-29 17:40:17 -0400558#include <__debug>
Marshall Clow3dc05502014-02-27 02:11:50 +0000559#include <__functional_base>
Christopher Di Bellac6ead652021-05-05 07:14:08 +0000560#include <__iterator/advance.h>
Louis Dionne463afb82021-04-22 11:05:30 -0400561#include <__iterator/concepts.h>
zoecarver63f13202021-06-01 12:55:33 -0700562#include <__iterator/default_sentinel.h>
zoecarver61ae1dc2021-04-19 14:28:27 -0400563#include <__iterator/incrementable_traits.h>
Louis Dionneca989a52021-04-20 14:40:43 -0400564#include <__iterator/iter_move.h>
zoecarver5d41ff52021-04-19 14:44:42 -0700565#include <__iterator/iterator_traits.h>
Christopher Di Bella9c0adab2021-05-08 05:02:43 +0000566#include <__iterator/next.h>
Christopher Di Bellab8e21042021-05-16 01:39:22 +0000567#include <__iterator/prev.h>
Louis Dionne170a03c2021-04-28 15:02:08 -0400568#include <__iterator/projected.h>
zoecarver61ae1dc2021-04-19 14:28:27 -0400569#include <__iterator/readable_traits.h>
Louis Dionne735bc462021-04-14 13:59:03 -0400570#include <__memory/addressof.h>
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -0500571#include <__memory/pointer_traits.h>
Arthur O'Dwyera2f99ee2021-04-29 17:40:17 -0400572#include <compare>
573#include <concepts> // Mandated by the Standard.
574#include <cstddef>
575#include <initializer_list>
576#include <iosfwd> // for forward declarations of vector and string
577#include <type_traits>
Marshall Clow0a1e7502018-09-12 19:41:40 +0000578#include <version>
Howard Hinnant48fd5d52012-11-14 21:17:15 +0000579
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000580#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000581#pragma GCC system_header
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000582#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000583
584_LIBCPP_BEGIN_NAMESPACE_STD
Christopher Di Bella490fe402021-03-23 03:55:52 +0000585
Howard Hinnantc51e1022010-05-11 19:42:16 +0000586template<class _Category, class _Tp, class _Distance = ptrdiff_t,
587 class _Pointer = _Tp*, class _Reference = _Tp&>
Louis Dionne8762e2b2021-05-25 18:15:58 -0400588struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 iterator
Howard Hinnantc51e1022010-05-11 19:42:16 +0000589{
590 typedef _Tp value_type;
591 typedef _Distance difference_type;
592 typedef _Pointer pointer;
593 typedef _Reference reference;
594 typedef _Category iterator_category;
595};
596
597template <class _InputIter>
Marshall Clow75468e72017-05-17 18:51:36 +0000598inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000599typename iterator_traits<_InputIter>::difference_type
600__distance(_InputIter __first, _InputIter __last, input_iterator_tag)
601{
602 typename iterator_traits<_InputIter>::difference_type __r(0);
603 for (; __first != __last; ++__first)
604 ++__r;
605 return __r;
606}
607
608template <class _RandIter>
Marshall Clow75468e72017-05-17 18:51:36 +0000609inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000610typename iterator_traits<_RandIter>::difference_type
611__distance(_RandIter __first, _RandIter __last, random_access_iterator_tag)
612{
613 return __last - __first;
614}
615
616template <class _InputIter>
Marshall Clow75468e72017-05-17 18:51:36 +0000617inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000618typename iterator_traits<_InputIter>::difference_type
619distance(_InputIter __first, _InputIter __last)
620{
Arthur O'Dwyer6e9069c2020-12-07 23:42:47 -0500621 return _VSTD::__distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category());
Howard Hinnantc51e1022010-05-11 19:42:16 +0000622}
623
Eric Fiselier883af112017-04-13 02:54:13 +0000624template <class _Tp, class = void>
625struct __is_stashing_iterator : false_type {};
626
627template <class _Tp>
628struct __is_stashing_iterator<_Tp, typename __void_t<typename _Tp::__stashing_iterator_tag>::type>
629 : true_type {};
630
Louis Dionne8762e2b2021-05-25 18:15:58 -0400631_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +0000632template <class _Iter>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000633class _LIBCPP_TEMPLATE_VIS reverse_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400634#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000635 : public iterator<typename iterator_traits<_Iter>::iterator_category,
636 typename iterator_traits<_Iter>::value_type,
637 typename iterator_traits<_Iter>::difference_type,
638 typename iterator_traits<_Iter>::pointer,
639 typename iterator_traits<_Iter>::reference>
Louis Dionne8762e2b2021-05-25 18:15:58 -0400640#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000641{
Louis Dionne8762e2b2021-05-25 18:15:58 -0400642_LIBCPP_SUPPRESS_DEPRECATED_POP
Marshall Clow0ad029e2014-03-11 22:05:31 +0000643private:
Louis Dionne8762e2b2021-05-25 18:15:58 -0400644#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
645 _Iter __t; // no longer used as of LWG #2360, not removed due to ABI break
646#endif
Eric Fiselier883af112017-04-13 02:54:13 +0000647
648 static_assert(!__is_stashing_iterator<_Iter>::value,
649 "The specified iterator type cannot be used with reverse_iterator; "
650 "Using stashing iterators with reverse_iterator causes undefined behavior");
651
Marshall Clow1f61f0a2014-03-12 01:19:36 +0000652protected:
653 _Iter current;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000654public:
655 typedef _Iter iterator_type;
656 typedef typename iterator_traits<_Iter>::difference_type difference_type;
657 typedef typename iterator_traits<_Iter>::reference reference;
658 typedef typename iterator_traits<_Iter>::pointer pointer;
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -0500659 typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
660 random_access_iterator_tag,
661 typename iterator_traits<_Iter>::iterator_category> iterator_category;
Louis Dionne8762e2b2021-05-25 18:15:58 -0400662 typedef typename iterator_traits<_Iter>::value_type value_type;
663
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -0500664#if _LIBCPP_STD_VER > 17
665 typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
666 random_access_iterator_tag,
667 bidirectional_iterator_tag> iterator_concept;
668#endif
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000669
Louis Dionne8762e2b2021-05-25 18:15:58 -0400670#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
Marshall Clow5ace5542016-10-19 15:12:50 +0000671 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
672 reverse_iterator() : __t(), current() {}
Louis Dionne130f0f92021-06-03 14:14:57 -0400673
Marshall Clow5ace5542016-10-19 15:12:50 +0000674 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
675 explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
Louis Dionne130f0f92021-06-03 14:14:57 -0400676
677 template <class _Up, class = _EnableIf<
678 !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
679 > >
680 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
681 reverse_iterator(const reverse_iterator<_Up>& __u)
682 : __t(__u.base()), current(__u.base())
683 { }
684
685 template <class _Up, class = _EnableIf<
686 !is_same<_Up, _Iter>::value &&
687 is_convertible<_Up const&, _Iter>::value &&
688 is_assignable<_Up const&, _Iter>::value
689 > >
690 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
691 reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
692 __t = current = __u.base();
693 return *this;
694 }
Louis Dionne8762e2b2021-05-25 18:15:58 -0400695#else
696 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
697 reverse_iterator() : current() {}
Louis Dionne130f0f92021-06-03 14:14:57 -0400698
Louis Dionne8762e2b2021-05-25 18:15:58 -0400699 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
700 explicit reverse_iterator(_Iter __x) : current(__x) {}
Louis Dionne130f0f92021-06-03 14:14:57 -0400701
702 template <class _Up, class = _EnableIf<
703 !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
704 > >
705 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
706 reverse_iterator(const reverse_iterator<_Up>& __u)
707 : current(__u.base())
708 { }
709
710 template <class _Up, class = _EnableIf<
711 !is_same<_Up, _Iter>::value &&
712 is_convertible<_Up const&, _Iter>::value &&
713 is_assignable<_Up const&, _Iter>::value
714 > >
715 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
716 reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
717 current = __u.base();
718 return *this;
719 }
Louis Dionne8762e2b2021-05-25 18:15:58 -0400720#endif
Marshall Clow5ace5542016-10-19 15:12:50 +0000721 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
722 _Iter base() const {return current;}
723 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
724 reference operator*() const {_Iter __tmp = current; return *--__tmp;}
725 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
726 pointer operator->() const {return _VSTD::addressof(operator*());}
727 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
728 reverse_iterator& operator++() {--current; return *this;}
729 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
730 reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
731 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
732 reverse_iterator& operator--() {++current; return *this;}
733 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
734 reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
735 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
736 reverse_iterator operator+ (difference_type __n) const {return reverse_iterator(current - __n);}
737 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
738 reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
739 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
740 reverse_iterator operator- (difference_type __n) const {return reverse_iterator(current + __n);}
741 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
742 reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
743 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
744 reference operator[](difference_type __n) const {return *(*this + __n);}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000745};
746
747template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000748inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000749bool
750operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
751{
752 return __x.base() == __y.base();
753}
754
755template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000756inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000757bool
758operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
759{
760 return __x.base() > __y.base();
761}
762
763template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000764inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000765bool
766operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
767{
768 return __x.base() != __y.base();
769}
770
771template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000772inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000773bool
774operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
775{
776 return __x.base() < __y.base();
777}
778
779template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000780inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000781bool
782operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
783{
784 return __x.base() <= __y.base();
785}
786
787template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000788inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000789bool
790operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
791{
792 return __x.base() >= __y.base();
793}
794
Marshall Clow476d3f42016-07-18 13:19:00 +0000795#ifndef _LIBCPP_CXX03_LANG
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000796template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000797inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000798auto
799operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
800-> decltype(__y.base() - __x.base())
801{
802 return __y.base() - __x.base();
803}
804#else
Howard Hinnantc51e1022010-05-11 19:42:16 +0000805template <class _Iter1, class _Iter2>
806inline _LIBCPP_INLINE_VISIBILITY
807typename reverse_iterator<_Iter1>::difference_type
808operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
809{
810 return __y.base() - __x.base();
811}
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000812#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000813
814template <class _Iter>
Marshall Clow5ace5542016-10-19 15:12:50 +0000815inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000816reverse_iterator<_Iter>
817operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
818{
819 return reverse_iterator<_Iter>(__x.base() - __n);
820}
821
Marshall Clow6dbbdc92014-03-03 01:24:04 +0000822#if _LIBCPP_STD_VER > 11
823template <class _Iter>
Marshall Clow5ace5542016-10-19 15:12:50 +0000824inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow6dbbdc92014-03-03 01:24:04 +0000825reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
826{
827 return reverse_iterator<_Iter>(__i);
828}
829#endif
830
Louis Dionne8762e2b2021-05-25 18:15:58 -0400831_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +0000832template <class _Container>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000833class _LIBCPP_TEMPLATE_VIS back_insert_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400834#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
835 : public iterator<output_iterator_tag, void, void, void, void>
836#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000837{
Louis Dionne8762e2b2021-05-25 18:15:58 -0400838_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +0000839protected:
840 _Container* container;
841public:
Louis Dionne8762e2b2021-05-25 18:15:58 -0400842 typedef output_iterator_tag iterator_category;
843 typedef void value_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400844#if _LIBCPP_STD_VER > 17
845 typedef ptrdiff_t difference_type;
846#else
Louis Dionne8762e2b2021-05-25 18:15:58 -0400847 typedef void difference_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400848#endif
Louis Dionne8762e2b2021-05-25 18:15:58 -0400849 typedef void pointer;
850 typedef void reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000851 typedef _Container container_type;
852
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500853 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
854 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(const typename _Container::value_type& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000855 {container->push_back(__value_); return *this;}
Eric Fiselierf07d88c2017-04-19 01:34:08 +0000856#ifndef _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500857 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(typename _Container::value_type&& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000858 {container->push_back(_VSTD::move(__value_)); return *this;}
Louis Dionne2b1ceaa2021-04-20 12:03:32 -0400859#endif // _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500860 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator*() {return *this;}
861 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator++() {return *this;}
862 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator operator++(int) {return *this;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000863};
864
865template <class _Container>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500866inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000867back_insert_iterator<_Container>
868back_inserter(_Container& __x)
869{
870 return back_insert_iterator<_Container>(__x);
871}
872
Louis Dionne8762e2b2021-05-25 18:15:58 -0400873_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +0000874template <class _Container>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000875class _LIBCPP_TEMPLATE_VIS front_insert_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400876#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
877 : public iterator<output_iterator_tag, void, void, void, void>
878#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000879{
Louis Dionne8762e2b2021-05-25 18:15:58 -0400880_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +0000881protected:
882 _Container* container;
883public:
Louis Dionne8762e2b2021-05-25 18:15:58 -0400884 typedef output_iterator_tag iterator_category;
885 typedef void value_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400886#if _LIBCPP_STD_VER > 17
887 typedef ptrdiff_t difference_type;
888#else
Louis Dionne8762e2b2021-05-25 18:15:58 -0400889 typedef void difference_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400890#endif
Louis Dionne8762e2b2021-05-25 18:15:58 -0400891 typedef void pointer;
892 typedef void reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000893 typedef _Container container_type;
894
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500895 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
896 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(const typename _Container::value_type& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000897 {container->push_front(__value_); return *this;}
Eric Fiselierf07d88c2017-04-19 01:34:08 +0000898#ifndef _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500899 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(typename _Container::value_type&& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000900 {container->push_front(_VSTD::move(__value_)); return *this;}
Louis Dionne2b1ceaa2021-04-20 12:03:32 -0400901#endif // _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500902 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator*() {return *this;}
903 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator++() {return *this;}
904 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator operator++(int) {return *this;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000905};
906
907template <class _Container>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500908inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000909front_insert_iterator<_Container>
910front_inserter(_Container& __x)
911{
912 return front_insert_iterator<_Container>(__x);
913}
914
Louis Dionne8762e2b2021-05-25 18:15:58 -0400915_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +0000916template <class _Container>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000917class _LIBCPP_TEMPLATE_VIS insert_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400918#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
919 : public iterator<output_iterator_tag, void, void, void, void>
920#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000921{
Louis Dionne8762e2b2021-05-25 18:15:58 -0400922_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +0000923protected:
924 _Container* container;
Christopher Di Bella92072c22021-05-14 06:20:07 +0000925 typename _Container::iterator iter; // FIXME: `ranges::iterator_t<Container>` in C++20 mode
Howard Hinnantc51e1022010-05-11 19:42:16 +0000926public:
Louis Dionne8762e2b2021-05-25 18:15:58 -0400927 typedef output_iterator_tag iterator_category;
928 typedef void value_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400929#if _LIBCPP_STD_VER > 17
930 typedef ptrdiff_t difference_type;
931#else
Louis Dionne8762e2b2021-05-25 18:15:58 -0400932 typedef void difference_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400933#endif
Louis Dionne8762e2b2021-05-25 18:15:58 -0400934 typedef void pointer;
935 typedef void reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000936 typedef _Container container_type;
937
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500938 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator(_Container& __x, typename _Container::iterator __i)
Marshall Clowcef31682014-03-03 19:20:40 +0000939 : container(_VSTD::addressof(__x)), iter(__i) {}
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500940 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000941 {iter = container->insert(iter, __value_); ++iter; return *this;}
Eric Fiselierf07d88c2017-04-19 01:34:08 +0000942#ifndef _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500943 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000944 {iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;}
Louis Dionne2b1ceaa2021-04-20 12:03:32 -0400945#endif // _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500946 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator*() {return *this;}
947 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++() {return *this;}
948 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++(int) {return *this;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000949};
950
951template <class _Container>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500952inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000953insert_iterator<_Container>
954inserter(_Container& __x, typename _Container::iterator __i)
955{
956 return insert_iterator<_Container>(__x, __i);
957}
958
Louis Dionne8762e2b2021-05-25 18:15:58 -0400959_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +0000960template <class _Tp, class _CharT = char,
961 class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000962class _LIBCPP_TEMPLATE_VIS istream_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400963#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000964 : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
Louis Dionne8762e2b2021-05-25 18:15:58 -0400965#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000966{
Louis Dionne8762e2b2021-05-25 18:15:58 -0400967_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +0000968public:
Louis Dionne8762e2b2021-05-25 18:15:58 -0400969 typedef input_iterator_tag iterator_category;
970 typedef _Tp value_type;
971 typedef _Distance difference_type;
972 typedef const _Tp* pointer;
973 typedef const _Tp& reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000974 typedef _CharT char_type;
975 typedef _Traits traits_type;
976 typedef basic_istream<_CharT,_Traits> istream_type;
977private:
978 istream_type* __in_stream_;
979 _Tp __value_;
980public:
Bruce Mitchener170d8972020-11-24 12:53:53 -0500981 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(nullptr), __value_() {}
Marshall Clowb7742702016-05-17 17:44:40 +0000982 _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(_VSTD::addressof(__s))
Howard Hinnantc51e1022010-05-11 19:42:16 +0000983 {
984 if (!(*__in_stream_ >> __value_))
Bruce Mitchener170d8972020-11-24 12:53:53 -0500985 __in_stream_ = nullptr;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000986 }
987
988 _LIBCPP_INLINE_VISIBILITY const _Tp& operator*() const {return __value_;}
Marshall Clowb7742702016-05-17 17:44:40 +0000989 _LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return _VSTD::addressof((operator*()));}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000990 _LIBCPP_INLINE_VISIBILITY istream_iterator& operator++()
991 {
992 if (!(*__in_stream_ >> __value_))
Bruce Mitchener170d8972020-11-24 12:53:53 -0500993 __in_stream_ = nullptr;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000994 return *this;
995 }
996 _LIBCPP_INLINE_VISIBILITY istream_iterator operator++(int)
997 {istream_iterator __t(*this); ++(*this); return __t;}
998
Roger Ferrer Ibanezd16858b2017-12-11 13:54:58 +0000999 template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001000 friend _LIBCPP_INLINE_VISIBILITY
Roger Ferrer Ibanezd16858b2017-12-11 13:54:58 +00001001 bool
1002 operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
1003 const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001004
Roger Ferrer Ibanezd16858b2017-12-11 13:54:58 +00001005 template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001006 friend _LIBCPP_INLINE_VISIBILITY
Roger Ferrer Ibanezd16858b2017-12-11 13:54:58 +00001007 bool
1008 operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
1009 const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001010};
1011
Roger Ferrer Ibanezd16858b2017-12-11 13:54:58 +00001012template <class _Tp, class _CharT, class _Traits, class _Distance>
1013inline _LIBCPP_INLINE_VISIBILITY
1014bool
1015operator==(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
1016 const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
1017{
1018 return __x.__in_stream_ == __y.__in_stream_;
1019}
1020
1021template <class _Tp, class _CharT, class _Traits, class _Distance>
1022inline _LIBCPP_INLINE_VISIBILITY
1023bool
1024operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
1025 const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
1026{
1027 return !(__x == __y);
1028}
1029
Louis Dionne8762e2b2021-05-25 18:15:58 -04001030_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +00001031template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001032class _LIBCPP_TEMPLATE_VIS ostream_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -04001033#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001034 : public iterator<output_iterator_tag, void, void, void, void>
Louis Dionne8762e2b2021-05-25 18:15:58 -04001035#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001036{
Louis Dionne8762e2b2021-05-25 18:15:58 -04001037_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +00001038public:
Louis Dionnea4d79522020-09-11 10:15:56 -04001039 typedef output_iterator_tag iterator_category;
1040 typedef void value_type;
1041#if _LIBCPP_STD_VER > 17
Louis Dionne3402c3c2021-05-27 12:56:12 -04001042 typedef ptrdiff_t difference_type;
Louis Dionnea4d79522020-09-11 10:15:56 -04001043#else
1044 typedef void difference_type;
1045#endif
1046 typedef void pointer;
1047 typedef void reference;
1048 typedef _CharT char_type;
1049 typedef _Traits traits_type;
1050 typedef basic_ostream<_CharT, _Traits> ostream_type;
1051
Howard Hinnantc51e1022010-05-11 19:42:16 +00001052private:
1053 ostream_type* __out_stream_;
1054 const char_type* __delim_;
1055public:
Marshall Clow27a89512016-10-12 16:13:48 +00001056 _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s) _NOEXCEPT
Bruce Mitchener170d8972020-11-24 12:53:53 -05001057 : __out_stream_(_VSTD::addressof(__s)), __delim_(nullptr) {}
Marshall Clow27a89512016-10-12 16:13:48 +00001058 _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT
Marshall Clowb7742702016-05-17 17:44:40 +00001059 : __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {}
Howard Hinnantbf074022011-10-22 20:59:45 +00001060 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001061 {
Howard Hinnantbf074022011-10-22 20:59:45 +00001062 *__out_stream_ << __value_;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001063 if (__delim_)
1064 *__out_stream_ << __delim_;
1065 return *this;
1066 }
1067
1068 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator*() {return *this;}
1069 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++() {return *this;}
1070 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++(int) {return *this;}
1071};
1072
Louis Dionne8762e2b2021-05-25 18:15:58 -04001073_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +00001074template<class _CharT, class _Traits>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001075class _LIBCPP_TEMPLATE_VIS istreambuf_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -04001076#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001077 : public iterator<input_iterator_tag, _CharT,
1078 typename _Traits::off_type, _CharT*,
1079 _CharT>
Louis Dionne8762e2b2021-05-25 18:15:58 -04001080#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001081{
Louis Dionne8762e2b2021-05-25 18:15:58 -04001082_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +00001083public:
Louis Dionne8762e2b2021-05-25 18:15:58 -04001084 typedef input_iterator_tag iterator_category;
1085 typedef _CharT value_type;
1086 typedef typename _Traits::off_type difference_type;
1087 typedef _CharT* pointer;
1088 typedef _CharT reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001089 typedef _CharT char_type;
1090 typedef _Traits traits_type;
1091 typedef typename _Traits::int_type int_type;
1092 typedef basic_streambuf<_CharT,_Traits> streambuf_type;
1093 typedef basic_istream<_CharT,_Traits> istream_type;
1094private:
Howard Hinnant3e57b272012-11-16 22:17:23 +00001095 mutable streambuf_type* __sbuf_;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001096
1097 class __proxy
1098 {
1099 char_type __keep_;
1100 streambuf_type* __sbuf_;
1101 _LIBCPP_INLINE_VISIBILITY __proxy(char_type __c, streambuf_type* __s)
1102 : __keep_(__c), __sbuf_(__s) {}
1103 friend class istreambuf_iterator;
1104 public:
1105 _LIBCPP_INLINE_VISIBILITY char_type operator*() const {return __keep_;}
1106 };
1107
Howard Hinnant756c69b2010-09-22 16:48:34 +00001108 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3e57b272012-11-16 22:17:23 +00001109 bool __test_for_eof() const
Howard Hinnantc51e1022010-05-11 19:42:16 +00001110 {
1111 if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
Bruce Mitchener170d8972020-11-24 12:53:53 -05001112 __sbuf_ = nullptr;
1113 return __sbuf_ == nullptr;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001114 }
1115public:
Bruce Mitchener170d8972020-11-24 12:53:53 -05001116 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istreambuf_iterator() _NOEXCEPT : __sbuf_(nullptr) {}
Howard Hinnant011138d2012-07-20 19:36:34 +00001117 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(istream_type& __s) _NOEXCEPT
Howard Hinnantb9af8d82012-12-29 17:45:42 +00001118 : __sbuf_(__s.rdbuf()) {}
Howard Hinnant011138d2012-07-20 19:36:34 +00001119 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(streambuf_type* __s) _NOEXCEPT
Howard Hinnantb9af8d82012-12-29 17:45:42 +00001120 : __sbuf_(__s) {}
Howard Hinnant011138d2012-07-20 19:36:34 +00001121 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001122 : __sbuf_(__p.__sbuf_) {}
1123
Howard Hinnant28b24882011-12-01 20:21:04 +00001124 _LIBCPP_INLINE_VISIBILITY char_type operator*() const
1125 {return static_cast<char_type>(__sbuf_->sgetc());}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001126 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++()
1127 {
Howard Hinnant3e57b272012-11-16 22:17:23 +00001128 __sbuf_->sbumpc();
Howard Hinnantc51e1022010-05-11 19:42:16 +00001129 return *this;
1130 }
1131 _LIBCPP_INLINE_VISIBILITY __proxy operator++(int)
1132 {
Howard Hinnant3e57b272012-11-16 22:17:23 +00001133 return __proxy(__sbuf_->sbumpc(), __sbuf_);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001134 }
1135
1136 _LIBCPP_INLINE_VISIBILITY bool equal(const istreambuf_iterator& __b) const
Howard Hinnant3e57b272012-11-16 22:17:23 +00001137 {return __test_for_eof() == __b.__test_for_eof();}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001138};
1139
1140template <class _CharT, class _Traits>
1141inline _LIBCPP_INLINE_VISIBILITY
1142bool operator==(const istreambuf_iterator<_CharT,_Traits>& __a,
1143 const istreambuf_iterator<_CharT,_Traits>& __b)
1144 {return __a.equal(__b);}
1145
1146template <class _CharT, class _Traits>
1147inline _LIBCPP_INLINE_VISIBILITY
1148bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a,
1149 const istreambuf_iterator<_CharT,_Traits>& __b)
1150 {return !__a.equal(__b);}
1151
Louis Dionne8762e2b2021-05-25 18:15:58 -04001152_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +00001153template <class _CharT, class _Traits>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001154class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -04001155#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001156 : public iterator<output_iterator_tag, void, void, void, void>
Louis Dionne8762e2b2021-05-25 18:15:58 -04001157#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001158{
Louis Dionne8762e2b2021-05-25 18:15:58 -04001159_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +00001160public:
Louis Dionnea4d79522020-09-11 10:15:56 -04001161 typedef output_iterator_tag iterator_category;
1162 typedef void value_type;
1163#if _LIBCPP_STD_VER > 17
Louis Dionne3402c3c2021-05-27 12:56:12 -04001164 typedef ptrdiff_t difference_type;
Louis Dionnea4d79522020-09-11 10:15:56 -04001165#else
1166 typedef void difference_type;
1167#endif
1168 typedef void pointer;
1169 typedef void reference;
1170 typedef _CharT char_type;
1171 typedef _Traits traits_type;
1172 typedef basic_streambuf<_CharT, _Traits> streambuf_type;
1173 typedef basic_ostream<_CharT, _Traits> ostream_type;
1174
Howard Hinnantc51e1022010-05-11 19:42:16 +00001175private:
1176 streambuf_type* __sbuf_;
1177public:
Howard Hinnant011138d2012-07-20 19:36:34 +00001178 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001179 : __sbuf_(__s.rdbuf()) {}
Howard Hinnant011138d2012-07-20 19:36:34 +00001180 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001181 : __sbuf_(__s) {}
1182 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c)
1183 {
1184 if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof()))
Bruce Mitchener170d8972020-11-24 12:53:53 -05001185 __sbuf_ = nullptr;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001186 return *this;
1187 }
1188 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator*() {return *this;}
1189 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++() {return *this;}
1190 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++(int) {return *this;}
Bruce Mitchener170d8972020-11-24 12:53:53 -05001191 _LIBCPP_INLINE_VISIBILITY bool failed() const _NOEXCEPT {return __sbuf_ == nullptr;}
Howard Hinnant97955172012-09-19 19:14:15 +00001192
1193 template <class _Ch, class _Tr>
1194 friend
1195 _LIBCPP_HIDDEN
1196 ostreambuf_iterator<_Ch, _Tr>
1197 __pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s,
1198 const _Ch* __ob, const _Ch* __op, const _Ch* __oe,
1199 ios_base& __iob, _Ch __fl);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001200};
1201
1202template <class _Iter>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001203class _LIBCPP_TEMPLATE_VIS move_iterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00001204{
1205private:
1206 _Iter __i;
1207public:
1208 typedef _Iter iterator_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001209 typedef typename iterator_traits<iterator_type>::value_type value_type;
1210 typedef typename iterator_traits<iterator_type>::difference_type difference_type;
Marshall Clowd85a0562016-04-11 03:54:53 +00001211 typedef iterator_type pointer;
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001212 typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
1213 random_access_iterator_tag,
1214 typename iterator_traits<_Iter>::iterator_category> iterator_category;
1215#if _LIBCPP_STD_VER > 17
1216 typedef input_iterator_tag iterator_concept;
1217#endif
1218
Eric Fiselierf07d88c2017-04-19 01:34:08 +00001219#ifndef _LIBCPP_CXX03_LANG
Eric Fiselier57b8e0e2016-04-22 00:49:12 +00001220 typedef typename iterator_traits<iterator_type>::reference __reference;
1221 typedef typename conditional<
1222 is_reference<__reference>::value,
1223 typename remove_reference<__reference>::type&&,
1224 __reference
1225 >::type reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001226#else
1227 typedef typename iterator_traits<iterator_type>::reference reference;
1228#endif
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001229
Marshall Clowb5f99122016-11-02 15:30:26 +00001230 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1231 move_iterator() : __i() {}
Louis Dionne130f0f92021-06-03 14:14:57 -04001232
Marshall Clowb5f99122016-11-02 15:30:26 +00001233 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1234 explicit move_iterator(_Iter __x) : __i(__x) {}
Louis Dionne130f0f92021-06-03 14:14:57 -04001235
1236 template <class _Up, class = _EnableIf<
1237 !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
1238 > >
1239 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1240 move_iterator(const move_iterator<_Up>& __u) : __i(__u.base()) {}
1241
1242 template <class _Up, class = _EnableIf<
1243 !is_same<_Up, _Iter>::value &&
1244 is_convertible<_Up const&, _Iter>::value &&
1245 is_assignable<_Iter&, _Up const&>::value
1246 > >
1247 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1248 move_iterator& operator=(const move_iterator<_Up>& __u) {
1249 __i = __u.base();
1250 return *this;
1251 }
1252
Marshall Clowb5f99122016-11-02 15:30:26 +00001253 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _Iter base() const {return __i;}
Louis Dionne173f29e2019-05-29 16:01:36 +00001254 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowb5f99122016-11-02 15:30:26 +00001255 reference operator*() const { return static_cast<reference>(*__i); }
1256 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1257 pointer operator->() const { return __i;}
1258 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1259 move_iterator& operator++() {++__i; return *this;}
1260 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1261 move_iterator operator++(int) {move_iterator __tmp(*this); ++__i; return __tmp;}
1262 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1263 move_iterator& operator--() {--__i; return *this;}
1264 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1265 move_iterator operator--(int) {move_iterator __tmp(*this); --__i; return __tmp;}
1266 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1267 move_iterator operator+ (difference_type __n) const {return move_iterator(__i + __n);}
1268 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1269 move_iterator& operator+=(difference_type __n) {__i += __n; return *this;}
1270 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1271 move_iterator operator- (difference_type __n) const {return move_iterator(__i - __n);}
1272 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1273 move_iterator& operator-=(difference_type __n) {__i -= __n; return *this;}
1274 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1275 reference operator[](difference_type __n) const { return static_cast<reference>(__i[__n]); }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001276};
1277
1278template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001279inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001280bool
1281operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1282{
1283 return __x.base() == __y.base();
1284}
1285
1286template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001287inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001288bool
1289operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1290{
1291 return __x.base() < __y.base();
1292}
1293
1294template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001295inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001296bool
1297operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1298{
1299 return __x.base() != __y.base();
1300}
1301
1302template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001303inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001304bool
1305operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1306{
1307 return __x.base() > __y.base();
1308}
1309
1310template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001311inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001312bool
1313operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1314{
1315 return __x.base() >= __y.base();
1316}
1317
1318template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001319inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001320bool
1321operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1322{
1323 return __x.base() <= __y.base();
1324}
1325
Marshall Clow476d3f42016-07-18 13:19:00 +00001326#ifndef _LIBCPP_CXX03_LANG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001327template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001328inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001329auto
1330operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1331-> decltype(__x.base() - __y.base())
1332{
1333 return __x.base() - __y.base();
1334}
1335#else
Howard Hinnantc51e1022010-05-11 19:42:16 +00001336template <class _Iter1, class _Iter2>
1337inline _LIBCPP_INLINE_VISIBILITY
1338typename move_iterator<_Iter1>::difference_type
1339operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1340{
1341 return __x.base() - __y.base();
1342}
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001343#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001344
1345template <class _Iter>
Marshall Clowb5f99122016-11-02 15:30:26 +00001346inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001347move_iterator<_Iter>
1348operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x)
1349{
1350 return move_iterator<_Iter>(__x.base() + __n);
1351}
1352
1353template <class _Iter>
Marshall Clowb5f99122016-11-02 15:30:26 +00001354inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001355move_iterator<_Iter>
Marshall Clow84f90cf2013-08-27 13:03:03 +00001356make_move_iterator(_Iter __i)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001357{
1358 return move_iterator<_Iter>(__i);
1359}
1360
1361// __wrap_iter
1362
1363template <class _Iter> class __wrap_iter;
1364
1365template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001366_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001367bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001368operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001369
1370template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001371_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001372bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001373operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001374
1375template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001376_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001377bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001378operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001379
1380template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001381_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001382bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001383operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001384
1385template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001386_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001387bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001388operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001389
1390template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001391_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001392bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001393operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001394
Marshall Clow476d3f42016-07-18 13:19:00 +00001395#ifndef _LIBCPP_CXX03_LANG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001396template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001397_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001398auto
Eric Fiselier873b8d32019-03-18 21:50:12 +00001399operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001400-> decltype(__x.base() - __y.base());
1401#else
Howard Hinnantc51e1022010-05-11 19:42:16 +00001402template <class _Iter1, class _Iter2>
Howard Hinnanta54386e2012-09-14 00:39:16 +00001403_LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001404typename __wrap_iter<_Iter1>::difference_type
Eric Fiselier873b8d32019-03-18 21:50:12 +00001405operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001406#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001407
1408template <class _Iter>
Marshall Clowae4f8312018-07-13 16:35:26 +00001409_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001410__wrap_iter<_Iter>
Eric Fiselier873b8d32019-03-18 21:50:12 +00001411operator+(typename __wrap_iter<_Iter>::difference_type, __wrap_iter<_Iter>) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001412
Louis Dionne65b433b2019-11-06 12:02:41 +00001413template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 copy(_Ip, _Ip, _Op);
1414template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 copy_backward(_B1, _B1, _B2);
zoecarverd0279de2020-09-14 18:11:08 -04001415template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 move(_Ip, _Ip, _Op);
1416template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 move_backward(_B1, _B1, _B2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001417
Howard Hinnantc51e1022010-05-11 19:42:16 +00001418template <class _Iter>
1419class __wrap_iter
1420{
1421public:
1422 typedef _Iter iterator_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001423 typedef typename iterator_traits<iterator_type>::value_type value_type;
1424 typedef typename iterator_traits<iterator_type>::difference_type difference_type;
1425 typedef typename iterator_traits<iterator_type>::pointer pointer;
1426 typedef typename iterator_traits<iterator_type>::reference reference;
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001427 typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
1428#if _LIBCPP_STD_VER > 17
Arthur O'Dwyer6eb8a5d2021-05-19 11:54:31 -04001429 typedef contiguous_iterator_tag iterator_concept;
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001430#endif
1431
Howard Hinnantc51e1022010-05-11 19:42:16 +00001432private:
1433 iterator_type __i;
1434public:
Eric Fiselier873b8d32019-03-18 21:50:12 +00001435 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter() _NOEXCEPT
Marshall Clow4e7b35b2013-08-07 20:48:48 +00001436#if _LIBCPP_STD_VER > 11
1437 : __i{}
1438#endif
Howard Hinnantc90aa632011-09-16 19:52:23 +00001439 {
Louis Dionneba400782020-10-02 15:02:52 -04001440#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnantc90aa632011-09-16 19:52:23 +00001441 __get_db()->__insert_i(this);
1442#endif
1443 }
Marshall Clowae4f8312018-07-13 16:35:26 +00001444 template <class _Up> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
1445 __wrap_iter(const __wrap_iter<_Up>& __u,
Bruce Mitchener170d8972020-11-24 12:53:53 -05001446 typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = nullptr) _NOEXCEPT
Marshall Clowae4f8312018-07-13 16:35:26 +00001447 : __i(__u.base())
Howard Hinnant27e0e772011-09-14 18:33:51 +00001448 {
Louis Dionneba400782020-10-02 15:02:52 -04001449#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001450 __get_db()->__iterator_copy(this, &__u);
1451#endif
1452 }
Louis Dionneba400782020-10-02 15:02:52 -04001453#if _LIBCPP_DEBUG_LEVEL == 2
Marshall Clowae4f8312018-07-13 16:35:26 +00001454 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnant27e0e772011-09-14 18:33:51 +00001455 __wrap_iter(const __wrap_iter& __x)
1456 : __i(__x.base())
1457 {
1458 __get_db()->__iterator_copy(this, &__x);
1459 }
Marshall Clowae4f8312018-07-13 16:35:26 +00001460 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnant27e0e772011-09-14 18:33:51 +00001461 __wrap_iter& operator=(const __wrap_iter& __x)
1462 {
1463 if (this != &__x)
1464 {
1465 __get_db()->__iterator_copy(this, &__x);
1466 __i = __x.__i;
1467 }
1468 return *this;
1469 }
Marshall Clowae4f8312018-07-13 16:35:26 +00001470 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnant27e0e772011-09-14 18:33:51 +00001471 ~__wrap_iter()
1472 {
1473 __get_db()->__erase_i(this);
1474 }
1475#endif
Eric Fiselier873b8d32019-03-18 21:50:12 +00001476 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG reference operator*() const _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001477 {
Louis Dionneba400782020-10-02 15:02:52 -04001478#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001479 _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
1480 "Attempted to dereference a non-dereferenceable iterator");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001481#endif
Howard Hinnant27e0e772011-09-14 18:33:51 +00001482 return *__i;
1483 }
Eric Fiselier873b8d32019-03-18 21:50:12 +00001484 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG pointer operator->() const _NOEXCEPT
Howard Hinnant76053d72013-06-27 19:35:32 +00001485 {
Louis Dionneba400782020-10-02 15:02:52 -04001486#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant76053d72013-06-27 19:35:32 +00001487 _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
1488 "Attempted to dereference a non-dereferenceable iterator");
1489#endif
Louis Dionne1c8315b2021-05-04 18:51:58 -04001490 return _VSTD::__to_address(__i);
Howard Hinnant76053d72013-06-27 19:35:32 +00001491 }
Eric Fiselier873b8d32019-03-18 21:50:12 +00001492 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator++() _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001493 {
Louis Dionneba400782020-10-02 15:02:52 -04001494#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001495 _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
Kristina Bessonovaaeeaa7e2021-05-09 19:29:56 +02001496 "Attempted to increment a non-incrementable iterator");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001497#endif
Howard Hinnant27e0e772011-09-14 18:33:51 +00001498 ++__i;
1499 return *this;
1500 }
Eric Fiselier873b8d32019-03-18 21:50:12 +00001501 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator++(int) _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001502 {__wrap_iter __tmp(*this); ++(*this); return __tmp;}
Marshall Clow6d553a52018-07-14 03:06:11 +00001503
Eric Fiselier873b8d32019-03-18 21:50:12 +00001504 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator--() _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001505 {
Louis Dionneba400782020-10-02 15:02:52 -04001506#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001507 _LIBCPP_ASSERT(__get_const_db()->__decrementable(this),
Kristina Bessonovaaeeaa7e2021-05-09 19:29:56 +02001508 "Attempted to decrement a non-decrementable iterator");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001509#endif
Howard Hinnant27e0e772011-09-14 18:33:51 +00001510 --__i;
1511 return *this;
1512 }
Eric Fiselier873b8d32019-03-18 21:50:12 +00001513 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator--(int) _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001514 {__wrap_iter __tmp(*this); --(*this); return __tmp;}
Eric Fiselier873b8d32019-03-18 21:50:12 +00001515 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator+ (difference_type __n) const _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001516 {__wrap_iter __w(*this); __w += __n; return __w;}
Eric Fiselier873b8d32019-03-18 21:50:12 +00001517 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator+=(difference_type __n) _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001518 {
Louis Dionneba400782020-10-02 15:02:52 -04001519#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001520 _LIBCPP_ASSERT(__get_const_db()->__addable(this, __n),
Kristina Bessonovaaeeaa7e2021-05-09 19:29:56 +02001521 "Attempted to add/subtract an iterator outside its valid range");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001522#endif
Howard Hinnant27e0e772011-09-14 18:33:51 +00001523 __i += __n;
1524 return *this;
1525 }
Eric Fiselier873b8d32019-03-18 21:50:12 +00001526 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator- (difference_type __n) const _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001527 {return *this + (-__n);}
Eric Fiselier873b8d32019-03-18 21:50:12 +00001528 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator-=(difference_type __n) _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001529 {*this += -__n; return *this;}
Eric Fiselier873b8d32019-03-18 21:50:12 +00001530 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG reference operator[](difference_type __n) const _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001531 {
Louis Dionneba400782020-10-02 15:02:52 -04001532#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001533 _LIBCPP_ASSERT(__get_const_db()->__subscriptable(this, __n),
Kristina Bessonovaaeeaa7e2021-05-09 19:29:56 +02001534 "Attempted to subscript an iterator outside its valid range");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001535#endif
Howard Hinnant27e0e772011-09-14 18:33:51 +00001536 return __i[__n];
1537 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001538
Eric Fiselier873b8d32019-03-18 21:50:12 +00001539 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG iterator_type base() const _NOEXCEPT {return __i;}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001540
1541private:
Louis Dionneba400782020-10-02 15:02:52 -04001542#if _LIBCPP_DEBUG_LEVEL == 2
Marshall Clowae4f8312018-07-13 16:35:26 +00001543 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter(const void* __p, iterator_type __x) : __i(__x)
Howard Hinnant27e0e772011-09-14 18:33:51 +00001544 {
1545 __get_db()->__insert_ic(this, __p);
1546 }
Howard Hinnant8ea98242013-08-23 17:37:05 +00001547#else
Eric Fiselier873b8d32019-03-18 21:50:12 +00001548 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter(iterator_type __x) _NOEXCEPT : __i(__x) {}
Howard Hinnant27e0e772011-09-14 18:33:51 +00001549#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001550
1551 template <class _Up> friend class __wrap_iter;
1552 template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001553 template <class _Tp, class _Alloc> friend class _LIBCPP_TEMPLATE_VIS vector;
Marshall Clowcd6d8802019-02-27 00:32:16 +00001554 template <class _Tp, size_t> friend class _LIBCPP_TEMPLATE_VIS span;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001555
1556 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001557 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001558 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001559 operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001560
Howard Hinnantc51e1022010-05-11 19:42:16 +00001561 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001562 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001563 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001564 operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001565
Howard Hinnantc51e1022010-05-11 19:42:16 +00001566 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001567 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001568 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001569 operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001570
Howard Hinnantc51e1022010-05-11 19:42:16 +00001571 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001572 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001573 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001574 operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001575
Howard Hinnantc51e1022010-05-11 19:42:16 +00001576 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001577 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001578 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001579 operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001580
Howard Hinnantc51e1022010-05-11 19:42:16 +00001581 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001582 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001583 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001584 operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001585
Marshall Clow476d3f42016-07-18 13:19:00 +00001586#ifndef _LIBCPP_CXX03_LANG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001587 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001588 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001589 auto
Eric Fiselier873b8d32019-03-18 21:50:12 +00001590 operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001591 -> decltype(__x.base() - __y.base());
1592#else
Howard Hinnantc51e1022010-05-11 19:42:16 +00001593 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001594 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001595 typename __wrap_iter<_Iter1>::difference_type
Eric Fiselier873b8d32019-03-18 21:50:12 +00001596 operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001597#endif
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001598
Howard Hinnantc51e1022010-05-11 19:42:16 +00001599 template <class _Iter1>
Marshall Clowae4f8312018-07-13 16:35:26 +00001600 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001601 __wrap_iter<_Iter1>
Eric Fiselier873b8d32019-03-18 21:50:12 +00001602 operator+(typename __wrap_iter<_Iter1>::difference_type, __wrap_iter<_Iter1>) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001603};
1604
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001605#if _LIBCPP_STD_VER <= 17
1606template <class _It>
Arthur O'Dwyer6eb8a5d2021-05-19 11:54:31 -04001607struct __is_cpp17_contiguous_iterator<__wrap_iter<_It> > : true_type {};
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001608#endif
1609
1610template <class _Iter>
1611_LIBCPP_CONSTEXPR
Arthur O'Dwyer6eb8a5d2021-05-19 11:54:31 -04001612decltype(_VSTD::__to_address(declval<_Iter>()))
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001613__to_address(__wrap_iter<_Iter> __w) _NOEXCEPT {
1614 return _VSTD::__to_address(__w.base());
1615}
1616
Howard Hinnantc51e1022010-05-11 19:42:16 +00001617template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001618inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001619bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001620operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001621{
1622 return __x.base() == __y.base();
1623}
1624
1625template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001626inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001627bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001628operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001629{
Louis Dionneba400782020-10-02 15:02:52 -04001630#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnante6ff0b62013-08-02 00:26:35 +00001631 _LIBCPP_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y),
Howard Hinnant27e0e772011-09-14 18:33:51 +00001632 "Attempted to compare incomparable iterators");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001633#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001634 return __x.base() < __y.base();
1635}
1636
1637template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001638inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001639bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001640operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001641{
Howard Hinnant27e0e772011-09-14 18:33:51 +00001642 return !(__x == __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001643}
1644
1645template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001646inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001647bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001648operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001649{
Howard Hinnant27e0e772011-09-14 18:33:51 +00001650 return __y < __x;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001651}
1652
1653template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001654inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001655bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001656operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001657{
Howard Hinnant27e0e772011-09-14 18:33:51 +00001658 return !(__x < __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001659}
1660
1661template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001662inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001663bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001664operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001665{
Howard Hinnant27e0e772011-09-14 18:33:51 +00001666 return !(__y < __x);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001667}
1668
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001669template <class _Iter1>
Marshall Clowae4f8312018-07-13 16:35:26 +00001670inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001671bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001672operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001673{
1674 return !(__x == __y);
1675}
1676
1677template <class _Iter1>
Marshall Clowae4f8312018-07-13 16:35:26 +00001678inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001679bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001680operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001681{
1682 return __y < __x;
1683}
1684
1685template <class _Iter1>
Marshall Clowae4f8312018-07-13 16:35:26 +00001686inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001687bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001688operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001689{
1690 return !(__x < __y);
1691}
1692
1693template <class _Iter1>
Marshall Clowae4f8312018-07-13 16:35:26 +00001694inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001695bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001696operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001697{
1698 return !(__y < __x);
1699}
1700
Marshall Clow476d3f42016-07-18 13:19:00 +00001701#ifndef _LIBCPP_CXX03_LANG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001702template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001703inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001704auto
Eric Fiselier873b8d32019-03-18 21:50:12 +00001705operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001706-> decltype(__x.base() - __y.base())
1707{
Louis Dionneba400782020-10-02 15:02:52 -04001708#if _LIBCPP_DEBUG_LEVEL == 2
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001709 _LIBCPP_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y),
1710 "Attempted to subtract incompatible iterators");
1711#endif
1712 return __x.base() - __y.base();
1713}
1714#else
Howard Hinnantc51e1022010-05-11 19:42:16 +00001715template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001716inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001717typename __wrap_iter<_Iter1>::difference_type
Eric Fiselier873b8d32019-03-18 21:50:12 +00001718operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001719{
Louis Dionneba400782020-10-02 15:02:52 -04001720#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnante6ff0b62013-08-02 00:26:35 +00001721 _LIBCPP_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y),
Howard Hinnant27e0e772011-09-14 18:33:51 +00001722 "Attempted to subtract incompatible iterators");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001723#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001724 return __x.base() - __y.base();
1725}
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001726#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001727
1728template <class _Iter>
Marshall Clowae4f8312018-07-13 16:35:26 +00001729inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001730__wrap_iter<_Iter>
1731operator+(typename __wrap_iter<_Iter>::difference_type __n,
Eric Fiselier873b8d32019-03-18 21:50:12 +00001732 __wrap_iter<_Iter> __x) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001733{
Howard Hinnant27e0e772011-09-14 18:33:51 +00001734 __x += __n;
1735 return __x;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001736}
1737
Marshall Clow8411ebf2013-12-02 03:24:33 +00001738template <class _Tp, size_t _Np>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001739_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Marshall Clow8411ebf2013-12-02 03:24:33 +00001740_Tp*
1741begin(_Tp (&__array)[_Np])
1742{
1743 return __array;
1744}
1745
1746template <class _Tp, size_t _Np>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001747_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Marshall Clow8411ebf2013-12-02 03:24:33 +00001748_Tp*
1749end(_Tp (&__array)[_Np])
1750{
1751 return __array + _Np;
1752}
1753
Eric Fiselierc6f17cc2016-09-25 03:34:28 +00001754#if !defined(_LIBCPP_CXX03_LANG)
Marshall Clow037fcb72013-12-11 19:32:32 +00001755
Howard Hinnantc834c512011-11-29 18:15:50 +00001756template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001757_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001758auto
Howard Hinnantc834c512011-11-29 18:15:50 +00001759begin(_Cp& __c) -> decltype(__c.begin())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001760{
1761 return __c.begin();
1762}
1763
Howard Hinnantc834c512011-11-29 18:15:50 +00001764template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001765_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001766auto
Howard Hinnantc834c512011-11-29 18:15:50 +00001767begin(const _Cp& __c) -> decltype(__c.begin())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001768{
1769 return __c.begin();
1770}
1771
Howard Hinnantc834c512011-11-29 18:15:50 +00001772template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001773_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001774auto
Howard Hinnantc834c512011-11-29 18:15:50 +00001775end(_Cp& __c) -> decltype(__c.end())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001776{
1777 return __c.end();
1778}
1779
Howard Hinnantc834c512011-11-29 18:15:50 +00001780template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001781_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001782auto
Howard Hinnantc834c512011-11-29 18:15:50 +00001783end(const _Cp& __c) -> decltype(__c.end())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001784{
1785 return __c.end();
1786}
1787
Marshall Clowb278e9c2013-08-30 01:17:07 +00001788#if _LIBCPP_STD_VER > 11
1789
Marshall Clow8411ebf2013-12-02 03:24:33 +00001790template <class _Tp, size_t _Np>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001791_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow8411ebf2013-12-02 03:24:33 +00001792reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np])
1793{
1794 return reverse_iterator<_Tp*>(__array + _Np);
1795}
1796
1797template <class _Tp, size_t _Np>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001798_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow8411ebf2013-12-02 03:24:33 +00001799reverse_iterator<_Tp*> rend(_Tp (&__array)[_Np])
1800{
1801 return reverse_iterator<_Tp*>(__array);
1802}
1803
1804template <class _Ep>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001805_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow8411ebf2013-12-02 03:24:33 +00001806reverse_iterator<const _Ep*> rbegin(initializer_list<_Ep> __il)
1807{
1808 return reverse_iterator<const _Ep*>(__il.end());
1809}
1810
1811template <class _Ep>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001812_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow8411ebf2013-12-02 03:24:33 +00001813reverse_iterator<const _Ep*> rend(initializer_list<_Ep> __il)
1814{
1815 return reverse_iterator<const _Ep*>(__il.begin());
1816}
1817
Marshall Clowb278e9c2013-08-30 01:17:07 +00001818template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001819_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Marshall Clow3862f532016-08-10 20:04:46 +00001820auto cbegin(const _Cp& __c) -> decltype(_VSTD::begin(__c))
Marshall Clowb278e9c2013-08-30 01:17:07 +00001821{
Marshall Clow3862f532016-08-10 20:04:46 +00001822 return _VSTD::begin(__c);
Marshall Clowb278e9c2013-08-30 01:17:07 +00001823}
1824
1825template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001826_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Marshall Clow3862f532016-08-10 20:04:46 +00001827auto cend(const _Cp& __c) -> decltype(_VSTD::end(__c))
Marshall Clowb278e9c2013-08-30 01:17:07 +00001828{
Marshall Clow3862f532016-08-10 20:04:46 +00001829 return _VSTD::end(__c);
Marshall Clowb278e9c2013-08-30 01:17:07 +00001830}
1831
1832template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001833_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowb278e9c2013-08-30 01:17:07 +00001834auto rbegin(_Cp& __c) -> decltype(__c.rbegin())
1835{
1836 return __c.rbegin();
1837}
1838
1839template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001840_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowb278e9c2013-08-30 01:17:07 +00001841auto rbegin(const _Cp& __c) -> decltype(__c.rbegin())
1842{
1843 return __c.rbegin();
1844}
1845
1846template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001847_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowb278e9c2013-08-30 01:17:07 +00001848auto rend(_Cp& __c) -> decltype(__c.rend())
1849{
1850 return __c.rend();
1851}
1852
1853template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001854_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowb278e9c2013-08-30 01:17:07 +00001855auto rend(const _Cp& __c) -> decltype(__c.rend())
1856{
1857 return __c.rend();
1858}
1859
1860template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001861_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow3862f532016-08-10 20:04:46 +00001862auto crbegin(const _Cp& __c) -> decltype(_VSTD::rbegin(__c))
Marshall Clowb278e9c2013-08-30 01:17:07 +00001863{
Marshall Clow3862f532016-08-10 20:04:46 +00001864 return _VSTD::rbegin(__c);
Marshall Clowb278e9c2013-08-30 01:17:07 +00001865}
1866
1867template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001868_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow3862f532016-08-10 20:04:46 +00001869auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c))
Marshall Clowb278e9c2013-08-30 01:17:07 +00001870{
Marshall Clow3862f532016-08-10 20:04:46 +00001871 return _VSTD::rend(__c);
Marshall Clowb278e9c2013-08-30 01:17:07 +00001872}
1873
1874#endif
1875
1876
Eric Fiselierc6f17cc2016-09-25 03:34:28 +00001877#else // defined(_LIBCPP_CXX03_LANG)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001878
Howard Hinnantc834c512011-11-29 18:15:50 +00001879template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001880_LIBCPP_INLINE_VISIBILITY
Howard Hinnantc834c512011-11-29 18:15:50 +00001881typename _Cp::iterator
1882begin(_Cp& __c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001883{
1884 return __c.begin();
1885}
1886
Howard Hinnantc834c512011-11-29 18:15:50 +00001887template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001888_LIBCPP_INLINE_VISIBILITY
Howard Hinnantc834c512011-11-29 18:15:50 +00001889typename _Cp::const_iterator
1890begin(const _Cp& __c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001891{
1892 return __c.begin();
1893}
1894
Howard Hinnantc834c512011-11-29 18:15:50 +00001895template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001896_LIBCPP_INLINE_VISIBILITY
Howard Hinnantc834c512011-11-29 18:15:50 +00001897typename _Cp::iterator
1898end(_Cp& __c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001899{
1900 return __c.end();
1901}
1902
Howard Hinnantc834c512011-11-29 18:15:50 +00001903template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001904_LIBCPP_INLINE_VISIBILITY
Howard Hinnantc834c512011-11-29 18:15:50 +00001905typename _Cp::const_iterator
1906end(const _Cp& __c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001907{
1908 return __c.end();
1909}
1910
Louis Dionne2b1ceaa2021-04-20 12:03:32 -04001911#endif // !defined(_LIBCPP_CXX03_LANG)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001912
Marshall Clowef357272014-11-19 19:43:23 +00001913#if _LIBCPP_STD_VER > 14
Marshall Clow344c41d2017-11-16 17:55:41 +00001914
1915// #if _LIBCPP_STD_VER > 11
1916// template <>
1917// struct _LIBCPP_TEMPLATE_VIS plus<void>
1918// {
1919// template <class _T1, class _T2>
1920// _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1921// auto operator()(_T1&& __t, _T2&& __u) const
1922// _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)))
1923// -> decltype (_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))
1924// { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); }
1925// typedef void is_transparent;
1926// };
1927// #endif
1928
Marshall Clowc4b4a342015-02-11 16:14:01 +00001929template <class _Cont>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001930_LIBCPP_INLINE_VISIBILITY
Marshall Clow344c41d2017-11-16 17:55:41 +00001931constexpr auto size(const _Cont& __c)
1932_NOEXCEPT_(noexcept(__c.size()))
1933-> decltype (__c.size())
1934{ return __c.size(); }
Marshall Clowef357272014-11-19 19:43:23 +00001935
Marshall Clowc4b4a342015-02-11 16:14:01 +00001936template <class _Tp, size_t _Sz>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001937_LIBCPP_INLINE_VISIBILITY
Eric Fiselier6003c772016-12-23 23:37:52 +00001938constexpr size_t size(const _Tp (&)[_Sz]) noexcept { return _Sz; }
Marshall Clowef357272014-11-19 19:43:23 +00001939
Marshall Clow3c5363e2019-02-27 02:58:56 +00001940#if _LIBCPP_STD_VER > 17
1941template <class _Cont>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001942_LIBCPP_INLINE_VISIBILITY
Marshall Clow3c5363e2019-02-27 02:58:56 +00001943constexpr auto ssize(const _Cont& __c)
1944_NOEXCEPT_(noexcept(static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size())))
1945-> common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>
1946{ return static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size()); }
1947
1948template <class _Tp, ptrdiff_t _Sz>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001949_LIBCPP_INLINE_VISIBILITY
Marshall Clow3c5363e2019-02-27 02:58:56 +00001950constexpr ptrdiff_t ssize(const _Tp (&)[_Sz]) noexcept { return _Sz; }
1951#endif
1952
Marshall Clowc4b4a342015-02-11 16:14:01 +00001953template <class _Cont>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001954_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
Marshall Clow344c41d2017-11-16 17:55:41 +00001955constexpr auto empty(const _Cont& __c)
1956_NOEXCEPT_(noexcept(__c.empty()))
1957-> decltype (__c.empty())
1958{ return __c.empty(); }
Marshall Clowef357272014-11-19 19:43:23 +00001959
Marshall Clowc4b4a342015-02-11 16:14:01 +00001960template <class _Tp, size_t _Sz>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001961_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier6003c772016-12-23 23:37:52 +00001962constexpr bool empty(const _Tp (&)[_Sz]) noexcept { return false; }
Marshall Clowef357272014-11-19 19:43:23 +00001963
1964template <class _Ep>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001965_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
Marshall Clowef357272014-11-19 19:43:23 +00001966constexpr bool empty(initializer_list<_Ep> __il) noexcept { return __il.size() == 0; }
1967
Marshall Clowc4b4a342015-02-11 16:14:01 +00001968template <class _Cont> constexpr
Marshall Clow0bd662d2019-02-27 03:25:43 +00001969_LIBCPP_INLINE_VISIBILITY
Marshall Clow344c41d2017-11-16 17:55:41 +00001970auto data(_Cont& __c)
1971_NOEXCEPT_(noexcept(__c.data()))
1972-> decltype (__c.data())
1973{ return __c.data(); }
Marshall Clowef357272014-11-19 19:43:23 +00001974
Marshall Clowc4b4a342015-02-11 16:14:01 +00001975template <class _Cont> constexpr
Marshall Clow0bd662d2019-02-27 03:25:43 +00001976_LIBCPP_INLINE_VISIBILITY
Marshall Clow344c41d2017-11-16 17:55:41 +00001977auto data(const _Cont& __c)
1978_NOEXCEPT_(noexcept(__c.data()))
Louis Dionne173f29e2019-05-29 16:01:36 +00001979-> decltype (__c.data())
Marshall Clow344c41d2017-11-16 17:55:41 +00001980{ return __c.data(); }
Marshall Clowef357272014-11-19 19:43:23 +00001981
Marshall Clowc4b4a342015-02-11 16:14:01 +00001982template <class _Tp, size_t _Sz>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001983_LIBCPP_INLINE_VISIBILITY
Marshall Clowc4b4a342015-02-11 16:14:01 +00001984constexpr _Tp* data(_Tp (&__array)[_Sz]) noexcept { return __array; }
Marshall Clowef357272014-11-19 19:43:23 +00001985
1986template <class _Ep>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001987_LIBCPP_INLINE_VISIBILITY
Marshall Clowef357272014-11-19 19:43:23 +00001988constexpr const _Ep* data(initializer_list<_Ep> __il) noexcept { return __il.begin(); }
1989#endif
1990
Arthur O'Dwyerb6738bd2021-03-21 16:53:09 -04001991template <class _Container, class _Predicate>
1992typename _Container::size_type
1993__libcpp_erase_if_container(_Container& __c, _Predicate& __pred) {
1994 typename _Container::size_type __old_size = __c.size();
1995
1996 const typename _Container::iterator __last = __c.end();
1997 for (typename _Container::iterator __iter = __c.begin(); __iter != __last;) {
1998 if (__pred(*__iter))
1999 __iter = __c.erase(__iter);
2000 else
2001 ++__iter;
2002 }
2003
2004 return __old_size - __c.size();
2005}
Marshall Clowef357272014-11-19 19:43:23 +00002006
Howard Hinnantc51e1022010-05-11 19:42:16 +00002007_LIBCPP_END_NAMESPACE_STD
2008
Louis Dionne2b1ceaa2021-04-20 12:03:32 -04002009#endif // _LIBCPP_ITERATOR