blob: 092e5898fc26a0458be891cc1734802e6be0a5dd [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>
zoecarver31f4f5d2021-05-18 16:18:18 -0700565#include <__iterator/iter_swap.h>
zoecarver5d41ff52021-04-19 14:44:42 -0700566#include <__iterator/iterator_traits.h>
Christopher Di Bella9c0adab2021-05-08 05:02:43 +0000567#include <__iterator/next.h>
Christopher Di Bellab8e21042021-05-16 01:39:22 +0000568#include <__iterator/prev.h>
Louis Dionne170a03c2021-04-28 15:02:08 -0400569#include <__iterator/projected.h>
zoecarver61ae1dc2021-04-19 14:28:27 -0400570#include <__iterator/readable_traits.h>
Louis Dionne735bc462021-04-14 13:59:03 -0400571#include <__memory/addressof.h>
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -0500572#include <__memory/pointer_traits.h>
Christopher Di Bella41f26e82021-06-05 02:47:47 +0000573#include <__utility/forward.h>
Arthur O'Dwyera2f99ee2021-04-29 17:40:17 -0400574#include <compare>
575#include <concepts> // Mandated by the Standard.
576#include <cstddef>
577#include <initializer_list>
578#include <iosfwd> // for forward declarations of vector and string
579#include <type_traits>
Marshall Clow0a1e7502018-09-12 19:41:40 +0000580#include <version>
Howard Hinnant48fd5d52012-11-14 21:17:15 +0000581
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000582#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000583#pragma GCC system_header
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000584#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000585
586_LIBCPP_BEGIN_NAMESPACE_STD
Christopher Di Bella490fe402021-03-23 03:55:52 +0000587
Howard Hinnantc51e1022010-05-11 19:42:16 +0000588template<class _Category, class _Tp, class _Distance = ptrdiff_t,
589 class _Pointer = _Tp*, class _Reference = _Tp&>
Louis Dionne8762e2b2021-05-25 18:15:58 -0400590struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 iterator
Howard Hinnantc51e1022010-05-11 19:42:16 +0000591{
592 typedef _Tp value_type;
593 typedef _Distance difference_type;
594 typedef _Pointer pointer;
595 typedef _Reference reference;
596 typedef _Category iterator_category;
597};
598
599template <class _InputIter>
Marshall Clow75468e72017-05-17 18:51:36 +0000600inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000601typename iterator_traits<_InputIter>::difference_type
602__distance(_InputIter __first, _InputIter __last, input_iterator_tag)
603{
604 typename iterator_traits<_InputIter>::difference_type __r(0);
605 for (; __first != __last; ++__first)
606 ++__r;
607 return __r;
608}
609
610template <class _RandIter>
Marshall Clow75468e72017-05-17 18:51:36 +0000611inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000612typename iterator_traits<_RandIter>::difference_type
613__distance(_RandIter __first, _RandIter __last, random_access_iterator_tag)
614{
615 return __last - __first;
616}
617
618template <class _InputIter>
Marshall Clow75468e72017-05-17 18:51:36 +0000619inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000620typename iterator_traits<_InputIter>::difference_type
621distance(_InputIter __first, _InputIter __last)
622{
Arthur O'Dwyer6e9069c2020-12-07 23:42:47 -0500623 return _VSTD::__distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category());
Howard Hinnantc51e1022010-05-11 19:42:16 +0000624}
625
Eric Fiselier883af112017-04-13 02:54:13 +0000626template <class _Tp, class = void>
627struct __is_stashing_iterator : false_type {};
628
629template <class _Tp>
630struct __is_stashing_iterator<_Tp, typename __void_t<typename _Tp::__stashing_iterator_tag>::type>
631 : true_type {};
632
Louis Dionne8762e2b2021-05-25 18:15:58 -0400633_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +0000634template <class _Iter>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000635class _LIBCPP_TEMPLATE_VIS reverse_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400636#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000637 : public iterator<typename iterator_traits<_Iter>::iterator_category,
638 typename iterator_traits<_Iter>::value_type,
639 typename iterator_traits<_Iter>::difference_type,
640 typename iterator_traits<_Iter>::pointer,
641 typename iterator_traits<_Iter>::reference>
Louis Dionne8762e2b2021-05-25 18:15:58 -0400642#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000643{
Louis Dionne8762e2b2021-05-25 18:15:58 -0400644_LIBCPP_SUPPRESS_DEPRECATED_POP
Marshall Clow0ad029e2014-03-11 22:05:31 +0000645private:
Louis Dionne8762e2b2021-05-25 18:15:58 -0400646#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
647 _Iter __t; // no longer used as of LWG #2360, not removed due to ABI break
648#endif
Eric Fiselier883af112017-04-13 02:54:13 +0000649
650 static_assert(!__is_stashing_iterator<_Iter>::value,
651 "The specified iterator type cannot be used with reverse_iterator; "
652 "Using stashing iterators with reverse_iterator causes undefined behavior");
653
Marshall Clow1f61f0a2014-03-12 01:19:36 +0000654protected:
655 _Iter current;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000656public:
657 typedef _Iter iterator_type;
658 typedef typename iterator_traits<_Iter>::difference_type difference_type;
659 typedef typename iterator_traits<_Iter>::reference reference;
660 typedef typename iterator_traits<_Iter>::pointer pointer;
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -0500661 typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
662 random_access_iterator_tag,
663 typename iterator_traits<_Iter>::iterator_category> iterator_category;
Louis Dionne8762e2b2021-05-25 18:15:58 -0400664 typedef typename iterator_traits<_Iter>::value_type value_type;
665
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -0500666#if _LIBCPP_STD_VER > 17
667 typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
668 random_access_iterator_tag,
669 bidirectional_iterator_tag> iterator_concept;
670#endif
Howard Hinnant3b6579a2010-08-22 00:02:43 +0000671
Louis Dionne8762e2b2021-05-25 18:15:58 -0400672#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
Marshall Clow5ace5542016-10-19 15:12:50 +0000673 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
674 reverse_iterator() : __t(), current() {}
Louis Dionne130f0f92021-06-03 14:14:57 -0400675
Marshall Clow5ace5542016-10-19 15:12:50 +0000676 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
677 explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
Louis Dionne130f0f92021-06-03 14:14:57 -0400678
679 template <class _Up, class = _EnableIf<
680 !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
681 > >
682 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
683 reverse_iterator(const reverse_iterator<_Up>& __u)
684 : __t(__u.base()), current(__u.base())
685 { }
686
687 template <class _Up, class = _EnableIf<
688 !is_same<_Up, _Iter>::value &&
689 is_convertible<_Up const&, _Iter>::value &&
690 is_assignable<_Up const&, _Iter>::value
691 > >
692 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
693 reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
694 __t = current = __u.base();
695 return *this;
696 }
Louis Dionne8762e2b2021-05-25 18:15:58 -0400697#else
698 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
699 reverse_iterator() : current() {}
Louis Dionne130f0f92021-06-03 14:14:57 -0400700
Louis Dionne8762e2b2021-05-25 18:15:58 -0400701 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
702 explicit reverse_iterator(_Iter __x) : current(__x) {}
Louis Dionne130f0f92021-06-03 14:14:57 -0400703
704 template <class _Up, class = _EnableIf<
705 !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
706 > >
707 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
708 reverse_iterator(const reverse_iterator<_Up>& __u)
709 : current(__u.base())
710 { }
711
712 template <class _Up, class = _EnableIf<
713 !is_same<_Up, _Iter>::value &&
714 is_convertible<_Up const&, _Iter>::value &&
715 is_assignable<_Up const&, _Iter>::value
716 > >
717 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
718 reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
719 current = __u.base();
720 return *this;
721 }
Louis Dionne8762e2b2021-05-25 18:15:58 -0400722#endif
Marshall Clow5ace5542016-10-19 15:12:50 +0000723 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
724 _Iter base() const {return current;}
725 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
726 reference operator*() const {_Iter __tmp = current; return *--__tmp;}
727 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
728 pointer operator->() const {return _VSTD::addressof(operator*());}
729 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
730 reverse_iterator& operator++() {--current; return *this;}
731 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
732 reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
733 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
734 reverse_iterator& operator--() {++current; return *this;}
735 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
736 reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
737 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
738 reverse_iterator operator+ (difference_type __n) const {return reverse_iterator(current - __n);}
739 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
740 reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
741 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
742 reverse_iterator operator- (difference_type __n) const {return reverse_iterator(current + __n);}
743 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
744 reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
745 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
746 reference operator[](difference_type __n) const {return *(*this + __n);}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000747};
748
749template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000750inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000751bool
752operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
753{
754 return __x.base() == __y.base();
755}
756
757template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000758inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000759bool
760operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
761{
762 return __x.base() > __y.base();
763}
764
765template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000766inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000767bool
768operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
769{
770 return __x.base() != __y.base();
771}
772
773template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000774inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000775bool
776operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
777{
778 return __x.base() < __y.base();
779}
780
781template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000782inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000783bool
784operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
785{
786 return __x.base() <= __y.base();
787}
788
789template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000790inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000791bool
792operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
793{
794 return __x.base() >= __y.base();
795}
796
Marshall Clow476d3f42016-07-18 13:19:00 +0000797#ifndef _LIBCPP_CXX03_LANG
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000798template <class _Iter1, class _Iter2>
Marshall Clow5ace5542016-10-19 15:12:50 +0000799inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000800auto
801operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
802-> decltype(__y.base() - __x.base())
803{
804 return __y.base() - __x.base();
805}
806#else
Howard Hinnantc51e1022010-05-11 19:42:16 +0000807template <class _Iter1, class _Iter2>
808inline _LIBCPP_INLINE_VISIBILITY
809typename reverse_iterator<_Iter1>::difference_type
810operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
811{
812 return __y.base() - __x.base();
813}
Marshall Clowf8fec4e2016-07-08 16:54:47 +0000814#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000815
816template <class _Iter>
Marshall Clow5ace5542016-10-19 15:12:50 +0000817inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000818reverse_iterator<_Iter>
819operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
820{
821 return reverse_iterator<_Iter>(__x.base() - __n);
822}
823
Marshall Clow6dbbdc92014-03-03 01:24:04 +0000824#if _LIBCPP_STD_VER > 11
825template <class _Iter>
Marshall Clow5ace5542016-10-19 15:12:50 +0000826inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow6dbbdc92014-03-03 01:24:04 +0000827reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
828{
829 return reverse_iterator<_Iter>(__i);
830}
831#endif
832
Louis Dionne8762e2b2021-05-25 18:15:58 -0400833_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +0000834template <class _Container>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000835class _LIBCPP_TEMPLATE_VIS back_insert_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400836#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
837 : public iterator<output_iterator_tag, void, void, void, void>
838#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000839{
Louis Dionne8762e2b2021-05-25 18:15:58 -0400840_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +0000841protected:
842 _Container* container;
843public:
Louis Dionne8762e2b2021-05-25 18:15:58 -0400844 typedef output_iterator_tag iterator_category;
845 typedef void value_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400846#if _LIBCPP_STD_VER > 17
847 typedef ptrdiff_t difference_type;
848#else
Louis Dionne8762e2b2021-05-25 18:15:58 -0400849 typedef void difference_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400850#endif
Louis Dionne8762e2b2021-05-25 18:15:58 -0400851 typedef void pointer;
852 typedef void reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000853 typedef _Container container_type;
854
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500855 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
856 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(const typename _Container::value_type& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000857 {container->push_back(__value_); return *this;}
Eric Fiselierf07d88c2017-04-19 01:34:08 +0000858#ifndef _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500859 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(typename _Container::value_type&& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000860 {container->push_back(_VSTD::move(__value_)); return *this;}
Louis Dionne2b1ceaa2021-04-20 12:03:32 -0400861#endif // _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500862 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator*() {return *this;}
863 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator++() {return *this;}
864 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator operator++(int) {return *this;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000865};
866
867template <class _Container>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500868inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000869back_insert_iterator<_Container>
870back_inserter(_Container& __x)
871{
872 return back_insert_iterator<_Container>(__x);
873}
874
Louis Dionne8762e2b2021-05-25 18:15:58 -0400875_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +0000876template <class _Container>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000877class _LIBCPP_TEMPLATE_VIS front_insert_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400878#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
879 : public iterator<output_iterator_tag, void, void, void, void>
880#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000881{
Louis Dionne8762e2b2021-05-25 18:15:58 -0400882_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +0000883protected:
884 _Container* container;
885public:
Louis Dionne8762e2b2021-05-25 18:15:58 -0400886 typedef output_iterator_tag iterator_category;
887 typedef void value_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400888#if _LIBCPP_STD_VER > 17
889 typedef ptrdiff_t difference_type;
890#else
Louis Dionne8762e2b2021-05-25 18:15:58 -0400891 typedef void difference_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400892#endif
Louis Dionne8762e2b2021-05-25 18:15:58 -0400893 typedef void pointer;
894 typedef void reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000895 typedef _Container container_type;
896
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500897 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
898 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(const typename _Container::value_type& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000899 {container->push_front(__value_); return *this;}
Eric Fiselierf07d88c2017-04-19 01:34:08 +0000900#ifndef _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500901 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(typename _Container::value_type&& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000902 {container->push_front(_VSTD::move(__value_)); return *this;}
Louis Dionne2b1ceaa2021-04-20 12:03:32 -0400903#endif // _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500904 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator*() {return *this;}
905 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator++() {return *this;}
906 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator operator++(int) {return *this;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000907};
908
909template <class _Container>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500910inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000911front_insert_iterator<_Container>
912front_inserter(_Container& __x)
913{
914 return front_insert_iterator<_Container>(__x);
915}
916
Louis Dionne8762e2b2021-05-25 18:15:58 -0400917_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +0000918template <class _Container>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000919class _LIBCPP_TEMPLATE_VIS insert_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400920#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
921 : public iterator<output_iterator_tag, void, void, void, void>
922#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000923{
Louis Dionne8762e2b2021-05-25 18:15:58 -0400924_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +0000925protected:
926 _Container* container;
Christopher Di Bella92072c22021-05-14 06:20:07 +0000927 typename _Container::iterator iter; // FIXME: `ranges::iterator_t<Container>` in C++20 mode
Howard Hinnantc51e1022010-05-11 19:42:16 +0000928public:
Louis Dionne8762e2b2021-05-25 18:15:58 -0400929 typedef output_iterator_tag iterator_category;
930 typedef void value_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400931#if _LIBCPP_STD_VER > 17
932 typedef ptrdiff_t difference_type;
933#else
Louis Dionne8762e2b2021-05-25 18:15:58 -0400934 typedef void difference_type;
Louis Dionne3402c3c2021-05-27 12:56:12 -0400935#endif
Louis Dionne8762e2b2021-05-25 18:15:58 -0400936 typedef void pointer;
937 typedef void reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000938 typedef _Container container_type;
939
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500940 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator(_Container& __x, typename _Container::iterator __i)
Marshall Clowcef31682014-03-03 19:20:40 +0000941 : container(_VSTD::addressof(__x)), iter(__i) {}
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500942 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000943 {iter = container->insert(iter, __value_); ++iter; return *this;}
Eric Fiselierf07d88c2017-04-19 01:34:08 +0000944#ifndef _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500945 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value_)
Howard Hinnantbf074022011-10-22 20:59:45 +0000946 {iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;}
Louis Dionne2b1ceaa2021-04-20 12:03:32 -0400947#endif // _LIBCPP_CXX03_LANG
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500948 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator*() {return *this;}
949 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++() {return *this;}
950 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++(int) {return *this;}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000951};
952
953template <class _Container>
Arthur O'Dwyer20638cc2021-02-09 19:12:16 -0500954inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000955insert_iterator<_Container>
956inserter(_Container& __x, typename _Container::iterator __i)
957{
958 return insert_iterator<_Container>(__x, __i);
959}
960
Louis Dionne8762e2b2021-05-25 18:15:58 -0400961_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +0000962template <class _Tp, class _CharT = char,
963 class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000964class _LIBCPP_TEMPLATE_VIS istream_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -0400965#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000966 : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
Louis Dionne8762e2b2021-05-25 18:15:58 -0400967#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000968{
Louis Dionne8762e2b2021-05-25 18:15:58 -0400969_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +0000970public:
Louis Dionne8762e2b2021-05-25 18:15:58 -0400971 typedef input_iterator_tag iterator_category;
972 typedef _Tp value_type;
973 typedef _Distance difference_type;
974 typedef const _Tp* pointer;
975 typedef const _Tp& reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000976 typedef _CharT char_type;
977 typedef _Traits traits_type;
978 typedef basic_istream<_CharT,_Traits> istream_type;
979private:
980 istream_type* __in_stream_;
981 _Tp __value_;
982public:
Bruce Mitchener170d8972020-11-24 12:53:53 -0500983 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(nullptr), __value_() {}
Marshall Clowb7742702016-05-17 17:44:40 +0000984 _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(_VSTD::addressof(__s))
Howard Hinnantc51e1022010-05-11 19:42:16 +0000985 {
986 if (!(*__in_stream_ >> __value_))
Bruce Mitchener170d8972020-11-24 12:53:53 -0500987 __in_stream_ = nullptr;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000988 }
989
990 _LIBCPP_INLINE_VISIBILITY const _Tp& operator*() const {return __value_;}
Marshall Clowb7742702016-05-17 17:44:40 +0000991 _LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return _VSTD::addressof((operator*()));}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000992 _LIBCPP_INLINE_VISIBILITY istream_iterator& operator++()
993 {
994 if (!(*__in_stream_ >> __value_))
Bruce Mitchener170d8972020-11-24 12:53:53 -0500995 __in_stream_ = nullptr;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000996 return *this;
997 }
998 _LIBCPP_INLINE_VISIBILITY istream_iterator operator++(int)
999 {istream_iterator __t(*this); ++(*this); return __t;}
1000
Roger Ferrer Ibanezd16858b2017-12-11 13:54:58 +00001001 template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001002 friend _LIBCPP_INLINE_VISIBILITY
Roger Ferrer Ibanezd16858b2017-12-11 13:54:58 +00001003 bool
1004 operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
1005 const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001006
Roger Ferrer Ibanezd16858b2017-12-11 13:54:58 +00001007 template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
Howard Hinnantc51e1022010-05-11 19:42:16 +00001008 friend _LIBCPP_INLINE_VISIBILITY
Roger Ferrer Ibanezd16858b2017-12-11 13:54:58 +00001009 bool
1010 operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
1011 const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001012};
1013
Roger Ferrer Ibanezd16858b2017-12-11 13:54:58 +00001014template <class _Tp, class _CharT, class _Traits, class _Distance>
1015inline _LIBCPP_INLINE_VISIBILITY
1016bool
1017operator==(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
1018 const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
1019{
1020 return __x.__in_stream_ == __y.__in_stream_;
1021}
1022
1023template <class _Tp, class _CharT, class _Traits, class _Distance>
1024inline _LIBCPP_INLINE_VISIBILITY
1025bool
1026operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
1027 const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
1028{
1029 return !(__x == __y);
1030}
1031
Louis Dionne8762e2b2021-05-25 18:15:58 -04001032_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +00001033template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001034class _LIBCPP_TEMPLATE_VIS ostream_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -04001035#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001036 : public iterator<output_iterator_tag, void, void, void, void>
Louis Dionne8762e2b2021-05-25 18:15:58 -04001037#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001038{
Louis Dionne8762e2b2021-05-25 18:15:58 -04001039_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +00001040public:
Louis Dionnea4d79522020-09-11 10:15:56 -04001041 typedef output_iterator_tag iterator_category;
1042 typedef void value_type;
1043#if _LIBCPP_STD_VER > 17
Louis Dionne3402c3c2021-05-27 12:56:12 -04001044 typedef ptrdiff_t difference_type;
Louis Dionnea4d79522020-09-11 10:15:56 -04001045#else
1046 typedef void difference_type;
1047#endif
1048 typedef void pointer;
1049 typedef void reference;
1050 typedef _CharT char_type;
1051 typedef _Traits traits_type;
1052 typedef basic_ostream<_CharT, _Traits> ostream_type;
1053
Howard Hinnantc51e1022010-05-11 19:42:16 +00001054private:
1055 ostream_type* __out_stream_;
1056 const char_type* __delim_;
1057public:
Marshall Clow27a89512016-10-12 16:13:48 +00001058 _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s) _NOEXCEPT
Bruce Mitchener170d8972020-11-24 12:53:53 -05001059 : __out_stream_(_VSTD::addressof(__s)), __delim_(nullptr) {}
Marshall Clow27a89512016-10-12 16:13:48 +00001060 _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT
Marshall Clowb7742702016-05-17 17:44:40 +00001061 : __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {}
Howard Hinnantbf074022011-10-22 20:59:45 +00001062 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001063 {
Howard Hinnantbf074022011-10-22 20:59:45 +00001064 *__out_stream_ << __value_;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001065 if (__delim_)
1066 *__out_stream_ << __delim_;
1067 return *this;
1068 }
1069
1070 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator*() {return *this;}
1071 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++() {return *this;}
1072 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++(int) {return *this;}
1073};
1074
Louis Dionne8762e2b2021-05-25 18:15:58 -04001075_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +00001076template<class _CharT, class _Traits>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001077class _LIBCPP_TEMPLATE_VIS istreambuf_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -04001078#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001079 : public iterator<input_iterator_tag, _CharT,
1080 typename _Traits::off_type, _CharT*,
1081 _CharT>
Louis Dionne8762e2b2021-05-25 18:15:58 -04001082#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001083{
Louis Dionne8762e2b2021-05-25 18:15:58 -04001084_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +00001085public:
Louis Dionne8762e2b2021-05-25 18:15:58 -04001086 typedef input_iterator_tag iterator_category;
1087 typedef _CharT value_type;
1088 typedef typename _Traits::off_type difference_type;
1089 typedef _CharT* pointer;
1090 typedef _CharT reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001091 typedef _CharT char_type;
1092 typedef _Traits traits_type;
1093 typedef typename _Traits::int_type int_type;
1094 typedef basic_streambuf<_CharT,_Traits> streambuf_type;
1095 typedef basic_istream<_CharT,_Traits> istream_type;
1096private:
Howard Hinnant3e57b272012-11-16 22:17:23 +00001097 mutable streambuf_type* __sbuf_;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001098
1099 class __proxy
1100 {
1101 char_type __keep_;
1102 streambuf_type* __sbuf_;
1103 _LIBCPP_INLINE_VISIBILITY __proxy(char_type __c, streambuf_type* __s)
1104 : __keep_(__c), __sbuf_(__s) {}
1105 friend class istreambuf_iterator;
1106 public:
1107 _LIBCPP_INLINE_VISIBILITY char_type operator*() const {return __keep_;}
1108 };
1109
Howard Hinnant756c69b2010-09-22 16:48:34 +00001110 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant3e57b272012-11-16 22:17:23 +00001111 bool __test_for_eof() const
Howard Hinnantc51e1022010-05-11 19:42:16 +00001112 {
1113 if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
Bruce Mitchener170d8972020-11-24 12:53:53 -05001114 __sbuf_ = nullptr;
1115 return __sbuf_ == nullptr;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001116 }
1117public:
Bruce Mitchener170d8972020-11-24 12:53:53 -05001118 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istreambuf_iterator() _NOEXCEPT : __sbuf_(nullptr) {}
Howard Hinnant011138d2012-07-20 19:36:34 +00001119 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(istream_type& __s) _NOEXCEPT
Howard Hinnantb9af8d82012-12-29 17:45:42 +00001120 : __sbuf_(__s.rdbuf()) {}
Howard Hinnant011138d2012-07-20 19:36:34 +00001121 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(streambuf_type* __s) _NOEXCEPT
Howard Hinnantb9af8d82012-12-29 17:45:42 +00001122 : __sbuf_(__s) {}
Howard Hinnant011138d2012-07-20 19:36:34 +00001123 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001124 : __sbuf_(__p.__sbuf_) {}
1125
Howard Hinnant28b24882011-12-01 20:21:04 +00001126 _LIBCPP_INLINE_VISIBILITY char_type operator*() const
1127 {return static_cast<char_type>(__sbuf_->sgetc());}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001128 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++()
1129 {
Howard Hinnant3e57b272012-11-16 22:17:23 +00001130 __sbuf_->sbumpc();
Howard Hinnantc51e1022010-05-11 19:42:16 +00001131 return *this;
1132 }
1133 _LIBCPP_INLINE_VISIBILITY __proxy operator++(int)
1134 {
Howard Hinnant3e57b272012-11-16 22:17:23 +00001135 return __proxy(__sbuf_->sbumpc(), __sbuf_);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001136 }
1137
1138 _LIBCPP_INLINE_VISIBILITY bool equal(const istreambuf_iterator& __b) const
Howard Hinnant3e57b272012-11-16 22:17:23 +00001139 {return __test_for_eof() == __b.__test_for_eof();}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001140};
1141
1142template <class _CharT, class _Traits>
1143inline _LIBCPP_INLINE_VISIBILITY
1144bool operator==(const istreambuf_iterator<_CharT,_Traits>& __a,
1145 const istreambuf_iterator<_CharT,_Traits>& __b)
1146 {return __a.equal(__b);}
1147
1148template <class _CharT, class _Traits>
1149inline _LIBCPP_INLINE_VISIBILITY
1150bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a,
1151 const istreambuf_iterator<_CharT,_Traits>& __b)
1152 {return !__a.equal(__b);}
1153
Louis Dionne8762e2b2021-05-25 18:15:58 -04001154_LIBCPP_SUPPRESS_DEPRECATED_PUSH
Howard Hinnantc51e1022010-05-11 19:42:16 +00001155template <class _CharT, class _Traits>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001156class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator
Louis Dionne8762e2b2021-05-25 18:15:58 -04001157#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001158 : public iterator<output_iterator_tag, void, void, void, void>
Louis Dionne8762e2b2021-05-25 18:15:58 -04001159#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001160{
Louis Dionne8762e2b2021-05-25 18:15:58 -04001161_LIBCPP_SUPPRESS_DEPRECATED_POP
Howard Hinnantc51e1022010-05-11 19:42:16 +00001162public:
Louis Dionnea4d79522020-09-11 10:15:56 -04001163 typedef output_iterator_tag iterator_category;
1164 typedef void value_type;
1165#if _LIBCPP_STD_VER > 17
Louis Dionne3402c3c2021-05-27 12:56:12 -04001166 typedef ptrdiff_t difference_type;
Louis Dionnea4d79522020-09-11 10:15:56 -04001167#else
1168 typedef void difference_type;
1169#endif
1170 typedef void pointer;
1171 typedef void reference;
1172 typedef _CharT char_type;
1173 typedef _Traits traits_type;
1174 typedef basic_streambuf<_CharT, _Traits> streambuf_type;
1175 typedef basic_ostream<_CharT, _Traits> ostream_type;
1176
Howard Hinnantc51e1022010-05-11 19:42:16 +00001177private:
1178 streambuf_type* __sbuf_;
1179public:
Howard Hinnant011138d2012-07-20 19:36:34 +00001180 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001181 : __sbuf_(__s.rdbuf()) {}
Howard Hinnant011138d2012-07-20 19:36:34 +00001182 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001183 : __sbuf_(__s) {}
1184 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c)
1185 {
1186 if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof()))
Bruce Mitchener170d8972020-11-24 12:53:53 -05001187 __sbuf_ = nullptr;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001188 return *this;
1189 }
1190 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator*() {return *this;}
1191 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++() {return *this;}
1192 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++(int) {return *this;}
Bruce Mitchener170d8972020-11-24 12:53:53 -05001193 _LIBCPP_INLINE_VISIBILITY bool failed() const _NOEXCEPT {return __sbuf_ == nullptr;}
Howard Hinnant97955172012-09-19 19:14:15 +00001194
1195 template <class _Ch, class _Tr>
1196 friend
1197 _LIBCPP_HIDDEN
1198 ostreambuf_iterator<_Ch, _Tr>
1199 __pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s,
1200 const _Ch* __ob, const _Ch* __op, const _Ch* __oe,
1201 ios_base& __iob, _Ch __fl);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001202};
1203
1204template <class _Iter>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001205class _LIBCPP_TEMPLATE_VIS move_iterator
Howard Hinnantc51e1022010-05-11 19:42:16 +00001206{
1207private:
1208 _Iter __i;
1209public:
1210 typedef _Iter iterator_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001211 typedef typename iterator_traits<iterator_type>::value_type value_type;
1212 typedef typename iterator_traits<iterator_type>::difference_type difference_type;
Marshall Clowd85a0562016-04-11 03:54:53 +00001213 typedef iterator_type pointer;
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001214 typedef _If<__is_cpp17_random_access_iterator<_Iter>::value,
1215 random_access_iterator_tag,
1216 typename iterator_traits<_Iter>::iterator_category> iterator_category;
1217#if _LIBCPP_STD_VER > 17
1218 typedef input_iterator_tag iterator_concept;
1219#endif
1220
Eric Fiselierf07d88c2017-04-19 01:34:08 +00001221#ifndef _LIBCPP_CXX03_LANG
Eric Fiselier57b8e0e2016-04-22 00:49:12 +00001222 typedef typename iterator_traits<iterator_type>::reference __reference;
1223 typedef typename conditional<
1224 is_reference<__reference>::value,
1225 typename remove_reference<__reference>::type&&,
1226 __reference
1227 >::type reference;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001228#else
1229 typedef typename iterator_traits<iterator_type>::reference reference;
1230#endif
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001231
Marshall Clowb5f99122016-11-02 15:30:26 +00001232 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1233 move_iterator() : __i() {}
Louis Dionne130f0f92021-06-03 14:14:57 -04001234
Marshall Clowb5f99122016-11-02 15:30:26 +00001235 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1236 explicit move_iterator(_Iter __x) : __i(__x) {}
Louis Dionne130f0f92021-06-03 14:14:57 -04001237
1238 template <class _Up, class = _EnableIf<
1239 !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
1240 > >
1241 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1242 move_iterator(const move_iterator<_Up>& __u) : __i(__u.base()) {}
1243
1244 template <class _Up, class = _EnableIf<
1245 !is_same<_Up, _Iter>::value &&
1246 is_convertible<_Up const&, _Iter>::value &&
1247 is_assignable<_Iter&, _Up const&>::value
1248 > >
1249 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1250 move_iterator& operator=(const move_iterator<_Up>& __u) {
1251 __i = __u.base();
1252 return *this;
1253 }
1254
Marshall Clowb5f99122016-11-02 15:30:26 +00001255 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _Iter base() const {return __i;}
Louis Dionne173f29e2019-05-29 16:01:36 +00001256 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowb5f99122016-11-02 15:30:26 +00001257 reference operator*() const { return static_cast<reference>(*__i); }
1258 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1259 pointer operator->() const { return __i;}
1260 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1261 move_iterator& operator++() {++__i; return *this;}
1262 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1263 move_iterator operator++(int) {move_iterator __tmp(*this); ++__i; return __tmp;}
1264 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1265 move_iterator& operator--() {--__i; return *this;}
1266 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1267 move_iterator operator--(int) {move_iterator __tmp(*this); --__i; return __tmp;}
1268 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1269 move_iterator operator+ (difference_type __n) const {return move_iterator(__i + __n);}
1270 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1271 move_iterator& operator+=(difference_type __n) {__i += __n; return *this;}
1272 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1273 move_iterator operator- (difference_type __n) const {return move_iterator(__i - __n);}
1274 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1275 move_iterator& operator-=(difference_type __n) {__i -= __n; return *this;}
1276 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
1277 reference operator[](difference_type __n) const { return static_cast<reference>(__i[__n]); }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001278};
1279
1280template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001281inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001282bool
1283operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1284{
1285 return __x.base() == __y.base();
1286}
1287
1288template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001289inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001290bool
1291operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1292{
1293 return __x.base() < __y.base();
1294}
1295
1296template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001297inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001298bool
1299operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1300{
1301 return __x.base() != __y.base();
1302}
1303
1304template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001305inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001306bool
1307operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1308{
1309 return __x.base() > __y.base();
1310}
1311
1312template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001313inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001314bool
1315operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1316{
1317 return __x.base() >= __y.base();
1318}
1319
1320template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001321inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001322bool
1323operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1324{
1325 return __x.base() <= __y.base();
1326}
1327
Marshall Clow476d3f42016-07-18 13:19:00 +00001328#ifndef _LIBCPP_CXX03_LANG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001329template <class _Iter1, class _Iter2>
Marshall Clowb5f99122016-11-02 15:30:26 +00001330inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001331auto
1332operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1333-> decltype(__x.base() - __y.base())
1334{
1335 return __x.base() - __y.base();
1336}
1337#else
Howard Hinnantc51e1022010-05-11 19:42:16 +00001338template <class _Iter1, class _Iter2>
1339inline _LIBCPP_INLINE_VISIBILITY
1340typename move_iterator<_Iter1>::difference_type
1341operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
1342{
1343 return __x.base() - __y.base();
1344}
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001345#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001346
1347template <class _Iter>
Marshall Clowb5f99122016-11-02 15:30:26 +00001348inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001349move_iterator<_Iter>
1350operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x)
1351{
1352 return move_iterator<_Iter>(__x.base() + __n);
1353}
1354
1355template <class _Iter>
Marshall Clowb5f99122016-11-02 15:30:26 +00001356inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001357move_iterator<_Iter>
Marshall Clow84f90cf2013-08-27 13:03:03 +00001358make_move_iterator(_Iter __i)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001359{
1360 return move_iterator<_Iter>(__i);
1361}
1362
1363// __wrap_iter
1364
1365template <class _Iter> class __wrap_iter;
1366
1367template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001368_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001369bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001370operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001371
1372template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001373_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001374bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001375operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001376
1377template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001378_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001379bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001380operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001381
1382template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001383_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001384bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001385operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001386
1387template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001388_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001389bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001390operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001391
1392template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001393_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001394bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001395operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001396
Marshall Clow476d3f42016-07-18 13:19:00 +00001397#ifndef _LIBCPP_CXX03_LANG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001398template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001399_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001400auto
Eric Fiselier873b8d32019-03-18 21:50:12 +00001401operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001402-> decltype(__x.base() - __y.base());
1403#else
Howard Hinnantc51e1022010-05-11 19:42:16 +00001404template <class _Iter1, class _Iter2>
Howard Hinnanta54386e2012-09-14 00:39:16 +00001405_LIBCPP_INLINE_VISIBILITY
Howard Hinnantc51e1022010-05-11 19:42:16 +00001406typename __wrap_iter<_Iter1>::difference_type
Eric Fiselier873b8d32019-03-18 21:50:12 +00001407operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001408#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001409
1410template <class _Iter>
Marshall Clowae4f8312018-07-13 16:35:26 +00001411_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001412__wrap_iter<_Iter>
Eric Fiselier873b8d32019-03-18 21:50:12 +00001413operator+(typename __wrap_iter<_Iter>::difference_type, __wrap_iter<_Iter>) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001414
Louis Dionne65b433b2019-11-06 12:02:41 +00001415template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 copy(_Ip, _Ip, _Op);
1416template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 copy_backward(_B1, _B1, _B2);
zoecarverd0279de2020-09-14 18:11:08 -04001417template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 move(_Ip, _Ip, _Op);
1418template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 move_backward(_B1, _B1, _B2);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001419
Howard Hinnantc51e1022010-05-11 19:42:16 +00001420template <class _Iter>
1421class __wrap_iter
1422{
1423public:
1424 typedef _Iter iterator_type;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001425 typedef typename iterator_traits<iterator_type>::value_type value_type;
1426 typedef typename iterator_traits<iterator_type>::difference_type difference_type;
1427 typedef typename iterator_traits<iterator_type>::pointer pointer;
1428 typedef typename iterator_traits<iterator_type>::reference reference;
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001429 typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
1430#if _LIBCPP_STD_VER > 17
Arthur O'Dwyer6eb8a5d2021-05-19 11:54:31 -04001431 typedef contiguous_iterator_tag iterator_concept;
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001432#endif
1433
Howard Hinnantc51e1022010-05-11 19:42:16 +00001434private:
1435 iterator_type __i;
1436public:
Eric Fiselier873b8d32019-03-18 21:50:12 +00001437 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter() _NOEXCEPT
Marshall Clow4e7b35b2013-08-07 20:48:48 +00001438#if _LIBCPP_STD_VER > 11
1439 : __i{}
1440#endif
Howard Hinnantc90aa632011-09-16 19:52:23 +00001441 {
Louis Dionneba400782020-10-02 15:02:52 -04001442#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnantc90aa632011-09-16 19:52:23 +00001443 __get_db()->__insert_i(this);
1444#endif
1445 }
Marshall Clowae4f8312018-07-13 16:35:26 +00001446 template <class _Up> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
1447 __wrap_iter(const __wrap_iter<_Up>& __u,
Bruce Mitchener170d8972020-11-24 12:53:53 -05001448 typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = nullptr) _NOEXCEPT
Marshall Clowae4f8312018-07-13 16:35:26 +00001449 : __i(__u.base())
Howard Hinnant27e0e772011-09-14 18:33:51 +00001450 {
Louis Dionneba400782020-10-02 15:02:52 -04001451#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001452 __get_db()->__iterator_copy(this, &__u);
1453#endif
1454 }
Louis Dionneba400782020-10-02 15:02:52 -04001455#if _LIBCPP_DEBUG_LEVEL == 2
Marshall Clowae4f8312018-07-13 16:35:26 +00001456 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnant27e0e772011-09-14 18:33:51 +00001457 __wrap_iter(const __wrap_iter& __x)
1458 : __i(__x.base())
1459 {
1460 __get_db()->__iterator_copy(this, &__x);
1461 }
Marshall Clowae4f8312018-07-13 16:35:26 +00001462 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnant27e0e772011-09-14 18:33:51 +00001463 __wrap_iter& operator=(const __wrap_iter& __x)
1464 {
1465 if (this != &__x)
1466 {
1467 __get_db()->__iterator_copy(this, &__x);
1468 __i = __x.__i;
1469 }
1470 return *this;
1471 }
Marshall Clowae4f8312018-07-13 16:35:26 +00001472 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnant27e0e772011-09-14 18:33:51 +00001473 ~__wrap_iter()
1474 {
1475 __get_db()->__erase_i(this);
1476 }
1477#endif
Eric Fiselier873b8d32019-03-18 21:50:12 +00001478 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG reference operator*() const _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001479 {
Louis Dionneba400782020-10-02 15:02:52 -04001480#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001481 _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
1482 "Attempted to dereference a non-dereferenceable iterator");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001483#endif
Howard Hinnant27e0e772011-09-14 18:33:51 +00001484 return *__i;
1485 }
Eric Fiselier873b8d32019-03-18 21:50:12 +00001486 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG pointer operator->() const _NOEXCEPT
Howard Hinnant76053d72013-06-27 19:35:32 +00001487 {
Louis Dionneba400782020-10-02 15:02:52 -04001488#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant76053d72013-06-27 19:35:32 +00001489 _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
1490 "Attempted to dereference a non-dereferenceable iterator");
1491#endif
Louis Dionne1c8315b2021-05-04 18:51:58 -04001492 return _VSTD::__to_address(__i);
Howard Hinnant76053d72013-06-27 19:35:32 +00001493 }
Eric Fiselier873b8d32019-03-18 21:50:12 +00001494 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator++() _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001495 {
Louis Dionneba400782020-10-02 15:02:52 -04001496#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001497 _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
Kristina Bessonovaaeeaa7e2021-05-09 19:29:56 +02001498 "Attempted to increment a non-incrementable iterator");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001499#endif
Howard Hinnant27e0e772011-09-14 18:33:51 +00001500 ++__i;
1501 return *this;
1502 }
Eric Fiselier873b8d32019-03-18 21:50:12 +00001503 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator++(int) _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001504 {__wrap_iter __tmp(*this); ++(*this); return __tmp;}
Marshall Clow6d553a52018-07-14 03:06:11 +00001505
Eric Fiselier873b8d32019-03-18 21:50:12 +00001506 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator--() _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001507 {
Louis Dionneba400782020-10-02 15:02:52 -04001508#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001509 _LIBCPP_ASSERT(__get_const_db()->__decrementable(this),
Kristina Bessonovaaeeaa7e2021-05-09 19:29:56 +02001510 "Attempted to decrement a non-decrementable iterator");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001511#endif
Howard Hinnant27e0e772011-09-14 18:33:51 +00001512 --__i;
1513 return *this;
1514 }
Eric Fiselier873b8d32019-03-18 21:50:12 +00001515 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator--(int) _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001516 {__wrap_iter __tmp(*this); --(*this); return __tmp;}
Eric Fiselier873b8d32019-03-18 21:50:12 +00001517 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator+ (difference_type __n) const _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001518 {__wrap_iter __w(*this); __w += __n; return __w;}
Eric Fiselier873b8d32019-03-18 21:50:12 +00001519 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator+=(difference_type __n) _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001520 {
Louis Dionneba400782020-10-02 15:02:52 -04001521#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001522 _LIBCPP_ASSERT(__get_const_db()->__addable(this, __n),
Kristina Bessonovaaeeaa7e2021-05-09 19:29:56 +02001523 "Attempted to add/subtract an iterator outside its valid range");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001524#endif
Howard Hinnant27e0e772011-09-14 18:33:51 +00001525 __i += __n;
1526 return *this;
1527 }
Eric Fiselier873b8d32019-03-18 21:50:12 +00001528 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter operator- (difference_type __n) const _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001529 {return *this + (-__n);}
Eric Fiselier873b8d32019-03-18 21:50:12 +00001530 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter& operator-=(difference_type __n) _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001531 {*this += -__n; return *this;}
Eric Fiselier873b8d32019-03-18 21:50:12 +00001532 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG reference operator[](difference_type __n) const _NOEXCEPT
Howard Hinnant27e0e772011-09-14 18:33:51 +00001533 {
Louis Dionneba400782020-10-02 15:02:52 -04001534#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnant27e0e772011-09-14 18:33:51 +00001535 _LIBCPP_ASSERT(__get_const_db()->__subscriptable(this, __n),
Kristina Bessonovaaeeaa7e2021-05-09 19:29:56 +02001536 "Attempted to subscript an iterator outside its valid range");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001537#endif
Howard Hinnant27e0e772011-09-14 18:33:51 +00001538 return __i[__n];
1539 }
Howard Hinnantc51e1022010-05-11 19:42:16 +00001540
Eric Fiselier873b8d32019-03-18 21:50:12 +00001541 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG iterator_type base() const _NOEXCEPT {return __i;}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001542
1543private:
Louis Dionneba400782020-10-02 15:02:52 -04001544#if _LIBCPP_DEBUG_LEVEL == 2
Marshall Clowae4f8312018-07-13 16:35:26 +00001545 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter(const void* __p, iterator_type __x) : __i(__x)
Howard Hinnant27e0e772011-09-14 18:33:51 +00001546 {
1547 __get_db()->__insert_ic(this, __p);
1548 }
Howard Hinnant8ea98242013-08-23 17:37:05 +00001549#else
Eric Fiselier873b8d32019-03-18 21:50:12 +00001550 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG __wrap_iter(iterator_type __x) _NOEXCEPT : __i(__x) {}
Howard Hinnant27e0e772011-09-14 18:33:51 +00001551#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001552
1553 template <class _Up> friend class __wrap_iter;
1554 template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001555 template <class _Tp, class _Alloc> friend class _LIBCPP_TEMPLATE_VIS vector;
Marshall Clowcd6d8802019-02-27 00:32:16 +00001556 template <class _Tp, size_t> friend class _LIBCPP_TEMPLATE_VIS span;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001557
1558 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001559 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001560 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001561 operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001562
Howard Hinnantc51e1022010-05-11 19:42:16 +00001563 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001564 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001565 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001566 operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001567
Howard Hinnantc51e1022010-05-11 19:42:16 +00001568 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001569 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001570 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001571 operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001572
Howard Hinnantc51e1022010-05-11 19:42:16 +00001573 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001574 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001575 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001576 operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001577
Howard Hinnantc51e1022010-05-11 19:42:16 +00001578 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001579 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001580 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001581 operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001582
Howard Hinnantc51e1022010-05-11 19:42:16 +00001583 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001584 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001585 bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001586 operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001587
Marshall Clow476d3f42016-07-18 13:19:00 +00001588#ifndef _LIBCPP_CXX03_LANG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001589 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001590 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001591 auto
Eric Fiselier873b8d32019-03-18 21:50:12 +00001592 operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001593 -> decltype(__x.base() - __y.base());
1594#else
Howard Hinnantc51e1022010-05-11 19:42:16 +00001595 template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001596 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001597 typename __wrap_iter<_Iter1>::difference_type
Eric Fiselier873b8d32019-03-18 21:50:12 +00001598 operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001599#endif
Howard Hinnant3b6579a2010-08-22 00:02:43 +00001600
Howard Hinnantc51e1022010-05-11 19:42:16 +00001601 template <class _Iter1>
Marshall Clowae4f8312018-07-13 16:35:26 +00001602 _LIBCPP_CONSTEXPR_IF_NODEBUG friend
Howard Hinnantc51e1022010-05-11 19:42:16 +00001603 __wrap_iter<_Iter1>
Eric Fiselier873b8d32019-03-18 21:50:12 +00001604 operator+(typename __wrap_iter<_Iter1>::difference_type, __wrap_iter<_Iter1>) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001605};
1606
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001607#if _LIBCPP_STD_VER <= 17
1608template <class _It>
Arthur O'Dwyer6eb8a5d2021-05-19 11:54:31 -04001609struct __is_cpp17_contiguous_iterator<__wrap_iter<_It> > : true_type {};
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001610#endif
1611
1612template <class _Iter>
1613_LIBCPP_CONSTEXPR
Arthur O'Dwyer6eb8a5d2021-05-19 11:54:31 -04001614decltype(_VSTD::__to_address(declval<_Iter>()))
Arthur O'Dwyer1ac9f092021-01-15 12:59:56 -05001615__to_address(__wrap_iter<_Iter> __w) _NOEXCEPT {
1616 return _VSTD::__to_address(__w.base());
1617}
1618
Howard Hinnantc51e1022010-05-11 19:42:16 +00001619template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001620inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001621bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001622operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001623{
1624 return __x.base() == __y.base();
1625}
1626
1627template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001628inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001629bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001630operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001631{
Louis Dionneba400782020-10-02 15:02:52 -04001632#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnante6ff0b62013-08-02 00:26:35 +00001633 _LIBCPP_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y),
Howard Hinnant27e0e772011-09-14 18:33:51 +00001634 "Attempted to compare incomparable iterators");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001635#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001636 return __x.base() < __y.base();
1637}
1638
1639template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001640inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001641bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001642operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001643{
Howard Hinnant27e0e772011-09-14 18:33:51 +00001644 return !(__x == __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001645}
1646
1647template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001648inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001649bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001650operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001651{
Howard Hinnant27e0e772011-09-14 18:33:51 +00001652 return __y < __x;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001653}
1654
1655template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001656inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001657bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001658operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001659{
Howard Hinnant27e0e772011-09-14 18:33:51 +00001660 return !(__x < __y);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001661}
1662
1663template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001664inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001665bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001666operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001667{
Howard Hinnant27e0e772011-09-14 18:33:51 +00001668 return !(__y < __x);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001669}
1670
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001671template <class _Iter1>
Marshall Clowae4f8312018-07-13 16:35:26 +00001672inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001673bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001674operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001675{
1676 return !(__x == __y);
1677}
1678
1679template <class _Iter1>
Marshall Clowae4f8312018-07-13 16:35:26 +00001680inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001681bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001682operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001683{
1684 return __y < __x;
1685}
1686
1687template <class _Iter1>
Marshall Clowae4f8312018-07-13 16:35:26 +00001688inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001689bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001690operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001691{
1692 return !(__x < __y);
1693}
1694
1695template <class _Iter1>
Marshall Clowae4f8312018-07-13 16:35:26 +00001696inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001697bool
Eric Fiselier873b8d32019-03-18 21:50:12 +00001698operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
Howard Hinnantf78e32c2012-10-02 19:45:42 +00001699{
1700 return !(__y < __x);
1701}
1702
Marshall Clow476d3f42016-07-18 13:19:00 +00001703#ifndef _LIBCPP_CXX03_LANG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001704template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001705inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001706auto
Eric Fiselier873b8d32019-03-18 21:50:12 +00001707operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001708-> decltype(__x.base() - __y.base())
1709{
Louis Dionneba400782020-10-02 15:02:52 -04001710#if _LIBCPP_DEBUG_LEVEL == 2
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001711 _LIBCPP_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y),
1712 "Attempted to subtract incompatible iterators");
1713#endif
1714 return __x.base() - __y.base();
1715}
1716#else
Howard Hinnantc51e1022010-05-11 19:42:16 +00001717template <class _Iter1, class _Iter2>
Marshall Clowae4f8312018-07-13 16:35:26 +00001718inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001719typename __wrap_iter<_Iter1>::difference_type
Eric Fiselier873b8d32019-03-18 21:50:12 +00001720operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001721{
Louis Dionneba400782020-10-02 15:02:52 -04001722#if _LIBCPP_DEBUG_LEVEL == 2
Howard Hinnante6ff0b62013-08-02 00:26:35 +00001723 _LIBCPP_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y),
Howard Hinnant27e0e772011-09-14 18:33:51 +00001724 "Attempted to subtract incompatible iterators");
Howard Hinnanta47c6d52011-09-16 17:29:17 +00001725#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001726 return __x.base() - __y.base();
1727}
Marshall Clowf8fec4e2016-07-08 16:54:47 +00001728#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001729
1730template <class _Iter>
Marshall Clowae4f8312018-07-13 16:35:26 +00001731inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_IF_NODEBUG
Howard Hinnantc51e1022010-05-11 19:42:16 +00001732__wrap_iter<_Iter>
1733operator+(typename __wrap_iter<_Iter>::difference_type __n,
Eric Fiselier873b8d32019-03-18 21:50:12 +00001734 __wrap_iter<_Iter> __x) _NOEXCEPT
Howard Hinnantc51e1022010-05-11 19:42:16 +00001735{
Howard Hinnant27e0e772011-09-14 18:33:51 +00001736 __x += __n;
1737 return __x;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001738}
1739
Marshall Clow8411ebf2013-12-02 03:24:33 +00001740template <class _Tp, size_t _Np>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001741_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Marshall Clow8411ebf2013-12-02 03:24:33 +00001742_Tp*
1743begin(_Tp (&__array)[_Np])
1744{
1745 return __array;
1746}
1747
1748template <class _Tp, size_t _Np>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001749_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Marshall Clow8411ebf2013-12-02 03:24:33 +00001750_Tp*
1751end(_Tp (&__array)[_Np])
1752{
1753 return __array + _Np;
1754}
1755
Eric Fiselierc6f17cc2016-09-25 03:34:28 +00001756#if !defined(_LIBCPP_CXX03_LANG)
Marshall Clow037fcb72013-12-11 19:32:32 +00001757
Howard Hinnantc834c512011-11-29 18:15:50 +00001758template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001759_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001760auto
Howard Hinnantc834c512011-11-29 18:15:50 +00001761begin(_Cp& __c) -> decltype(__c.begin())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001762{
1763 return __c.begin();
1764}
1765
Howard Hinnantc834c512011-11-29 18:15:50 +00001766template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001767_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001768auto
Howard Hinnantc834c512011-11-29 18:15:50 +00001769begin(const _Cp& __c) -> decltype(__c.begin())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001770{
1771 return __c.begin();
1772}
1773
Howard Hinnantc834c512011-11-29 18:15:50 +00001774template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001775_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001776auto
Howard Hinnantc834c512011-11-29 18:15:50 +00001777end(_Cp& __c) -> decltype(__c.end())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001778{
1779 return __c.end();
1780}
1781
Howard Hinnantc834c512011-11-29 18:15:50 +00001782template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001783_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Howard Hinnantc51e1022010-05-11 19:42:16 +00001784auto
Howard Hinnantc834c512011-11-29 18:15:50 +00001785end(const _Cp& __c) -> decltype(__c.end())
Howard Hinnantc51e1022010-05-11 19:42:16 +00001786{
1787 return __c.end();
1788}
1789
Marshall Clowb278e9c2013-08-30 01:17:07 +00001790#if _LIBCPP_STD_VER > 11
1791
Marshall Clow8411ebf2013-12-02 03:24:33 +00001792template <class _Tp, size_t _Np>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001793_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow8411ebf2013-12-02 03:24:33 +00001794reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np])
1795{
1796 return reverse_iterator<_Tp*>(__array + _Np);
1797}
1798
1799template <class _Tp, size_t _Np>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001800_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow8411ebf2013-12-02 03:24:33 +00001801reverse_iterator<_Tp*> rend(_Tp (&__array)[_Np])
1802{
1803 return reverse_iterator<_Tp*>(__array);
1804}
1805
1806template <class _Ep>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001807_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow8411ebf2013-12-02 03:24:33 +00001808reverse_iterator<const _Ep*> rbegin(initializer_list<_Ep> __il)
1809{
1810 return reverse_iterator<const _Ep*>(__il.end());
1811}
1812
1813template <class _Ep>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001814_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow8411ebf2013-12-02 03:24:33 +00001815reverse_iterator<const _Ep*> rend(initializer_list<_Ep> __il)
1816{
1817 return reverse_iterator<const _Ep*>(__il.begin());
1818}
1819
Marshall Clowb278e9c2013-08-30 01:17:07 +00001820template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001821_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Marshall Clow3862f532016-08-10 20:04:46 +00001822auto cbegin(const _Cp& __c) -> decltype(_VSTD::begin(__c))
Marshall Clowb278e9c2013-08-30 01:17:07 +00001823{
Marshall Clow3862f532016-08-10 20:04:46 +00001824 return _VSTD::begin(__c);
Marshall Clowb278e9c2013-08-30 01:17:07 +00001825}
1826
1827template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001828_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Marshall Clow3862f532016-08-10 20:04:46 +00001829auto cend(const _Cp& __c) -> decltype(_VSTD::end(__c))
Marshall Clowb278e9c2013-08-30 01:17:07 +00001830{
Marshall Clow3862f532016-08-10 20:04:46 +00001831 return _VSTD::end(__c);
Marshall Clowb278e9c2013-08-30 01:17:07 +00001832}
1833
1834template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001835_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowb278e9c2013-08-30 01:17:07 +00001836auto rbegin(_Cp& __c) -> decltype(__c.rbegin())
1837{
1838 return __c.rbegin();
1839}
1840
1841template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001842_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowb278e9c2013-08-30 01:17:07 +00001843auto rbegin(const _Cp& __c) -> decltype(__c.rbegin())
1844{
1845 return __c.rbegin();
1846}
1847
1848template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001849_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowb278e9c2013-08-30 01:17:07 +00001850auto rend(_Cp& __c) -> decltype(__c.rend())
1851{
1852 return __c.rend();
1853}
1854
1855template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001856_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clowb278e9c2013-08-30 01:17:07 +00001857auto rend(const _Cp& __c) -> decltype(__c.rend())
1858{
1859 return __c.rend();
1860}
1861
1862template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001863_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow3862f532016-08-10 20:04:46 +00001864auto crbegin(const _Cp& __c) -> decltype(_VSTD::rbegin(__c))
Marshall Clowb278e9c2013-08-30 01:17:07 +00001865{
Marshall Clow3862f532016-08-10 20:04:46 +00001866 return _VSTD::rbegin(__c);
Marshall Clowb278e9c2013-08-30 01:17:07 +00001867}
1868
1869template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001870_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
Marshall Clow3862f532016-08-10 20:04:46 +00001871auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c))
Marshall Clowb278e9c2013-08-30 01:17:07 +00001872{
Marshall Clow3862f532016-08-10 20:04:46 +00001873 return _VSTD::rend(__c);
Marshall Clowb278e9c2013-08-30 01:17:07 +00001874}
1875
1876#endif
1877
1878
Eric Fiselierc6f17cc2016-09-25 03:34:28 +00001879#else // defined(_LIBCPP_CXX03_LANG)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001880
Howard Hinnantc834c512011-11-29 18:15:50 +00001881template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001882_LIBCPP_INLINE_VISIBILITY
Howard Hinnantc834c512011-11-29 18:15:50 +00001883typename _Cp::iterator
1884begin(_Cp& __c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001885{
1886 return __c.begin();
1887}
1888
Howard Hinnantc834c512011-11-29 18:15:50 +00001889template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001890_LIBCPP_INLINE_VISIBILITY
Howard Hinnantc834c512011-11-29 18:15:50 +00001891typename _Cp::const_iterator
1892begin(const _Cp& __c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001893{
1894 return __c.begin();
1895}
1896
Howard Hinnantc834c512011-11-29 18:15:50 +00001897template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001898_LIBCPP_INLINE_VISIBILITY
Howard Hinnantc834c512011-11-29 18:15:50 +00001899typename _Cp::iterator
1900end(_Cp& __c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001901{
1902 return __c.end();
1903}
1904
Howard Hinnantc834c512011-11-29 18:15:50 +00001905template <class _Cp>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001906_LIBCPP_INLINE_VISIBILITY
Howard Hinnantc834c512011-11-29 18:15:50 +00001907typename _Cp::const_iterator
1908end(const _Cp& __c)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001909{
1910 return __c.end();
1911}
1912
Louis Dionne2b1ceaa2021-04-20 12:03:32 -04001913#endif // !defined(_LIBCPP_CXX03_LANG)
Howard Hinnantc51e1022010-05-11 19:42:16 +00001914
Marshall Clowef357272014-11-19 19:43:23 +00001915#if _LIBCPP_STD_VER > 14
Marshall Clow344c41d2017-11-16 17:55:41 +00001916
1917// #if _LIBCPP_STD_VER > 11
1918// template <>
1919// struct _LIBCPP_TEMPLATE_VIS plus<void>
1920// {
1921// template <class _T1, class _T2>
1922// _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
1923// auto operator()(_T1&& __t, _T2&& __u) const
1924// _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)))
1925// -> decltype (_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))
1926// { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); }
1927// typedef void is_transparent;
1928// };
1929// #endif
1930
Marshall Clowc4b4a342015-02-11 16:14:01 +00001931template <class _Cont>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001932_LIBCPP_INLINE_VISIBILITY
Marshall Clow344c41d2017-11-16 17:55:41 +00001933constexpr auto size(const _Cont& __c)
1934_NOEXCEPT_(noexcept(__c.size()))
1935-> decltype (__c.size())
1936{ return __c.size(); }
Marshall Clowef357272014-11-19 19:43:23 +00001937
Marshall Clowc4b4a342015-02-11 16:14:01 +00001938template <class _Tp, size_t _Sz>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001939_LIBCPP_INLINE_VISIBILITY
Eric Fiselier6003c772016-12-23 23:37:52 +00001940constexpr size_t size(const _Tp (&)[_Sz]) noexcept { return _Sz; }
Marshall Clowef357272014-11-19 19:43:23 +00001941
Marshall Clow3c5363e2019-02-27 02:58:56 +00001942#if _LIBCPP_STD_VER > 17
1943template <class _Cont>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001944_LIBCPP_INLINE_VISIBILITY
Marshall Clow3c5363e2019-02-27 02:58:56 +00001945constexpr auto ssize(const _Cont& __c)
1946_NOEXCEPT_(noexcept(static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size())))
1947-> common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>
1948{ return static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size()); }
1949
1950template <class _Tp, ptrdiff_t _Sz>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001951_LIBCPP_INLINE_VISIBILITY
Marshall Clow3c5363e2019-02-27 02:58:56 +00001952constexpr ptrdiff_t ssize(const _Tp (&)[_Sz]) noexcept { return _Sz; }
1953#endif
1954
Marshall Clowc4b4a342015-02-11 16:14:01 +00001955template <class _Cont>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001956_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
Marshall Clow344c41d2017-11-16 17:55:41 +00001957constexpr auto empty(const _Cont& __c)
1958_NOEXCEPT_(noexcept(__c.empty()))
1959-> decltype (__c.empty())
1960{ return __c.empty(); }
Marshall Clowef357272014-11-19 19:43:23 +00001961
Marshall Clowc4b4a342015-02-11 16:14:01 +00001962template <class _Tp, size_t _Sz>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001963_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
Eric Fiselier6003c772016-12-23 23:37:52 +00001964constexpr bool empty(const _Tp (&)[_Sz]) noexcept { return false; }
Marshall Clowef357272014-11-19 19:43:23 +00001965
1966template <class _Ep>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001967_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
Marshall Clowef357272014-11-19 19:43:23 +00001968constexpr bool empty(initializer_list<_Ep> __il) noexcept { return __il.size() == 0; }
1969
Marshall Clowc4b4a342015-02-11 16:14:01 +00001970template <class _Cont> constexpr
Marshall Clow0bd662d2019-02-27 03:25:43 +00001971_LIBCPP_INLINE_VISIBILITY
Marshall Clow344c41d2017-11-16 17:55:41 +00001972auto data(_Cont& __c)
1973_NOEXCEPT_(noexcept(__c.data()))
1974-> decltype (__c.data())
1975{ return __c.data(); }
Marshall Clowef357272014-11-19 19:43:23 +00001976
Marshall Clowc4b4a342015-02-11 16:14:01 +00001977template <class _Cont> constexpr
Marshall Clow0bd662d2019-02-27 03:25:43 +00001978_LIBCPP_INLINE_VISIBILITY
Marshall Clow344c41d2017-11-16 17:55:41 +00001979auto data(const _Cont& __c)
1980_NOEXCEPT_(noexcept(__c.data()))
Louis Dionne173f29e2019-05-29 16:01:36 +00001981-> decltype (__c.data())
Marshall Clow344c41d2017-11-16 17:55:41 +00001982{ return __c.data(); }
Marshall Clowef357272014-11-19 19:43:23 +00001983
Marshall Clowc4b4a342015-02-11 16:14:01 +00001984template <class _Tp, size_t _Sz>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001985_LIBCPP_INLINE_VISIBILITY
Marshall Clowc4b4a342015-02-11 16:14:01 +00001986constexpr _Tp* data(_Tp (&__array)[_Sz]) noexcept { return __array; }
Marshall Clowef357272014-11-19 19:43:23 +00001987
1988template <class _Ep>
Marshall Clow0bd662d2019-02-27 03:25:43 +00001989_LIBCPP_INLINE_VISIBILITY
Marshall Clowef357272014-11-19 19:43:23 +00001990constexpr const _Ep* data(initializer_list<_Ep> __il) noexcept { return __il.begin(); }
1991#endif
1992
Arthur O'Dwyerb6738bd2021-03-21 16:53:09 -04001993template <class _Container, class _Predicate>
1994typename _Container::size_type
1995__libcpp_erase_if_container(_Container& __c, _Predicate& __pred) {
1996 typename _Container::size_type __old_size = __c.size();
1997
1998 const typename _Container::iterator __last = __c.end();
1999 for (typename _Container::iterator __iter = __c.begin(); __iter != __last;) {
2000 if (__pred(*__iter))
2001 __iter = __c.erase(__iter);
2002 else
2003 ++__iter;
2004 }
2005
2006 return __old_size - __c.size();
2007}
Marshall Clowef357272014-11-19 19:43:23 +00002008
Howard Hinnantc51e1022010-05-11 19:42:16 +00002009_LIBCPP_END_NAMESPACE_STD
2010
Louis Dionne2b1ceaa2021-04-20 12:03:32 -04002011#endif // _LIBCPP_ITERATOR