1// -*- C++ -*- 2//===----------------------------------------------------------------------===// 3// 4// 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 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef _LIBCPP_ITERATOR 11#define _LIBCPP_ITERATOR 12 13/* 14 iterator synopsis 15 16#include <concepts> 17 18namespace std 19{ 20template<class> struct incrementable_traits; // since C++20 21template<class T> 22 using iter_difference_t = see below; // since C++20 23 24template<class> struct indirectly_readable_traits; // since C++20 25template<class T> 26 using iter_value_t = see below; // since C++20 27 28template<class Iterator> 29struct iterator_traits; 30 31template<class T> 32 requires is_object_v<T> // since C++20 33struct iterator_traits<T*>; 34 35template<dereferenceable T> 36 using iter_reference_t = decltype(*declval<T&>()); 37 38namespace 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 46// [iterator.concepts], iterator concepts 47// [iterator.concept.readable], concept indirectly_readable 48template<class In> 49 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 54 55// [iterator.concept.writable], concept indirectly_writable 56template<class Out, class T> 57 concept indirectly_writable = see below; // since C++20 58 59// [iterator.concept.winc], concept weakly_incrementable 60template<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 67// [iterator.concept.iterator], concept input_or_output_iterator 68 template<class I> 69 concept input_or_output_iterator = see below; // since C++20 70 71// [iterator.concept.sentinel], concept sentinel_for 72template<class S, class I> 73 concept sentinel_for = see below; // since C++20 74 75// [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 82// [iterator.concept.input], concept input_iterator 83template<class I> 84 concept input_iterator = see below; // since C++20 85 86// [iterator.concept.output], concept output_iterator 87template<class I, class T> 88 concept output_iterator = see below; // since C++20 89 90// [iterator.concept.forward], concept forward_iterator 91template<class I> 92 concept forward_iterator = see below; // since C++20 93 94// [iterator.concept.bidir], concept bidirectional_iterator 95template<class I> 96 concept bidirectional_iterator = see below; // since C++20 97 98// [iterator.concept.random.access], concept random_access_iterator 99template<class I> 100 concept random_access_iterator = see below; // since C++20 101 102// [indirectcallable] 103// [indirectcallable.indirectinvocable] 104template<class F, class I> 105 concept indirectly_unary_invocable = see below; // since C++20 106 107template<class F, class I> 108 concept indirectly_regular_unary_invocable = see below; // since C++20 109 110template<class F, class I> 111 concept indirect_unary_predicate = see below; // since C++20 112 113template<class F, class I1, class I2> 114 concept indirect_binary_predicate = see below; // since C++20 115 116template<class F, class I1, class I2 = I1> 117 concept indirect_equivalence_relation = see below; // since C++20 118 119template<class F, class I1, class I2 = I1> 120 concept indirect_strict_weak_order = see below; // since C++20 121 122template<class F, class... Is> 123 using indirect_result_t = see below; // since C++20 124 125// [projected], projected 126template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj> 127 struct projected; // since C++20 128 129template<weakly_incrementable I, indirectly_regular_unary_invocable<I> Proj> 130 struct incrementable_traits<projected<I, Proj>>; // since C++20 131 132// [alg.req.ind.move], concept indirectly_movable 133template<class In, class Out> 134 concept indirectly_movable = see below; // since C++20 135 136template<class In, class Out> 137 concept indirectly_movable_storable = see below; // since C++20 138 139// [alg.req.ind.copy], concept indirectly_copyable 140template<class In, class Out> 141 concept indirectly_copyable = see below; // since C++20 142 143template<class In, class Out> 144 concept indirectly_copyable_storable = see below; // since C++20 145 146// [alg.req.ind.swap], concept indirectly_swappable 147template<class I1, class I2 = I1> 148 concept indirectly_swappable = see below; // since C++20 149 150template<class I1, class I2, class R, class P1 = identity, 151 class P2 = identity> 152 concept indirectly_comparable = 153 indirect_binary_predicate<R, projected<I1, P1>, projected<I2, P2>>; // since C++20 154 155// [alg.req.permutable], concept permutable 156template<class I> 157 concept permutable = see below; // since C++20 158 159 // [alg.req.mergeable], concept mergeable 160template<class I1, class I2, class Out, 161 class R = ranges::less, class P1 = identity, class P2 = identity> 162 concept mergeable = see below; // since C++20 163 164// [alg.req.sortable], concept sortable 165template<class I, class R = ranges::less, class P = identity> 166 concept sortable = see below; // since C++20 167 168template<input_or_output_iterator I, sentinel_for<I> S> 169 requires (!same_as<I, S> && copyable<I>) 170class common_iterator; // since C++20 171 172template<class Category, class T, class Distance = ptrdiff_t, 173 class Pointer = T*, class Reference = T&> 174struct iterator // deprecated in C++17 175{ 176 typedef T value_type; 177 typedef Distance difference_type; 178 typedef Pointer pointer; 179 typedef Reference reference; 180 typedef Category iterator_category; 181}; 182 183struct input_iterator_tag {}; 184struct output_iterator_tag {}; 185struct forward_iterator_tag : public input_iterator_tag {}; 186struct bidirectional_iterator_tag : public forward_iterator_tag {}; 187struct random_access_iterator_tag : public bidirectional_iterator_tag {}; 188struct contiguous_iterator_tag : public random_access_iterator_tag {}; 189 190// 27.4.3, iterator operations 191template <class InputIterator, class Distance> // constexpr in C++17 192 constexpr void advance(InputIterator& i, Distance n); 193 194template <class InputIterator> // constexpr in C++17 195 constexpr typename iterator_traits<InputIterator>::difference_type 196 distance(InputIterator first, InputIterator last); 197 198template <class InputIterator> // constexpr in C++17 199 constexpr InputIterator next(InputIterator x, 200typename iterator_traits<InputIterator>::difference_type n = 1); 201 202template <class BidirectionalIterator> // constexpr in C++17 203 constexpr BidirectionalIterator prev(BidirectionalIterator x, 204 typename iterator_traits<BidirectionalIterator>::difference_type n = 1); 205 206// [range.iter.ops], range iterator operations 207namespace ranges { 208 // [range.iter.op.advance], ranges::advance 209 template<input_or_output_iterator I> 210 constexpr void advance(I& i, iter_difference_t<I> n); // since C++20 211 template<input_or_output_iterator I, sentinel_for<I> S> 212 constexpr void advance(I& i, S bound); // since C++20 213 template<input_or_output_iterator I, sentinel_for<I> S> 214 constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound); // since C++20 215} 216 217template <class Iterator> 218class reverse_iterator 219 : public iterator<typename iterator_traits<Iterator>::iterator_category, // until C++17 220 typename iterator_traits<Iterator>::value_type, 221 typename iterator_traits<Iterator>::difference_type, 222 typename iterator_traits<Iterator>::pointer, 223 typename iterator_traits<Iterator>::reference> 224{ 225protected: 226 Iterator current; 227public: 228 typedef Iterator iterator_type; 229 typedef typename iterator_traits<Iterator>::difference_type difference_type; 230 typedef typename iterator_traits<Iterator>::reference reference; 231 typedef typename iterator_traits<Iterator>::pointer pointer; 232 233 constexpr reverse_iterator(); 234 constexpr explicit reverse_iterator(Iterator x); 235 template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u); 236 template <class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u); 237 constexpr Iterator base() const; 238 constexpr reference operator*() const; 239 constexpr pointer operator->() const; 240 constexpr reverse_iterator& operator++(); 241 constexpr reverse_iterator operator++(int); 242 constexpr reverse_iterator& operator--(); 243 constexpr reverse_iterator operator--(int); 244 constexpr reverse_iterator operator+ (difference_type n) const; 245 constexpr reverse_iterator& operator+=(difference_type n); 246 constexpr reverse_iterator operator- (difference_type n) const; 247 constexpr reverse_iterator& operator-=(difference_type n); 248 constexpr reference operator[](difference_type n) const; 249}; 250 251template <class Iterator1, class Iterator2> 252constexpr bool // constexpr in C++17 253operator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 254 255template <class Iterator1, class Iterator2> 256constexpr bool // constexpr in C++17 257operator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 258 259template <class Iterator1, class Iterator2> 260constexpr bool // constexpr in C++17 261operator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 262 263template <class Iterator1, class Iterator2> 264constexpr bool // constexpr in C++17 265operator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 266 267template <class Iterator1, class Iterator2> 268constexpr bool // constexpr in C++17 269operator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 270 271template <class Iterator1, class Iterator2> 272constexpr bool // constexpr in C++17 273operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 274 275template <class Iterator1, class Iterator2> 276constexpr auto 277operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y) 278-> decltype(__y.base() - __x.base()); // constexpr in C++17 279 280template <class Iterator> 281constexpr reverse_iterator<Iterator> 282operator+(typename reverse_iterator<Iterator>::difference_type n, 283 const reverse_iterator<Iterator>& x); // constexpr in C++17 284 285template <class Iterator> 286constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17 287 288template <class Container> 289class back_insert_iterator 290 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 291{ 292protected: 293 Container* container; 294public: 295 typedef Container container_type; 296 typedef void value_type; 297 typedef void difference_type; // until C++20 298 typedef ptrdiff_t difference_type; // since C++20 299 typedef void reference; 300 typedef void pointer; 301 302 explicit back_insert_iterator(Container& x); // constexpr in C++20 303 back_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 304 back_insert_iterator& operator*(); // constexpr in C++20 305 back_insert_iterator& operator++(); // constexpr in C++20 306 back_insert_iterator operator++(int); // constexpr in C++20 307}; 308 309template <class Container> back_insert_iterator<Container> back_inserter(Container& x); // constexpr in C++20 310 311template <class Container> 312class front_insert_iterator 313 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 314{ 315protected: 316 Container* container; 317public: 318 typedef Container container_type; 319 typedef void value_type; 320 typedef void difference_type; // until C++20 321 typedef ptrdiff_t difference_type; // since C++20 322 typedef void reference; 323 typedef void pointer; 324 325 explicit front_insert_iterator(Container& x); // constexpr in C++20 326 front_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 327 front_insert_iterator& operator*(); // constexpr in C++20 328 front_insert_iterator& operator++(); // constexpr in C++20 329 front_insert_iterator operator++(int); // constexpr in C++20 330}; 331 332template <class Container> front_insert_iterator<Container> front_inserter(Container& x); // constexpr in C++20 333 334template <class Container> 335class insert_iterator 336 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 337{ 338protected: 339 Container* container; 340 typename Container::iterator iter; 341public: 342 typedef Container container_type; 343 typedef void value_type; 344 typedef void difference_type; // until C++20 345 typedef ptrdiff_t difference_type; // since C++20 346 typedef void reference; 347 typedef void pointer; 348 349 insert_iterator(Container& x, typename Container::iterator i); // constexpr in C++20 350 insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 351 insert_iterator& operator*(); // constexpr in C++20 352 insert_iterator& operator++(); // constexpr in C++20 353 insert_iterator& operator++(int); // constexpr in C++20 354}; 355 356template <class Container> 357insert_iterator<Container> inserter(Container& x, typename Container::iterator i); // until C++20 358template <class Container> 359constexpr insert_iterator<Container> inserter(Container& x, ranges::iterator_t<Container> i); // since C++20 360 361template <class Iterator> 362class move_iterator { 363public: 364 typedef Iterator iterator_type; 365 typedef typename iterator_traits<Iterator>::difference_type difference_type; 366 typedef Iterator pointer; 367 typedef typename iterator_traits<Iterator>::value_type value_type; 368 typedef typename iterator_traits<Iterator>::iterator_category iterator_category; 369 typedef value_type&& reference; 370 371 constexpr move_iterator(); // all the constexprs are in C++17 372 constexpr explicit move_iterator(Iterator i); 373 template <class U> 374 constexpr move_iterator(const move_iterator<U>& u); 375 template <class U> 376 constexpr move_iterator& operator=(const move_iterator<U>& u); 377 constexpr iterator_type base() const; 378 constexpr reference operator*() const; 379 constexpr pointer operator->() const; 380 constexpr move_iterator& operator++(); 381 constexpr move_iterator operator++(int); 382 constexpr move_iterator& operator--(); 383 constexpr move_iterator operator--(int); 384 constexpr move_iterator operator+(difference_type n) const; 385 constexpr move_iterator& operator+=(difference_type n); 386 constexpr move_iterator operator-(difference_type n) const; 387 constexpr move_iterator& operator-=(difference_type n); 388 constexpr unspecified operator[](difference_type n) const; 389private: 390 Iterator current; // exposition only 391}; 392 393template <class Iterator1, class Iterator2> 394constexpr bool // constexpr in C++17 395operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 396 397template <class Iterator1, class Iterator2> 398constexpr bool // constexpr in C++17 399operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 400 401template <class Iterator1, class Iterator2> 402constexpr bool // constexpr in C++17 403operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 404 405template <class Iterator1, class Iterator2> 406constexpr bool // constexpr in C++17 407operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 408 409template <class Iterator1, class Iterator2> 410constexpr bool // constexpr in C++17 411operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 412 413template <class Iterator1, class Iterator2> 414constexpr bool // constexpr in C++17 415operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 416 417template <class Iterator1, class Iterator2> 418constexpr auto // constexpr in C++17 419operator-(const move_iterator<Iterator1>& x, 420 const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base()); 421 422template <class Iterator> 423constexpr move_iterator<Iterator> operator+( // constexpr in C++17 424 typename move_iterator<Iterator>::difference_type n, 425 const move_iterator<Iterator>& x); 426 427template <class Iterator> // constexpr in C++17 428constexpr move_iterator<Iterator> make_move_iterator(const Iterator& i); 429 430// [default.sentinel], default sentinel 431struct default_sentinel_t; 432inline constexpr default_sentinel_t default_sentinel{}; 433 434// [iterators.counted], counted iterators 435template<input_or_output_iterator I> class counted_iterator; 436 437template<input_iterator I> 438 requires see below 439 struct iterator_traits<counted_iterator<I>>; 440 441// [unreachable.sentinel], unreachable sentinel 442struct unreachable_sentinel_t; 443inline constexpr unreachable_sentinel_t unreachable_sentinel{}; 444 445template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> 446class istream_iterator 447 : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17 448{ 449public: 450 typedef input_iterator_tag iterator_category; 451 typedef T value_type; 452 typedef Distance difference_type; 453 typedef const T* pointer; 454 typedef const T& reference; 455 456 typedef charT char_type; 457 typedef traits traits_type; 458 typedef basic_istream<charT, traits> istream_type; 459 460 istream_iterator(); // constexpr since C++11 461 constexpr istream_iterator(default_sentinel_t); // since C++20 462 istream_iterator(istream_type& s); 463 istream_iterator(const istream_iterator& x); 464 ~istream_iterator(); 465 466 const T& operator*() const; 467 const T* operator->() const; 468 istream_iterator& operator++(); 469 istream_iterator operator++(int); 470 friend bool operator==(const istream_iterator& i, default_sentinel_t); // since C++20 471}; 472 473template <class T, class charT, class traits, class Distance> 474bool operator==(const istream_iterator<T,charT,traits,Distance>& x, 475 const istream_iterator<T,charT,traits,Distance>& y); 476template <class T, class charT, class traits, class Distance> 477bool operator!=(const istream_iterator<T,charT,traits,Distance>& x, 478 const istream_iterator<T,charT,traits,Distance>& y); // until C++20 479 480template <class T, class charT = char, class traits = char_traits<charT> > 481class ostream_iterator 482 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 483{ 484public: 485 typedef output_iterator_tag iterator_category; 486 typedef void value_type; 487 typedef void difference_type; // until C++20 488 typedef ptrdiff_t difference_type; // since C++20 489 typedef void pointer; 490 typedef void reference; 491 492 typedef charT char_type; 493 typedef traits traits_type; 494 typedef basic_ostream<charT,traits> ostream_type; 495 496 ostream_iterator(ostream_type& s); 497 ostream_iterator(ostream_type& s, const charT* delimiter); 498 ostream_iterator(const ostream_iterator& x); 499 ~ostream_iterator(); 500 ostream_iterator& operator=(const T& value); 501 502 ostream_iterator& operator*(); 503 ostream_iterator& operator++(); 504 ostream_iterator& operator++(int); 505}; 506 507template<class charT, class traits = char_traits<charT> > 508class istreambuf_iterator 509 : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17 510{ 511public: 512 typedef input_iterator_tag iterator_category; 513 typedef charT value_type; 514 typedef traits::off_type difference_type; 515 typedef unspecified pointer; 516 typedef charT reference; 517 518 typedef charT char_type; 519 typedef traits traits_type; 520 typedef traits::int_type int_type; 521 typedef basic_streambuf<charT, traits> streambuf_type; 522 typedef basic_istream<charT, traits> istream_type; 523 524 istreambuf_iterator() noexcept; // constexpr since C++11 525 constexpr istreambuf_iterator(default_sentinel_t) noexcept; // since C++20 526 istreambuf_iterator(istream_type& s) noexcept; 527 istreambuf_iterator(streambuf_type* s) noexcept; 528 istreambuf_iterator(a-private-type) noexcept; 529 530 charT operator*() const; 531 pointer operator->() const; 532 istreambuf_iterator& operator++(); 533 a-private-type operator++(int); 534 535 bool equal(const istreambuf_iterator& b) const; 536 friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s); // since C++20 537}; 538 539template <class charT, class traits> 540bool operator==(const istreambuf_iterator<charT,traits>& a, 541 const istreambuf_iterator<charT,traits>& b); 542template <class charT, class traits> 543bool operator!=(const istreambuf_iterator<charT,traits>& a, 544 const istreambuf_iterator<charT,traits>& b); // until C++20 545 546template <class charT, class traits = char_traits<charT> > 547class ostreambuf_iterator 548 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 549{ 550public: 551 typedef output_iterator_tag iterator_category; 552 typedef void value_type; 553 typedef void difference_type; // until C++20 554 typedef ptrdiff_t difference_type; // since C++20 555 typedef void pointer; 556 typedef void reference; 557 558 typedef charT char_type; 559 typedef traits traits_type; 560 typedef basic_streambuf<charT, traits> streambuf_type; 561 typedef basic_ostream<charT, traits> ostream_type; 562 563 ostreambuf_iterator(ostream_type& s) noexcept; 564 ostreambuf_iterator(streambuf_type* s) noexcept; 565 ostreambuf_iterator& operator=(charT c); 566 ostreambuf_iterator& operator*(); 567 ostreambuf_iterator& operator++(); 568 ostreambuf_iterator& operator++(int); 569 bool failed() const noexcept; 570}; 571 572template <class C> constexpr auto begin(C& c) -> decltype(c.begin()); 573template <class C> constexpr auto begin(const C& c) -> decltype(c.begin()); 574template <class C> constexpr auto end(C& c) -> decltype(c.end()); 575template <class C> constexpr auto end(const C& c) -> decltype(c.end()); 576template <class T, size_t N> constexpr T* begin(T (&array)[N]); 577template <class T, size_t N> constexpr T* end(T (&array)[N]); 578 579template <class C> auto constexpr cbegin(const C& c) -> decltype(std::begin(c)); // C++14 580template <class C> auto constexpr cend(const C& c) -> decltype(std::end(c)); // C++14 581template <class C> auto constexpr rbegin(C& c) -> decltype(c.rbegin()); // C++14 582template <class C> auto constexpr rbegin(const C& c) -> decltype(c.rbegin()); // C++14 583template <class C> auto constexpr rend(C& c) -> decltype(c.rend()); // C++14 584template <class C> constexpr auto rend(const C& c) -> decltype(c.rend()); // C++14 585template <class E> reverse_iterator<const E*> constexpr rbegin(initializer_list<E> il); // C++14 586template <class E> reverse_iterator<const E*> constexpr rend(initializer_list<E> il); // C++14 587template <class T, size_t N> reverse_iterator<T*> constexpr rbegin(T (&array)[N]); // C++14 588template <class T, size_t N> reverse_iterator<T*> constexpr rend(T (&array)[N]); // C++14 589template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); // C++14 590template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c)); // C++14 591 592// 24.8, container access: 593template <class C> constexpr auto size(const C& c) -> decltype(c.size()); // C++17 594template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17 595 596template <class C> constexpr auto ssize(const C& c) 597 -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>; // C++20 598template <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20 599 600template <class C> constexpr auto empty(const C& c) -> decltype(c.empty()); // C++17 601template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept; // C++17 602template <class E> constexpr bool empty(initializer_list<E> il) noexcept; // C++17 603template <class C> constexpr auto data(C& c) -> decltype(c.data()); // C++17 604template <class C> constexpr auto data(const C& c) -> decltype(c.data()); // C++17 605template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept; // C++17 606template <class E> constexpr const E* data(initializer_list<E> il) noexcept; // C++17 607 608} // std 609 610*/ 611 612#include <__config> 613#include <__debug> 614#include <__iterator/access.h> 615#include <__iterator/advance.h> 616#include <__iterator/back_insert_iterator.h> 617#include <__iterator/common_iterator.h> 618#include <__iterator/concepts.h> 619#include <__iterator/counted_iterator.h> 620#include <__iterator/data.h> 621#include <__iterator/default_sentinel.h> 622#include <__iterator/distance.h> 623#include <__iterator/empty.h> 624#include <__iterator/erase_if_container.h> 625#include <__iterator/front_insert_iterator.h> 626#include <__iterator/incrementable_traits.h> 627#include <__iterator/indirectly_comparable.h> 628#include <__iterator/insert_iterator.h> 629#include <__iterator/istream_iterator.h> 630#include <__iterator/istreambuf_iterator.h> 631#include <__iterator/iter_move.h> 632#include <__iterator/iter_swap.h> 633#include <__iterator/iterator.h> 634#include <__iterator/iterator_traits.h> 635#include <__iterator/mergeable.h> 636#include <__iterator/move_iterator.h> 637#include <__iterator/next.h> 638#include <__iterator/ostream_iterator.h> 639#include <__iterator/ostreambuf_iterator.h> 640#include <__iterator/permutable.h> 641#include <__iterator/prev.h> 642#include <__iterator/projected.h> 643#include <__iterator/readable_traits.h> 644#include <__iterator/reverse_access.h> 645#include <__iterator/reverse_iterator.h> 646#include <__iterator/size.h> 647#include <__iterator/sortable.h> 648#include <__iterator/unreachable_sentinel.h> 649#include <__iterator/wrap_iter.h> 650#include <__memory/addressof.h> 651#include <__memory/pointer_traits.h> 652#include <compare> 653#include <concepts> // Mandated by the Standard. 654#include <cstddef> 655#include <initializer_list> 656#include <type_traits> 657#include <version> 658 659#include <utility> // TODO: Remove this 660 661// TODO: remove these headers 662#include <__functional/binary_function.h> 663#include <__functional/invoke.h> 664#include <__functional/operations.h> 665#include <__functional/reference_wrapper.h> 666#include <__functional/unary_function.h> 667#include <__functional/weak_result_type.h> 668#include <__memory/allocator_arg_t.h> 669#include <__memory/uses_allocator.h> 670#include <exception> 671#include <new> 672#include <typeinfo> 673 674#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 675# pragma GCC system_header 676#endif 677 678#endif // _LIBCPP_ITERATOR 679