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 using iterator_type = Iterator; 229 using iterator_concept = see below; // since C++20 230 using iterator_category = typename iterator_traits<Iterator>::iterator_category; // since C++17, until C++20 231 using iterator_category = see below; // since C++20 232 using value_type = typename iterator_traits<Iterator>::value_type; // since C++17, until C++20 233 using value_type = iter_value_t<Iterator>; // since C++20 234 using difference_type = typename iterator_traits<Iterator>::difference_type; // until C++20 235 using difference_type = iter_difference_t<Iterator>; // since C++20 236 using pointer = typename iterator_traits<Iterator>::pointer; 237 using reference = typename iterator_traits<Iterator>::reference; // until C++20 238 using reference = iter_reference_t<Iterator>; // since C++20 239 240 constexpr reverse_iterator(); 241 constexpr explicit reverse_iterator(Iterator x); 242 template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u); 243 template <class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u); 244 constexpr Iterator base() const; 245 constexpr reference operator*() const; 246 constexpr pointer operator->() const; // until C++20 247 constexpr pointer operator->() const requires see below; // since C++20 248 constexpr reverse_iterator& operator++(); 249 constexpr reverse_iterator operator++(int); 250 constexpr reverse_iterator& operator--(); 251 constexpr reverse_iterator operator--(int); 252 constexpr reverse_iterator operator+ (difference_type n) const; 253 constexpr reverse_iterator& operator+=(difference_type n); 254 constexpr reverse_iterator operator- (difference_type n) const; 255 constexpr reverse_iterator& operator-=(difference_type n); 256 constexpr unspecified operator[](difference_type n) const; 257 258 friend constexpr iter_rvalue_reference_t<Iterator> 259 iter_move(const reverse_iterator& i) noexcept(see below); 260 template<indirectly_swappable<Iterator> Iterator2> 261 friend constexpr void 262 iter_swap(const reverse_iterator& x, 263 const reverse_iterator<Iterator2>& y) noexcept(see below); 264}; 265 266template <class Iterator1, class Iterator2> 267constexpr bool // constexpr in C++17 268operator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 269 270template <class Iterator1, class Iterator2> 271constexpr bool // constexpr in C++17 272operator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 273 274template <class Iterator1, class Iterator2> 275constexpr bool // constexpr in C++17 276operator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 277 278template <class Iterator1, class Iterator2> 279constexpr bool // constexpr in C++17 280operator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 281 282template <class Iterator1, class Iterator2> 283constexpr bool // constexpr in C++17 284operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 285 286template <class Iterator1, class Iterator2> 287constexpr bool // constexpr in C++17 288operator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 289 290template<class Iterator1, three_way_comparable_with<Iterator1> Iterator2> 291 constexpr compare_three_way_result_t<Iterator1, Iterator2> 292 operator<=>(const reverse_iterator<Iterator1>& x, 293 const reverse_iterator<Iterator2>& y); 294 295template <class Iterator1, class Iterator2> 296constexpr auto 297operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y) 298-> decltype(__y.base() - __x.base()); // constexpr in C++17 299 300template <class Iterator> 301constexpr reverse_iterator<Iterator> 302operator+(typename reverse_iterator<Iterator>::difference_type n, 303 const reverse_iterator<Iterator>& x); // constexpr in C++17 304 305template <class Iterator> 306constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17 307 308template<class Iterator1, class Iterator2> 309 requires (!sized_sentinel_for<Iterator1, Iterator2>) 310 inline constexpr bool disable_sized_sentinel_for<reverse_iterator<Iterator1>, 311 reverse_iterator<Iterator2>> = true; 312 313template <class Container> 314class back_insert_iterator 315 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 316{ 317protected: 318 Container* container; 319public: 320 typedef Container container_type; 321 typedef void value_type; 322 typedef void difference_type; // until C++20 323 typedef ptrdiff_t difference_type; // since C++20 324 typedef void reference; 325 typedef void pointer; 326 327 explicit back_insert_iterator(Container& x); // constexpr in C++20 328 back_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 329 back_insert_iterator& operator*(); // constexpr in C++20 330 back_insert_iterator& operator++(); // constexpr in C++20 331 back_insert_iterator operator++(int); // constexpr in C++20 332}; 333 334template <class Container> back_insert_iterator<Container> back_inserter(Container& x); // constexpr in C++20 335 336template <class Container> 337class front_insert_iterator 338 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 339{ 340protected: 341 Container* container; 342public: 343 typedef Container container_type; 344 typedef void value_type; 345 typedef void difference_type; // until C++20 346 typedef ptrdiff_t difference_type; // since C++20 347 typedef void reference; 348 typedef void pointer; 349 350 explicit front_insert_iterator(Container& x); // constexpr in C++20 351 front_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 352 front_insert_iterator& operator*(); // constexpr in C++20 353 front_insert_iterator& operator++(); // constexpr in C++20 354 front_insert_iterator operator++(int); // constexpr in C++20 355}; 356 357template <class Container> front_insert_iterator<Container> front_inserter(Container& x); // constexpr in C++20 358 359template <class Container> 360class insert_iterator 361 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 362{ 363protected: 364 Container* container; 365 typename Container::iterator iter; 366public: 367 typedef Container container_type; 368 typedef void value_type; 369 typedef void difference_type; // until C++20 370 typedef ptrdiff_t difference_type; // since C++20 371 typedef void reference; 372 typedef void pointer; 373 374 insert_iterator(Container& x, typename Container::iterator i); // constexpr in C++20 375 insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 376 insert_iterator& operator*(); // constexpr in C++20 377 insert_iterator& operator++(); // constexpr in C++20 378 insert_iterator& operator++(int); // constexpr in C++20 379}; 380 381template <class Container> 382insert_iterator<Container> inserter(Container& x, typename Container::iterator i); // until C++20 383template <class Container> 384constexpr insert_iterator<Container> inserter(Container& x, ranges::iterator_t<Container> i); // since C++20 385 386template <class Iterator> 387class move_iterator { 388public: 389 using iterator_type = Iterator; 390 using iterator_concept = input_iterator_tag; // From C++20 391 using iterator_category = see below; // not always present starting from C++20 392 using value_type = iter_value_t<Iterator>; // Until C++20, iterator_traits<Iterator>::value_type 393 using difference_type = iter_difference_t<Iterator>; // Until C++20, iterator_traits<Iterator>::difference_type; 394 using pointer = Iterator; 395 using reference = iter_rvalue_reference_t<Iterator>; // Until C++20, value_type&& 396 397 constexpr move_iterator(); // all the constexprs are in C++17 398 constexpr explicit move_iterator(Iterator i); 399 template <class U> 400 constexpr move_iterator(const move_iterator<U>& u); 401 template <class U> 402 constexpr move_iterator& operator=(const move_iterator<U>& u); 403 404 constexpr iterator_type base() const; // Until C++20 405 constexpr const Iterator& base() const & noexcept; // From C++20 406 constexpr Iterator base() &&; // From C++20 407 408 constexpr reference operator*() const; 409 constexpr pointer operator->() const; // Deprecated in C++20 410 constexpr move_iterator& operator++(); 411 constexpr auto operator++(int); // Return type was move_iterator until C++20 412 constexpr move_iterator& operator--(); 413 constexpr move_iterator operator--(int); 414 constexpr move_iterator operator+(difference_type n) const; 415 constexpr move_iterator& operator+=(difference_type n); 416 constexpr move_iterator operator-(difference_type n) const; 417 constexpr move_iterator& operator-=(difference_type n); 418 constexpr reference operator[](difference_type n) const; // Return type unspecified until C++20 419 420 template<sentinel_for<Iterator> S> 421 friend constexpr bool 422 operator==(const move_iterator& x, const move_sentinel<S>& y); // Since C++20 423 template<sized_sentinel_for<Iterator> S> 424 friend constexpr iter_difference_t<Iterator> 425 operator-(const move_sentinel<S>& x, const move_iterator& y); // Since C++20 426 template<sized_sentinel_for<Iterator> S> 427 friend constexpr iter_difference_t<Iterator> 428 operator-(const move_iterator& x, const move_sentinel<S>& y); // Since C++20 429 friend constexpr iter_rvalue_reference_t<Iterator> 430 iter_move(const move_iterator& i) 431 noexcept(noexcept(ranges::iter_move(i.current))); // Since C++20 432 template<indirectly_swappable<Iterator> Iterator2> 433 friend constexpr void 434 iter_swap(const move_iterator& x, const move_iterator<Iterator2>& y) 435 noexcept(noexcept(ranges::iter_swap(x.current, y.current))); // Since C++20 436 437private: 438 Iterator current; // exposition only 439}; 440 441template <class Iterator1, class Iterator2> 442constexpr bool // constexpr in C++17 443operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 444 445template <class Iterator1, class Iterator2> 446constexpr bool // constexpr in C++17 447operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 448 449template <class Iterator1, class Iterator2> 450constexpr bool // constexpr in C++17 451operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 452 453template <class Iterator1, class Iterator2> 454constexpr bool // constexpr in C++17 455operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 456 457template <class Iterator1, class Iterator2> 458constexpr bool // constexpr in C++17 459operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 460 461template <class Iterator1, class Iterator2> 462constexpr bool // constexpr in C++17 463operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 464 465template <class Iterator1, class Iterator2> 466constexpr auto // constexpr in C++17 467operator-(const move_iterator<Iterator1>& x, 468 const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base()); 469 470template <class Iterator> 471constexpr move_iterator<Iterator> operator+( // constexpr in C++17 472 typename move_iterator<Iterator>::difference_type n, 473 const move_iterator<Iterator>& x); 474 475template <class Iterator> // constexpr in C++17 476constexpr move_iterator<Iterator> make_move_iterator(const Iterator& i); 477 478template<semiregular S> 479class move_sentinel { 480public: 481 constexpr move_sentinel(); 482 constexpr explicit move_sentinel(S s); 483 template<class S2> 484 requires convertible_to<const S2&, S> 485 constexpr move_sentinel(const move_sentinel<S2>& s); 486 template<class S2> 487 requires assignable_from<S&, const S2&> 488 constexpr move_sentinel& operator=(const move_sentinel<S2>& s); 489 490 constexpr S base() const; 491private: 492 S last; // exposition only 493}; 494 495// [default.sentinel], default sentinel 496struct default_sentinel_t; 497inline constexpr default_sentinel_t default_sentinel{}; 498 499// [iterators.counted], counted iterators 500template<input_or_output_iterator I> class counted_iterator; 501 502template<input_iterator I> 503 requires see below 504 struct iterator_traits<counted_iterator<I>>; 505 506// [unreachable.sentinel], unreachable sentinel 507struct unreachable_sentinel_t; 508inline constexpr unreachable_sentinel_t unreachable_sentinel{}; 509 510template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> 511class istream_iterator 512 : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17 513{ 514public: 515 typedef input_iterator_tag iterator_category; 516 typedef T value_type; 517 typedef Distance difference_type; 518 typedef const T* pointer; 519 typedef const T& reference; 520 521 typedef charT char_type; 522 typedef traits traits_type; 523 typedef basic_istream<charT, traits> istream_type; 524 525 istream_iterator(); // constexpr since C++11 526 constexpr istream_iterator(default_sentinel_t); // since C++20 527 istream_iterator(istream_type& s); 528 istream_iterator(const istream_iterator& x); 529 ~istream_iterator(); 530 531 const T& operator*() const; 532 const T* operator->() const; 533 istream_iterator& operator++(); 534 istream_iterator operator++(int); 535 friend bool operator==(const istream_iterator& i, default_sentinel_t); // since C++20 536}; 537 538template <class T, class charT, class traits, class Distance> 539bool operator==(const istream_iterator<T,charT,traits,Distance>& x, 540 const istream_iterator<T,charT,traits,Distance>& y); 541template <class T, class charT, class traits, class Distance> 542bool operator!=(const istream_iterator<T,charT,traits,Distance>& x, 543 const istream_iterator<T,charT,traits,Distance>& y); // until C++20 544 545template <class T, class charT = char, class traits = char_traits<charT> > 546class ostream_iterator 547 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 548{ 549public: 550 typedef output_iterator_tag iterator_category; 551 typedef void value_type; 552 typedef void difference_type; // until C++20 553 typedef ptrdiff_t difference_type; // since C++20 554 typedef void pointer; 555 typedef void reference; 556 557 typedef charT char_type; 558 typedef traits traits_type; 559 typedef basic_ostream<charT,traits> ostream_type; 560 561 ostream_iterator(ostream_type& s); 562 ostream_iterator(ostream_type& s, const charT* delimiter); 563 ostream_iterator(const ostream_iterator& x); 564 ~ostream_iterator(); 565 ostream_iterator& operator=(const T& value); 566 567 ostream_iterator& operator*(); 568 ostream_iterator& operator++(); 569 ostream_iterator& operator++(int); 570}; 571 572template<class charT, class traits = char_traits<charT> > 573class istreambuf_iterator 574 : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17 575{ 576public: 577 typedef input_iterator_tag iterator_category; 578 typedef charT value_type; 579 typedef traits::off_type difference_type; 580 typedef unspecified pointer; 581 typedef charT reference; 582 583 typedef charT char_type; 584 typedef traits traits_type; 585 typedef traits::int_type int_type; 586 typedef basic_streambuf<charT, traits> streambuf_type; 587 typedef basic_istream<charT, traits> istream_type; 588 589 istreambuf_iterator() noexcept; // constexpr since C++11 590 constexpr istreambuf_iterator(default_sentinel_t) noexcept; // since C++20 591 istreambuf_iterator(istream_type& s) noexcept; 592 istreambuf_iterator(streambuf_type* s) noexcept; 593 istreambuf_iterator(a-private-type) noexcept; 594 595 charT operator*() const; 596 pointer operator->() const; 597 istreambuf_iterator& operator++(); 598 a-private-type operator++(int); 599 600 bool equal(const istreambuf_iterator& b) const; 601 friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s); // since C++20 602}; 603 604template <class charT, class traits> 605bool operator==(const istreambuf_iterator<charT,traits>& a, 606 const istreambuf_iterator<charT,traits>& b); 607template <class charT, class traits> 608bool operator!=(const istreambuf_iterator<charT,traits>& a, 609 const istreambuf_iterator<charT,traits>& b); // until C++20 610 611template <class charT, class traits = char_traits<charT> > 612class ostreambuf_iterator 613 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 614{ 615public: 616 typedef output_iterator_tag iterator_category; 617 typedef void value_type; 618 typedef void difference_type; // until C++20 619 typedef ptrdiff_t difference_type; // since C++20 620 typedef void pointer; 621 typedef void reference; 622 623 typedef charT char_type; 624 typedef traits traits_type; 625 typedef basic_streambuf<charT, traits> streambuf_type; 626 typedef basic_ostream<charT, traits> ostream_type; 627 628 ostreambuf_iterator(ostream_type& s) noexcept; 629 ostreambuf_iterator(streambuf_type* s) noexcept; 630 ostreambuf_iterator& operator=(charT c); 631 ostreambuf_iterator& operator*(); 632 ostreambuf_iterator& operator++(); 633 ostreambuf_iterator& operator++(int); 634 bool failed() const noexcept; 635}; 636 637template <class C> constexpr auto begin(C& c) -> decltype(c.begin()); 638template <class C> constexpr auto begin(const C& c) -> decltype(c.begin()); 639template <class C> constexpr auto end(C& c) -> decltype(c.end()); 640template <class C> constexpr auto end(const C& c) -> decltype(c.end()); 641template <class T, size_t N> constexpr T* begin(T (&array)[N]); 642template <class T, size_t N> constexpr T* end(T (&array)[N]); 643 644template <class C> auto constexpr cbegin(const C& c) -> decltype(std::begin(c)); // C++14 645template <class C> auto constexpr cend(const C& c) -> decltype(std::end(c)); // C++14 646template <class C> auto constexpr rbegin(C& c) -> decltype(c.rbegin()); // C++14 647template <class C> auto constexpr rbegin(const C& c) -> decltype(c.rbegin()); // C++14 648template <class C> auto constexpr rend(C& c) -> decltype(c.rend()); // C++14 649template <class C> constexpr auto rend(const C& c) -> decltype(c.rend()); // C++14 650template <class E> reverse_iterator<const E*> constexpr rbegin(initializer_list<E> il); // C++14 651template <class E> reverse_iterator<const E*> constexpr rend(initializer_list<E> il); // C++14 652template <class T, size_t N> reverse_iterator<T*> constexpr rbegin(T (&array)[N]); // C++14 653template <class T, size_t N> reverse_iterator<T*> constexpr rend(T (&array)[N]); // C++14 654template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); // C++14 655template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c)); // C++14 656 657// 24.8, container access: 658template <class C> constexpr auto size(const C& c) -> decltype(c.size()); // C++17 659template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17 660 661template <class C> constexpr auto ssize(const C& c) 662 -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>; // C++20 663template <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20 664 665template <class C> constexpr auto empty(const C& c) -> decltype(c.empty()); // C++17 666template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept; // C++17 667template <class E> constexpr bool empty(initializer_list<E> il) noexcept; // C++17 668template <class C> constexpr auto data(C& c) -> decltype(c.data()); // C++17 669template <class C> constexpr auto data(const C& c) -> decltype(c.data()); // C++17 670template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept; // C++17 671template <class E> constexpr const E* data(initializer_list<E> il) noexcept; // C++17 672 673} // std 674 675*/ 676 677#include <__assert> // all public C++ headers provide the assertion handler 678#include <__config> 679#include <__debug> 680#include <__iterator/access.h> 681#include <__iterator/advance.h> 682#include <__iterator/back_insert_iterator.h> 683#include <__iterator/bounded_iter.h> 684#include <__iterator/common_iterator.h> 685#include <__iterator/concepts.h> 686#include <__iterator/counted_iterator.h> 687#include <__iterator/data.h> 688#include <__iterator/default_sentinel.h> 689#include <__iterator/distance.h> 690#include <__iterator/empty.h> 691#include <__iterator/erase_if_container.h> 692#include <__iterator/front_insert_iterator.h> 693#include <__iterator/incrementable_traits.h> 694#include <__iterator/indirectly_comparable.h> 695#include <__iterator/insert_iterator.h> 696#include <__iterator/istream_iterator.h> 697#include <__iterator/istreambuf_iterator.h> 698#include <__iterator/iter_move.h> 699#include <__iterator/iter_swap.h> 700#include <__iterator/iterator.h> 701#include <__iterator/iterator_traits.h> 702#include <__iterator/mergeable.h> 703#include <__iterator/move_iterator.h> 704#include <__iterator/move_sentinel.h> 705#include <__iterator/next.h> 706#include <__iterator/ostream_iterator.h> 707#include <__iterator/ostreambuf_iterator.h> 708#include <__iterator/permutable.h> 709#include <__iterator/prev.h> 710#include <__iterator/projected.h> 711#include <__iterator/readable_traits.h> 712#include <__iterator/reverse_access.h> 713#include <__iterator/reverse_iterator.h> 714#include <__iterator/size.h> 715#include <__iterator/sortable.h> 716#include <__iterator/unreachable_sentinel.h> 717#include <__iterator/wrap_iter.h> 718#include <__memory/addressof.h> 719#include <__memory/pointer_traits.h> 720#include <cstddef> 721#include <initializer_list> 722#include <version> 723 724// standard-mandated includes 725 726// [iterator.synopsis] 727#include <compare> 728#include <concepts> 729 730#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 731# pragma GCC system_header 732#endif 733 734#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 735# include <exception> 736# include <new> 737# include <type_traits> 738# include <typeinfo> 739# include <utility> 740#endif 741 742#endif // _LIBCPP_ITERATOR 743