00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066 #ifndef _STL_ITERATOR_H
00067 #define _STL_ITERATOR_H 1
00068
00069 #include <bits/cpp_type_traits.h>
00070 #include <ext/type_traits.h>
00071 #include <bits/stl_move.h>
00072
00073 _GLIBCXX_BEGIN_NAMESPACE(std)
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094 template<typename _Iterator>
00095 class reverse_iterator
00096 : public iterator<typename iterator_traits<_Iterator>::iterator_category,
00097 typename iterator_traits<_Iterator>::value_type,
00098 typename iterator_traits<_Iterator>::difference_type,
00099 typename iterator_traits<_Iterator>::pointer,
00100 typename iterator_traits<_Iterator>::reference>
00101 {
00102 protected:
00103 _Iterator current;
00104
00105 public:
00106 typedef _Iterator iterator_type;
00107 typedef typename iterator_traits<_Iterator>::difference_type
00108 difference_type;
00109 typedef typename iterator_traits<_Iterator>::reference reference;
00110 typedef typename iterator_traits<_Iterator>::pointer pointer;
00111
00112 public:
00113
00114
00115
00116
00117
00118
00119 reverse_iterator() : current() { }
00120
00121
00122
00123
00124 explicit
00125 reverse_iterator(iterator_type __x) : current(__x) { }
00126
00127
00128
00129
00130 reverse_iterator(const reverse_iterator& __x)
00131 : current(__x.current) { }
00132
00133
00134
00135
00136
00137 template<typename _Iter>
00138 reverse_iterator(const reverse_iterator<_Iter>& __x)
00139 : current(__x.base()) { }
00140
00141
00142
00143
00144 iterator_type
00145 base() const
00146 { return current; }
00147
00148
00149
00150
00151
00152
00153 reference
00154 operator*() const
00155 {
00156 _Iterator __tmp = current;
00157 return *--__tmp;
00158 }
00159
00160
00161
00162
00163
00164
00165 pointer
00166 operator->() const
00167 { return &(operator*()); }
00168
00169
00170
00171
00172
00173
00174 reverse_iterator&
00175 operator++()
00176 {
00177 --current;
00178 return *this;
00179 }
00180
00181
00182
00183
00184
00185
00186 reverse_iterator
00187 operator++(int)
00188 {
00189 reverse_iterator __tmp = *this;
00190 --current;
00191 return __tmp;
00192 }
00193
00194
00195
00196
00197
00198
00199 reverse_iterator&
00200 operator--()
00201 {
00202 ++current;
00203 return *this;
00204 }
00205
00206
00207
00208
00209
00210
00211 reverse_iterator
00212 operator--(int)
00213 {
00214 reverse_iterator __tmp = *this;
00215 ++current;
00216 return __tmp;
00217 }
00218
00219
00220
00221
00222
00223
00224 reverse_iterator
00225 operator+(difference_type __n) const
00226 { return reverse_iterator(current - __n); }
00227
00228
00229
00230
00231
00232
00233 reverse_iterator&
00234 operator+=(difference_type __n)
00235 {
00236 current -= __n;
00237 return *this;
00238 }
00239
00240
00241
00242
00243
00244
00245 reverse_iterator
00246 operator-(difference_type __n) const
00247 { return reverse_iterator(current + __n); }
00248
00249
00250
00251
00252
00253
00254 reverse_iterator&
00255 operator-=(difference_type __n)
00256 {
00257 current += __n;
00258 return *this;
00259 }
00260
00261
00262
00263
00264
00265
00266 reference
00267 operator[](difference_type __n) const
00268 { return *(*this + __n); }
00269 };
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281 template<typename _Iterator>
00282 inline bool
00283 operator==(const reverse_iterator<_Iterator>& __x,
00284 const reverse_iterator<_Iterator>& __y)
00285 { return __x.base() == __y.base(); }
00286
00287 template<typename _Iterator>
00288 inline bool
00289 operator<(const reverse_iterator<_Iterator>& __x,
00290 const reverse_iterator<_Iterator>& __y)
00291 { return __y.base() < __x.base(); }
00292
00293 template<typename _Iterator>
00294 inline bool
00295 operator!=(const reverse_iterator<_Iterator>& __x,
00296 const reverse_iterator<_Iterator>& __y)
00297 { return !(__x == __y); }
00298
00299 template<typename _Iterator>
00300 inline bool
00301 operator>(const reverse_iterator<_Iterator>& __x,
00302 const reverse_iterator<_Iterator>& __y)
00303 { return __y < __x; }
00304
00305 template<typename _Iterator>
00306 inline bool
00307 operator<=(const reverse_iterator<_Iterator>& __x,
00308 const reverse_iterator<_Iterator>& __y)
00309 { return !(__y < __x); }
00310
00311 template<typename _Iterator>
00312 inline bool
00313 operator>=(const reverse_iterator<_Iterator>& __x,
00314 const reverse_iterator<_Iterator>& __y)
00315 { return !(__x < __y); }
00316
00317 template<typename _Iterator>
00318 inline typename reverse_iterator<_Iterator>::difference_type
00319 operator-(const reverse_iterator<_Iterator>& __x,
00320 const reverse_iterator<_Iterator>& __y)
00321 { return __y.base() - __x.base(); }
00322
00323 template<typename _Iterator>
00324 inline reverse_iterator<_Iterator>
00325 operator+(typename reverse_iterator<_Iterator>::difference_type __n,
00326 const reverse_iterator<_Iterator>& __x)
00327 { return reverse_iterator<_Iterator>(__x.base() - __n); }
00328
00329
00330
00331 template<typename _IteratorL, typename _IteratorR>
00332 inline bool
00333 operator==(const reverse_iterator<_IteratorL>& __x,
00334 const reverse_iterator<_IteratorR>& __y)
00335 { return __x.base() == __y.base(); }
00336
00337 template<typename _IteratorL, typename _IteratorR>
00338 inline bool
00339 operator<(const reverse_iterator<_IteratorL>& __x,
00340 const reverse_iterator<_IteratorR>& __y)
00341 { return __y.base() < __x.base(); }
00342
00343 template<typename _IteratorL, typename _IteratorR>
00344 inline bool
00345 operator!=(const reverse_iterator<_IteratorL>& __x,
00346 const reverse_iterator<_IteratorR>& __y)
00347 { return !(__x == __y); }
00348
00349 template<typename _IteratorL, typename _IteratorR>
00350 inline bool
00351 operator>(const reverse_iterator<_IteratorL>& __x,
00352 const reverse_iterator<_IteratorR>& __y)
00353 { return __y < __x; }
00354
00355 template<typename _IteratorL, typename _IteratorR>
00356 inline bool
00357 operator<=(const reverse_iterator<_IteratorL>& __x,
00358 const reverse_iterator<_IteratorR>& __y)
00359 { return !(__y < __x); }
00360
00361 template<typename _IteratorL, typename _IteratorR>
00362 inline bool
00363 operator>=(const reverse_iterator<_IteratorL>& __x,
00364 const reverse_iterator<_IteratorR>& __y)
00365 { return !(__x < __y); }
00366
00367 template<typename _IteratorL, typename _IteratorR>
00368 inline typename reverse_iterator<_IteratorL>::difference_type
00369 operator-(const reverse_iterator<_IteratorL>& __x,
00370 const reverse_iterator<_IteratorR>& __y)
00371 { return __y.base() - __x.base(); }
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385 template<typename _Container>
00386 class back_insert_iterator
00387 : public iterator<output_iterator_tag, void, void, void, void>
00388 {
00389 protected:
00390 _Container* container;
00391
00392 public:
00393
00394 typedef _Container container_type;
00395
00396
00397 explicit
00398 back_insert_iterator(_Container& __x) : container(&__x) { }
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411 back_insert_iterator&
00412 operator=(typename _Container::const_reference __value)
00413 {
00414 container->push_back(__value);
00415 return *this;
00416 }
00417
00418 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00419 back_insert_iterator&
00420 operator=(typename _Container::value_type&& __value)
00421 {
00422 container->push_back(std::move(__value));
00423 return *this;
00424 }
00425 #endif
00426
00427
00428 back_insert_iterator&
00429 operator*()
00430 { return *this; }
00431
00432
00433 back_insert_iterator&
00434 operator++()
00435 { return *this; }
00436
00437
00438 back_insert_iterator
00439 operator++(int)
00440 { return *this; }
00441 };
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454 template<typename _Container>
00455 inline back_insert_iterator<_Container>
00456 back_inserter(_Container& __x)
00457 { return back_insert_iterator<_Container>(__x); }
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469 template<typename _Container>
00470 class front_insert_iterator
00471 : public iterator<output_iterator_tag, void, void, void, void>
00472 {
00473 protected:
00474 _Container* container;
00475
00476 public:
00477
00478 typedef _Container container_type;
00479
00480
00481 explicit front_insert_iterator(_Container& __x) : container(&__x) { }
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494 front_insert_iterator&
00495 operator=(typename _Container::const_reference __value)
00496 {
00497 container->push_front(__value);
00498 return *this;
00499 }
00500
00501 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00502 front_insert_iterator&
00503 operator=(typename _Container::value_type&& __value)
00504 {
00505 container->push_front(std::move(__value));
00506 return *this;
00507 }
00508 #endif
00509
00510
00511 front_insert_iterator&
00512 operator*()
00513 { return *this; }
00514
00515
00516 front_insert_iterator&
00517 operator++()
00518 { return *this; }
00519
00520
00521 front_insert_iterator
00522 operator++(int)
00523 { return *this; }
00524 };
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537 template<typename _Container>
00538 inline front_insert_iterator<_Container>
00539 front_inserter(_Container& __x)
00540 { return front_insert_iterator<_Container>(__x); }
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556 template<typename _Container>
00557 class insert_iterator
00558 : public iterator<output_iterator_tag, void, void, void, void>
00559 {
00560 protected:
00561 _Container* container;
00562 typename _Container::iterator iter;
00563
00564 public:
00565
00566 typedef _Container container_type;
00567
00568
00569
00570
00571
00572 insert_iterator(_Container& __x, typename _Container::iterator __i)
00573 : container(&__x), iter(__i) {}
00574
00575
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598 insert_iterator&
00599 operator=(typename _Container::const_reference __value)
00600 {
00601 iter = container->insert(iter, __value);
00602 ++iter;
00603 return *this;
00604 }
00605
00606 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00607 insert_iterator&
00608 operator=(typename _Container::value_type&& __value)
00609 {
00610 iter = container->insert(iter, std::move(__value));
00611 ++iter;
00612 return *this;
00613 }
00614 #endif
00615
00616
00617 insert_iterator&
00618 operator*()
00619 { return *this; }
00620
00621
00622 insert_iterator&
00623 operator++()
00624 { return *this; }
00625
00626
00627 insert_iterator&
00628 operator++(int)
00629 { return *this; }
00630 };
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643 template<typename _Container, typename _Iterator>
00644 inline insert_iterator<_Container>
00645 inserter(_Container& __x, _Iterator __i)
00646 {
00647 return insert_iterator<_Container>(__x,
00648 typename _Container::iterator(__i));
00649 }
00650
00651 _GLIBCXX_END_NAMESPACE
00652
00653 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
00654
00655
00656
00657
00658
00659
00660
00661
00662 using std::iterator_traits;
00663 using std::iterator;
00664 template<typename _Iterator, typename _Container>
00665 class __normal_iterator
00666 {
00667 protected:
00668 _Iterator _M_current;
00669
00670 public:
00671 typedef _Iterator iterator_type;
00672 typedef typename iterator_traits<_Iterator>::iterator_category
00673 iterator_category;
00674 typedef typename iterator_traits<_Iterator>::value_type value_type;
00675 typedef typename iterator_traits<_Iterator>::difference_type
00676 difference_type;
00677 typedef typename iterator_traits<_Iterator>::reference reference;
00678 typedef typename iterator_traits<_Iterator>::pointer pointer;
00679
00680 __normal_iterator() : _M_current(_Iterator()) { }
00681
00682 explicit
00683 __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
00684
00685
00686 template<typename _Iter>
00687 __normal_iterator(const __normal_iterator<_Iter,
00688 typename __enable_if<
00689 (std::__are_same<_Iter, typename _Container::pointer>::__value),
00690 _Container>::__type>& __i)
00691 : _M_current(__i.base()) { }
00692
00693
00694 reference
00695 operator*() const
00696 { return *_M_current; }
00697
00698 pointer
00699 operator->() const
00700 { return _M_current; }
00701
00702 __normal_iterator&
00703 operator++()
00704 {
00705 ++_M_current;
00706 return *this;
00707 }
00708
00709 __normal_iterator
00710 operator++(int)
00711 { return __normal_iterator(_M_current++); }
00712
00713
00714 __normal_iterator&
00715 operator--()
00716 {
00717 --_M_current;
00718 return *this;
00719 }
00720
00721 __normal_iterator
00722 operator--(int)
00723 { return __normal_iterator(_M_current--); }
00724
00725
00726 reference
00727 operator[](const difference_type& __n) const
00728 { return _M_current[__n]; }
00729
00730 __normal_iterator&
00731 operator+=(const difference_type& __n)
00732 { _M_current += __n; return *this; }
00733
00734 __normal_iterator
00735 operator+(const difference_type& __n) const
00736 { return __normal_iterator(_M_current + __n); }
00737
00738 __normal_iterator&
00739 operator-=(const difference_type& __n)
00740 { _M_current -= __n; return *this; }
00741
00742 __normal_iterator
00743 operator-(const difference_type& __n) const
00744 { return __normal_iterator(_M_current - __n); }
00745
00746 const _Iterator&
00747 base() const
00748 { return _M_current; }
00749 };
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760 template<typename _IteratorL, typename _IteratorR, typename _Container>
00761 inline bool
00762 operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
00763 const __normal_iterator<_IteratorR, _Container>& __rhs)
00764 { return __lhs.base() == __rhs.base(); }
00765
00766 template<typename _Iterator, typename _Container>
00767 inline bool
00768 operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
00769 const __normal_iterator<_Iterator, _Container>& __rhs)
00770 { return __lhs.base() == __rhs.base(); }
00771
00772 template<typename _IteratorL, typename _IteratorR, typename _Container>
00773 inline bool
00774 operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
00775 const __normal_iterator<_IteratorR, _Container>& __rhs)
00776 { return __lhs.base() != __rhs.base(); }
00777
00778 template<typename _Iterator, typename _Container>
00779 inline bool
00780 operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
00781 const __normal_iterator<_Iterator, _Container>& __rhs)
00782 { return __lhs.base() != __rhs.base(); }
00783
00784
00785 template<typename _IteratorL, typename _IteratorR, typename _Container>
00786 inline bool
00787 operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
00788 const __normal_iterator<_IteratorR, _Container>& __rhs)
00789 { return __lhs.base() < __rhs.base(); }
00790
00791 template<typename _Iterator, typename _Container>
00792 inline bool
00793 operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
00794 const __normal_iterator<_Iterator, _Container>& __rhs)
00795 { return __lhs.base() < __rhs.base(); }
00796
00797 template<typename _IteratorL, typename _IteratorR, typename _Container>
00798 inline bool
00799 operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
00800 const __normal_iterator<_IteratorR, _Container>& __rhs)
00801 { return __lhs.base() > __rhs.base(); }
00802
00803 template<typename _Iterator, typename _Container>
00804 inline bool
00805 operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
00806 const __normal_iterator<_Iterator, _Container>& __rhs)
00807 { return __lhs.base() > __rhs.base(); }
00808
00809 template<typename _IteratorL, typename _IteratorR, typename _Container>
00810 inline bool
00811 operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
00812 const __normal_iterator<_IteratorR, _Container>& __rhs)
00813 { return __lhs.base() <= __rhs.base(); }
00814
00815 template<typename _Iterator, typename _Container>
00816 inline bool
00817 operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
00818 const __normal_iterator<_Iterator, _Container>& __rhs)
00819 { return __lhs.base() <= __rhs.base(); }
00820
00821 template<typename _IteratorL, typename _IteratorR, typename _Container>
00822 inline bool
00823 operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
00824 const __normal_iterator<_IteratorR, _Container>& __rhs)
00825 { return __lhs.base() >= __rhs.base(); }
00826
00827 template<typename _Iterator, typename _Container>
00828 inline bool
00829 operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
00830 const __normal_iterator<_Iterator, _Container>& __rhs)
00831 { return __lhs.base() >= __rhs.base(); }
00832
00833
00834
00835
00836
00837 template<typename _IteratorL, typename _IteratorR, typename _Container>
00838 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
00839 operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
00840 const __normal_iterator<_IteratorR, _Container>& __rhs)
00841 { return __lhs.base() - __rhs.base(); }
00842
00843 template<typename _Iterator, typename _Container>
00844 inline typename __normal_iterator<_Iterator, _Container>::difference_type
00845 operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
00846 const __normal_iterator<_Iterator, _Container>& __rhs)
00847 { return __lhs.base() - __rhs.base(); }
00848
00849 template<typename _Iterator, typename _Container>
00850 inline __normal_iterator<_Iterator, _Container>
00851 operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
00852 __n, const __normal_iterator<_Iterator, _Container>& __i)
00853 { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
00854
00855 _GLIBCXX_END_NAMESPACE
00856
00857 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00858
00859 _GLIBCXX_BEGIN_NAMESPACE(std)
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870 template<typename _Iterator>
00871 class move_iterator
00872 {
00873 protected:
00874 _Iterator _M_current;
00875
00876 public:
00877 typedef _Iterator iterator_type;
00878 typedef typename iterator_traits<_Iterator>::difference_type
00879 difference_type;
00880
00881 typedef _Iterator pointer;
00882 typedef typename iterator_traits<_Iterator>::value_type value_type;
00883 typedef typename iterator_traits<_Iterator>::iterator_category
00884 iterator_category;
00885 typedef value_type&& reference;
00886
00887 public:
00888 move_iterator()
00889 : _M_current() { }
00890
00891 explicit
00892 move_iterator(iterator_type __i)
00893 : _M_current(__i) { }
00894
00895 template<typename _Iter>
00896 move_iterator(const move_iterator<_Iter>& __i)
00897 : _M_current(__i.base()) { }
00898
00899 iterator_type
00900 base() const
00901 { return _M_current; }
00902
00903 reference
00904 operator*() const
00905 { return *_M_current; }
00906
00907 pointer
00908 operator->() const
00909 { return _M_current; }
00910
00911 move_iterator&
00912 operator++()
00913 {
00914 ++_M_current;
00915 return *this;
00916 }
00917
00918 move_iterator
00919 operator++(int)
00920 {
00921 move_iterator __tmp = *this;
00922 ++_M_current;
00923 return __tmp;
00924 }
00925
00926 move_iterator&
00927 operator--()
00928 {
00929 --_M_current;
00930 return *this;
00931 }
00932
00933 move_iterator
00934 operator--(int)
00935 {
00936 move_iterator __tmp = *this;
00937 --_M_current;
00938 return __tmp;
00939 }
00940
00941 move_iterator
00942 operator+(difference_type __n) const
00943 { return move_iterator(_M_current + __n); }
00944
00945 move_iterator&
00946 operator+=(difference_type __n)
00947 {
00948 _M_current += __n;
00949 return *this;
00950 }
00951
00952 move_iterator
00953 operator-(difference_type __n) const
00954 { return move_iterator(_M_current - __n); }
00955
00956 move_iterator&
00957 operator-=(difference_type __n)
00958 {
00959 _M_current -= __n;
00960 return *this;
00961 }
00962
00963 reference
00964 operator[](difference_type __n) const
00965 { return _M_current[__n]; }
00966 };
00967
00968 template<typename _IteratorL, typename _IteratorR>
00969 inline bool
00970 operator==(const move_iterator<_IteratorL>& __x,
00971 const move_iterator<_IteratorR>& __y)
00972 { return __x.base() == __y.base(); }
00973
00974 template<typename _IteratorL, typename _IteratorR>
00975 inline bool
00976 operator!=(const move_iterator<_IteratorL>& __x,
00977 const move_iterator<_IteratorR>& __y)
00978 { return !(__x == __y); }
00979
00980 template<typename _IteratorL, typename _IteratorR>
00981 inline bool
00982 operator<(const move_iterator<_IteratorL>& __x,
00983 const move_iterator<_IteratorR>& __y)
00984 { return __x.base() < __y.base(); }
00985
00986 template<typename _IteratorL, typename _IteratorR>
00987 inline bool
00988 operator<=(const move_iterator<_IteratorL>& __x,
00989 const move_iterator<_IteratorR>& __y)
00990 { return !(__y < __x); }
00991
00992 template<typename _IteratorL, typename _IteratorR>
00993 inline bool
00994 operator>(const move_iterator<_IteratorL>& __x,
00995 const move_iterator<_IteratorR>& __y)
00996 { return __y < __x; }
00997
00998 template<typename _IteratorL, typename _IteratorR>
00999 inline bool
01000 operator>=(const move_iterator<_IteratorL>& __x,
01001 const move_iterator<_IteratorR>& __y)
01002 { return !(__x < __y); }
01003
01004 template<typename _IteratorL, typename _IteratorR>
01005 inline typename move_iterator<_IteratorL>::difference_type
01006 operator-(const move_iterator<_IteratorL>& __x,
01007 const move_iterator<_IteratorR>& __y)
01008 { return __x.base() - __y.base(); }
01009
01010 template<typename _Iterator>
01011 inline move_iterator<_Iterator>
01012 operator+(typename move_iterator<_Iterator>::difference_type __n,
01013 const move_iterator<_Iterator>& __x)
01014 { return __x + __n; }
01015
01016 template<typename _Iterator>
01017 inline move_iterator<_Iterator>
01018 make_move_iterator(const _Iterator& __i)
01019 { return move_iterator<_Iterator>(__i); }
01020
01021 _GLIBCXX_END_NAMESPACE
01022
01023 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
01024 #else
01025 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
01026 #endif // __GXX_EXPERIMENTAL_CXX0X__
01027
01028 #endif