1// -*- C++ -*- 2//===-------------------------- iterator ----------------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP_ITERATOR 12#define _LIBCPP_ITERATOR 13 14/* 15 iterator synopsis 16 17namespace std 18{ 19 20template<class Iterator> 21struct iterator_traits 22{ 23 typedef typename Iterator::difference_type difference_type; 24 typedef typename Iterator::value_type value_type; 25 typedef typename Iterator::pointer pointer; 26 typedef typename Iterator::reference reference; 27 typedef typename Iterator::iterator_category iterator_category; 28}; 29 30template<class T> 31struct iterator_traits<T*> 32{ 33 typedef ptrdiff_t difference_type; 34 typedef T value_type; 35 typedef T* pointer; 36 typedef T& reference; 37 typedef random_access_iterator_tag iterator_category; 38}; 39 40template<class T> 41struct iterator_traits<const T*> 42{ 43 typedef ptrdiff_t difference_type; 44 typedef T value_type; 45 typedef const T* pointer; 46 typedef const T& reference; 47 typedef random_access_iterator_tag iterator_category; 48}; 49 50template<class Category, class T, class Distance = ptrdiff_t, 51 class Pointer = T*, class Reference = T&> 52struct iterator 53{ 54 typedef T value_type; 55 typedef Distance difference_type; 56 typedef Pointer pointer; 57 typedef Reference reference; 58 typedef Category iterator_category; 59}; 60 61struct input_iterator_tag {}; 62struct output_iterator_tag {}; 63struct forward_iterator_tag : public input_iterator_tag {}; 64struct bidirectional_iterator_tag : public forward_iterator_tag {}; 65struct random_access_iterator_tag : public bidirectional_iterator_tag {}; 66 67// extension: second argument not conforming to C++03 68template <class InputIterator> 69void advance(InputIterator& i, 70 typename iterator_traits<InputIterator>::difference_type n); 71 72template <class InputIterator> 73typename iterator_traits<InputIterator>::difference_type 74distance(InputIterator first, InputIterator last); 75 76template <class Iterator> 77class reverse_iterator 78 : public iterator<typename iterator_traits<Iterator>::iterator_category, 79 typename iterator_traits<Iterator>::value_type, 80 typename iterator_traits<Iterator>::difference_type, 81 typename iterator_traits<Iterator>::pointer, 82 typename iterator_traits<Iterator>::reference> 83{ 84protected: 85 Iterator current; 86public: 87 typedef Iterator iterator_type; 88 typedef typename iterator_traits<Iterator>::difference_type difference_type; 89 typedef typename iterator_traits<Iterator>::reference reference; 90 typedef typename iterator_traits<Iterator>::pointer pointer; 91 92 constexpr reverse_iterator(); 93 constexpr explicit reverse_iterator(Iterator x); 94 template <class U> constexpr reverse_iterator(const reverse_iterator<U>& u); 95 template <class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u); 96 constexpr Iterator base() const; 97 constexpr reference operator*() const; 98 constexpr pointer operator->() const; 99 constexpr reverse_iterator& operator++(); 100 constexpr reverse_iterator operator++(int); 101 constexpr reverse_iterator& operator--(); 102 constexpr reverse_iterator operator--(int); 103 constexpr reverse_iterator operator+ (difference_type n) const; 104 constexpr reverse_iterator& operator+=(difference_type n); 105 constexpr reverse_iterator operator- (difference_type n) const; 106 constexpr reverse_iterator& operator-=(difference_type n); 107 constexpr reference operator[](difference_type n) const; 108}; 109 110template <class Iterator1, class Iterator2> 111constexpr bool // constexpr in C++17 112operator==(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 113 114template <class Iterator1, class Iterator2> 115constexpr bool // constexpr in C++17 116operator<(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 117 118template <class Iterator1, class Iterator2> 119constexpr bool // constexpr in C++17 120operator!=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 121 122template <class Iterator1, class Iterator2> 123constexpr bool // constexpr in C++17 124operator>(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 125 126template <class Iterator1, class Iterator2> 127constexpr bool // constexpr in C++17 128operator>=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 129 130template <class Iterator1, class Iterator2> 131constexpr bool // constexpr in C++17 132operator<=(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y); 133 134template <class Iterator1, class Iterator2> 135constexpr auto 136operator-(const reverse_iterator<Iterator1>& x, const reverse_iterator<Iterator2>& y) 137-> decltype(__y.base() - __x.base()); // constexpr in C++17 138 139template <class Iterator> 140constexpr reverse_iterator<Iterator> 141operator+(typename reverse_iterator<Iterator>::difference_type n, 142 const reverse_iterator<Iterator>& x); // constexpr in C++17 143 144template <class Iterator> 145constexpr reverse_iterator<Iterator> make_reverse_iterator(Iterator i); // C++14, constexpr in C++17 146 147template <class Container> 148class back_insert_iterator 149{ 150protected: 151 Container* container; 152public: 153 typedef Container container_type; 154 typedef void value_type; 155 typedef void difference_type; 156 typedef void reference; 157 typedef void pointer; 158 159 explicit back_insert_iterator(Container& x); 160 back_insert_iterator& operator=(const typename Container::value_type& value); 161 back_insert_iterator& operator*(); 162 back_insert_iterator& operator++(); 163 back_insert_iterator operator++(int); 164}; 165 166template <class Container> back_insert_iterator<Container> back_inserter(Container& x); 167 168template <class Container> 169class front_insert_iterator 170{ 171protected: 172 Container* container; 173public: 174 typedef Container container_type; 175 typedef void value_type; 176 typedef void difference_type; 177 typedef void reference; 178 typedef void pointer; 179 180 explicit front_insert_iterator(Container& x); 181 front_insert_iterator& operator=(const typename Container::value_type& value); 182 front_insert_iterator& operator*(); 183 front_insert_iterator& operator++(); 184 front_insert_iterator operator++(int); 185}; 186 187template <class Container> front_insert_iterator<Container> front_inserter(Container& x); 188 189template <class Container> 190class insert_iterator 191{ 192protected: 193 Container* container; 194 typename Container::iterator iter; 195public: 196 typedef Container container_type; 197 typedef void value_type; 198 typedef void difference_type; 199 typedef void reference; 200 typedef void pointer; 201 202 insert_iterator(Container& x, typename Container::iterator i); 203 insert_iterator& operator=(const typename Container::value_type& value); 204 insert_iterator& operator*(); 205 insert_iterator& operator++(); 206 insert_iterator& operator++(int); 207}; 208 209template <class Container, class Iterator> 210insert_iterator<Container> inserter(Container& x, Iterator i); 211 212template <class Iterator> 213class move_iterator { 214public: 215 typedef Iterator iterator_type; 216 typedef typename iterator_traits<Iterator>::difference_type difference_type; 217 typedef Iterator pointer; 218 typedef typename iterator_traits<Iterator>::value_type value_type; 219 typedef typename iterator_traits<Iterator>::iterator_category iterator_category; 220 typedef value_type&& reference; 221 222 constexpr move_iterator(); // all the constexprs are in C++17 223 constexpr explicit move_iterator(Iterator i); 224 template <class U> 225 constexpr move_iterator(const move_iterator<U>& u); 226 template <class U> 227 constexpr move_iterator& operator=(const move_iterator<U>& u); 228 constexpr iterator_type base() const; 229 constexpr reference operator*() const; 230 constexpr pointer operator->() const; 231 constexpr move_iterator& operator++(); 232 constexpr move_iterator operator++(int); 233 constexpr move_iterator& operator--(); 234 constexpr move_iterator operator--(int); 235 constexpr move_iterator operator+(difference_type n) const; 236 constexpr move_iterator& operator+=(difference_type n); 237 constexpr move_iterator operator-(difference_type n) const; 238 constexpr move_iterator& operator-=(difference_type n); 239 constexpr unspecified operator[](difference_type n) const; 240private: 241 Iterator current; // exposition only 242}; 243 244template <class Iterator1, class Iterator2> 245constexpr bool // constexpr in C++17 246operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 247 248template <class Iterator1, class Iterator2> 249constexpr bool // constexpr in C++17 250operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 251 252template <class Iterator1, class Iterator2> 253constexpr bool // constexpr in C++17 254operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 255 256template <class Iterator1, class Iterator2> 257constexpr bool // constexpr in C++17 258operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 259 260template <class Iterator1, class Iterator2> 261constexpr bool // constexpr in C++17 262operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 263 264template <class Iterator1, class Iterator2> 265constexpr bool // constexpr in C++17 266operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y); 267 268template <class Iterator1, class Iterator2> 269constexpr auto // constexpr in C++17 270operator-(const move_iterator<Iterator1>& x, 271 const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base()); 272 273template <class Iterator> 274constexpr move_iterator<Iterator> operator+( // constexpr in C++17 275 typename move_iterator<Iterator>::difference_type n, 276 const move_iterator<Iterator>& x); 277 278template <class Iterator> // constexpr in C++17 279constexpr move_iterator<Iterator> make_move_iterator(const Iterator& i); 280 281 282template <class T, class charT = char, class traits = char_traits<charT>, class Distance = ptrdiff_t> 283class istream_iterator 284 : public iterator<input_iterator_tag, T, Distance, const T*, const T&> 285{ 286public: 287 typedef charT char_type; 288 typedef traits traits_type; 289 typedef basic_istream<charT,traits> istream_type; 290 291 constexpr istream_iterator(); 292 istream_iterator(istream_type& s); 293 istream_iterator(const istream_iterator& x); 294 ~istream_iterator(); 295 296 const T& operator*() const; 297 const T* operator->() const; 298 istream_iterator& operator++(); 299 istream_iterator operator++(int); 300}; 301 302template <class T, class charT, class traits, class Distance> 303bool operator==(const istream_iterator<T,charT,traits,Distance>& x, 304 const istream_iterator<T,charT,traits,Distance>& y); 305template <class T, class charT, class traits, class Distance> 306bool operator!=(const istream_iterator<T,charT,traits,Distance>& x, 307 const istream_iterator<T,charT,traits,Distance>& y); 308 309template <class T, class charT = char, class traits = char_traits<charT> > 310class ostream_iterator 311 : public iterator<output_iterator_tag, void, void, void ,void> 312{ 313public: 314 typedef charT char_type; 315 typedef traits traits_type; 316 typedef basic_ostream<charT,traits> ostream_type; 317 318 ostream_iterator(ostream_type& s); 319 ostream_iterator(ostream_type& s, const charT* delimiter); 320 ostream_iterator(const ostream_iterator& x); 321 ~ostream_iterator(); 322 ostream_iterator& operator=(const T& value); 323 324 ostream_iterator& operator*(); 325 ostream_iterator& operator++(); 326 ostream_iterator& operator++(int); 327}; 328 329template<class charT, class traits = char_traits<charT> > 330class istreambuf_iterator 331 : public iterator<input_iterator_tag, charT, 332 typename traits::off_type, unspecified, 333 charT> 334{ 335public: 336 typedef charT char_type; 337 typedef traits traits_type; 338 typedef typename traits::int_type int_type; 339 typedef basic_streambuf<charT,traits> streambuf_type; 340 typedef basic_istream<charT,traits> istream_type; 341 342 istreambuf_iterator() noexcept; 343 istreambuf_iterator(istream_type& s) noexcept; 344 istreambuf_iterator(streambuf_type* s) noexcept; 345 istreambuf_iterator(a-private-type) noexcept; 346 347 charT operator*() const; 348 pointer operator->() const; 349 istreambuf_iterator& operator++(); 350 a-private-type operator++(int); 351 352 bool equal(const istreambuf_iterator& b) const; 353}; 354 355template <class charT, class traits> 356bool operator==(const istreambuf_iterator<charT,traits>& a, 357 const istreambuf_iterator<charT,traits>& b); 358template <class charT, class traits> 359bool operator!=(const istreambuf_iterator<charT,traits>& a, 360 const istreambuf_iterator<charT,traits>& b); 361 362template <class charT, class traits = char_traits<charT> > 363class ostreambuf_iterator 364 : public iterator<output_iterator_tag, void, void, void, void> 365{ 366public: 367 typedef charT char_type; 368 typedef traits traits_type; 369 typedef basic_streambuf<charT,traits> streambuf_type; 370 typedef basic_ostream<charT,traits> ostream_type; 371 372 ostreambuf_iterator(ostream_type& s) noexcept; 373 ostreambuf_iterator(streambuf_type* s) noexcept; 374 ostreambuf_iterator& operator=(charT c); 375 ostreambuf_iterator& operator*(); 376 ostreambuf_iterator& operator++(); 377 ostreambuf_iterator& operator++(int); 378 bool failed() const noexcept; 379}; 380 381template <class C> constexpr auto begin(C& c) -> decltype(c.begin()); 382template <class C> constexpr auto begin(const C& c) -> decltype(c.begin()); 383template <class C> constexpr auto end(C& c) -> decltype(c.end()); 384template <class C> constexpr auto end(const C& c) -> decltype(c.end()); 385template <class T, size_t N> constexpr T* begin(T (&array)[N]); 386template <class T, size_t N> constexpr T* end(T (&array)[N]); 387 388template <class C> auto constexpr cbegin(const C& c) -> decltype(std::begin(c)); // C++14 389template <class C> auto constexpr cend(const C& c) -> decltype(std::end(c)); // C++14 390template <class C> auto constexpr rbegin(C& c) -> decltype(c.rbegin()); // C++14 391template <class C> auto constexpr rbegin(const C& c) -> decltype(c.rbegin()); // C++14 392template <class C> auto constexpr rend(C& c) -> decltype(c.rend()); // C++14 393template <class C> constexpr auto rend(const C& c) -> decltype(c.rend()); // C++14 394template <class E> reverse_iterator<const E*> constexpr rbegin(initializer_list<E> il); // C++14 395template <class E> reverse_iterator<const E*> constexpr rend(initializer_list<E> il); // C++14 396template <class T, size_t N> reverse_iterator<T*> constexpr rbegin(T (&array)[N]); // C++14 397template <class T, size_t N> reverse_iterator<T*> constexpr rend(T (&array)[N]); // C++14 398template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c)); // C++14 399template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c)); // C++14 400 401// 24.8, container access: 402template <class C> constexpr auto size(const C& c) -> decltype(c.size()); // C++17 403template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept; // C++17 404template <class C> constexpr auto empty(const C& c) -> decltype(c.empty()); // C++17 405template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept; // C++17 406template <class E> constexpr bool empty(initializer_list<E> il) noexcept; // C++17 407template <class C> constexpr auto data(C& c) -> decltype(c.data()); // C++17 408template <class C> constexpr auto data(const C& c) -> decltype(c.data()); // C++17 409template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept; // C++17 410template <class E> constexpr const E* data(initializer_list<E> il) noexcept; // C++17 411 412} // std 413 414*/ 415 416#include <__config> 417#include <iosfwd> // for forward declarations of vector and string. 418#include <__functional_base> 419#include <type_traits> 420#include <cstddef> 421#include <initializer_list> 422#ifdef __APPLE__ 423#include <Availability.h> 424#endif 425 426#include <__debug> 427 428#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 429#pragma GCC system_header 430#endif 431 432_LIBCPP_BEGIN_NAMESPACE_STD 433 434struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {}; 435struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {}; 436struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag : public input_iterator_tag {}; 437struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {}; 438struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {}; 439 440template <class _Tp> 441struct __has_iterator_category 442{ 443private: 444 struct __two {char __lx; char __lxx;}; 445 template <class _Up> static __two __test(...); 446 template <class _Up> static char __test(typename _Up::iterator_category* = 0); 447public: 448 static const bool value = sizeof(__test<_Tp>(0)) == 1; 449}; 450 451template <class _Iter, bool> struct __iterator_traits_impl {}; 452 453template <class _Iter> 454struct __iterator_traits_impl<_Iter, true> 455{ 456 typedef typename _Iter::difference_type difference_type; 457 typedef typename _Iter::value_type value_type; 458 typedef typename _Iter::pointer pointer; 459 typedef typename _Iter::reference reference; 460 typedef typename _Iter::iterator_category iterator_category; 461}; 462 463template <class _Iter, bool> struct __iterator_traits {}; 464 465template <class _Iter> 466struct __iterator_traits<_Iter, true> 467 : __iterator_traits_impl 468 < 469 _Iter, 470 is_convertible<typename _Iter::iterator_category, input_iterator_tag>::value || 471 is_convertible<typename _Iter::iterator_category, output_iterator_tag>::value 472 > 473{}; 474 475// iterator_traits<Iterator> will only have the nested types if Iterator::iterator_category 476// exists. Else iterator_traits<Iterator> will be an empty class. This is a 477// conforming extension which allows some programs to compile and behave as 478// the client expects instead of failing at compile time. 479 480template <class _Iter> 481struct _LIBCPP_TEMPLATE_VIS iterator_traits 482 : __iterator_traits<_Iter, __has_iterator_category<_Iter>::value> {}; 483 484template<class _Tp> 485struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*> 486{ 487 typedef ptrdiff_t difference_type; 488 typedef typename remove_const<_Tp>::type value_type; 489 typedef _Tp* pointer; 490 typedef _Tp& reference; 491 typedef random_access_iterator_tag iterator_category; 492}; 493 494template <class _Tp, class _Up, bool = __has_iterator_category<iterator_traits<_Tp> >::value> 495struct __has_iterator_category_convertible_to 496 : public integral_constant<bool, is_convertible<typename iterator_traits<_Tp>::iterator_category, _Up>::value> 497{}; 498 499template <class _Tp, class _Up> 500struct __has_iterator_category_convertible_to<_Tp, _Up, false> : public false_type {}; 501 502template <class _Tp> 503struct __is_input_iterator : public __has_iterator_category_convertible_to<_Tp, input_iterator_tag> {}; 504 505template <class _Tp> 506struct __is_forward_iterator : public __has_iterator_category_convertible_to<_Tp, forward_iterator_tag> {}; 507 508template <class _Tp> 509struct __is_bidirectional_iterator : public __has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag> {}; 510 511template <class _Tp> 512struct __is_random_access_iterator : public __has_iterator_category_convertible_to<_Tp, random_access_iterator_tag> {}; 513 514template <class _Tp> 515struct __is_exactly_input_iterator 516 : public integral_constant<bool, 517 __has_iterator_category_convertible_to<_Tp, input_iterator_tag>::value && 518 !__has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value> {}; 519 520template<class _Category, class _Tp, class _Distance = ptrdiff_t, 521 class _Pointer = _Tp*, class _Reference = _Tp&> 522struct _LIBCPP_TEMPLATE_VIS iterator 523{ 524 typedef _Tp value_type; 525 typedef _Distance difference_type; 526 typedef _Pointer pointer; 527 typedef _Reference reference; 528 typedef _Category iterator_category; 529}; 530 531template <class _InputIter> 532inline _LIBCPP_INLINE_VISIBILITY 533void __advance(_InputIter& __i, 534 typename iterator_traits<_InputIter>::difference_type __n, input_iterator_tag) 535{ 536 for (; __n > 0; --__n) 537 ++__i; 538} 539 540template <class _BiDirIter> 541inline _LIBCPP_INLINE_VISIBILITY 542void __advance(_BiDirIter& __i, 543 typename iterator_traits<_BiDirIter>::difference_type __n, bidirectional_iterator_tag) 544{ 545 if (__n >= 0) 546 for (; __n > 0; --__n) 547 ++__i; 548 else 549 for (; __n < 0; ++__n) 550 --__i; 551} 552 553template <class _RandIter> 554inline _LIBCPP_INLINE_VISIBILITY 555void __advance(_RandIter& __i, 556 typename iterator_traits<_RandIter>::difference_type __n, random_access_iterator_tag) 557{ 558 __i += __n; 559} 560 561template <class _InputIter> 562inline _LIBCPP_INLINE_VISIBILITY 563void advance(_InputIter& __i, 564 typename iterator_traits<_InputIter>::difference_type __n) 565{ 566 __advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category()); 567} 568 569template <class _InputIter> 570inline _LIBCPP_INLINE_VISIBILITY 571typename iterator_traits<_InputIter>::difference_type 572__distance(_InputIter __first, _InputIter __last, input_iterator_tag) 573{ 574 typename iterator_traits<_InputIter>::difference_type __r(0); 575 for (; __first != __last; ++__first) 576 ++__r; 577 return __r; 578} 579 580template <class _RandIter> 581inline _LIBCPP_INLINE_VISIBILITY 582typename iterator_traits<_RandIter>::difference_type 583__distance(_RandIter __first, _RandIter __last, random_access_iterator_tag) 584{ 585 return __last - __first; 586} 587 588template <class _InputIter> 589inline _LIBCPP_INLINE_VISIBILITY 590typename iterator_traits<_InputIter>::difference_type 591distance(_InputIter __first, _InputIter __last) 592{ 593 return __distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category()); 594} 595 596template <class _InputIter> 597inline _LIBCPP_INLINE_VISIBILITY 598_InputIter 599next(_InputIter __x, 600 typename iterator_traits<_InputIter>::difference_type __n = 1, 601 typename enable_if<__is_input_iterator<_InputIter>::value>::type* = 0) 602{ 603 _VSTD::advance(__x, __n); 604 return __x; 605} 606 607template <class _BidiretionalIter> 608inline _LIBCPP_INLINE_VISIBILITY 609_BidiretionalIter 610prev(_BidiretionalIter __x, 611 typename iterator_traits<_BidiretionalIter>::difference_type __n = 1, 612 typename enable_if<__is_bidirectional_iterator<_BidiretionalIter>::value>::type* = 0) 613{ 614 _VSTD::advance(__x, -__n); 615 return __x; 616} 617 618template <class _Iter> 619class _LIBCPP_TEMPLATE_VIS reverse_iterator 620 : public iterator<typename iterator_traits<_Iter>::iterator_category, 621 typename iterator_traits<_Iter>::value_type, 622 typename iterator_traits<_Iter>::difference_type, 623 typename iterator_traits<_Iter>::pointer, 624 typename iterator_traits<_Iter>::reference> 625{ 626private: 627 /*mutable*/ _Iter __t; // no longer used as of LWG #2360, not removed due to ABI break 628protected: 629 _Iter current; 630public: 631 typedef _Iter iterator_type; 632 typedef typename iterator_traits<_Iter>::difference_type difference_type; 633 typedef typename iterator_traits<_Iter>::reference reference; 634 typedef typename iterator_traits<_Iter>::pointer pointer; 635 636 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 637 reverse_iterator() : __t(), current() {} 638 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 639 explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {} 640 template <class _Up> 641 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 642 reverse_iterator(const reverse_iterator<_Up>& __u) : __t(__u.base()), current(__u.base()) {} 643 template <class _Up> 644 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 645 reverse_iterator& operator=(const reverse_iterator<_Up>& __u) 646 { __t = current = __u.base(); return *this; } 647 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 648 _Iter base() const {return current;} 649 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 650 reference operator*() const {_Iter __tmp = current; return *--__tmp;} 651 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 652 pointer operator->() const {return _VSTD::addressof(operator*());} 653 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 654 reverse_iterator& operator++() {--current; return *this;} 655 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 656 reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;} 657 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 658 reverse_iterator& operator--() {++current; return *this;} 659 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 660 reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;} 661 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 662 reverse_iterator operator+ (difference_type __n) const {return reverse_iterator(current - __n);} 663 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 664 reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;} 665 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 666 reverse_iterator operator- (difference_type __n) const {return reverse_iterator(current + __n);} 667 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 668 reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;} 669 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 670 reference operator[](difference_type __n) const {return *(*this + __n);} 671}; 672 673template <class _Iter1, class _Iter2> 674inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 675bool 676operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) 677{ 678 return __x.base() == __y.base(); 679} 680 681template <class _Iter1, class _Iter2> 682inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 683bool 684operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) 685{ 686 return __x.base() > __y.base(); 687} 688 689template <class _Iter1, class _Iter2> 690inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 691bool 692operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) 693{ 694 return __x.base() != __y.base(); 695} 696 697template <class _Iter1, class _Iter2> 698inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 699bool 700operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) 701{ 702 return __x.base() < __y.base(); 703} 704 705template <class _Iter1, class _Iter2> 706inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 707bool 708operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) 709{ 710 return __x.base() <= __y.base(); 711} 712 713template <class _Iter1, class _Iter2> 714inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 715bool 716operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) 717{ 718 return __x.base() >= __y.base(); 719} 720 721#ifndef _LIBCPP_CXX03_LANG 722template <class _Iter1, class _Iter2> 723inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 724auto 725operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) 726-> decltype(__y.base() - __x.base()) 727{ 728 return __y.base() - __x.base(); 729} 730#else 731template <class _Iter1, class _Iter2> 732inline _LIBCPP_INLINE_VISIBILITY 733typename reverse_iterator<_Iter1>::difference_type 734operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) 735{ 736 return __y.base() - __x.base(); 737} 738#endif 739 740template <class _Iter> 741inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 742reverse_iterator<_Iter> 743operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x) 744{ 745 return reverse_iterator<_Iter>(__x.base() - __n); 746} 747 748#if _LIBCPP_STD_VER > 11 749template <class _Iter> 750inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 751reverse_iterator<_Iter> make_reverse_iterator(_Iter __i) 752{ 753 return reverse_iterator<_Iter>(__i); 754} 755#endif 756 757template <class _Container> 758class _LIBCPP_TEMPLATE_VIS back_insert_iterator 759 : public iterator<output_iterator_tag, 760 void, 761 void, 762 void, 763 void> 764{ 765protected: 766 _Container* container; 767public: 768 typedef _Container container_type; 769 770 _LIBCPP_INLINE_VISIBILITY explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {} 771 _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(const typename _Container::value_type& __value_) 772 {container->push_back(__value_); return *this;} 773#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 774 _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(typename _Container::value_type&& __value_) 775 {container->push_back(_VSTD::move(__value_)); return *this;} 776#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 777 _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator*() {return *this;} 778 _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator++() {return *this;} 779 _LIBCPP_INLINE_VISIBILITY back_insert_iterator operator++(int) {return *this;} 780}; 781 782template <class _Container> 783inline _LIBCPP_INLINE_VISIBILITY 784back_insert_iterator<_Container> 785back_inserter(_Container& __x) 786{ 787 return back_insert_iterator<_Container>(__x); 788} 789 790template <class _Container> 791class _LIBCPP_TEMPLATE_VIS front_insert_iterator 792 : public iterator<output_iterator_tag, 793 void, 794 void, 795 void, 796 void> 797{ 798protected: 799 _Container* container; 800public: 801 typedef _Container container_type; 802 803 _LIBCPP_INLINE_VISIBILITY explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {} 804 _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(const typename _Container::value_type& __value_) 805 {container->push_front(__value_); return *this;} 806#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 807 _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::value_type&& __value_) 808 {container->push_front(_VSTD::move(__value_)); return *this;} 809#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 810 _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator*() {return *this;} 811 _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator++() {return *this;} 812 _LIBCPP_INLINE_VISIBILITY front_insert_iterator operator++(int) {return *this;} 813}; 814 815template <class _Container> 816inline _LIBCPP_INLINE_VISIBILITY 817front_insert_iterator<_Container> 818front_inserter(_Container& __x) 819{ 820 return front_insert_iterator<_Container>(__x); 821} 822 823template <class _Container> 824class _LIBCPP_TEMPLATE_VIS insert_iterator 825 : public iterator<output_iterator_tag, 826 void, 827 void, 828 void, 829 void> 830{ 831protected: 832 _Container* container; 833 typename _Container::iterator iter; 834public: 835 typedef _Container container_type; 836 837 _LIBCPP_INLINE_VISIBILITY insert_iterator(_Container& __x, typename _Container::iterator __i) 838 : container(_VSTD::addressof(__x)), iter(__i) {} 839 _LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(const typename _Container::value_type& __value_) 840 {iter = container->insert(iter, __value_); ++iter; return *this;} 841#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 842 _LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::value_type&& __value_) 843 {iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;} 844#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 845 _LIBCPP_INLINE_VISIBILITY insert_iterator& operator*() {return *this;} 846 _LIBCPP_INLINE_VISIBILITY insert_iterator& operator++() {return *this;} 847 _LIBCPP_INLINE_VISIBILITY insert_iterator& operator++(int) {return *this;} 848}; 849 850template <class _Container> 851inline _LIBCPP_INLINE_VISIBILITY 852insert_iterator<_Container> 853inserter(_Container& __x, typename _Container::iterator __i) 854{ 855 return insert_iterator<_Container>(__x, __i); 856} 857 858template <class _Tp, class _CharT = char, 859 class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t> 860class _LIBCPP_TEMPLATE_VIS istream_iterator 861 : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&> 862{ 863public: 864 typedef _CharT char_type; 865 typedef _Traits traits_type; 866 typedef basic_istream<_CharT,_Traits> istream_type; 867private: 868 istream_type* __in_stream_; 869 _Tp __value_; 870public: 871 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(0), __value_() {} 872 _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(_VSTD::addressof(__s)) 873 { 874 if (!(*__in_stream_ >> __value_)) 875 __in_stream_ = 0; 876 } 877 878 _LIBCPP_INLINE_VISIBILITY const _Tp& operator*() const {return __value_;} 879 _LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return _VSTD::addressof((operator*()));} 880 _LIBCPP_INLINE_VISIBILITY istream_iterator& operator++() 881 { 882 if (!(*__in_stream_ >> __value_)) 883 __in_stream_ = 0; 884 return *this; 885 } 886 _LIBCPP_INLINE_VISIBILITY istream_iterator operator++(int) 887 {istream_iterator __t(*this); ++(*this); return __t;} 888 889 friend _LIBCPP_INLINE_VISIBILITY 890 bool operator==(const istream_iterator& __x, const istream_iterator& __y) 891 {return __x.__in_stream_ == __y.__in_stream_;} 892 893 friend _LIBCPP_INLINE_VISIBILITY 894 bool operator!=(const istream_iterator& __x, const istream_iterator& __y) 895 {return !(__x == __y);} 896}; 897 898template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> > 899class _LIBCPP_TEMPLATE_VIS ostream_iterator 900 : public iterator<output_iterator_tag, void, void, void, void> 901{ 902public: 903 typedef _CharT char_type; 904 typedef _Traits traits_type; 905 typedef basic_ostream<_CharT,_Traits> ostream_type; 906private: 907 ostream_type* __out_stream_; 908 const char_type* __delim_; 909public: 910 _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s) _NOEXCEPT 911 : __out_stream_(_VSTD::addressof(__s)), __delim_(0) {} 912 _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT 913 : __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {} 914 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_) 915 { 916 *__out_stream_ << __value_; 917 if (__delim_) 918 *__out_stream_ << __delim_; 919 return *this; 920 } 921 922 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator*() {return *this;} 923 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++() {return *this;} 924 _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++(int) {return *this;} 925}; 926 927template<class _CharT, class _Traits> 928class _LIBCPP_TEMPLATE_VIS istreambuf_iterator 929 : public iterator<input_iterator_tag, _CharT, 930 typename _Traits::off_type, _CharT*, 931 _CharT> 932{ 933public: 934 typedef _CharT char_type; 935 typedef _Traits traits_type; 936 typedef typename _Traits::int_type int_type; 937 typedef basic_streambuf<_CharT,_Traits> streambuf_type; 938 typedef basic_istream<_CharT,_Traits> istream_type; 939private: 940 mutable streambuf_type* __sbuf_; 941 942 class __proxy 943 { 944 char_type __keep_; 945 streambuf_type* __sbuf_; 946 _LIBCPP_INLINE_VISIBILITY __proxy(char_type __c, streambuf_type* __s) 947 : __keep_(__c), __sbuf_(__s) {} 948 friend class istreambuf_iterator; 949 public: 950 _LIBCPP_INLINE_VISIBILITY char_type operator*() const {return __keep_;} 951 }; 952 953 _LIBCPP_INLINE_VISIBILITY 954 bool __test_for_eof() const 955 { 956 if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof())) 957 __sbuf_ = 0; 958 return __sbuf_ == 0; 959 } 960public: 961 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istreambuf_iterator() _NOEXCEPT : __sbuf_(0) {} 962 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(istream_type& __s) _NOEXCEPT 963 : __sbuf_(__s.rdbuf()) {} 964 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(streambuf_type* __s) _NOEXCEPT 965 : __sbuf_(__s) {} 966 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) _NOEXCEPT 967 : __sbuf_(__p.__sbuf_) {} 968 969 _LIBCPP_INLINE_VISIBILITY char_type operator*() const 970 {return static_cast<char_type>(__sbuf_->sgetc());} 971 _LIBCPP_INLINE_VISIBILITY char_type* operator->() const {return nullptr;} 972 _LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++() 973 { 974 __sbuf_->sbumpc(); 975 return *this; 976 } 977 _LIBCPP_INLINE_VISIBILITY __proxy operator++(int) 978 { 979 return __proxy(__sbuf_->sbumpc(), __sbuf_); 980 } 981 982 _LIBCPP_INLINE_VISIBILITY bool equal(const istreambuf_iterator& __b) const 983 {return __test_for_eof() == __b.__test_for_eof();} 984}; 985 986template <class _CharT, class _Traits> 987inline _LIBCPP_INLINE_VISIBILITY 988bool operator==(const istreambuf_iterator<_CharT,_Traits>& __a, 989 const istreambuf_iterator<_CharT,_Traits>& __b) 990 {return __a.equal(__b);} 991 992template <class _CharT, class _Traits> 993inline _LIBCPP_INLINE_VISIBILITY 994bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a, 995 const istreambuf_iterator<_CharT,_Traits>& __b) 996 {return !__a.equal(__b);} 997 998template <class _CharT, class _Traits> 999class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator 1000 : public iterator<output_iterator_tag, void, void, void, void> 1001{ 1002public: 1003 typedef _CharT char_type; 1004 typedef _Traits traits_type; 1005 typedef basic_streambuf<_CharT,_Traits> streambuf_type; 1006 typedef basic_ostream<_CharT,_Traits> ostream_type; 1007private: 1008 streambuf_type* __sbuf_; 1009public: 1010 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) _NOEXCEPT 1011 : __sbuf_(__s.rdbuf()) {} 1012 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT 1013 : __sbuf_(__s) {} 1014 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c) 1015 { 1016 if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof())) 1017 __sbuf_ = 0; 1018 return *this; 1019 } 1020 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator*() {return *this;} 1021 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++() {return *this;} 1022 _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++(int) {return *this;} 1023 _LIBCPP_INLINE_VISIBILITY bool failed() const _NOEXCEPT {return __sbuf_ == 0;} 1024 1025#if !defined(__APPLE__) || \ 1026 (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED > __MAC_10_8) || \ 1027 (defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED > __IPHONE_6_0) 1028 1029 template <class _Ch, class _Tr> 1030 friend 1031 _LIBCPP_HIDDEN 1032 ostreambuf_iterator<_Ch, _Tr> 1033 __pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s, 1034 const _Ch* __ob, const _Ch* __op, const _Ch* __oe, 1035 ios_base& __iob, _Ch __fl); 1036#endif 1037}; 1038 1039template <class _Iter> 1040class _LIBCPP_TEMPLATE_VIS move_iterator 1041{ 1042private: 1043 _Iter __i; 1044public: 1045 typedef _Iter iterator_type; 1046 typedef typename iterator_traits<iterator_type>::iterator_category iterator_category; 1047 typedef typename iterator_traits<iterator_type>::value_type value_type; 1048 typedef typename iterator_traits<iterator_type>::difference_type difference_type; 1049 typedef iterator_type pointer; 1050#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1051 typedef typename iterator_traits<iterator_type>::reference __reference; 1052 typedef typename conditional< 1053 is_reference<__reference>::value, 1054 typename remove_reference<__reference>::type&&, 1055 __reference 1056 >::type reference; 1057#else 1058 typedef typename iterator_traits<iterator_type>::reference reference; 1059#endif 1060 1061 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1062 move_iterator() : __i() {} 1063 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1064 explicit move_iterator(_Iter __x) : __i(__x) {} 1065 template <class _Up> 1066 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1067 move_iterator(const move_iterator<_Up>& __u) : __i(__u.base()) {} 1068 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 _Iter base() const {return __i;} 1069 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1070 reference operator*() const { return static_cast<reference>(*__i); } 1071 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1072 pointer operator->() const { return __i;} 1073 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1074 move_iterator& operator++() {++__i; return *this;} 1075 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1076 move_iterator operator++(int) {move_iterator __tmp(*this); ++__i; return __tmp;} 1077 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1078 move_iterator& operator--() {--__i; return *this;} 1079 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1080 move_iterator operator--(int) {move_iterator __tmp(*this); --__i; return __tmp;} 1081 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1082 move_iterator operator+ (difference_type __n) const {return move_iterator(__i + __n);} 1083 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1084 move_iterator& operator+=(difference_type __n) {__i += __n; return *this;} 1085 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1086 move_iterator operator- (difference_type __n) const {return move_iterator(__i - __n);} 1087 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1088 move_iterator& operator-=(difference_type __n) {__i -= __n; return *this;} 1089 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1090 reference operator[](difference_type __n) const { return static_cast<reference>(__i[__n]); } 1091}; 1092 1093template <class _Iter1, class _Iter2> 1094inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1095bool 1096operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) 1097{ 1098 return __x.base() == __y.base(); 1099} 1100 1101template <class _Iter1, class _Iter2> 1102inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1103bool 1104operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) 1105{ 1106 return __x.base() < __y.base(); 1107} 1108 1109template <class _Iter1, class _Iter2> 1110inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1111bool 1112operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) 1113{ 1114 return __x.base() != __y.base(); 1115} 1116 1117template <class _Iter1, class _Iter2> 1118inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1119bool 1120operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) 1121{ 1122 return __x.base() > __y.base(); 1123} 1124 1125template <class _Iter1, class _Iter2> 1126inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1127bool 1128operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) 1129{ 1130 return __x.base() >= __y.base(); 1131} 1132 1133template <class _Iter1, class _Iter2> 1134inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1135bool 1136operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) 1137{ 1138 return __x.base() <= __y.base(); 1139} 1140 1141#ifndef _LIBCPP_CXX03_LANG 1142template <class _Iter1, class _Iter2> 1143inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1144auto 1145operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) 1146-> decltype(__x.base() - __y.base()) 1147{ 1148 return __x.base() - __y.base(); 1149} 1150#else 1151template <class _Iter1, class _Iter2> 1152inline _LIBCPP_INLINE_VISIBILITY 1153typename move_iterator<_Iter1>::difference_type 1154operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) 1155{ 1156 return __x.base() - __y.base(); 1157} 1158#endif 1159 1160template <class _Iter> 1161inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1162move_iterator<_Iter> 1163operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x) 1164{ 1165 return move_iterator<_Iter>(__x.base() + __n); 1166} 1167 1168template <class _Iter> 1169inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1170move_iterator<_Iter> 1171make_move_iterator(_Iter __i) 1172{ 1173 return move_iterator<_Iter>(__i); 1174} 1175 1176// __wrap_iter 1177 1178template <class _Iter> class __wrap_iter; 1179 1180template <class _Iter1, class _Iter2> 1181_LIBCPP_INLINE_VISIBILITY 1182bool 1183operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1184 1185template <class _Iter1, class _Iter2> 1186_LIBCPP_INLINE_VISIBILITY 1187bool 1188operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1189 1190template <class _Iter1, class _Iter2> 1191_LIBCPP_INLINE_VISIBILITY 1192bool 1193operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1194 1195template <class _Iter1, class _Iter2> 1196_LIBCPP_INLINE_VISIBILITY 1197bool 1198operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1199 1200template <class _Iter1, class _Iter2> 1201_LIBCPP_INLINE_VISIBILITY 1202bool 1203operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1204 1205template <class _Iter1, class _Iter2> 1206_LIBCPP_INLINE_VISIBILITY 1207bool 1208operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1209 1210#ifndef _LIBCPP_CXX03_LANG 1211template <class _Iter1, class _Iter2> 1212_LIBCPP_INLINE_VISIBILITY 1213auto 1214operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG 1215-> decltype(__x.base() - __y.base()); 1216#else 1217template <class _Iter1, class _Iter2> 1218_LIBCPP_INLINE_VISIBILITY 1219typename __wrap_iter<_Iter1>::difference_type 1220operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1221#endif 1222 1223template <class _Iter> 1224_LIBCPP_INLINE_VISIBILITY 1225__wrap_iter<_Iter> 1226operator+(typename __wrap_iter<_Iter>::difference_type, __wrap_iter<_Iter>) _NOEXCEPT_DEBUG; 1227 1228template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY copy(_Ip, _Ip, _Op); 1229template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY copy_backward(_B1, _B1, _B2); 1230template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY move(_Ip, _Ip, _Op); 1231template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY move_backward(_B1, _B1, _B2); 1232 1233#if _LIBCPP_DEBUG_LEVEL < 2 1234 1235template <class _Tp> 1236_LIBCPP_INLINE_VISIBILITY 1237typename enable_if 1238< 1239 is_trivially_copy_assignable<_Tp>::value, 1240 _Tp* 1241>::type 1242__unwrap_iter(__wrap_iter<_Tp*>); 1243 1244#else 1245 1246template <class _Tp> 1247inline _LIBCPP_INLINE_VISIBILITY 1248typename enable_if 1249< 1250 is_trivially_copy_assignable<_Tp>::value, 1251 __wrap_iter<_Tp*> 1252>::type 1253__unwrap_iter(__wrap_iter<_Tp*> __i); 1254 1255#endif 1256 1257template <class _Iter> 1258class __wrap_iter 1259{ 1260public: 1261 typedef _Iter iterator_type; 1262 typedef typename iterator_traits<iterator_type>::iterator_category iterator_category; 1263 typedef typename iterator_traits<iterator_type>::value_type value_type; 1264 typedef typename iterator_traits<iterator_type>::difference_type difference_type; 1265 typedef typename iterator_traits<iterator_type>::pointer pointer; 1266 typedef typename iterator_traits<iterator_type>::reference reference; 1267private: 1268 iterator_type __i; 1269public: 1270 _LIBCPP_INLINE_VISIBILITY __wrap_iter() _NOEXCEPT_DEBUG 1271#if _LIBCPP_STD_VER > 11 1272 : __i{} 1273#endif 1274 { 1275#if _LIBCPP_DEBUG_LEVEL >= 2 1276 __get_db()->__insert_i(this); 1277#endif 1278 } 1279 template <class _Up> _LIBCPP_INLINE_VISIBILITY __wrap_iter(const __wrap_iter<_Up>& __u, 1280 typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = 0) _NOEXCEPT_DEBUG 1281 : __i(__u.base()) 1282 { 1283#if _LIBCPP_DEBUG_LEVEL >= 2 1284 __get_db()->__iterator_copy(this, &__u); 1285#endif 1286 } 1287#if _LIBCPP_DEBUG_LEVEL >= 2 1288 _LIBCPP_INLINE_VISIBILITY 1289 __wrap_iter(const __wrap_iter& __x) 1290 : __i(__x.base()) 1291 { 1292 __get_db()->__iterator_copy(this, &__x); 1293 } 1294 _LIBCPP_INLINE_VISIBILITY 1295 __wrap_iter& operator=(const __wrap_iter& __x) 1296 { 1297 if (this != &__x) 1298 { 1299 __get_db()->__iterator_copy(this, &__x); 1300 __i = __x.__i; 1301 } 1302 return *this; 1303 } 1304 _LIBCPP_INLINE_VISIBILITY 1305 ~__wrap_iter() 1306 { 1307 __get_db()->__erase_i(this); 1308 } 1309#endif 1310 _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT_DEBUG 1311 { 1312#if _LIBCPP_DEBUG_LEVEL >= 2 1313 _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this), 1314 "Attempted to dereference a non-dereferenceable iterator"); 1315#endif 1316 return *__i; 1317 } 1318 _LIBCPP_INLINE_VISIBILITY pointer operator->() const _NOEXCEPT_DEBUG 1319 { 1320#if _LIBCPP_DEBUG_LEVEL >= 2 1321 _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this), 1322 "Attempted to dereference a non-dereferenceable iterator"); 1323#endif 1324 return (pointer)_VSTD::addressof(*__i); 1325 } 1326 _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator++() _NOEXCEPT_DEBUG 1327 { 1328#if _LIBCPP_DEBUG_LEVEL >= 2 1329 _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this), 1330 "Attempted to increment non-incrementable iterator"); 1331#endif 1332 ++__i; 1333 return *this; 1334 } 1335 _LIBCPP_INLINE_VISIBILITY __wrap_iter operator++(int) _NOEXCEPT_DEBUG 1336 {__wrap_iter __tmp(*this); ++(*this); return __tmp;} 1337 _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator--() _NOEXCEPT_DEBUG 1338 { 1339#if _LIBCPP_DEBUG_LEVEL >= 2 1340 _LIBCPP_ASSERT(__get_const_db()->__decrementable(this), 1341 "Attempted to decrement non-decrementable iterator"); 1342#endif 1343 --__i; 1344 return *this; 1345 } 1346 _LIBCPP_INLINE_VISIBILITY __wrap_iter operator--(int) _NOEXCEPT_DEBUG 1347 {__wrap_iter __tmp(*this); --(*this); return __tmp;} 1348 _LIBCPP_INLINE_VISIBILITY __wrap_iter operator+ (difference_type __n) const _NOEXCEPT_DEBUG 1349 {__wrap_iter __w(*this); __w += __n; return __w;} 1350 _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator+=(difference_type __n) _NOEXCEPT_DEBUG 1351 { 1352#if _LIBCPP_DEBUG_LEVEL >= 2 1353 _LIBCPP_ASSERT(__get_const_db()->__addable(this, __n), 1354 "Attempted to add/subtract iterator outside of valid range"); 1355#endif 1356 __i += __n; 1357 return *this; 1358 } 1359 _LIBCPP_INLINE_VISIBILITY __wrap_iter operator- (difference_type __n) const _NOEXCEPT_DEBUG 1360 {return *this + (-__n);} 1361 _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator-=(difference_type __n) _NOEXCEPT_DEBUG 1362 {*this += -__n; return *this;} 1363 _LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const _NOEXCEPT_DEBUG 1364 { 1365#if _LIBCPP_DEBUG_LEVEL >= 2 1366 _LIBCPP_ASSERT(__get_const_db()->__subscriptable(this, __n), 1367 "Attempted to subscript iterator outside of valid range"); 1368#endif 1369 return __i[__n]; 1370 } 1371 1372 _LIBCPP_INLINE_VISIBILITY iterator_type base() const _NOEXCEPT_DEBUG {return __i;} 1373 1374private: 1375#if _LIBCPP_DEBUG_LEVEL >= 2 1376 _LIBCPP_INLINE_VISIBILITY __wrap_iter(const void* __p, iterator_type __x) : __i(__x) 1377 { 1378 __get_db()->__insert_ic(this, __p); 1379 } 1380#else 1381 _LIBCPP_INLINE_VISIBILITY __wrap_iter(iterator_type __x) _NOEXCEPT_DEBUG : __i(__x) {} 1382#endif 1383 1384 template <class _Up> friend class __wrap_iter; 1385 template <class _CharT, class _Traits, class _Alloc> friend class basic_string; 1386 template <class _Tp, class _Alloc> friend class _LIBCPP_TEMPLATE_VIS vector; 1387 1388 template <class _Iter1, class _Iter2> 1389 friend 1390 bool 1391 operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1392 1393 template <class _Iter1, class _Iter2> 1394 friend 1395 bool 1396 operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1397 1398 template <class _Iter1, class _Iter2> 1399 friend 1400 bool 1401 operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1402 1403 template <class _Iter1, class _Iter2> 1404 friend 1405 bool 1406 operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1407 1408 template <class _Iter1, class _Iter2> 1409 friend 1410 bool 1411 operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1412 1413 template <class _Iter1, class _Iter2> 1414 friend 1415 bool 1416 operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1417 1418#ifndef _LIBCPP_CXX03_LANG 1419 template <class _Iter1, class _Iter2> 1420 friend 1421 auto 1422 operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG 1423 -> decltype(__x.base() - __y.base()); 1424#else 1425 template <class _Iter1, class _Iter2> 1426 friend 1427 typename __wrap_iter<_Iter1>::difference_type 1428 operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT_DEBUG; 1429#endif 1430 1431 template <class _Iter1> 1432 friend 1433 __wrap_iter<_Iter1> 1434 operator+(typename __wrap_iter<_Iter1>::difference_type, __wrap_iter<_Iter1>) _NOEXCEPT_DEBUG; 1435 1436 template <class _Ip, class _Op> friend _Op copy(_Ip, _Ip, _Op); 1437 template <class _B1, class _B2> friend _B2 copy_backward(_B1, _B1, _B2); 1438 template <class _Ip, class _Op> friend _Op move(_Ip, _Ip, _Op); 1439 template <class _B1, class _B2> friend _B2 move_backward(_B1, _B1, _B2); 1440 1441#if _LIBCPP_DEBUG_LEVEL < 2 1442 template <class _Tp> 1443 friend 1444 typename enable_if 1445 < 1446 is_trivially_copy_assignable<_Tp>::value, 1447 _Tp* 1448 >::type 1449 __unwrap_iter(__wrap_iter<_Tp*>); 1450#else 1451 template <class _Tp> 1452 inline _LIBCPP_INLINE_VISIBILITY 1453 typename enable_if 1454 < 1455 is_trivially_copy_assignable<_Tp>::value, 1456 __wrap_iter<_Tp*> 1457 >::type 1458 __unwrap_iter(__wrap_iter<_Tp*> __i); 1459#endif 1460}; 1461 1462template <class _Iter1, class _Iter2> 1463inline _LIBCPP_INLINE_VISIBILITY 1464bool 1465operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG 1466{ 1467 return __x.base() == __y.base(); 1468} 1469 1470template <class _Iter1, class _Iter2> 1471inline _LIBCPP_INLINE_VISIBILITY 1472bool 1473operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG 1474{ 1475#if _LIBCPP_DEBUG_LEVEL >= 2 1476 _LIBCPP_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y), 1477 "Attempted to compare incomparable iterators"); 1478#endif 1479 return __x.base() < __y.base(); 1480} 1481 1482template <class _Iter1, class _Iter2> 1483inline _LIBCPP_INLINE_VISIBILITY 1484bool 1485operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG 1486{ 1487 return !(__x == __y); 1488} 1489 1490template <class _Iter1, class _Iter2> 1491inline _LIBCPP_INLINE_VISIBILITY 1492bool 1493operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG 1494{ 1495 return __y < __x; 1496} 1497 1498template <class _Iter1, class _Iter2> 1499inline _LIBCPP_INLINE_VISIBILITY 1500bool 1501operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG 1502{ 1503 return !(__x < __y); 1504} 1505 1506template <class _Iter1, class _Iter2> 1507inline _LIBCPP_INLINE_VISIBILITY 1508bool 1509operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG 1510{ 1511 return !(__y < __x); 1512} 1513 1514template <class _Iter1> 1515inline _LIBCPP_INLINE_VISIBILITY 1516bool 1517operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT_DEBUG 1518{ 1519 return !(__x == __y); 1520} 1521 1522template <class _Iter1> 1523inline _LIBCPP_INLINE_VISIBILITY 1524bool 1525operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT_DEBUG 1526{ 1527 return __y < __x; 1528} 1529 1530template <class _Iter1> 1531inline _LIBCPP_INLINE_VISIBILITY 1532bool 1533operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT_DEBUG 1534{ 1535 return !(__x < __y); 1536} 1537 1538template <class _Iter1> 1539inline _LIBCPP_INLINE_VISIBILITY 1540bool 1541operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT_DEBUG 1542{ 1543 return !(__y < __x); 1544} 1545 1546#ifndef _LIBCPP_CXX03_LANG 1547template <class _Iter1, class _Iter2> 1548inline _LIBCPP_INLINE_VISIBILITY 1549auto 1550operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG 1551-> decltype(__x.base() - __y.base()) 1552{ 1553#if _LIBCPP_DEBUG_LEVEL >= 2 1554 _LIBCPP_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y), 1555 "Attempted to subtract incompatible iterators"); 1556#endif 1557 return __x.base() - __y.base(); 1558} 1559#else 1560template <class _Iter1, class _Iter2> 1561inline _LIBCPP_INLINE_VISIBILITY 1562typename __wrap_iter<_Iter1>::difference_type 1563operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT_DEBUG 1564{ 1565#if _LIBCPP_DEBUG_LEVEL >= 2 1566 _LIBCPP_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y), 1567 "Attempted to subtract incompatible iterators"); 1568#endif 1569 return __x.base() - __y.base(); 1570} 1571#endif 1572 1573template <class _Iter> 1574inline _LIBCPP_INLINE_VISIBILITY 1575__wrap_iter<_Iter> 1576operator+(typename __wrap_iter<_Iter>::difference_type __n, 1577 __wrap_iter<_Iter> __x) _NOEXCEPT_DEBUG 1578{ 1579 __x += __n; 1580 return __x; 1581} 1582 1583template <class _Iter> 1584struct __libcpp_is_trivial_iterator 1585 : public _LIBCPP_BOOL_CONSTANT(is_pointer<_Iter>::value) {}; 1586 1587template <class _Iter> 1588struct __libcpp_is_trivial_iterator<move_iterator<_Iter> > 1589 : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {}; 1590 1591template <class _Iter> 1592struct __libcpp_is_trivial_iterator<reverse_iterator<_Iter> > 1593 : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {}; 1594 1595template <class _Iter> 1596struct __libcpp_is_trivial_iterator<__wrap_iter<_Iter> > 1597 : public _LIBCPP_BOOL_CONSTANT(__libcpp_is_trivial_iterator<_Iter>::value) {}; 1598 1599 1600template <class _Tp, size_t _Np> 1601inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1602_Tp* 1603begin(_Tp (&__array)[_Np]) 1604{ 1605 return __array; 1606} 1607 1608template <class _Tp, size_t _Np> 1609inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1610_Tp* 1611end(_Tp (&__array)[_Np]) 1612{ 1613 return __array + _Np; 1614} 1615 1616#if !defined(_LIBCPP_CXX03_LANG) 1617 1618template <class _Cp> 1619inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1620auto 1621begin(_Cp& __c) -> decltype(__c.begin()) 1622{ 1623 return __c.begin(); 1624} 1625 1626template <class _Cp> 1627inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1628auto 1629begin(const _Cp& __c) -> decltype(__c.begin()) 1630{ 1631 return __c.begin(); 1632} 1633 1634template <class _Cp> 1635inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1636auto 1637end(_Cp& __c) -> decltype(__c.end()) 1638{ 1639 return __c.end(); 1640} 1641 1642template <class _Cp> 1643inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1644auto 1645end(const _Cp& __c) -> decltype(__c.end()) 1646{ 1647 return __c.end(); 1648} 1649 1650#if _LIBCPP_STD_VER > 11 1651 1652template <class _Tp, size_t _Np> 1653inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1654reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np]) 1655{ 1656 return reverse_iterator<_Tp*>(__array + _Np); 1657} 1658 1659template <class _Tp, size_t _Np> 1660inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1661reverse_iterator<_Tp*> rend(_Tp (&__array)[_Np]) 1662{ 1663 return reverse_iterator<_Tp*>(__array); 1664} 1665 1666template <class _Ep> 1667inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1668reverse_iterator<const _Ep*> rbegin(initializer_list<_Ep> __il) 1669{ 1670 return reverse_iterator<const _Ep*>(__il.end()); 1671} 1672 1673template <class _Ep> 1674inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1675reverse_iterator<const _Ep*> rend(initializer_list<_Ep> __il) 1676{ 1677 return reverse_iterator<const _Ep*>(__il.begin()); 1678} 1679 1680template <class _Cp> 1681inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1682auto cbegin(const _Cp& __c) -> decltype(_VSTD::begin(__c)) 1683{ 1684 return _VSTD::begin(__c); 1685} 1686 1687template <class _Cp> 1688inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1689auto cend(const _Cp& __c) -> decltype(_VSTD::end(__c)) 1690{ 1691 return _VSTD::end(__c); 1692} 1693 1694template <class _Cp> 1695inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1696auto rbegin(_Cp& __c) -> decltype(__c.rbegin()) 1697{ 1698 return __c.rbegin(); 1699} 1700 1701template <class _Cp> 1702inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1703auto rbegin(const _Cp& __c) -> decltype(__c.rbegin()) 1704{ 1705 return __c.rbegin(); 1706} 1707 1708template <class _Cp> 1709inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1710auto rend(_Cp& __c) -> decltype(__c.rend()) 1711{ 1712 return __c.rend(); 1713} 1714 1715template <class _Cp> 1716inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1717auto rend(const _Cp& __c) -> decltype(__c.rend()) 1718{ 1719 return __c.rend(); 1720} 1721 1722template <class _Cp> 1723inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1724auto crbegin(const _Cp& __c) -> decltype(_VSTD::rbegin(__c)) 1725{ 1726 return _VSTD::rbegin(__c); 1727} 1728 1729template <class _Cp> 1730inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 1731auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c)) 1732{ 1733 return _VSTD::rend(__c); 1734} 1735 1736#endif 1737 1738 1739#else // defined(_LIBCPP_CXX03_LANG) 1740 1741template <class _Cp> 1742inline _LIBCPP_INLINE_VISIBILITY 1743typename _Cp::iterator 1744begin(_Cp& __c) 1745{ 1746 return __c.begin(); 1747} 1748 1749template <class _Cp> 1750inline _LIBCPP_INLINE_VISIBILITY 1751typename _Cp::const_iterator 1752begin(const _Cp& __c) 1753{ 1754 return __c.begin(); 1755} 1756 1757template <class _Cp> 1758inline _LIBCPP_INLINE_VISIBILITY 1759typename _Cp::iterator 1760end(_Cp& __c) 1761{ 1762 return __c.end(); 1763} 1764 1765template <class _Cp> 1766inline _LIBCPP_INLINE_VISIBILITY 1767typename _Cp::const_iterator 1768end(const _Cp& __c) 1769{ 1770 return __c.end(); 1771} 1772 1773#endif // !defined(_LIBCPP_CXX03_LANG) 1774 1775#if _LIBCPP_STD_VER > 14 1776template <class _Cont> 1777constexpr auto size(const _Cont& __c) -> decltype(__c.size()) { return __c.size(); } 1778 1779template <class _Tp, size_t _Sz> 1780constexpr size_t size(const _Tp (&)[_Sz]) noexcept { return _Sz; } 1781 1782template <class _Cont> 1783constexpr auto empty(const _Cont& __c) -> decltype(__c.empty()) { return __c.empty(); } 1784 1785template <class _Tp, size_t _Sz> 1786constexpr bool empty(const _Tp (&)[_Sz]) noexcept { return false; } 1787 1788template <class _Ep> 1789constexpr bool empty(initializer_list<_Ep> __il) noexcept { return __il.size() == 0; } 1790 1791template <class _Cont> constexpr 1792auto data(_Cont& __c) -> decltype(__c.data()) { return __c.data(); } 1793 1794template <class _Cont> constexpr 1795auto data(const _Cont& __c) -> decltype(__c.data()) { return __c.data(); } 1796 1797template <class _Tp, size_t _Sz> 1798constexpr _Tp* data(_Tp (&__array)[_Sz]) noexcept { return __array; } 1799 1800template <class _Ep> 1801constexpr const _Ep* data(initializer_list<_Ep> __il) noexcept { return __il.begin(); } 1802#endif 1803 1804 1805_LIBCPP_END_NAMESPACE_STD 1806 1807#endif // _LIBCPP_ITERATOR 1808