From 3ad39e9878310e5317ee73c9b353c1e2c1c5c4ee Mon Sep 17 00:00:00 2001 From: Richard Qin Date: Sat, 11 Jul 2026 22:48:30 +0800 Subject: lib: establish Zircon libc++ and KTL foundation --- third_party/libcxx/include/c++/v1/iterator | 769 +++++++++++++++++++++++++++++ 1 file changed, 769 insertions(+) create mode 100644 third_party/libcxx/include/c++/v1/iterator (limited to 'third_party/libcxx/include/c++/v1/iterator') diff --git a/third_party/libcxx/include/c++/v1/iterator b/third_party/libcxx/include/c++/v1/iterator new file mode 100644 index 0000000..fc8bdc5 --- /dev/null +++ b/third_party/libcxx/include/c++/v1/iterator @@ -0,0 +1,769 @@ +// -*- 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 + +namespace std +{ +template struct incrementable_traits; // since C++20 +template + using iter_difference_t = see below; // since C++20 + +template struct indirectly_readable_traits; // since C++20 +template + using iter_value_t = see below; // since C++20 + +template +struct iterator_traits; + +template + requires is_object_v // since C++20 +struct iterator_traits; + +template + using iter_reference_t = decltype(*declval()); + +namespace ranges::inline unspecified { + inline constexpr unspecified iter_move = unspecified; // since C++20, nodiscard as an extension +}} + +template + requires ... +using iter_rvalue_reference_t = decltype(ranges::iter_move(declval())); // since C++20 + +// [iterator.concepts], iterator concepts +// [iterator.concept.readable], concept indirectly_readable +template + concept indirectly_readable = see below; // since C++20 + +template + using iter_common_reference_t = + common_reference_t, iter_value_t&>; // since C++20 + +// [iterator.concept.writable], concept indirectly_writable +template + concept indirectly_writable = see below; // since C++20 + +// [iterator.concept.winc], concept weakly_incrementable +template + concept weakly_incrementable = see below; // since C++20 + +// [iterator.concept.inc], concept incrementable +template + concept incrementable = see below; // since C++20 + +// [iterator.concept.iterator], concept input_or_output_iterator + template + concept input_or_output_iterator = see below; // since C++20 + +// [iterator.concept.sentinel], concept sentinel_for +template + concept sentinel_for = see below; // since C++20 + +// [iterator.concept.sizedsentinel], concept sized_sentinel_for +template + inline constexpr bool disable_sized_sentinel_for = false; + +template + concept sized_sentinel_for = see below; + +// [iterator.concept.input], concept input_iterator +template + concept input_iterator = see below; // since C++20 + +// [iterator.concept.output], concept output_iterator +template + concept output_iterator = see below; // since C++20 + +// [iterator.concept.forward], concept forward_iterator +template + concept forward_iterator = see below; // since C++20 + +// [iterator.concept.bidir], concept bidirectional_iterator +template + concept bidirectional_iterator = see below; // since C++20 + +// [iterator.concept.random.access], concept random_access_iterator +template + concept random_access_iterator = see below; // since C++20 + +// [indirectcallable] +// [indirectcallable.indirectinvocable] +template + concept indirectly_unary_invocable = see below; // since C++20 + +template + concept indirectly_regular_unary_invocable = see below; // since C++20 + +template + concept indirect_unary_predicate = see below; // since C++20 + +template + concept indirect_binary_predicate = see below; // since C++20 + +template + concept indirect_equivalence_relation = see below; // since C++20 + +template + concept indirect_strict_weak_order = see below; // since C++20 + +template + using indirect_result_t = see below; // since C++20 + +// [projected], projected +template Proj> + struct projected; // since C++20 + +template Proj> + struct incrementable_traits>; // since C++20 + +// [alg.req.ind.move], concept indirectly_movable +template + concept indirectly_movable = see below; // since C++20 + +template + concept indirectly_movable_storable = see below; // since C++20 + +// [alg.req.ind.copy], concept indirectly_copyable +template + concept indirectly_copyable = see below; // since C++20 + +template + concept indirectly_copyable_storable = see below; // since C++20 + +// [alg.req.ind.swap], concept indirectly_swappable +template + concept indirectly_swappable = see below; // since C++20 + +template + concept indirectly_comparable = + indirect_binary_predicate, projected>; // since C++20 + +// [alg.req.permutable], concept permutable +template + concept permutable = see below; // since C++20 + + // [alg.req.mergeable], concept mergeable +template + concept mergeable = see below; // since C++20 + +// [alg.req.sortable], concept sortable +template + concept sortable = see below; // since C++20 + +template S> + requires (!same_as && copyable) +class common_iterator; // since C++20 + +template +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 // constexpr in C++17 + constexpr void advance(InputIterator& i, Distance n); + +template // constexpr in C++17 + constexpr typename iterator_traits::difference_type + distance(InputIterator first, InputIterator last); + +template // constexpr in C++17 + constexpr InputIterator next(InputIterator x, +typename iterator_traits::difference_type n = 1); + +template // constexpr in C++17 + constexpr BidirectionalIterator prev(BidirectionalIterator x, + typename iterator_traits::difference_type n = 1); + +// [range.iter.ops], range iterator operations +namespace ranges { + // [range.iter.op.advance], ranges::advance + template + constexpr void advance(I& i, iter_difference_t n); // since C++20 + template S> + constexpr void advance(I& i, S bound); // since C++20 + template S> + constexpr iter_difference_t advance(I& i, iter_difference_t n, S bound); // since C++20 +} + +template +class reverse_iterator + : public iterator::iterator_category, // until C++17 + typename iterator_traits::value_type, + typename iterator_traits::difference_type, + typename iterator_traits::pointer, + typename iterator_traits::reference> +{ +protected: + Iterator current; +public: + using iterator_type = Iterator; + using iterator_concept = see below; // since C++20 + using iterator_category = typename iterator_traits::iterator_category; // since C++17, until C++20 + using iterator_category = see below; // since C++20 + using value_type = typename iterator_traits::value_type; // since C++17, until C++20 + using value_type = iter_value_t; // since C++20 + using difference_type = typename iterator_traits::difference_type; // until C++20 + using difference_type = iter_difference_t; // since C++20 + using pointer = typename iterator_traits::pointer; + using reference = typename iterator_traits::reference; // until C++20 + using reference = iter_reference_t; // since C++20 + + constexpr reverse_iterator(); + constexpr explicit reverse_iterator(Iterator x); + template constexpr reverse_iterator(const reverse_iterator& u); + template constexpr reverse_iterator& operator=(const reverse_iterator& 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 + iter_move(const reverse_iterator& i) noexcept(see below); + template Iterator2> + friend constexpr void + iter_swap(const reverse_iterator& x, + const reverse_iterator& y) noexcept(see below); +}; + +template +constexpr bool // constexpr in C++17 +operator==(const reverse_iterator& x, const reverse_iterator& y); + +template +constexpr bool // constexpr in C++17 +operator!=(const reverse_iterator& x, const reverse_iterator& y); + +template +constexpr bool // constexpr in C++17 +operator<(const reverse_iterator& x, const reverse_iterator& y); + +template +constexpr bool // constexpr in C++17 +operator>(const reverse_iterator& x, const reverse_iterator& y); + +template +constexpr bool // constexpr in C++17 +operator<=(const reverse_iterator& x, const reverse_iterator& y); + +template +constexpr bool // constexpr in C++17 +operator>=(const reverse_iterator& x, const reverse_iterator& y); + +template Iterator2> + constexpr compare_three_way_result_t + operator<=>(const reverse_iterator& x, + const reverse_iterator& y); + +template +constexpr auto +operator-(const reverse_iterator& x, const reverse_iterator& y) +-> decltype(__y.base() - __x.base()); // constexpr in C++17 + +template +constexpr reverse_iterator +operator+(typename reverse_iterator::difference_type n, + const reverse_iterator& x); // constexpr in C++17 + +template +constexpr reverse_iterator make_reverse_iterator(Iterator i); // C++14, constexpr in C++17 + +template + requires (!sized_sentinel_for) + inline constexpr bool disable_sized_sentinel_for, + reverse_iterator> = true; + +template +class back_insert_iterator + : public iterator // 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 back_insert_iterator back_inserter(Container& x); // constexpr in C++20 + +template +class front_insert_iterator + : public iterator // 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 front_insert_iterator front_inserter(Container& x); // constexpr in C++20 + +template +class insert_iterator + : public iterator // 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 +insert_iterator inserter(Container& x, typename Container::iterator i); // until C++20 +template +constexpr insert_iterator inserter(Container& x, ranges::iterator_t i); // since C++20 + +template +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; // Until C++20, iterator_traits::value_type + using difference_type = iter_difference_t; // Until C++20, iterator_traits::difference_type; + using pointer = Iterator; + using reference = iter_rvalue_reference_t; // Until C++20, value_type&& + + constexpr move_iterator(); // all the constexprs are in C++17 + constexpr explicit move_iterator(Iterator i); + template + constexpr move_iterator(const move_iterator& u); + template + constexpr move_iterator& operator=(const move_iterator& 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 S> + friend constexpr bool + operator==(const move_iterator& x, const move_sentinel& y); // Since C++20 + template S> + friend constexpr iter_difference_t + operator-(const move_sentinel& x, const move_iterator& y); // Since C++20 + template S> + friend constexpr iter_difference_t + operator-(const move_iterator& x, const move_sentinel& y); // Since C++20 + friend constexpr iter_rvalue_reference_t + iter_move(const move_iterator& i) + noexcept(noexcept(ranges::iter_move(i.current))); // Since C++20 + template Iterator2> + friend constexpr void + iter_swap(const move_iterator& x, const move_iterator& y) + noexcept(noexcept(ranges::iter_swap(x.current, y.current))); // Since C++20 + +private: + Iterator current; // exposition only +}; + +template +constexpr bool // constexpr in C++17 +operator==(const move_iterator& x, const move_iterator& y); + +template +constexpr bool // constexpr in C++17 +operator!=(const move_iterator& x, const move_iterator& y); + +template +constexpr bool // constexpr in C++17 +operator<(const move_iterator& x, const move_iterator& y); + +template +constexpr bool // constexpr in C++17 +operator<=(const move_iterator& x, const move_iterator& y); + +template +constexpr bool // constexpr in C++17 +operator>(const move_iterator& x, const move_iterator& y); + +template +constexpr bool // constexpr in C++17 +operator>=(const move_iterator& x, const move_iterator& y); + +template +constexpr auto // constexpr in C++17 +operator-(const move_iterator& x, + const move_iterator& y) -> decltype(x.base() - y.base()); + +template +constexpr move_iterator operator+( // constexpr in C++17 + typename move_iterator::difference_type n, + const move_iterator& x); + +template // constexpr in C++17 +constexpr move_iterator make_move_iterator(const Iterator& i); + +template + requires (!sized_sentinel_for) + inline constexpr bool disable_sized_sentinel_for, // since C++20 + move_iterator> = true; + +template +class move_sentinel { +public: + constexpr move_sentinel(); + constexpr explicit move_sentinel(S s); + template + requires convertible_to + constexpr move_sentinel(const move_sentinel& s); + template + requires assignable_from + constexpr move_sentinel& operator=(const move_sentinel& 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 class counted_iterator; + +template + requires see below + struct iterator_traits>; + +// [unreachable.sentinel], unreachable sentinel +struct unreachable_sentinel_t; +inline constexpr unreachable_sentinel_t unreachable_sentinel{}; + +template , class Distance = ptrdiff_t> +class istream_iterator + : public iterator // 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 istream_type; + + istream_iterator(); // constexpr since C++11 + constexpr istream_iterator(default_sentinel_t); // since C++20 + istream_iterator(istream_type& s); + constexpr istream_iterator(const istream_iterator& x) noexcept(see below); + ~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 +bool operator==(const istream_iterator& x, + const istream_iterator& y); +template +bool operator!=(const istream_iterator& x, + const istream_iterator& y); // until C++20 + +template > +class ostream_iterator + : public iterator // 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 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 istreambuf_iterator + : public iterator // 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 streambuf_type; + typedef basic_istream 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 +bool operator==(const istreambuf_iterator& a, + const istreambuf_iterator& b); +template +bool operator!=(const istreambuf_iterator& a, + const istreambuf_iterator& b); // until C++20 + +template > +class ostreambuf_iterator + : public iterator // 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 streambuf_type; + typedef basic_ostream 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 constexpr auto begin(C& c) -> decltype(c.begin()); // constexpr since C++17 +template constexpr auto begin(const C& c) -> decltype(c.begin()); // constexpr since C++17 +template constexpr auto end(C& c) -> decltype(c.end()); // constexpr since C++17 +template constexpr auto end(const C& c) -> decltype(c.end()); // constexpr since C++17 +template constexpr T* begin(T (&array)[N]) noexcept; +template constexpr T* end(T (&array)[N]) noexcept; + +template constexpr auto cbegin(const C& c) noexcept(see-below) -> decltype(std::begin(c)); // C++14 +template constexpr auto cend(const C& c) noexcept(see-below) -> decltype(std::end(c)); // C++14 +template constexpr auto rbegin(C& c) -> decltype(c.rbegin()); // C++14, constexpr since C++17 +template constexpr auto rbegin(const C& c) -> decltype(c.rbegin()); // C++14, constexpr since C++17 +template constexpr auto rend(C& c) -> decltype(c.rend()); // C++14, constexpr since C++17 +template constexpr auto rend(const C& c) -> decltype(c.rend()); // C++14, constexpr since C++17 +template constexpr reverse_iterator rbegin(initializer_list il); // C++14, constexpr since C++17 +template constexpr reverse_iterator rend(initializer_list il); // C++14, constexpr since C++17 +template constexpr reverse_iterator rbegin(T (&array)[N]); // C++14, constexpr since C++17 +template constexpr reverse_iterator rend(T (&array)[N]); // C++14, constexpr since C++17 +template constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); // C++14, constexpr since C++17 +template constexpr auto crend(const C& c) -> decltype(std::rend(c)); // C++14, constexpr since C++17 + +// 24.8, container access: +template constexpr auto size(const C& c) -> decltype(c.size()); // C++17 +template constexpr size_t size(const T (&array)[N]) noexcept; // C++17 + +template constexpr auto ssize(const C& c) + -> common_type_t>; // C++20 +template constexpr ptrdiff_t ssize(const T (&array)[N]) noexcept; // C++20 + +template constexpr auto empty(const C& c) -> decltype(c.empty()); // C++17 +template constexpr bool empty(const T (&array)[N]) noexcept; // C++17 +template constexpr bool empty(initializer_list il) noexcept; // C++17 +template constexpr auto data(C& c) -> decltype(c.data()); // C++17 +template constexpr auto data(const C& c) -> decltype(c.data()); // C++17 +template constexpr T* data(T (&array)[N]) noexcept; // C++17 +template constexpr const E* data(initializer_list 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 + +// standard-mandated includes + +// [iterator.synopsis] +# include +# include + +// [range.access.general] +# if _LIBCPP_STD_VER >= 20 +# include <__ranges/access.h> +# include <__ranges/data.h> +# include <__ranges/empty.h> +# include <__ranges/rbegin.h> +# include <__ranges/rend.h> +# include <__ranges/size.h> +# endif + +# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +# endif + +# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17 +# include +# endif + +# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 +# include +# include +# include +# include +# include +# include +# include +# endif +#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS) + +#endif // _LIBCPP_ITERATOR -- cgit v1.2.3