10b57cec5SDimitry Andric// -*- C++ -*- 2349cc55cSDimitry Andric//===----------------------------------------------------------------------===// 30b57cec5SDimitry Andric// 40b57cec5SDimitry Andric// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 50b57cec5SDimitry Andric// See https://llvm.org/LICENSE.txt for license information. 60b57cec5SDimitry Andric// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 70b57cec5SDimitry Andric// 80b57cec5SDimitry Andric//===----------------------------------------------------------------------===// 90b57cec5SDimitry Andric 100b57cec5SDimitry Andric#ifndef _LIBCPP_ITERATOR 110b57cec5SDimitry Andric#define _LIBCPP_ITERATOR 120b57cec5SDimitry Andric 130b57cec5SDimitry Andric/* 140b57cec5SDimitry Andric iterator synopsis 150b57cec5SDimitry Andric 16fe6060f1SDimitry Andric#include <concepts> 17fe6060f1SDimitry Andric 180b57cec5SDimitry Andricnamespace std 190b57cec5SDimitry Andric{ 20fe6060f1SDimitry Andrictemplate<class> struct incrementable_traits; // since C++20 21fe6060f1SDimitry Andrictemplate<class T> 22fe6060f1SDimitry Andric using iter_difference_t = see below; // since C++20 23fe6060f1SDimitry Andric 24fe6060f1SDimitry Andrictemplate<class> struct indirectly_readable_traits; // since C++20 25fe6060f1SDimitry Andrictemplate<class T> 26fe6060f1SDimitry Andric using iter_value_t = see below; // since C++20 270b57cec5SDimitry Andric 280b57cec5SDimitry Andrictemplate<class Iterator> 29fe6060f1SDimitry Andricstruct iterator_traits; 300b57cec5SDimitry Andric 310b57cec5SDimitry Andrictemplate<class T> 32fe6060f1SDimitry Andric requires is_object_v<T> // since C++20 33fe6060f1SDimitry Andricstruct iterator_traits<T*>; 34fe6060f1SDimitry Andric 35fe6060f1SDimitry Andrictemplate<dereferenceable T> 36fe6060f1SDimitry Andric using iter_reference_t = decltype(*declval<T&>()); 37fe6060f1SDimitry Andric 38fe6060f1SDimitry Andricnamespace ranges::inline unspecified { 39fe6060f1SDimitry Andric inline constexpr unspecified iter_move = unspecified; // since C++20, nodiscard as an extension 40fe6060f1SDimitry Andric}} 41fe6060f1SDimitry Andric 42fe6060f1SDimitry Andrictemplate<dereferenceable T> 43fe6060f1SDimitry Andric requires ... 44fe6060f1SDimitry Andricusing iter_rvalue_reference_t = decltype(ranges::iter_move(declval<T&>())); // since C++20 45fe6060f1SDimitry Andric 46fe6060f1SDimitry Andric// [iterator.concepts], iterator concepts 47fe6060f1SDimitry Andric// [iterator.concept.readable], concept indirectly_readable 48fe6060f1SDimitry Andrictemplate<class In> 49fe6060f1SDimitry Andric concept indirectly_readable = see below; // since C++20 50fe6060f1SDimitry Andric 51fe6060f1SDimitry Andrictemplate<indirectly_readable T> 52fe6060f1SDimitry Andric using iter_common_reference_t = 53fe6060f1SDimitry Andric common_reference_t<iter_reference_t<T>, iter_value_t<T>&>; // since C++20 54fe6060f1SDimitry Andric 55fe6060f1SDimitry Andric// [iterator.concept.writable], concept indirectly_writable 56fe6060f1SDimitry Andrictemplate<class Out, class T> 57fe6060f1SDimitry Andric concept indirectly_writable = see below; // since C++20 58fe6060f1SDimitry Andric 59fe6060f1SDimitry Andric// [iterator.concept.winc], concept weakly_incrementable 60fe6060f1SDimitry Andrictemplate<class I> 61fe6060f1SDimitry Andric concept weakly_incrementable = see below; // since C++20 62fe6060f1SDimitry Andric 63fe6060f1SDimitry Andric// [iterator.concept.inc], concept incrementable 64fe6060f1SDimitry Andrictemplate<class I> 65fe6060f1SDimitry Andric concept incrementable = see below; // since C++20 66fe6060f1SDimitry Andric 67fe6060f1SDimitry Andric// [iterator.concept.iterator], concept input_or_output_iterator 68fe6060f1SDimitry Andric template<class I> 69fe6060f1SDimitry Andric concept input_or_output_iterator = see below; // since C++20 70fe6060f1SDimitry Andric 71fe6060f1SDimitry Andric// [iterator.concept.sentinel], concept sentinel_for 72fe6060f1SDimitry Andrictemplate<class S, class I> 73fe6060f1SDimitry Andric concept sentinel_for = see below; // since C++20 74fe6060f1SDimitry Andric 75fe6060f1SDimitry Andric// [iterator.concept.sizedsentinel], concept sized_sentinel_for 76fe6060f1SDimitry Andrictemplate<class S, class I> 77fe6060f1SDimitry Andric inline constexpr bool disable_sized_sentinel_for = false; 78fe6060f1SDimitry Andric 79fe6060f1SDimitry Andrictemplate<class S, class I> 80fe6060f1SDimitry Andric concept sized_sentinel_for = see below; 81fe6060f1SDimitry Andric 82fe6060f1SDimitry Andric// [iterator.concept.input], concept input_iterator 83fe6060f1SDimitry Andrictemplate<class I> 84fe6060f1SDimitry Andric concept input_iterator = see below; // since C++20 85fe6060f1SDimitry Andric 86fe6060f1SDimitry Andric// [iterator.concept.output], concept output_iterator 87fe6060f1SDimitry Andrictemplate<class I, class T> 88fe6060f1SDimitry Andric concept output_iterator = see below; // since C++20 89fe6060f1SDimitry Andric 90fe6060f1SDimitry Andric// [iterator.concept.forward], concept forward_iterator 91fe6060f1SDimitry Andrictemplate<class I> 92fe6060f1SDimitry Andric concept forward_iterator = see below; // since C++20 93fe6060f1SDimitry Andric 94fe6060f1SDimitry Andric// [iterator.concept.bidir], concept bidirectional_iterator 95fe6060f1SDimitry Andrictemplate<class I> 96fe6060f1SDimitry Andric concept bidirectional_iterator = see below; // since C++20 97fe6060f1SDimitry Andric 98fe6060f1SDimitry Andric// [iterator.concept.random.access], concept random_access_iterator 99fe6060f1SDimitry Andrictemplate<class I> 100fe6060f1SDimitry Andric concept random_access_iterator = see below; // since C++20 101fe6060f1SDimitry Andric 102fe6060f1SDimitry Andric// [indirectcallable] 103fe6060f1SDimitry Andric// [indirectcallable.indirectinvocable] 104fe6060f1SDimitry Andrictemplate<class F, class I> 105fe6060f1SDimitry Andric concept indirectly_unary_invocable = see below; // since C++20 106fe6060f1SDimitry Andric 107fe6060f1SDimitry Andrictemplate<class F, class I> 108fe6060f1SDimitry Andric concept indirectly_regular_unary_invocable = see below; // since C++20 109fe6060f1SDimitry Andric 110fe6060f1SDimitry Andrictemplate<class F, class I> 111fe6060f1SDimitry Andric concept indirect_unary_predicate = see below; // since C++20 112fe6060f1SDimitry Andric 113fe6060f1SDimitry Andrictemplate<class F, class I1, class I2> 114fe6060f1SDimitry Andric concept indirect_binary_predicate = see below; // since C++20 115fe6060f1SDimitry Andric 116fe6060f1SDimitry Andrictemplate<class F, class I1, class I2 = I1> 117fe6060f1SDimitry Andric concept indirect_equivalence_relation = see below; // since C++20 118fe6060f1SDimitry Andric 119fe6060f1SDimitry Andrictemplate<class F, class I1, class I2 = I1> 120fe6060f1SDimitry Andric concept indirect_strict_weak_order = see below; // since C++20 121fe6060f1SDimitry Andric 122fe6060f1SDimitry Andrictemplate<class F, class... Is> 123fe6060f1SDimitry Andric using indirect_result_t = see below; // since C++20 124fe6060f1SDimitry Andric 125fe6060f1SDimitry Andric// [projected], projected 126fe6060f1SDimitry Andrictemplate<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj> 127fe6060f1SDimitry Andric struct projected; // since C++20 128fe6060f1SDimitry Andric 129fe6060f1SDimitry Andrictemplate<weakly_incrementable I, indirectly_regular_unary_invocable<I> Proj> 130fe6060f1SDimitry Andric struct incrementable_traits<projected<I, Proj>>; // since C++20 131fe6060f1SDimitry Andric 132fe6060f1SDimitry Andric// [alg.req.ind.move], concept indirectly_movable 133fe6060f1SDimitry Andrictemplate<class In, class Out> 134fe6060f1SDimitry Andric concept indirectly_movable = see below; // since C++20 135fe6060f1SDimitry Andric 136fe6060f1SDimitry Andrictemplate<class In, class Out> 137fe6060f1SDimitry Andric concept indirectly_movable_storable = see below; // since C++20 138fe6060f1SDimitry Andric 13981ad6265SDimitry Andric// [alg.req.ind.copy], concept indirectly_copyable 14081ad6265SDimitry Andrictemplate<class In, class Out> 14181ad6265SDimitry Andric concept indirectly_copyable = see below; // since C++20 14281ad6265SDimitry Andric 14381ad6265SDimitry Andrictemplate<class In, class Out> 14481ad6265SDimitry Andric concept indirectly_copyable_storable = see below; // since C++20 14581ad6265SDimitry Andric 146fe6060f1SDimitry Andric// [alg.req.ind.swap], concept indirectly_swappable 147fe6060f1SDimitry Andrictemplate<class I1, class I2 = I1> 148fe6060f1SDimitry Andric concept indirectly_swappable = see below; // since C++20 149fe6060f1SDimitry Andric 15004eeddc0SDimitry Andrictemplate<class I1, class I2, class R, class P1 = identity, 15104eeddc0SDimitry Andric class P2 = identity> 15204eeddc0SDimitry Andric concept indirectly_comparable = 15304eeddc0SDimitry Andric indirect_binary_predicate<R, projected<I1, P1>, projected<I2, P2>>; // since C++20 15404eeddc0SDimitry Andric 15581ad6265SDimitry Andric// [alg.req.permutable], concept permutable 15681ad6265SDimitry Andrictemplate<class I> 15781ad6265SDimitry Andric concept permutable = see below; // since C++20 15881ad6265SDimitry Andric 15981ad6265SDimitry Andric // [alg.req.mergeable], concept mergeable 16081ad6265SDimitry Andrictemplate<class I1, class I2, class Out, 16181ad6265SDimitry Andric class R = ranges::less, class P1 = identity, class P2 = identity> 16281ad6265SDimitry Andric concept mergeable = see below; // since C++20 16381ad6265SDimitry Andric 16481ad6265SDimitry Andric// [alg.req.sortable], concept sortable 16581ad6265SDimitry Andrictemplate<class I, class R = ranges::less, class P = identity> 16681ad6265SDimitry Andric concept sortable = see below; // since C++20 16781ad6265SDimitry Andric 168fe6060f1SDimitry Andrictemplate<input_or_output_iterator I, sentinel_for<I> S> 169fe6060f1SDimitry Andric requires (!same_as<I, S> && copyable<I>) 170fe6060f1SDimitry Andricclass common_iterator; // since C++20 1710b57cec5SDimitry Andric 1720b57cec5SDimitry Andrictemplate<class Category, class T, class Distance = ptrdiff_t, 1730b57cec5SDimitry Andric class Pointer = T*, class Reference = T&> 174fe6060f1SDimitry Andricstruct iterator // deprecated in C++17 1750b57cec5SDimitry Andric{ 1760b57cec5SDimitry Andric typedef T value_type; 1770b57cec5SDimitry Andric typedef Distance difference_type; 1780b57cec5SDimitry Andric typedef Pointer pointer; 1790b57cec5SDimitry Andric typedef Reference reference; 1800b57cec5SDimitry Andric typedef Category iterator_category; 1810b57cec5SDimitry Andric}; 1820b57cec5SDimitry Andric 1830b57cec5SDimitry Andricstruct input_iterator_tag {}; 1840b57cec5SDimitry Andricstruct output_iterator_tag {}; 1850b57cec5SDimitry Andricstruct forward_iterator_tag : public input_iterator_tag {}; 1860b57cec5SDimitry Andricstruct bidirectional_iterator_tag : public forward_iterator_tag {}; 1870b57cec5SDimitry Andricstruct random_access_iterator_tag : public bidirectional_iterator_tag {}; 18881ad6265SDimitry Andricstruct contiguous_iterator_tag : public random_access_iterator_tag {}; 1890b57cec5SDimitry Andric 1900b57cec5SDimitry Andric// 27.4.3, iterator operations 1915ffd83dbSDimitry Andrictemplate <class InputIterator, class Distance> // constexpr in C++17 1925ffd83dbSDimitry Andric constexpr void advance(InputIterator& i, Distance n); 1930b57cec5SDimitry Andric 1940b57cec5SDimitry Andrictemplate <class InputIterator> // constexpr in C++17 1950b57cec5SDimitry Andric constexpr typename iterator_traits<InputIterator>::difference_type 1960b57cec5SDimitry Andric distance(InputIterator first, InputIterator last); 1970b57cec5SDimitry Andric 1980b57cec5SDimitry Andrictemplate <class InputIterator> // constexpr in C++17 1990b57cec5SDimitry Andric constexpr InputIterator next(InputIterator x, 2000b57cec5SDimitry Andrictypename iterator_traits<InputIterator>::difference_type n = 1); 2010b57cec5SDimitry Andric 2020b57cec5SDimitry Andrictemplate <class BidirectionalIterator> // constexpr in C++17 2030b57cec5SDimitry Andric constexpr BidirectionalIterator prev(BidirectionalIterator x, 2040b57cec5SDimitry Andric typename iterator_traits<BidirectionalIterator>::difference_type n = 1); 2050b57cec5SDimitry Andric 206fe6060f1SDimitry Andric// [range.iter.ops], range iterator operations 207fe6060f1SDimitry Andricnamespace ranges { 208fe6060f1SDimitry Andric // [range.iter.op.advance], ranges::advance 209fe6060f1SDimitry Andric template<input_or_output_iterator I> 210fe6060f1SDimitry Andric constexpr void advance(I& i, iter_difference_t<I> n); // since C++20 211fe6060f1SDimitry Andric template<input_or_output_iterator I, sentinel_for<I> S> 212fe6060f1SDimitry Andric constexpr void advance(I& i, S bound); // since C++20 213fe6060f1SDimitry Andric template<input_or_output_iterator I, sentinel_for<I> S> 214fe6060f1SDimitry Andric constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound); // since C++20 215fe6060f1SDimitry Andric} 216fe6060f1SDimitry Andric 2170b57cec5SDimitry Andrictemplate <class Iterator> 2180b57cec5SDimitry Andricclass reverse_iterator 219fe6060f1SDimitry Andric : public iterator<typename iterator_traits<Iterator>::iterator_category, // until C++17 2200b57cec5SDimitry Andric typename iterator_traits<Iterator>::value_type, 2210b57cec5SDimitry Andric typename iterator_traits<Iterator>::difference_type, 2220b57cec5SDimitry Andric typename iterator_traits<Iterator>::pointer, 2230b57cec5SDimitry Andric typename iterator_traits<Iterator>::reference> 2240b57cec5SDimitry Andric{ 2250b57cec5SDimitry Andricprotected: 2260b57cec5SDimitry Andric Iterator current; 2270b57cec5SDimitry Andricpublic: 22881ad6265SDimitry Andric using iterator_type = Iterator; 22981ad6265SDimitry Andric using iterator_concept = see below; // since C++20 23081ad6265SDimitry Andric using iterator_category = typename iterator_traits<Iterator>::iterator_category; // since C++17, until C++20 23181ad6265SDimitry Andric using iterator_category = see below; // since C++20 23281ad6265SDimitry Andric using value_type = typename iterator_traits<Iterator>::value_type; // since C++17, until C++20 23381ad6265SDimitry Andric using value_type = iter_value_t<Iterator>; // since C++20 23481ad6265SDimitry Andric using difference_type = typename iterator_traits<Iterator>::difference_type; // until C++20 23581ad6265SDimitry Andric using difference_type = iter_difference_t<Iterator>; // since C++20 23681ad6265SDimitry Andric using pointer = typename iterator_traits<Iterator>::pointer; 23781ad6265SDimitry Andric using reference = typename iterator_traits<Iterator>::reference; // until C++20 23881ad6265SDimitry Andric using reference = iter_reference_t<Iterator>; // since C++20 2390b57cec5SDimitry Andric 2400b57cec5SDimitry Andric constexpr reverse_iterator(); 2410b57cec5SDimitry Andric constexpr explicit reverse_iterator(Iterator x); 2420b57cec5SDimitry Andric template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u); 2430b57cec5SDimitry Andric template <class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u); 2440b57cec5SDimitry Andric constexpr Iterator base() const; 2450b57cec5SDimitry Andric constexpr reference operator*() const; 24681ad6265SDimitry Andric constexpr pointer operator->() const; // until C++20 24781ad6265SDimitry Andric constexpr pointer operator->() const requires see below; // since C++20 2480b57cec5SDimitry Andric constexpr reverse_iterator& operator++(); 2490b57cec5SDimitry Andric constexpr reverse_iterator operator++(int); 2500b57cec5SDimitry Andric constexpr reverse_iterator& operator--(); 2510b57cec5SDimitry Andric constexpr reverse_iterator operator--(int); 2520b57cec5SDimitry Andric constexpr reverse_iterator operator+ (difference_type n) const; 2530b57cec5SDimitry Andric constexpr reverse_iterator& operator+=(difference_type n); 2540b57cec5SDimitry Andric constexpr reverse_iterator operator- (difference_type n) const; 2550b57cec5SDimitry Andric constexpr reverse_iterator& operator-=(difference_type n); 25681ad6265SDimitry Andric constexpr unspecified operator[](difference_type n) const; 25781ad6265SDimitry Andric 25881ad6265SDimitry Andric friend constexpr iter_rvalue_reference_t<Iterator> 25981ad6265SDimitry Andric iter_move(const reverse_iterator& i) noexcept(see below); 26081ad6265SDimitry Andric template<indirectly_swappable<Iterator> Iterator2> 26181ad6265SDimitry Andric friend constexpr void 26281ad6265SDimitry Andric iter_swap(const reverse_iterator& x, 26381ad6265SDimitry Andric const reverse_iterator<Iterator2>& y) noexcept(see below); 2640b57cec5SDimitry Andric}; 2650b57cec5SDimitry Andric 2660b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 2670b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 2680b57cec5SDimitry Andricoperator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 2690b57cec5SDimitry Andric 2700b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 2710b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 27281ad6265SDimitry Andricoperator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 2730b57cec5SDimitry Andric 2740b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 2750b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 27681ad6265SDimitry Andricoperator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 2770b57cec5SDimitry Andric 2780b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 2790b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 2800b57cec5SDimitry Andricoperator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 2810b57cec5SDimitry Andric 2820b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 2830b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 28481ad6265SDimitry Andricoperator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 2850b57cec5SDimitry Andric 2860b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 2870b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 28881ad6265SDimitry Andricoperator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 28981ad6265SDimitry Andric 29081ad6265SDimitry Andrictemplate<class Iterator1, three_way_comparable_with<Iterator1> Iterator2> 29181ad6265SDimitry Andric constexpr compare_three_way_result_t<Iterator1, Iterator2> 29281ad6265SDimitry Andric operator<=>(const reverse_iterator<Iterator1>& x, 29381ad6265SDimitry Andric const reverse_iterator<Iterator2>& y); 2940b57cec5SDimitry Andric 2950b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 2960b57cec5SDimitry Andricconstexpr auto 2970b57cec5SDimitry Andricoperator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y) 2980b57cec5SDimitry Andric-> decltype(__y.base() - __x.base()); // constexpr in C++17 2990b57cec5SDimitry Andric 3000b57cec5SDimitry Andrictemplate <class Iterator> 3010b57cec5SDimitry Andricconstexpr reverse_iterator<Iterator> 3020b57cec5SDimitry Andricoperator+(typename reverse_iterator<Iterator>::difference_type n, 3030b57cec5SDimitry Andric const reverse_iterator<Iterator>& x); // constexpr in C++17 3040b57cec5SDimitry Andric 3050b57cec5SDimitry Andrictemplate <class Iterator> 3060b57cec5SDimitry Andricconstexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17 3070b57cec5SDimitry Andric 30881ad6265SDimitry Andrictemplate<class Iterator1, class Iterator2> 30981ad6265SDimitry Andric requires (!sized_sentinel_for<Iterator1, Iterator2>) 31081ad6265SDimitry Andric inline constexpr bool disable_sized_sentinel_for<reverse_iterator<Iterator1>, 31181ad6265SDimitry Andric reverse_iterator<Iterator2>> = true; 31281ad6265SDimitry Andric 3130b57cec5SDimitry Andrictemplate <class Container> 3140b57cec5SDimitry Andricclass back_insert_iterator 315fe6060f1SDimitry Andric : public iterator<output_iterator_tag, void, void, void, void> // until C++17 3160b57cec5SDimitry Andric{ 3170b57cec5SDimitry Andricprotected: 3180b57cec5SDimitry Andric Container* container; 3190b57cec5SDimitry Andricpublic: 3200b57cec5SDimitry Andric typedef Container container_type; 3210b57cec5SDimitry Andric typedef void value_type; 322fe6060f1SDimitry Andric typedef void difference_type; // until C++20 323fe6060f1SDimitry Andric typedef ptrdiff_t difference_type; // since C++20 3240b57cec5SDimitry Andric typedef void reference; 3250b57cec5SDimitry Andric typedef void pointer; 3260b57cec5SDimitry Andric 327fe6060f1SDimitry Andric explicit back_insert_iterator(Container& x); // constexpr in C++20 328fe6060f1SDimitry Andric back_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 329fe6060f1SDimitry Andric back_insert_iterator& operator*(); // constexpr in C++20 330fe6060f1SDimitry Andric back_insert_iterator& operator++(); // constexpr in C++20 331fe6060f1SDimitry Andric back_insert_iterator operator++(int); // constexpr in C++20 3320b57cec5SDimitry Andric}; 3330b57cec5SDimitry Andric 334fe6060f1SDimitry Andrictemplate <class Container> back_insert_iterator<Container> back_inserter(Container& x); // constexpr in C++20 3350b57cec5SDimitry Andric 3360b57cec5SDimitry Andrictemplate <class Container> 3370b57cec5SDimitry Andricclass front_insert_iterator 338fe6060f1SDimitry Andric : public iterator<output_iterator_tag, void, void, void, void> // until C++17 3390b57cec5SDimitry Andric{ 3400b57cec5SDimitry Andricprotected: 3410b57cec5SDimitry Andric Container* container; 3420b57cec5SDimitry Andricpublic: 3430b57cec5SDimitry Andric typedef Container container_type; 3440b57cec5SDimitry Andric typedef void value_type; 345fe6060f1SDimitry Andric typedef void difference_type; // until C++20 346fe6060f1SDimitry Andric typedef ptrdiff_t difference_type; // since C++20 3470b57cec5SDimitry Andric typedef void reference; 3480b57cec5SDimitry Andric typedef void pointer; 3490b57cec5SDimitry Andric 350fe6060f1SDimitry Andric explicit front_insert_iterator(Container& x); // constexpr in C++20 351fe6060f1SDimitry Andric front_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 352fe6060f1SDimitry Andric front_insert_iterator& operator*(); // constexpr in C++20 353fe6060f1SDimitry Andric front_insert_iterator& operator++(); // constexpr in C++20 354fe6060f1SDimitry Andric front_insert_iterator operator++(int); // constexpr in C++20 3550b57cec5SDimitry Andric}; 3560b57cec5SDimitry Andric 357fe6060f1SDimitry Andrictemplate <class Container> front_insert_iterator<Container> front_inserter(Container& x); // constexpr in C++20 3580b57cec5SDimitry Andric 3590b57cec5SDimitry Andrictemplate <class Container> 3600b57cec5SDimitry Andricclass insert_iterator 361fe6060f1SDimitry Andric : public iterator<output_iterator_tag, void, void, void, void> // until C++17 3620b57cec5SDimitry Andric{ 3630b57cec5SDimitry Andricprotected: 3640b57cec5SDimitry Andric Container* container; 3650b57cec5SDimitry Andric typename Container::iterator iter; 3660b57cec5SDimitry Andricpublic: 3670b57cec5SDimitry Andric typedef Container container_type; 3680b57cec5SDimitry Andric typedef void value_type; 369fe6060f1SDimitry Andric typedef void difference_type; // until C++20 370fe6060f1SDimitry Andric typedef ptrdiff_t difference_type; // since C++20 3710b57cec5SDimitry Andric typedef void reference; 3720b57cec5SDimitry Andric typedef void pointer; 3730b57cec5SDimitry Andric 374fe6060f1SDimitry Andric insert_iterator(Container& x, typename Container::iterator i); // constexpr in C++20 375fe6060f1SDimitry Andric insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20 376fe6060f1SDimitry Andric insert_iterator& operator*(); // constexpr in C++20 377fe6060f1SDimitry Andric insert_iterator& operator++(); // constexpr in C++20 378fe6060f1SDimitry Andric insert_iterator& operator++(int); // constexpr in C++20 3790b57cec5SDimitry Andric}; 3800b57cec5SDimitry Andric 38181ad6265SDimitry Andrictemplate <class Container> 38281ad6265SDimitry Andricinsert_iterator<Container> inserter(Container& x, typename Container::iterator i); // until C++20 38381ad6265SDimitry Andrictemplate <class Container> 38481ad6265SDimitry Andricconstexpr insert_iterator<Container> inserter(Container& x, ranges::iterator_t<Container> i); // since C++20 3850b57cec5SDimitry Andric 3860b57cec5SDimitry Andrictemplate <class Iterator> 3870b57cec5SDimitry Andricclass move_iterator { 3880b57cec5SDimitry Andricpublic: 38981ad6265SDimitry Andric using iterator_type = Iterator; 39081ad6265SDimitry Andric using iterator_concept = input_iterator_tag; // From C++20 39181ad6265SDimitry Andric using iterator_category = see below; // not always present starting from C++20 39281ad6265SDimitry Andric using value_type = iter_value_t<Iterator>; // Until C++20, iterator_traits<Iterator>::value_type 39381ad6265SDimitry Andric using difference_type = iter_difference_t<Iterator>; // Until C++20, iterator_traits<Iterator>::difference_type; 39481ad6265SDimitry Andric using pointer = Iterator; 39581ad6265SDimitry Andric using reference = iter_rvalue_reference_t<Iterator>; // Until C++20, value_type&& 3960b57cec5SDimitry Andric 3970b57cec5SDimitry Andric constexpr move_iterator(); // all the constexprs are in C++17 3980b57cec5SDimitry Andric constexpr explicit move_iterator(Iterator i); 3990b57cec5SDimitry Andric template <class U> 4000b57cec5SDimitry Andric constexpr move_iterator(const move_iterator<U>& u); 4010b57cec5SDimitry Andric template <class U> 4020b57cec5SDimitry Andric constexpr move_iterator& operator=(const move_iterator<U>& u); 40381ad6265SDimitry Andric 40481ad6265SDimitry Andric constexpr iterator_type base() const; // Until C++20 40581ad6265SDimitry Andric constexpr const Iterator& base() const & noexcept; // From C++20 40681ad6265SDimitry Andric constexpr Iterator base() &&; // From C++20 40781ad6265SDimitry Andric 4080b57cec5SDimitry Andric constexpr reference operator*() const; 40981ad6265SDimitry Andric constexpr pointer operator->() const; // Deprecated in C++20 4100b57cec5SDimitry Andric constexpr move_iterator& operator++(); 41181ad6265SDimitry Andric constexpr auto operator++(int); // Return type was move_iterator until C++20 4120b57cec5SDimitry Andric constexpr move_iterator& operator--(); 4130b57cec5SDimitry Andric constexpr move_iterator operator--(int); 4140b57cec5SDimitry Andric constexpr move_iterator operator+(difference_type n) const; 4150b57cec5SDimitry Andric constexpr move_iterator& operator+=(difference_type n); 4160b57cec5SDimitry Andric constexpr move_iterator operator-(difference_type n) const; 4170b57cec5SDimitry Andric constexpr move_iterator& operator-=(difference_type n); 41881ad6265SDimitry Andric constexpr reference operator[](difference_type n) const; // Return type unspecified until C++20 41981ad6265SDimitry Andric 42081ad6265SDimitry Andric template<sentinel_for<Iterator> S> 42181ad6265SDimitry Andric friend constexpr bool 42281ad6265SDimitry Andric operator==(const move_iterator& x, const move_sentinel<S>& y); // Since C++20 42381ad6265SDimitry Andric template<sized_sentinel_for<Iterator> S> 42481ad6265SDimitry Andric friend constexpr iter_difference_t<Iterator> 42581ad6265SDimitry Andric operator-(const move_sentinel<S>& x, const move_iterator& y); // Since C++20 42681ad6265SDimitry Andric template<sized_sentinel_for<Iterator> S> 42781ad6265SDimitry Andric friend constexpr iter_difference_t<Iterator> 42881ad6265SDimitry Andric operator-(const move_iterator& x, const move_sentinel<S>& y); // Since C++20 42981ad6265SDimitry Andric friend constexpr iter_rvalue_reference_t<Iterator> 43081ad6265SDimitry Andric iter_move(const move_iterator& i) 43181ad6265SDimitry Andric noexcept(noexcept(ranges::iter_move(i.current))); // Since C++20 43281ad6265SDimitry Andric template<indirectly_swappable<Iterator> Iterator2> 43381ad6265SDimitry Andric friend constexpr void 43481ad6265SDimitry Andric iter_swap(const move_iterator& x, const move_iterator<Iterator2>& y) 43581ad6265SDimitry Andric noexcept(noexcept(ranges::iter_swap(x.current, y.current))); // Since C++20 43681ad6265SDimitry Andric 4370b57cec5SDimitry Andricprivate: 4380b57cec5SDimitry Andric Iterator current; // exposition only 4390b57cec5SDimitry Andric}; 4400b57cec5SDimitry Andric 4410b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 4420b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 4430b57cec5SDimitry Andricoperator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 4440b57cec5SDimitry Andric 4450b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 4460b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 4470b57cec5SDimitry Andricoperator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 4480b57cec5SDimitry Andric 4490b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 4500b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 4510b57cec5SDimitry Andricoperator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 4520b57cec5SDimitry Andric 4530b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 4540b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 4550b57cec5SDimitry Andricoperator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 4560b57cec5SDimitry Andric 4570b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 4580b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 4590b57cec5SDimitry Andricoperator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 4600b57cec5SDimitry Andric 4610b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 4620b57cec5SDimitry Andricconstexpr bool // constexpr in C++17 4630b57cec5SDimitry Andricoperator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 4640b57cec5SDimitry Andric 4650b57cec5SDimitry Andrictemplate <class Iterator1, class Iterator2> 4660b57cec5SDimitry Andricconstexpr auto // constexpr in C++17 4670b57cec5SDimitry Andricoperator-(const move_iterator<Iterator1>& x, 4680b57cec5SDimitry Andric const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base()); 4690b57cec5SDimitry Andric 4700b57cec5SDimitry Andrictemplate <class Iterator> 4710b57cec5SDimitry Andricconstexpr move_iterator<Iterator> operator+( // constexpr in C++17 4720b57cec5SDimitry Andric typename move_iterator<Iterator>::difference_type n, 4730b57cec5SDimitry Andric const move_iterator<Iterator>& x); 4740b57cec5SDimitry Andric 4750b57cec5SDimitry Andrictemplate <class Iterator> // constexpr in C++17 4760b57cec5SDimitry Andricconstexpr move_iterator<Iterator> make_move_iterator(const Iterator& i); 4770b57cec5SDimitry Andric 47881ad6265SDimitry Andrictemplate<semiregular S> 47981ad6265SDimitry Andricclass move_sentinel { 48081ad6265SDimitry Andricpublic: 48181ad6265SDimitry Andric constexpr move_sentinel(); 48281ad6265SDimitry Andric constexpr explicit move_sentinel(S s); 48381ad6265SDimitry Andric template<class S2> 48481ad6265SDimitry Andric requires convertible_to<const S2&, S> 48581ad6265SDimitry Andric constexpr move_sentinel(const move_sentinel<S2>& s); 48681ad6265SDimitry Andric template<class S2> 48781ad6265SDimitry Andric requires assignable_from<S&, const S2&> 48881ad6265SDimitry Andric constexpr move_sentinel& operator=(const move_sentinel<S2>& s); 48981ad6265SDimitry Andric 49081ad6265SDimitry Andric constexpr S base() const; 49181ad6265SDimitry Andricprivate: 49281ad6265SDimitry Andric S last; // exposition only 49381ad6265SDimitry Andric}; 49481ad6265SDimitry Andric 495fe6060f1SDimitry Andric// [default.sentinel], default sentinel 496fe6060f1SDimitry Andricstruct default_sentinel_t; 497fe6060f1SDimitry Andricinline constexpr default_sentinel_t default_sentinel{}; 498fe6060f1SDimitry Andric 499fe6060f1SDimitry Andric// [iterators.counted], counted iterators 500fe6060f1SDimitry Andrictemplate<input_or_output_iterator I> class counted_iterator; 501fe6060f1SDimitry Andric 502fe6060f1SDimitry Andrictemplate<input_iterator I> 503fe6060f1SDimitry Andric requires see below 504fe6060f1SDimitry Andric struct iterator_traits<counted_iterator<I>>; 5050b57cec5SDimitry Andric 506349cc55cSDimitry Andric// [unreachable.sentinel], unreachable sentinel 507349cc55cSDimitry Andricstruct unreachable_sentinel_t; 508349cc55cSDimitry Andricinline constexpr unreachable_sentinel_t unreachable_sentinel{}; 509349cc55cSDimitry Andric 5100b57cec5SDimitry Andrictemplate <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> 5110b57cec5SDimitry Andricclass istream_iterator 512fe6060f1SDimitry Andric : public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17 5130b57cec5SDimitry Andric{ 5140b57cec5SDimitry Andricpublic: 515fe6060f1SDimitry Andric typedef input_iterator_tag iterator_category; 516fe6060f1SDimitry Andric typedef T value_type; 517fe6060f1SDimitry Andric typedef Distance difference_type; 518fe6060f1SDimitry Andric typedef const T* pointer; 519fe6060f1SDimitry Andric typedef const T& reference; 520fe6060f1SDimitry Andric 5210b57cec5SDimitry Andric typedef charT char_type; 5220b57cec5SDimitry Andric typedef traits traits_type; 5230b57cec5SDimitry Andric typedef basic_istream<charT, traits> istream_type; 5240b57cec5SDimitry Andric 52581ad6265SDimitry Andric istream_iterator(); // constexpr since C++11 52681ad6265SDimitry Andric constexpr istream_iterator(default_sentinel_t); // since C++20 5270b57cec5SDimitry Andric istream_iterator(istream_type& s); 5280b57cec5SDimitry Andric istream_iterator(const istream_iterator& x); 5290b57cec5SDimitry Andric ~istream_iterator(); 5300b57cec5SDimitry Andric 5310b57cec5SDimitry Andric const T& operator*() const; 5320b57cec5SDimitry Andric const T* operator->() const; 5330b57cec5SDimitry Andric istream_iterator& operator++(); 5340b57cec5SDimitry Andric istream_iterator operator++(int); 53581ad6265SDimitry Andric friend bool operator==(const istream_iterator& i, default_sentinel_t); // since C++20 5360b57cec5SDimitry Andric}; 5370b57cec5SDimitry Andric 5380b57cec5SDimitry Andrictemplate <class T, class charT, class traits, class Distance> 5390b57cec5SDimitry Andricbool operator==(const istream_iterator<T,charT,traits,Distance>& x, 5400b57cec5SDimitry Andric const istream_iterator<T,charT,traits,Distance>& y); 5410b57cec5SDimitry Andrictemplate <class T, class charT, class traits, class Distance> 5420b57cec5SDimitry Andricbool operator!=(const istream_iterator<T,charT,traits,Distance>& x, 54381ad6265SDimitry Andric const istream_iterator<T,charT,traits,Distance>& y); // until C++20 5440b57cec5SDimitry Andric 5450b57cec5SDimitry Andrictemplate <class T, class charT = char, class traits = char_traits<charT> > 5460b57cec5SDimitry Andricclass ostream_iterator 547fe6060f1SDimitry Andric : public iterator<output_iterator_tag, void, void, void, void> // until C++17 5480b57cec5SDimitry Andric{ 5490b57cec5SDimitry Andricpublic: 550fe6060f1SDimitry Andric typedef output_iterator_tag iterator_category; 551fe6060f1SDimitry Andric typedef void value_type; 552fe6060f1SDimitry Andric typedef void difference_type; // until C++20 553fe6060f1SDimitry Andric typedef ptrdiff_t difference_type; // since C++20 554fe6060f1SDimitry Andric typedef void pointer; 555fe6060f1SDimitry Andric typedef void reference; 556fe6060f1SDimitry Andric 5570b57cec5SDimitry Andric typedef charT char_type; 5580b57cec5SDimitry Andric typedef traits traits_type; 5590b57cec5SDimitry Andric typedef basic_ostream<charT,traits> ostream_type; 5600b57cec5SDimitry Andric 5610b57cec5SDimitry Andric ostream_iterator(ostream_type& s); 5620b57cec5SDimitry Andric ostream_iterator(ostream_type& s, const charT* delimiter); 5630b57cec5SDimitry Andric ostream_iterator(const ostream_iterator& x); 5640b57cec5SDimitry Andric ~ostream_iterator(); 5650b57cec5SDimitry Andric ostream_iterator& operator=(const T& value); 5660b57cec5SDimitry Andric 5670b57cec5SDimitry Andric ostream_iterator& operator*(); 5680b57cec5SDimitry Andric ostream_iterator& operator++(); 5690b57cec5SDimitry Andric ostream_iterator& operator++(int); 5700b57cec5SDimitry Andric}; 5710b57cec5SDimitry Andric 5720b57cec5SDimitry Andrictemplate<class charT, class traits = char_traits<charT> > 5730b57cec5SDimitry Andricclass istreambuf_iterator 574fe6060f1SDimitry Andric : public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17 5750b57cec5SDimitry Andric{ 5760b57cec5SDimitry Andricpublic: 577fe6060f1SDimitry Andric typedef input_iterator_tag iterator_category; 578fe6060f1SDimitry Andric typedef charT value_type; 579fe6060f1SDimitry Andric typedef traits::off_type difference_type; 580fe6060f1SDimitry Andric typedef unspecified pointer; 581fe6060f1SDimitry Andric typedef charT reference; 582fe6060f1SDimitry Andric 5830b57cec5SDimitry Andric typedef charT char_type; 5840b57cec5SDimitry Andric typedef traits traits_type; 585fe6060f1SDimitry Andric typedef traits::int_type int_type; 5860b57cec5SDimitry Andric typedef basic_streambuf<charT, traits> streambuf_type; 5870b57cec5SDimitry Andric typedef basic_istream<charT, traits> istream_type; 5880b57cec5SDimitry Andric 58981ad6265SDimitry Andric istreambuf_iterator() noexcept; // constexpr since C++11 59081ad6265SDimitry Andric constexpr istreambuf_iterator(default_sentinel_t) noexcept; // since C++20 5910b57cec5SDimitry Andric istreambuf_iterator(istream_type& s) noexcept; 5920b57cec5SDimitry Andric istreambuf_iterator(streambuf_type* s) noexcept; 5930b57cec5SDimitry Andric istreambuf_iterator(a-private-type) noexcept; 5940b57cec5SDimitry Andric 5950b57cec5SDimitry Andric charT operator*() const; 5960b57cec5SDimitry Andric pointer operator->() const; 5970b57cec5SDimitry Andric istreambuf_iterator& operator++(); 5980b57cec5SDimitry Andric a-private-type operator++(int); 5990b57cec5SDimitry Andric 6000b57cec5SDimitry Andric bool equal(const istreambuf_iterator& b) const; 60181ad6265SDimitry Andric friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s); // since C++20 6020b57cec5SDimitry Andric}; 6030b57cec5SDimitry Andric 6040b57cec5SDimitry Andrictemplate <class charT, class traits> 6050b57cec5SDimitry Andricbool operator==(const istreambuf_iterator<charT,traits>& a, 6060b57cec5SDimitry Andric const istreambuf_iterator<charT,traits>& b); 6070b57cec5SDimitry Andrictemplate <class charT, class traits> 6080b57cec5SDimitry Andricbool operator!=(const istreambuf_iterator<charT,traits>& a, 60981ad6265SDimitry Andric const istreambuf_iterator<charT,traits>& b); // until C++20 6100b57cec5SDimitry Andric 6110b57cec5SDimitry Andrictemplate <class charT, class traits = char_traits<charT> > 6120b57cec5SDimitry Andricclass ostreambuf_iterator 613fe6060f1SDimitry Andric : public iterator<output_iterator_tag, void, void, void, void> // until C++17 6140b57cec5SDimitry Andric{ 6150b57cec5SDimitry Andricpublic: 616fe6060f1SDimitry Andric typedef output_iterator_tag iterator_category; 617fe6060f1SDimitry Andric typedef void value_type; 618fe6060f1SDimitry Andric typedef void difference_type; // until C++20 619fe6060f1SDimitry Andric typedef ptrdiff_t difference_type; // since C++20 620fe6060f1SDimitry Andric typedef void pointer; 621fe6060f1SDimitry Andric typedef void reference; 622fe6060f1SDimitry Andric 6230b57cec5SDimitry Andric typedef charT char_type; 6240b57cec5SDimitry Andric typedef traits traits_type; 6250b57cec5SDimitry Andric typedef basic_streambuf<charT, traits> streambuf_type; 6260b57cec5SDimitry Andric typedef basic_ostream<charT, traits> ostream_type; 6270b57cec5SDimitry Andric 6280b57cec5SDimitry Andric ostreambuf_iterator(ostream_type& s) noexcept; 6290b57cec5SDimitry Andric ostreambuf_iterator(streambuf_type* s) noexcept; 6300b57cec5SDimitry Andric ostreambuf_iterator& operator=(charT c); 6310b57cec5SDimitry Andric ostreambuf_iterator& operator*(); 6320b57cec5SDimitry Andric ostreambuf_iterator& operator++(); 6330b57cec5SDimitry Andric ostreambuf_iterator& operator++(int); 6340b57cec5SDimitry Andric bool failed() const noexcept; 6350b57cec5SDimitry Andric}; 6360b57cec5SDimitry Andric 6370b57cec5SDimitry Andrictemplate <class C> constexpr auto begin(C& c) -> decltype(c.begin()); 6380b57cec5SDimitry Andrictemplate <class C> constexpr auto begin(const C& c) -> decltype(c.begin()); 6390b57cec5SDimitry Andrictemplate <class C> constexpr auto end(C& c) -> decltype(c.end()); 6400b57cec5SDimitry Andrictemplate <class C> constexpr auto end(const C& c) -> decltype(c.end()); 6410b57cec5SDimitry Andrictemplate <class T, size_t N> constexpr T* begin(T (&array)[N]); 6420b57cec5SDimitry Andrictemplate <class T, size_t N> constexpr T* end(T (&array)[N]); 6430b57cec5SDimitry Andric 6440b57cec5SDimitry Andrictemplate <class C> auto constexpr cbegin(const C& c) -> decltype(std::begin(c)); // C++14 6450b57cec5SDimitry Andrictemplate <class C> auto constexpr cend(const C& c) -> decltype(std::end(c)); // C++14 6460b57cec5SDimitry Andrictemplate <class C> auto constexpr rbegin(C& c) -> decltype(c.rbegin()); // C++14 6470b57cec5SDimitry Andrictemplate <class C> auto constexpr rbegin(const C& c) -> decltype(c.rbegin()); // C++14 6480b57cec5SDimitry Andrictemplate <class C> auto constexpr rend(C& c) -> decltype(c.rend()); // C++14 6490b57cec5SDimitry Andrictemplate <class C> constexpr auto rend(const C& c) -> decltype(c.rend()); // C++14 6500b57cec5SDimitry Andrictemplate <class E> reverse_iterator<const E*> constexpr rbegin(initializer_list<E> il); // C++14 6510b57cec5SDimitry Andrictemplate <class E> reverse_iterator<const E*> constexpr rend(initializer_list<E> il); // C++14 6520b57cec5SDimitry Andrictemplate <class T, size_t N> reverse_iterator<T*> constexpr rbegin(T (&array)[N]); // C++14 6530b57cec5SDimitry Andrictemplate <class T, size_t N> reverse_iterator<T*> constexpr rend(T (&array)[N]); // C++14 6540b57cec5SDimitry Andrictemplate <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); // C++14 6550b57cec5SDimitry Andrictemplate <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c)); // C++14 6560b57cec5SDimitry Andric 6570b57cec5SDimitry Andric// 24.8, container access: 6580b57cec5SDimitry Andrictemplate <class C> constexpr auto size(const C& c) -> decltype(c.size()); // C++17 6590b57cec5SDimitry Andrictemplate <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17 6600b57cec5SDimitry Andric 6610b57cec5SDimitry Andrictemplate <class C> constexpr auto ssize(const C& c) 6620b57cec5SDimitry Andric -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>; // C++20 6630b57cec5SDimitry Andrictemplate <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20 6640b57cec5SDimitry Andric 6650b57cec5SDimitry Andrictemplate <class C> constexpr auto empty(const C& c) -> decltype(c.empty()); // C++17 6660b57cec5SDimitry Andrictemplate <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept; // C++17 6670b57cec5SDimitry Andrictemplate <class E> constexpr bool empty(initializer_list<E> il) noexcept; // C++17 6680b57cec5SDimitry Andrictemplate <class C> constexpr auto data(C& c) -> decltype(c.data()); // C++17 6690b57cec5SDimitry Andrictemplate <class C> constexpr auto data(const C& c) -> decltype(c.data()); // C++17 6700b57cec5SDimitry Andrictemplate <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept; // C++17 6710b57cec5SDimitry Andrictemplate <class E> constexpr const E* data(initializer_list<E> il) noexcept; // C++17 6720b57cec5SDimitry Andric 6730b57cec5SDimitry Andric} // std 6740b57cec5SDimitry Andric 6750b57cec5SDimitry Andric*/ 6760b57cec5SDimitry Andric 67781ad6265SDimitry Andric#include <__assert> // all public C++ headers provide the assertion handler 6780b57cec5SDimitry Andric#include <__config> 679fe6060f1SDimitry Andric#include <__debug> 680fe6060f1SDimitry Andric#include <__iterator/access.h> 681fe6060f1SDimitry Andric#include <__iterator/advance.h> 682fe6060f1SDimitry Andric#include <__iterator/back_insert_iterator.h> 68381ad6265SDimitry Andric#include <__iterator/bounded_iter.h> 684fe6060f1SDimitry Andric#include <__iterator/common_iterator.h> 685fe6060f1SDimitry Andric#include <__iterator/concepts.h> 686fe6060f1SDimitry Andric#include <__iterator/counted_iterator.h> 687fe6060f1SDimitry Andric#include <__iterator/data.h> 688fe6060f1SDimitry Andric#include <__iterator/default_sentinel.h> 689fe6060f1SDimitry Andric#include <__iterator/distance.h> 690fe6060f1SDimitry Andric#include <__iterator/empty.h> 691fe6060f1SDimitry Andric#include <__iterator/erase_if_container.h> 692fe6060f1SDimitry Andric#include <__iterator/front_insert_iterator.h> 693fe6060f1SDimitry Andric#include <__iterator/incrementable_traits.h> 69404eeddc0SDimitry Andric#include <__iterator/indirectly_comparable.h> 695fe6060f1SDimitry Andric#include <__iterator/insert_iterator.h> 696fe6060f1SDimitry Andric#include <__iterator/istream_iterator.h> 69704eeddc0SDimitry Andric#include <__iterator/istreambuf_iterator.h> 698fe6060f1SDimitry Andric#include <__iterator/iter_move.h> 699fe6060f1SDimitry Andric#include <__iterator/iter_swap.h> 70004eeddc0SDimitry Andric#include <__iterator/iterator.h> 70104eeddc0SDimitry Andric#include <__iterator/iterator_traits.h> 70281ad6265SDimitry Andric#include <__iterator/mergeable.h> 703fe6060f1SDimitry Andric#include <__iterator/move_iterator.h> 70481ad6265SDimitry Andric#include <__iterator/move_sentinel.h> 705fe6060f1SDimitry Andric#include <__iterator/next.h> 706fe6060f1SDimitry Andric#include <__iterator/ostream_iterator.h> 70704eeddc0SDimitry Andric#include <__iterator/ostreambuf_iterator.h> 70881ad6265SDimitry Andric#include <__iterator/permutable.h> 709fe6060f1SDimitry Andric#include <__iterator/prev.h> 710fe6060f1SDimitry Andric#include <__iterator/projected.h> 711fe6060f1SDimitry Andric#include <__iterator/readable_traits.h> 712fe6060f1SDimitry Andric#include <__iterator/reverse_access.h> 713fe6060f1SDimitry Andric#include <__iterator/reverse_iterator.h> 714fe6060f1SDimitry Andric#include <__iterator/size.h> 71581ad6265SDimitry Andric#include <__iterator/sortable.h> 716349cc55cSDimitry Andric#include <__iterator/unreachable_sentinel.h> 717fe6060f1SDimitry Andric#include <__iterator/wrap_iter.h> 718fe6060f1SDimitry Andric#include <__memory/addressof.h> 719fe6060f1SDimitry Andric#include <__memory/pointer_traits.h> 7200b57cec5SDimitry Andric#include <cstddef> 7210b57cec5SDimitry Andric#include <initializer_list> 7220b57cec5SDimitry Andric#include <version> 7230b57cec5SDimitry Andric 724*bdd1243dSDimitry Andric// standard-mandated includes 725*bdd1243dSDimitry Andric 726*bdd1243dSDimitry Andric// [iterator.synopsis] 727*bdd1243dSDimitry Andric#include <compare> 728*bdd1243dSDimitry Andric#include <concepts> 72981ad6265SDimitry Andric 7300b57cec5SDimitry Andric#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 7310b57cec5SDimitry Andric# pragma GCC system_header 7320b57cec5SDimitry Andric#endif 7330b57cec5SDimitry Andric 734*bdd1243dSDimitry Andric#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 735*bdd1243dSDimitry Andric# include <exception> 736*bdd1243dSDimitry Andric# include <new> 737*bdd1243dSDimitry Andric# include <type_traits> 738*bdd1243dSDimitry Andric# include <typeinfo> 739*bdd1243dSDimitry Andric# include <utility> 740*bdd1243dSDimitry Andric#endif 741*bdd1243dSDimitry Andric 7420b57cec5SDimitry Andric#endif // _LIBCPP_ITERATOR 743