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 typedef Iterator iterator_type; 390 typedef typename iterator_traits<Iterator>::difference_type difference_type; 391 typedef Iterator pointer; 392 typedef typename iterator_traits<Iterator>::value_type value_type; 393 typedef typename iterator_traits<Iterator>::iterator_category iterator_category; 394 typedef value_type&& reference; 395 396 constexpr move_iterator(); // all the constexprs are in C++17 397 constexpr explicit move_iterator(Iterator i); 398 template <class U> 399 constexpr move_iterator(const move_iterator<U>& u); 400 template <class U> 401 constexpr move_iterator& operator=(const move_iterator<U>& u); 402 constexpr iterator_type base() const; 403 constexpr reference operator*() const; 404 constexpr pointer operator->() const; 405 constexpr move_iterator& operator++(); 406 constexpr move_iterator operator++(int); 407 constexpr move_iterator& operator--(); 408 constexpr move_iterator operator--(int); 409 constexpr move_iterator operator+(difference_type n) const; 410 constexpr move_iterator& operator+=(difference_type n); 411 constexpr move_iterator operator-(difference_type n) const; 412 constexpr move_iterator& operator-=(difference_type n); 413 constexpr unspecified operator[](difference_type n) const; 414private: 415 Iterator current; // exposition only 416}; 417 418template <class Iterator1, class Iterator2> 419constexpr bool // constexpr in C++17 420operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 421 422template <class Iterator1, class Iterator2> 423constexpr bool // constexpr in C++17 424operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 425 426template <class Iterator1, class Iterator2> 427constexpr bool // constexpr in C++17 428operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 429 430template <class Iterator1, class Iterator2> 431constexpr bool // constexpr in C++17 432operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 433 434template <class Iterator1, class Iterator2> 435constexpr bool // constexpr in C++17 436operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 437 438template <class Iterator1, class Iterator2> 439constexpr bool // constexpr in C++17 440operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 441 442template <class Iterator1, class Iterator2> 443constexpr auto // constexpr in C++17 444operator-(const move_iterator<Iterator1>& x, 445 const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base()); 446 447template <class Iterator> 448constexpr move_iterator<Iterator> operator+( // constexpr in C++17 449 typename move_iterator<Iterator>::difference_type n, 450 const move_iterator<Iterator>& x); 451 452template <class Iterator> // constexpr in C++17 453constexpr move_iterator<Iterator> make_move_iterator(const Iterator& i); 454 455// [default.sentinel], default sentinel 456struct default_sentinel_t; 457inline constexpr default_sentinel_t default_sentinel{}; 458 459// [iterators.counted], counted iterators 460template<input_or_output_iterator I> class counted_iterator; 461 462template<input_iterator I> 463 requires see below 464 struct iterator_traits<counted_iterator<I>>; 465 466// [unreachable.sentinel], unreachable sentinel 467struct unreachable_sentinel_t; 468inline constexpr unreachable_sentinel_t unreachable_sentinel{}; 469 470template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> 471class istream_iterator 472 : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17 473{ 474public: 475 typedef input_iterator_tag iterator_category; 476 typedef T value_type; 477 typedef Distance difference_type; 478 typedef const T* pointer; 479 typedef const T& reference; 480 481 typedef charT char_type; 482 typedef traits traits_type; 483 typedef basic_istream<charT, traits> istream_type; 484 485 istream_iterator(); // constexpr since C++11 486 constexpr istream_iterator(default_sentinel_t); // since C++20 487 istream_iterator(istream_type& s); 488 istream_iterator(const istream_iterator& x); 489 ~istream_iterator(); 490 491 const T& operator*() const; 492 const T* operator->() const; 493 istream_iterator& operator++(); 494 istream_iterator operator++(int); 495 friend bool operator==(const istream_iterator& i, default_sentinel_t); // since C++20 496}; 497 498template <class T, class charT, class traits, class Distance> 499bool operator==(const istream_iterator<T,charT,traits,Distance>& x, 500 const istream_iterator<T,charT,traits,Distance>& y); 501template <class T, class charT, class traits, class Distance> 502bool operator!=(const istream_iterator<T,charT,traits,Distance>& x, 503 const istream_iterator<T,charT,traits,Distance>& y); // until C++20 504 505template <class T, class charT = char, class traits = char_traits<charT> > 506class ostream_iterator 507 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 508{ 509public: 510 typedef output_iterator_tag iterator_category; 511 typedef void value_type; 512 typedef void difference_type; // until C++20 513 typedef ptrdiff_t difference_type; // since C++20 514 typedef void pointer; 515 typedef void reference; 516 517 typedef charT char_type; 518 typedef traits traits_type; 519 typedef basic_ostream<charT,traits> ostream_type; 520 521 ostream_iterator(ostream_type& s); 522 ostream_iterator(ostream_type& s, const charT* delimiter); 523 ostream_iterator(const ostream_iterator& x); 524 ~ostream_iterator(); 525 ostream_iterator& operator=(const T& value); 526 527 ostream_iterator& operator*(); 528 ostream_iterator& operator++(); 529 ostream_iterator& operator++(int); 530}; 531 532template<class charT, class traits = char_traits<charT> > 533class istreambuf_iterator 534 : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17 535{ 536public: 537 typedef input_iterator_tag iterator_category; 538 typedef charT value_type; 539 typedef traits::off_type difference_type; 540 typedef unspecified pointer; 541 typedef charT reference; 542 543 typedef charT char_type; 544 typedef traits traits_type; 545 typedef traits::int_type int_type; 546 typedef basic_streambuf<charT, traits> streambuf_type; 547 typedef basic_istream<charT, traits> istream_type; 548 549 istreambuf_iterator() noexcept; // constexpr since C++11 550 constexpr istreambuf_iterator(default_sentinel_t) noexcept; // since C++20 551 istreambuf_iterator(istream_type& s) noexcept; 552 istreambuf_iterator(streambuf_type* s) noexcept; 553 istreambuf_iterator(a-private-type) noexcept; 554 555 charT operator*() const; 556 pointer operator->() const; 557 istreambuf_iterator& operator++(); 558 a-private-type operator++(int); 559 560 bool equal(const istreambuf_iterator& b) const; 561 friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s); // since C++20 562}; 563 564template <class charT, class traits> 565bool operator==(const istreambuf_iterator<charT,traits>& a, 566 const istreambuf_iterator<charT,traits>& b); 567template <class charT, class traits> 568bool operator!=(const istreambuf_iterator<charT,traits>& a, 569 const istreambuf_iterator<charT,traits>& b); // until C++20 570 571template <class charT, class traits = char_traits<charT> > 572class ostreambuf_iterator 573 : public iterator<output_iterator_tag, void, void, void, void> // until C++17 574{ 575public: 576 typedef output_iterator_tag iterator_category; 577 typedef void value_type; 578 typedef void difference_type; // until C++20 579 typedef ptrdiff_t difference_type; // since C++20 580 typedef void pointer; 581 typedef void reference; 582 583 typedef charT char_type; 584 typedef traits traits_type; 585 typedef basic_streambuf<charT, traits> streambuf_type; 586 typedef basic_ostream<charT, traits> ostream_type; 587 588 ostreambuf_iterator(ostream_type& s) noexcept; 589 ostreambuf_iterator(streambuf_type* s) noexcept; 590 ostreambuf_iterator& operator=(charT c); 591 ostreambuf_iterator& operator*(); 592 ostreambuf_iterator& operator++(); 593 ostreambuf_iterator& operator++(int); 594 bool failed() const noexcept; 595}; 596 597template <class C> constexpr auto begin(C& c) -> decltype(c.begin()); 598template <class C> constexpr auto begin(const C& c) -> decltype(c.begin()); 599template <class C> constexpr auto end(C& c) -> decltype(c.end()); 600template <class C> constexpr auto end(const C& c) -> decltype(c.end()); 601template <class T, size_t N> constexpr T* begin(T (&array)[N]); 602template <class T, size_t N> constexpr T* end(T (&array)[N]); 603 604template <class C> auto constexpr cbegin(const C& c) -> decltype(std::begin(c)); // C++14 605template <class C> auto constexpr cend(const C& c) -> decltype(std::end(c)); // C++14 606template <class C> auto constexpr rbegin(C& c) -> decltype(c.rbegin()); // C++14 607template <class C> auto constexpr rbegin(const C& c) -> decltype(c.rbegin()); // C++14 608template <class C> auto constexpr rend(C& c) -> decltype(c.rend()); // C++14 609template <class C> constexpr auto rend(const C& c) -> decltype(c.rend()); // C++14 610template <class E> reverse_iterator<const E*> constexpr rbegin(initializer_list<E> il); // C++14 611template <class E> reverse_iterator<const E*> constexpr rend(initializer_list<E> il); // C++14 612template <class T, size_t N> reverse_iterator<T*> constexpr rbegin(T (&array)[N]); // C++14 613template <class T, size_t N> reverse_iterator<T*> constexpr rend(T (&array)[N]); // C++14 614template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); // C++14 615template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c)); // C++14 616 617// 24.8, container access: 618template <class C> constexpr auto size(const C& c) -> decltype(c.size()); // C++17 619template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17 620 621template <class C> constexpr auto ssize(const C& c) 622 -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>; // C++20 623template <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20 624 625template <class C> constexpr auto empty(const C& c) -> decltype(c.empty()); // C++17 626template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept; // C++17 627template <class E> constexpr bool empty(initializer_list<E> il) noexcept; // C++17 628template <class C> constexpr auto data(C& c) -> decltype(c.data()); // C++17 629template <class C> constexpr auto data(const C& c) -> decltype(c.data()); // C++17 630template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept; // C++17 631template <class E> constexpr const E* data(initializer_list<E> il) noexcept; // C++17 632 633} // std 634 635*/ 636 637#include <__assert> // all public C++ headers provide the assertion handler 638#include <__config> 639#include <__debug> 640#include <__iterator/access.h> 641#include <__iterator/advance.h> 642#include <__iterator/back_insert_iterator.h> 643#include <__iterator/common_iterator.h> 644#include <__iterator/concepts.h> 645#include <__iterator/counted_iterator.h> 646#include <__iterator/data.h> 647#include <__iterator/default_sentinel.h> 648#include <__iterator/distance.h> 649#include <__iterator/empty.h> 650#include <__iterator/erase_if_container.h> 651#include <__iterator/front_insert_iterator.h> 652#include <__iterator/incrementable_traits.h> 653#include <__iterator/indirectly_comparable.h> 654#include <__iterator/insert_iterator.h> 655#include <__iterator/istream_iterator.h> 656#include <__iterator/istreambuf_iterator.h> 657#include <__iterator/iter_move.h> 658#include <__iterator/iter_swap.h> 659#include <__iterator/iterator.h> 660#include <__iterator/iterator_traits.h> 661#include <__iterator/mergeable.h> 662#include <__iterator/move_iterator.h> 663#include <__iterator/next.h> 664#include <__iterator/ostream_iterator.h> 665#include <__iterator/ostreambuf_iterator.h> 666#include <__iterator/permutable.h> 667#include <__iterator/prev.h> 668#include <__iterator/projected.h> 669#include <__iterator/readable_traits.h> 670#include <__iterator/reverse_access.h> 671#include <__iterator/reverse_iterator.h> 672#include <__iterator/size.h> 673#include <__iterator/sortable.h> 674#include <__iterator/unreachable_sentinel.h> 675#include <__iterator/wrap_iter.h> 676#include <__memory/addressof.h> 677#include <__memory/pointer_traits.h> 678#include <compare> 679#include <concepts> // Mandated by the Standard. 680#include <cstddef> 681#include <initializer_list> 682#include <type_traits> 683#include <version> 684 685// TODO: remove these headers 686#include <__functional/binary_function.h> 687#include <__functional/invoke.h> 688#include <__functional/operations.h> 689#include <__functional/reference_wrapper.h> 690#include <__functional/unary_function.h> 691#include <__functional/weak_result_type.h> 692#include <__memory/allocator_arg_t.h> 693#include <__memory/uses_allocator.h> 694#include <exception> 695#include <new> 696#include <typeinfo> 697 698#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 699# pragma GCC system_header 700#endif 701 702#endif // _LIBCPP_ITERATOR 703