mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-25 11:06:07 +00:00
b9a2658a3e
This patch implements the forwarding to frozen C++03 headers as discussed in https://discourse.llvm.org/t/rfc-freezing-c-03-headers-in-libc. In the RFC, we initially proposed selecting the right headers from the Clang driver, however consensus seemed to steer towards handling this in the library itself. This patch implements that direction. At a high level, the changes basically amount to making each public header look like this: ``` // inside <vector> #ifdef _LIBCPP_CXX03_LANG # include <__cxx03/vector> #else // normal <vector> content #endif ``` In most cases, public headers are simple umbrella headers so there isn't much code in the #else branch. In other cases, the #else branch contains the actual implementation of the header.
760 lines
32 KiB
C++
760 lines
32 KiB
C++
// -*- C++ -*-
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP_ITERATOR
|
|
#define _LIBCPP_ITERATOR
|
|
|
|
/*
|
|
iterator synopsis
|
|
|
|
#include <concepts>
|
|
|
|
namespace std
|
|
{
|
|
template<class> struct incrementable_traits; // since C++20
|
|
template<class T>
|
|
using iter_difference_t = see below; // since C++20
|
|
|
|
template<class> struct indirectly_readable_traits; // since C++20
|
|
template<class T>
|
|
using iter_value_t = see below; // since C++20
|
|
|
|
template<class Iterator>
|
|
struct iterator_traits;
|
|
|
|
template<class T>
|
|
requires is_object_v<T> // since C++20
|
|
struct iterator_traits<T*>;
|
|
|
|
template<dereferenceable T>
|
|
using iter_reference_t = decltype(*declval<T&>());
|
|
|
|
namespace ranges::inline unspecified {
|
|
inline constexpr unspecified iter_move = unspecified; // since C++20, nodiscard as an extension
|
|
}}
|
|
|
|
template<dereferenceable T>
|
|
requires ...
|
|
using iter_rvalue_reference_t = decltype(ranges::iter_move(declval<T&>())); // since C++20
|
|
|
|
// [iterator.concepts], iterator concepts
|
|
// [iterator.concept.readable], concept indirectly_readable
|
|
template<class In>
|
|
concept indirectly_readable = see below; // since C++20
|
|
|
|
template<indirectly_readable T>
|
|
using iter_common_reference_t =
|
|
common_reference_t<iter_reference_t<T>, iter_value_t<T>&>; // since C++20
|
|
|
|
// [iterator.concept.writable], concept indirectly_writable
|
|
template<class Out, class T>
|
|
concept indirectly_writable = see below; // since C++20
|
|
|
|
// [iterator.concept.winc], concept weakly_incrementable
|
|
template<class I>
|
|
concept weakly_incrementable = see below; // since C++20
|
|
|
|
// [iterator.concept.inc], concept incrementable
|
|
template<class I>
|
|
concept incrementable = see below; // since C++20
|
|
|
|
// [iterator.concept.iterator], concept input_or_output_iterator
|
|
template<class I>
|
|
concept input_or_output_iterator = see below; // since C++20
|
|
|
|
// [iterator.concept.sentinel], concept sentinel_for
|
|
template<class S, class I>
|
|
concept sentinel_for = see below; // since C++20
|
|
|
|
// [iterator.concept.sizedsentinel], concept sized_sentinel_for
|
|
template<class S, class I>
|
|
inline constexpr bool disable_sized_sentinel_for = false;
|
|
|
|
template<class S, class I>
|
|
concept sized_sentinel_for = see below;
|
|
|
|
// [iterator.concept.input], concept input_iterator
|
|
template<class I>
|
|
concept input_iterator = see below; // since C++20
|
|
|
|
// [iterator.concept.output], concept output_iterator
|
|
template<class I, class T>
|
|
concept output_iterator = see below; // since C++20
|
|
|
|
// [iterator.concept.forward], concept forward_iterator
|
|
template<class I>
|
|
concept forward_iterator = see below; // since C++20
|
|
|
|
// [iterator.concept.bidir], concept bidirectional_iterator
|
|
template<class I>
|
|
concept bidirectional_iterator = see below; // since C++20
|
|
|
|
// [iterator.concept.random.access], concept random_access_iterator
|
|
template<class I>
|
|
concept random_access_iterator = see below; // since C++20
|
|
|
|
// [indirectcallable]
|
|
// [indirectcallable.indirectinvocable]
|
|
template<class F, class I>
|
|
concept indirectly_unary_invocable = see below; // since C++20
|
|
|
|
template<class F, class I>
|
|
concept indirectly_regular_unary_invocable = see below; // since C++20
|
|
|
|
template<class F, class I>
|
|
concept indirect_unary_predicate = see below; // since C++20
|
|
|
|
template<class F, class I1, class I2>
|
|
concept indirect_binary_predicate = see below; // since C++20
|
|
|
|
template<class F, class I1, class I2 = I1>
|
|
concept indirect_equivalence_relation = see below; // since C++20
|
|
|
|
template<class F, class I1, class I2 = I1>
|
|
concept indirect_strict_weak_order = see below; // since C++20
|
|
|
|
template<class F, class... Is>
|
|
using indirect_result_t = see below; // since C++20
|
|
|
|
// [projected], projected
|
|
template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
|
|
struct projected; // since C++20
|
|
|
|
template<weakly_incrementable I, indirectly_regular_unary_invocable<I> Proj>
|
|
struct incrementable_traits<projected<I, Proj>>; // since C++20
|
|
|
|
// [alg.req.ind.move], concept indirectly_movable
|
|
template<class In, class Out>
|
|
concept indirectly_movable = see below; // since C++20
|
|
|
|
template<class In, class Out>
|
|
concept indirectly_movable_storable = see below; // since C++20
|
|
|
|
// [alg.req.ind.copy], concept indirectly_copyable
|
|
template<class In, class Out>
|
|
concept indirectly_copyable = see below; // since C++20
|
|
|
|
template<class In, class Out>
|
|
concept indirectly_copyable_storable = see below; // since C++20
|
|
|
|
// [alg.req.ind.swap], concept indirectly_swappable
|
|
template<class I1, class I2 = I1>
|
|
concept indirectly_swappable = see below; // since C++20
|
|
|
|
template<class I1, class I2, class R, class P1 = identity,
|
|
class P2 = identity>
|
|
concept indirectly_comparable =
|
|
indirect_binary_predicate<R, projected<I1, P1>, projected<I2, P2>>; // since C++20
|
|
|
|
// [alg.req.permutable], concept permutable
|
|
template<class I>
|
|
concept permutable = see below; // since C++20
|
|
|
|
// [alg.req.mergeable], concept mergeable
|
|
template<class I1, class I2, class Out,
|
|
class R = ranges::less, class P1 = identity, class P2 = identity>
|
|
concept mergeable = see below; // since C++20
|
|
|
|
// [alg.req.sortable], concept sortable
|
|
template<class I, class R = ranges::less, class P = identity>
|
|
concept sortable = see below; // since C++20
|
|
|
|
template<input_or_output_iterator I, sentinel_for<I> S>
|
|
requires (!same_as<I, S> && copyable<I>)
|
|
class common_iterator; // since C++20
|
|
|
|
template<class Category, class T, class Distance = ptrdiff_t,
|
|
class Pointer = T*, class Reference = T&>
|
|
struct iterator // deprecated in C++17
|
|
{
|
|
typedef T value_type;
|
|
typedef Distance difference_type;
|
|
typedef Pointer pointer;
|
|
typedef Reference reference;
|
|
typedef Category iterator_category;
|
|
};
|
|
|
|
struct input_iterator_tag {};
|
|
struct output_iterator_tag {};
|
|
struct forward_iterator_tag : public input_iterator_tag {};
|
|
struct bidirectional_iterator_tag : public forward_iterator_tag {};
|
|
struct random_access_iterator_tag : public bidirectional_iterator_tag {};
|
|
struct contiguous_iterator_tag : public random_access_iterator_tag {};
|
|
|
|
// 27.4.3, iterator operations
|
|
template <class InputIterator, class Distance> // constexpr in C++17
|
|
constexpr void advance(InputIterator& i, Distance n);
|
|
|
|
template <class InputIterator> // constexpr in C++17
|
|
constexpr typename iterator_traits<InputIterator>::difference_type
|
|
distance(InputIterator first, InputIterator last);
|
|
|
|
template <class InputIterator> // constexpr in C++17
|
|
constexpr InputIterator next(InputIterator x,
|
|
typename iterator_traits<InputIterator>::difference_type n = 1);
|
|
|
|
template <class BidirectionalIterator> // constexpr in C++17
|
|
constexpr BidirectionalIterator prev(BidirectionalIterator x,
|
|
typename iterator_traits<BidirectionalIterator>::difference_type n = 1);
|
|
|
|
// [range.iter.ops], range iterator operations
|
|
namespace ranges {
|
|
// [range.iter.op.advance], ranges::advance
|
|
template<input_or_output_iterator I>
|
|
constexpr void advance(I& i, iter_difference_t<I> n); // since C++20
|
|
template<input_or_output_iterator I, sentinel_for<I> S>
|
|
constexpr void advance(I& i, S bound); // since C++20
|
|
template<input_or_output_iterator I, sentinel_for<I> S>
|
|
constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound); // since C++20
|
|
}
|
|
|
|
template <class Iterator>
|
|
class reverse_iterator
|
|
: public iterator<typename iterator_traits<Iterator>::iterator_category, // until C++17
|
|
typename iterator_traits<Iterator>::value_type,
|
|
typename iterator_traits<Iterator>::difference_type,
|
|
typename iterator_traits<Iterator>::pointer,
|
|
typename iterator_traits<Iterator>::reference>
|
|
{
|
|
protected:
|
|
Iterator current;
|
|
public:
|
|
using iterator_type = Iterator;
|
|
using iterator_concept = see below; // since C++20
|
|
using iterator_category = typename iterator_traits<Iterator>::iterator_category; // since C++17, until C++20
|
|
using iterator_category = see below; // since C++20
|
|
using value_type = typename iterator_traits<Iterator>::value_type; // since C++17, until C++20
|
|
using value_type = iter_value_t<Iterator>; // since C++20
|
|
using difference_type = typename iterator_traits<Iterator>::difference_type; // until C++20
|
|
using difference_type = iter_difference_t<Iterator>; // since C++20
|
|
using pointer = typename iterator_traits<Iterator>::pointer;
|
|
using reference = typename iterator_traits<Iterator>::reference; // until C++20
|
|
using reference = iter_reference_t<Iterator>; // since C++20
|
|
|
|
constexpr reverse_iterator();
|
|
constexpr explicit reverse_iterator(Iterator x);
|
|
template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
|
|
template <class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u);
|
|
constexpr Iterator base() const;
|
|
constexpr reference operator*() const;
|
|
constexpr pointer operator->() const; // until C++20
|
|
constexpr pointer operator->() const requires see below; // since C++20
|
|
constexpr reverse_iterator& operator++();
|
|
constexpr reverse_iterator operator++(int);
|
|
constexpr reverse_iterator& operator--();
|
|
constexpr reverse_iterator operator--(int);
|
|
constexpr reverse_iterator operator+ (difference_type n) const;
|
|
constexpr reverse_iterator& operator+=(difference_type n);
|
|
constexpr reverse_iterator operator- (difference_type n) const;
|
|
constexpr reverse_iterator& operator-=(difference_type n);
|
|
constexpr unspecified operator[](difference_type n) const;
|
|
|
|
friend constexpr iter_rvalue_reference_t<Iterator>
|
|
iter_move(const reverse_iterator& i) noexcept(see below);
|
|
template<indirectly_swappable<Iterator> Iterator2>
|
|
friend constexpr void
|
|
iter_swap(const reverse_iterator& x,
|
|
const reverse_iterator<Iterator2>& y) noexcept(see below);
|
|
};
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y);
|
|
|
|
template<class Iterator1, three_way_comparable_with<Iterator1> Iterator2>
|
|
constexpr compare_three_way_result_t<Iterator1, Iterator2>
|
|
operator<=>(const reverse_iterator<Iterator1>& x,
|
|
const reverse_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr auto
|
|
operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y)
|
|
-> decltype(__y.base() - __x.base()); // constexpr in C++17
|
|
|
|
template <class Iterator>
|
|
constexpr reverse_iterator<Iterator>
|
|
operator+(typename reverse_iterator<Iterator>::difference_type n,
|
|
const reverse_iterator<Iterator>& x); // constexpr in C++17
|
|
|
|
template <class Iterator>
|
|
constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17
|
|
|
|
template<class Iterator1, class Iterator2>
|
|
requires (!sized_sentinel_for<Iterator1, Iterator2>)
|
|
inline constexpr bool disable_sized_sentinel_for<reverse_iterator<Iterator1>,
|
|
reverse_iterator<Iterator2>> = true;
|
|
|
|
template <class Container>
|
|
class back_insert_iterator
|
|
: public iterator<output_iterator_tag, void, void, void, void> // until C++17
|
|
{
|
|
protected:
|
|
Container* container;
|
|
public:
|
|
typedef Container container_type;
|
|
typedef void value_type;
|
|
typedef void difference_type; // until C++20
|
|
typedef ptrdiff_t difference_type; // since C++20
|
|
typedef void reference;
|
|
typedef void pointer;
|
|
|
|
explicit back_insert_iterator(Container& x); // constexpr in C++20
|
|
back_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20
|
|
back_insert_iterator& operator*(); // constexpr in C++20
|
|
back_insert_iterator& operator++(); // constexpr in C++20
|
|
back_insert_iterator operator++(int); // constexpr in C++20
|
|
};
|
|
|
|
template <class Container> back_insert_iterator<Container> back_inserter(Container& x); // constexpr in C++20
|
|
|
|
template <class Container>
|
|
class front_insert_iterator
|
|
: public iterator<output_iterator_tag, void, void, void, void> // until C++17
|
|
{
|
|
protected:
|
|
Container* container;
|
|
public:
|
|
typedef Container container_type;
|
|
typedef void value_type;
|
|
typedef void difference_type; // until C++20
|
|
typedef ptrdiff_t difference_type; // since C++20
|
|
typedef void reference;
|
|
typedef void pointer;
|
|
|
|
explicit front_insert_iterator(Container& x); // constexpr in C++20
|
|
front_insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20
|
|
front_insert_iterator& operator*(); // constexpr in C++20
|
|
front_insert_iterator& operator++(); // constexpr in C++20
|
|
front_insert_iterator operator++(int); // constexpr in C++20
|
|
};
|
|
|
|
template <class Container> front_insert_iterator<Container> front_inserter(Container& x); // constexpr in C++20
|
|
|
|
template <class Container>
|
|
class insert_iterator
|
|
: public iterator<output_iterator_tag, void, void, void, void> // until C++17
|
|
{
|
|
protected:
|
|
Container* container;
|
|
typename Container::iterator iter;
|
|
public:
|
|
typedef Container container_type;
|
|
typedef void value_type;
|
|
typedef void difference_type; // until C++20
|
|
typedef ptrdiff_t difference_type; // since C++20
|
|
typedef void reference;
|
|
typedef void pointer;
|
|
|
|
insert_iterator(Container& x, typename Container::iterator i); // constexpr in C++20
|
|
insert_iterator& operator=(const typename Container::value_type& value); // constexpr in C++20
|
|
insert_iterator& operator*(); // constexpr in C++20
|
|
insert_iterator& operator++(); // constexpr in C++20
|
|
insert_iterator& operator++(int); // constexpr in C++20
|
|
};
|
|
|
|
template <class Container>
|
|
insert_iterator<Container> inserter(Container& x, typename Container::iterator i); // until C++20
|
|
template <class Container>
|
|
constexpr insert_iterator<Container> inserter(Container& x, ranges::iterator_t<Container> i); // since C++20
|
|
|
|
template <class Iterator>
|
|
class move_iterator {
|
|
public:
|
|
using iterator_type = Iterator;
|
|
using iterator_concept = see below; // From C++20
|
|
using iterator_category = see below; // not always present starting from C++20
|
|
using value_type = iter_value_t<Iterator>; // Until C++20, iterator_traits<Iterator>::value_type
|
|
using difference_type = iter_difference_t<Iterator>; // Until C++20, iterator_traits<Iterator>::difference_type;
|
|
using pointer = Iterator;
|
|
using reference = iter_rvalue_reference_t<Iterator>; // Until C++20, value_type&&
|
|
|
|
constexpr move_iterator(); // all the constexprs are in C++17
|
|
constexpr explicit move_iterator(Iterator i);
|
|
template <class U>
|
|
constexpr move_iterator(const move_iterator<U>& u);
|
|
template <class U>
|
|
constexpr move_iterator& operator=(const move_iterator<U>& u);
|
|
|
|
constexpr iterator_type base() const; // Until C++20
|
|
constexpr const Iterator& base() const & noexcept; // From C++20
|
|
constexpr Iterator base() &&; // From C++20
|
|
|
|
constexpr reference operator*() const;
|
|
constexpr pointer operator->() const; // Deprecated in C++20
|
|
constexpr move_iterator& operator++();
|
|
constexpr auto operator++(int); // Return type was move_iterator until C++20
|
|
constexpr move_iterator& operator--();
|
|
constexpr move_iterator operator--(int);
|
|
constexpr move_iterator operator+(difference_type n) const;
|
|
constexpr move_iterator& operator+=(difference_type n);
|
|
constexpr move_iterator operator-(difference_type n) const;
|
|
constexpr move_iterator& operator-=(difference_type n);
|
|
constexpr reference operator[](difference_type n) const; // Return type unspecified until C++20
|
|
|
|
template<sentinel_for<Iterator> S>
|
|
friend constexpr bool
|
|
operator==(const move_iterator& x, const move_sentinel<S>& y); // Since C++20
|
|
template<sized_sentinel_for<Iterator> S>
|
|
friend constexpr iter_difference_t<Iterator>
|
|
operator-(const move_sentinel<S>& x, const move_iterator& y); // Since C++20
|
|
template<sized_sentinel_for<Iterator> S>
|
|
friend constexpr iter_difference_t<Iterator>
|
|
operator-(const move_iterator& x, const move_sentinel<S>& y); // Since C++20
|
|
friend constexpr iter_rvalue_reference_t<Iterator>
|
|
iter_move(const move_iterator& i)
|
|
noexcept(noexcept(ranges::iter_move(i.current))); // Since C++20
|
|
template<indirectly_swappable<Iterator> Iterator2>
|
|
friend constexpr void
|
|
iter_swap(const move_iterator& x, const move_iterator<Iterator2>& y)
|
|
noexcept(noexcept(ranges::iter_swap(x.current, y.current))); // Since C++20
|
|
|
|
private:
|
|
Iterator current; // exposition only
|
|
};
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr bool // constexpr in C++17
|
|
operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y);
|
|
|
|
template <class Iterator1, class Iterator2>
|
|
constexpr auto // constexpr in C++17
|
|
operator-(const move_iterator<Iterator1>& x,
|
|
const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base());
|
|
|
|
template <class Iterator>
|
|
constexpr move_iterator<Iterator> operator+( // constexpr in C++17
|
|
typename move_iterator<Iterator>::difference_type n,
|
|
const move_iterator<Iterator>& x);
|
|
|
|
template <class Iterator> // constexpr in C++17
|
|
constexpr move_iterator<Iterator> make_move_iterator(const Iterator& i);
|
|
|
|
template<class Iterator1, class Iterator2>
|
|
requires (!sized_sentinel_for<Iterator1, Iterator2>)
|
|
inline constexpr bool disable_sized_sentinel_for<move_iterator<Iterator1>, // since C++20
|
|
move_iterator<Iterator2>> = true;
|
|
|
|
template<semiregular S>
|
|
class move_sentinel {
|
|
public:
|
|
constexpr move_sentinel();
|
|
constexpr explicit move_sentinel(S s);
|
|
template<class S2>
|
|
requires convertible_to<const S2&, S>
|
|
constexpr move_sentinel(const move_sentinel<S2>& s);
|
|
template<class S2>
|
|
requires assignable_from<S&, const S2&>
|
|
constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
|
|
|
|
constexpr S base() const;
|
|
private:
|
|
S last; // exposition only
|
|
};
|
|
|
|
// [default.sentinel], default sentinel
|
|
struct default_sentinel_t;
|
|
inline constexpr default_sentinel_t default_sentinel{};
|
|
|
|
// [iterators.counted], counted iterators
|
|
template<input_or_output_iterator I> class counted_iterator;
|
|
|
|
template<input_iterator I>
|
|
requires see below
|
|
struct iterator_traits<counted_iterator<I>>;
|
|
|
|
// [unreachable.sentinel], unreachable sentinel
|
|
struct unreachable_sentinel_t;
|
|
inline constexpr unreachable_sentinel_t unreachable_sentinel{};
|
|
|
|
template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t>
|
|
class istream_iterator
|
|
: public iterator<input_iterator_tag, T, Distance, const T*, const T&> // until C++17
|
|
{
|
|
public:
|
|
typedef input_iterator_tag iterator_category;
|
|
typedef T value_type;
|
|
typedef Distance difference_type;
|
|
typedef const T* pointer;
|
|
typedef const T& reference;
|
|
|
|
typedef charT char_type;
|
|
typedef traits traits_type;
|
|
typedef basic_istream<charT, traits> istream_type;
|
|
|
|
istream_iterator(); // constexpr since C++11
|
|
constexpr istream_iterator(default_sentinel_t); // since C++20
|
|
istream_iterator(istream_type& s);
|
|
istream_iterator(const istream_iterator& x);
|
|
~istream_iterator();
|
|
|
|
const T& operator*() const;
|
|
const T* operator->() const;
|
|
istream_iterator& operator++();
|
|
istream_iterator operator++(int);
|
|
friend bool operator==(const istream_iterator& i, default_sentinel_t); // since C++20
|
|
};
|
|
|
|
template <class T, class charT, class traits, class Distance>
|
|
bool operator==(const istream_iterator<T,charT,traits,Distance>& x,
|
|
const istream_iterator<T,charT,traits,Distance>& y);
|
|
template <class T, class charT, class traits, class Distance>
|
|
bool operator!=(const istream_iterator<T,charT,traits,Distance>& x,
|
|
const istream_iterator<T,charT,traits,Distance>& y); // until C++20
|
|
|
|
template <class T, class charT = char, class traits = char_traits<charT> >
|
|
class ostream_iterator
|
|
: public iterator<output_iterator_tag, void, void, void, void> // until C++17
|
|
{
|
|
public:
|
|
typedef output_iterator_tag iterator_category;
|
|
typedef void value_type;
|
|
typedef void difference_type; // until C++20
|
|
typedef ptrdiff_t difference_type; // since C++20
|
|
typedef void pointer;
|
|
typedef void reference;
|
|
|
|
typedef charT char_type;
|
|
typedef traits traits_type;
|
|
typedef basic_ostream<charT,traits> ostream_type;
|
|
|
|
ostream_iterator(ostream_type& s);
|
|
ostream_iterator(ostream_type& s, const charT* delimiter);
|
|
ostream_iterator(const ostream_iterator& x);
|
|
~ostream_iterator();
|
|
ostream_iterator& operator=(const T& value);
|
|
|
|
ostream_iterator& operator*();
|
|
ostream_iterator& operator++();
|
|
ostream_iterator& operator++(int);
|
|
};
|
|
|
|
template<class charT, class traits = char_traits<charT> >
|
|
class istreambuf_iterator
|
|
: public iterator<input_iterator_tag, charT, traits::off_type, unspecified, charT> // until C++17
|
|
{
|
|
public:
|
|
typedef input_iterator_tag iterator_category;
|
|
typedef charT value_type;
|
|
typedef traits::off_type difference_type;
|
|
typedef unspecified pointer;
|
|
typedef charT reference;
|
|
|
|
typedef charT char_type;
|
|
typedef traits traits_type;
|
|
typedef traits::int_type int_type;
|
|
typedef basic_streambuf<charT, traits> streambuf_type;
|
|
typedef basic_istream<charT, traits> istream_type;
|
|
|
|
istreambuf_iterator() noexcept; // constexpr since C++11
|
|
constexpr istreambuf_iterator(default_sentinel_t) noexcept; // since C++20
|
|
istreambuf_iterator(istream_type& s) noexcept;
|
|
istreambuf_iterator(streambuf_type* s) noexcept;
|
|
istreambuf_iterator(a-private-type) noexcept;
|
|
|
|
charT operator*() const;
|
|
pointer operator->() const;
|
|
istreambuf_iterator& operator++();
|
|
a-private-type operator++(int);
|
|
|
|
bool equal(const istreambuf_iterator& b) const;
|
|
friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s); // since C++20
|
|
};
|
|
|
|
template <class charT, class traits>
|
|
bool operator==(const istreambuf_iterator<charT,traits>& a,
|
|
const istreambuf_iterator<charT,traits>& b);
|
|
template <class charT, class traits>
|
|
bool operator!=(const istreambuf_iterator<charT,traits>& a,
|
|
const istreambuf_iterator<charT,traits>& b); // until C++20
|
|
|
|
template <class charT, class traits = char_traits<charT> >
|
|
class ostreambuf_iterator
|
|
: public iterator<output_iterator_tag, void, void, void, void> // until C++17
|
|
{
|
|
public:
|
|
typedef output_iterator_tag iterator_category;
|
|
typedef void value_type;
|
|
typedef void difference_type; // until C++20
|
|
typedef ptrdiff_t difference_type; // since C++20
|
|
typedef void pointer;
|
|
typedef void reference;
|
|
|
|
typedef charT char_type;
|
|
typedef traits traits_type;
|
|
typedef basic_streambuf<charT, traits> streambuf_type;
|
|
typedef basic_ostream<charT, traits> ostream_type;
|
|
|
|
ostreambuf_iterator(ostream_type& s) noexcept;
|
|
ostreambuf_iterator(streambuf_type* s) noexcept;
|
|
ostreambuf_iterator& operator=(charT c);
|
|
ostreambuf_iterator& operator*();
|
|
ostreambuf_iterator& operator++();
|
|
ostreambuf_iterator& operator++(int);
|
|
bool failed() const noexcept;
|
|
};
|
|
|
|
template <class C> constexpr auto begin(C& c) -> decltype(c.begin()); // constexpr since C++17
|
|
template <class C> constexpr auto begin(const C& c) -> decltype(c.begin()); // constexpr since C++17
|
|
template <class C> constexpr auto end(C& c) -> decltype(c.end()); // constexpr since C++17
|
|
template <class C> constexpr auto end(const C& c) -> decltype(c.end()); // constexpr since C++17
|
|
template <class T, size_t N> constexpr T* begin(T (&array)[N]) noexcept;
|
|
template <class T, size_t N> constexpr T* end(T (&array)[N]) noexcept;
|
|
|
|
template <class C> constexpr auto cbegin(const C& c) noexcept(see-below) -> decltype(std::begin(c)); // C++14
|
|
template <class C> constexpr auto cend(const C& c) noexcept(see-below) -> decltype(std::end(c)); // C++14
|
|
template <class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin()); // C++14, constexpr since C++17
|
|
template <class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin()); // C++14, constexpr since C++17
|
|
template <class C> constexpr auto rend(C& c) -> decltype(c.rend()); // C++14, constexpr since C++17
|
|
template <class C> constexpr auto rend(const C& c) -> decltype(c.rend()); // C++14, constexpr since C++17
|
|
template <class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il); // C++14, constexpr since C++17
|
|
template <class E> constexpr reverse_iterator<const E*> rend(initializer_list<E> il); // C++14, constexpr since C++17
|
|
template <class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N]); // C++14, constexpr since C++17
|
|
template <class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]); // C++14, constexpr since C++17
|
|
template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); // C++14, constexpr since C++17
|
|
template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c)); // C++14, constexpr since C++17
|
|
|
|
// 24.8, container access:
|
|
template <class C> constexpr auto size(const C& c) -> decltype(c.size()); // C++17
|
|
template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17
|
|
|
|
template <class C> constexpr auto ssize(const C& c)
|
|
-> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>; // C++20
|
|
template <class T, ptrdiff_t> constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20
|
|
|
|
template <class C> constexpr auto empty(const C& c) -> decltype(c.empty()); // C++17
|
|
template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept; // C++17
|
|
template <class E> constexpr bool empty(initializer_list<E> il) noexcept; // C++17
|
|
template <class C> constexpr auto data(C& c) -> decltype(c.data()); // C++17
|
|
template <class C> constexpr auto data(const C& c) -> decltype(c.data()); // C++17
|
|
template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept; // C++17
|
|
template <class E> constexpr const E* data(initializer_list<E> il) noexcept; // C++17
|
|
|
|
} // std
|
|
|
|
*/
|
|
|
|
#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
|
|
# include <__cxx03/iterator>
|
|
#else
|
|
# include <__config>
|
|
# include <__iterator/access.h>
|
|
# include <__iterator/advance.h>
|
|
# include <__iterator/back_insert_iterator.h>
|
|
# include <__iterator/distance.h>
|
|
# include <__iterator/front_insert_iterator.h>
|
|
# include <__iterator/insert_iterator.h>
|
|
# include <__iterator/istream_iterator.h>
|
|
# include <__iterator/istreambuf_iterator.h>
|
|
# include <__iterator/iterator.h>
|
|
# include <__iterator/iterator_traits.h>
|
|
# include <__iterator/move_iterator.h>
|
|
# include <__iterator/next.h>
|
|
# include <__iterator/ostream_iterator.h>
|
|
# include <__iterator/ostreambuf_iterator.h>
|
|
# include <__iterator/prev.h>
|
|
# include <__iterator/reverse_iterator.h>
|
|
# include <__iterator/wrap_iter.h>
|
|
|
|
# if _LIBCPP_STD_VER >= 14
|
|
# include <__iterator/reverse_access.h>
|
|
# endif
|
|
|
|
# if _LIBCPP_STD_VER >= 17
|
|
# include <__iterator/data.h>
|
|
# include <__iterator/empty.h>
|
|
# include <__iterator/size.h>
|
|
# endif
|
|
|
|
# if _LIBCPP_STD_VER >= 20
|
|
# include <__iterator/common_iterator.h>
|
|
# include <__iterator/concepts.h>
|
|
# include <__iterator/counted_iterator.h>
|
|
# include <__iterator/default_sentinel.h>
|
|
# include <__iterator/incrementable_traits.h>
|
|
# include <__iterator/indirectly_comparable.h>
|
|
# include <__iterator/iter_move.h>
|
|
# include <__iterator/iter_swap.h>
|
|
# include <__iterator/mergeable.h>
|
|
# include <__iterator/move_sentinel.h>
|
|
# include <__iterator/permutable.h>
|
|
# include <__iterator/projected.h>
|
|
# include <__iterator/readable_traits.h>
|
|
# include <__iterator/sortable.h>
|
|
# include <__iterator/unreachable_sentinel.h>
|
|
# endif
|
|
|
|
# include <version>
|
|
|
|
// standard-mandated includes
|
|
|
|
// [iterator.synopsis]
|
|
# include <compare>
|
|
# include <concepts>
|
|
|
|
# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
# pragma GCC system_header
|
|
# endif
|
|
|
|
# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
|
|
# include <variant>
|
|
# endif
|
|
|
|
# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
|
|
# include <cstddef>
|
|
# include <cstdlib>
|
|
# include <exception>
|
|
# include <new>
|
|
# include <type_traits>
|
|
# include <typeinfo>
|
|
# include <utility>
|
|
# endif
|
|
#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
|
|
|
|
#endif // _LIBCPP_ITERATOR
|