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
00061 #include <bits/concept_check.h>
00062 #include <bits/stl_iterator_base_types.h>
00063 #include <bits/stl_iterator_base_funcs.h>
00064
00065 #ifndef __GLIBCPP_INTERNAL_DEQUE_H
00066 #define __GLIBCPP_INTERNAL_DEQUE_H
00067
00068
00069
00070
00071
00072 namespace std
00073 {
00074
00085 inline size_t
00086 __deque_buf_size(size_t __size)
00087 { return __size < 512 ? size_t(512 / __size) : size_t(1); }
00088
00089
00091
00101 template <class _Tp, class _Ref, class _Ptr>
00102 struct _Deque_iterator
00103 {
00104 typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
00105 typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
00106 static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }
00107
00108 typedef random_access_iterator_tag iterator_category;
00109 typedef _Tp value_type;
00110 typedef _Ptr pointer;
00111 typedef _Ref reference;
00112 typedef size_t size_type;
00113 typedef ptrdiff_t difference_type;
00114 typedef _Tp** _Map_pointer;
00115 typedef _Deque_iterator _Self;
00116
00117 _Tp* _M_cur;
00118 _Tp* _M_first;
00119 _Tp* _M_last;
00120 _Map_pointer _M_node;
00121
00122 _Deque_iterator(_Tp* __x, _Map_pointer __y)
00123 : _M_cur(__x), _M_first(*__y),
00124 _M_last(*__y + _S_buffer_size()), _M_node(__y) {}
00125 _Deque_iterator() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {}
00126 _Deque_iterator(const iterator& __x)
00127 : _M_cur(__x._M_cur), _M_first(__x._M_first),
00128 _M_last(__x._M_last), _M_node(__x._M_node) {}
00129
00130 reference operator*() const { return *_M_cur; }
00131 pointer operator->() const { return _M_cur; }
00132
00133 difference_type operator-(const _Self& __x) const {
00134 return difference_type(_S_buffer_size()) * (_M_node - __x._M_node - 1) +
00135 (_M_cur - _M_first) + (__x._M_last - __x._M_cur);
00136 }
00137
00138 _Self& operator++() {
00139 ++_M_cur;
00140 if (_M_cur == _M_last) {
00141 _M_set_node(_M_node + 1);
00142 _M_cur = _M_first;
00143 }
00144 return *this;
00145 }
00146 _Self operator++(int) {
00147 _Self __tmp = *this;
00148 ++*this;
00149 return __tmp;
00150 }
00151
00152 _Self& operator--() {
00153 if (_M_cur == _M_first) {
00154 _M_set_node(_M_node - 1);
00155 _M_cur = _M_last;
00156 }
00157 --_M_cur;
00158 return *this;
00159 }
00160 _Self operator--(int) {
00161 _Self __tmp = *this;
00162 --*this;
00163 return __tmp;
00164 }
00165
00166 _Self& operator+=(difference_type __n)
00167 {
00168 difference_type __offset = __n + (_M_cur - _M_first);
00169 if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
00170 _M_cur += __n;
00171 else {
00172 difference_type __node_offset =
00173 __offset > 0 ? __offset / difference_type(_S_buffer_size())
00174 : -difference_type((-__offset - 1) / _S_buffer_size()) - 1;
00175 _M_set_node(_M_node + __node_offset);
00176 _M_cur = _M_first +
00177 (__offset - __node_offset * difference_type(_S_buffer_size()));
00178 }
00179 return *this;
00180 }
00181
00182 _Self operator+(difference_type __n) const
00183 {
00184 _Self __tmp = *this;
00185 return __tmp += __n;
00186 }
00187
00188 _Self& operator-=(difference_type __n) { return *this += -__n; }
00189
00190 _Self operator-(difference_type __n) const {
00191 _Self __tmp = *this;
00192 return __tmp -= __n;
00193 }
00194
00195 reference operator[](difference_type __n) const { return *(*this + __n); }
00196
00197 bool operator==(const _Self& __x) const { return _M_cur == __x._M_cur; }
00198 bool operator!=(const _Self& __x) const { return !(*this == __x); }
00199 bool operator<(const _Self& __x) const {
00200 return (_M_node == __x._M_node) ?
00201 (_M_cur < __x._M_cur) : (_M_node < __x._M_node);
00202 }
00203 bool operator>(const _Self& __x) const { return __x < *this; }
00204 bool operator<=(const _Self& __x) const { return !(__x < *this); }
00205 bool operator>=(const _Self& __x) const { return !(*this < __x); }
00206
00213 void _M_set_node(_Map_pointer __new_node) {
00214 _M_node = __new_node;
00215 _M_first = *__new_node;
00216 _M_last = _M_first + difference_type(_S_buffer_size());
00217 }
00218 };
00219
00220 template <class _Tp, class _Ref, class _Ptr>
00221 inline _Deque_iterator<_Tp, _Ref, _Ptr>
00222 operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
00223 {
00224 return __x + __n;
00225 }
00226
00227
00229
00239 template <class _Tp, class _Alloc, bool __is_static>
00240 class _Deque_alloc_base
00241 {
00242 public:
00243 typedef typename _Alloc_traits<_Tp,_Alloc>::allocator_type allocator_type;
00244 allocator_type get_allocator() const { return _M_node_allocator; }
00245
00246 _Deque_alloc_base(const allocator_type& __a)
00247 : _M_node_allocator(__a), _M_map_allocator(__a),
00248 _M_map(0), _M_map_size(0)
00249 {}
00250
00251 protected:
00252 typedef typename _Alloc_traits<_Tp*, _Alloc>::allocator_type
00253 _Map_allocator_type;
00254
00255 allocator_type _M_node_allocator;
00256 _Map_allocator_type _M_map_allocator;
00257
00258 _Tp* _M_allocate_node() {
00259 return _M_node_allocator.allocate(__deque_buf_size(sizeof(_Tp)));
00260 }
00261 void _M_deallocate_node(_Tp* __p) {
00262 _M_node_allocator.deallocate(__p, __deque_buf_size(sizeof(_Tp)));
00263 }
00264 _Tp** _M_allocate_map(size_t __n)
00265 { return _M_map_allocator.allocate(__n); }
00266 void _M_deallocate_map(_Tp** __p, size_t __n)
00267 { _M_map_allocator.deallocate(__p, __n); }
00268
00269 _Tp** _M_map;
00270 size_t _M_map_size;
00271 };
00272
00274 template <class _Tp, class _Alloc>
00275 class _Deque_alloc_base<_Tp, _Alloc, true>
00276 {
00277 public:
00278 typedef typename _Alloc_traits<_Tp,_Alloc>::allocator_type allocator_type;
00279 allocator_type get_allocator() const { return allocator_type(); }
00280
00281 _Deque_alloc_base(const allocator_type&) : _M_map(0), _M_map_size(0) {}
00282
00283 protected:
00284 typedef typename _Alloc_traits<_Tp, _Alloc>::_Alloc_type _Node_alloc_type;
00285 typedef typename _Alloc_traits<_Tp*, _Alloc>::_Alloc_type _Map_alloc_type;
00286
00287 _Tp* _M_allocate_node() {
00288 return _Node_alloc_type::allocate(__deque_buf_size(sizeof(_Tp)));
00289 }
00290 void _M_deallocate_node(_Tp* __p) {
00291 _Node_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
00292 }
00293 _Tp** _M_allocate_map(size_t __n)
00294 { return _Map_alloc_type::allocate(__n); }
00295 void _M_deallocate_map(_Tp** __p, size_t __n)
00296 { _Map_alloc_type::deallocate(__p, __n); }
00297
00298 _Tp** _M_map;
00299 size_t _M_map_size;
00300 };
00301
00302
00313 template <class _Tp, class _Alloc>
00314 class _Deque_base
00315 : public _Deque_alloc_base<_Tp,_Alloc,
00316 _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
00317 {
00318 public:
00319 typedef _Deque_alloc_base<_Tp,_Alloc,
00320 _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
00321 _Base;
00322 typedef typename _Base::allocator_type allocator_type;
00323 typedef _Deque_iterator<_Tp,_Tp&,_Tp*> iterator;
00324 typedef _Deque_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
00325
00326 _Deque_base(const allocator_type& __a, size_t __num_elements)
00327 : _Base(__a), _M_start(), _M_finish()
00328 { _M_initialize_map(__num_elements); }
00329 _Deque_base(const allocator_type& __a)
00330 : _Base(__a), _M_start(), _M_finish() {}
00331 ~_Deque_base();
00332
00333 protected:
00334 void _M_initialize_map(size_t);
00335 void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
00336 void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
00337 enum { _S_initial_map_size = 8 };
00338
00339 protected:
00340 iterator _M_start;
00341 iterator _M_finish;
00342 };
00343
00344
00345 template <class _Tp, class _Alloc>
00346 _Deque_base<_Tp,_Alloc>::~_Deque_base()
00347 {
00348 if (_M_map) {
00349 _M_destroy_nodes(_M_start._M_node, _M_finish._M_node + 1);
00350 _M_deallocate_map(_M_map, _M_map_size);
00351 }
00352 }
00353
00363 template <class _Tp, class _Alloc>
00364 void
00365 _Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements)
00366 {
00367 size_t __num_nodes =
00368 __num_elements / __deque_buf_size(sizeof(_Tp)) + 1;
00369
00370 _M_map_size = max((size_t) _S_initial_map_size, __num_nodes + 2);
00371 _M_map = _M_allocate_map(_M_map_size);
00372
00373 _Tp** __nstart = _M_map + (_M_map_size - __num_nodes) / 2;
00374 _Tp** __nfinish = __nstart + __num_nodes;
00375
00376 try
00377 { _M_create_nodes(__nstart, __nfinish); }
00378 catch(...)
00379 {
00380 _M_deallocate_map(_M_map, _M_map_size);
00381 _M_map = 0;
00382 _M_map_size = 0;
00383 __throw_exception_again;
00384 }
00385
00386 _M_start._M_set_node(__nstart);
00387 _M_finish._M_set_node(__nfinish - 1);
00388 _M_start._M_cur = _M_start._M_first;
00389 _M_finish._M_cur = _M_finish._M_first +
00390 __num_elements % __deque_buf_size(sizeof(_Tp));
00391 }
00392
00393 template <class _Tp, class _Alloc>
00394 void _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
00395 {
00396 _Tp** __cur;
00397 try {
00398 for (__cur = __nstart; __cur < __nfinish; ++__cur)
00399 *__cur = _M_allocate_node();
00400 }
00401 catch(...)
00402 {
00403 _M_destroy_nodes(__nstart, __cur);
00404 __throw_exception_again;
00405 }
00406 }
00407
00408 template <class _Tp, class _Alloc>
00409 void
00410 _Deque_base<_Tp,_Alloc>::_M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish)
00411 {
00412 for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
00413 _M_deallocate_node(*__n);
00414 }
00415
00416
00497 template <class _Tp, class _Alloc = allocator<_Tp> >
00498 class deque : protected _Deque_base<_Tp, _Alloc>
00499 {
00500
00501 __glibcpp_class_requires(_Tp, _SGIAssignableConcept)
00502
00503 typedef _Deque_base<_Tp, _Alloc> _Base;
00504
00505 public:
00506 typedef _Tp value_type;
00507 typedef value_type* pointer;
00508 typedef const value_type* const_pointer;
00509 typedef value_type& reference;
00510 typedef const value_type& const_reference;
00511 typedef size_t size_type;
00512 typedef ptrdiff_t difference_type;
00513
00514 typedef typename _Base::allocator_type allocator_type;
00515 allocator_type get_allocator() const { return _Base::get_allocator(); }
00516
00517 typedef typename _Base::iterator iterator;
00518 typedef typename _Base::const_iterator const_iterator;
00519 typedef reverse_iterator<const_iterator> const_reverse_iterator;
00520 typedef reverse_iterator<iterator> reverse_iterator;
00521
00522 protected:
00523 typedef pointer* _Map_pointer;
00524 static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }
00525
00526
00527 using _Base::_M_initialize_map;
00528 using _Base::_M_create_nodes;
00529 using _Base::_M_destroy_nodes;
00530 using _Base::_M_allocate_node;
00531 using _Base::_M_deallocate_node;
00532 using _Base::_M_allocate_map;
00533 using _Base::_M_deallocate_map;
00534
00541 using _Base::_M_map;
00542 using _Base::_M_map_size;
00543 using _Base::_M_start;
00544 using _Base::_M_finish;
00545
00546 public:
00547 iterator begin() { return _M_start; }
00548 iterator end() { return _M_finish; }
00549 const_iterator begin() const { return _M_start; }
00550 const_iterator end() const { return _M_finish; }
00551
00552 reverse_iterator rbegin() { return reverse_iterator(_M_finish); }
00553 reverse_iterator rend() { return reverse_iterator(_M_start); }
00554 const_reverse_iterator rbegin() const
00555 { return const_reverse_iterator(_M_finish); }
00556 const_reverse_iterator rend() const
00557 { return const_reverse_iterator(_M_start); }
00558
00559 reference operator[](size_type __n)
00560 { return _M_start[difference_type(__n)]; }
00561 const_reference operator[](size_type __n) const
00562 { return _M_start[difference_type(__n)]; }
00563
00564 void _M_range_check(size_type __n) const {
00565 if (__n >= this->size())
00566 __throw_range_error("deque");
00567 }
00568
00569 reference at(size_type __n)
00570 { _M_range_check(__n); return (*this)[__n]; }
00571 const_reference at(size_type __n) const
00572 { _M_range_check(__n); return (*this)[__n]; }
00573
00574 reference front() { return *_M_start; }
00575 reference back() {
00576 iterator __tmp = _M_finish;
00577 --__tmp;
00578 return *__tmp;
00579 }
00580 const_reference front() const { return *_M_start; }
00581 const_reference back() const {
00582 const_iterator __tmp = _M_finish;
00583 --__tmp;
00584 return *__tmp;
00585 }
00586
00587 size_type size() const { return _M_finish - _M_start; }
00588 size_type max_size() const { return size_type(-1); }
00589 bool empty() const { return _M_finish == _M_start; }
00590
00591 public:
00592 explicit deque(const allocator_type& __a = allocator_type())
00593 : _Base(__a, 0) {}
00594 deque(const deque& __x) : _Base(__x.get_allocator(), __x.size())
00595 { uninitialized_copy(__x.begin(), __x.end(), _M_start); }
00596 deque(size_type __n, const value_type& __value,
00597 const allocator_type& __a = allocator_type()) : _Base(__a, __n)
00598 { _M_fill_initialize(__value); }
00599
00600 explicit
00601 deque(size_type __n)
00602 : _Base(allocator_type(), __n)
00603 { _M_fill_initialize(value_type()); }
00604
00605
00606 template<class _InputIterator>
00607 deque(_InputIterator __first, _InputIterator __last,
00608 const allocator_type& __a = allocator_type())
00609 : _Base(__a)
00610 {
00611 typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
00612 _M_initialize_dispatch(__first, __last, _Integral());
00613 }
00614
00615 template<class _Integer>
00616 void
00617 _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
00618 {
00619 _M_initialize_map(__n);
00620 _M_fill_initialize(__x);
00621 }
00622
00623 template<class _InputIter>
00624 void
00625 _M_initialize_dispatch(_InputIter __first, _InputIter __last, __false_type)
00626 {
00627 typedef typename iterator_traits<_InputIter>::iterator_category _IterCategory;
00628 _M_range_initialize(__first, __last, _IterCategory());
00629 }
00630
00631 ~deque()
00632 { _Destroy(_M_start, _M_finish); }
00633
00634 deque& operator= (const deque& __x) {
00635 const size_type __len = size();
00636 if (&__x != this) {
00637 if (__len >= __x.size())
00638 erase(copy(__x.begin(), __x.end(), _M_start), _M_finish);
00639 else {
00640 const_iterator __mid = __x.begin() + difference_type(__len);
00641 copy(__x.begin(), __mid, _M_start);
00642 insert(_M_finish, __mid, __x.end());
00643 }
00644 }
00645 return *this;
00646 }
00647
00648 void swap(deque& __x) {
00649 std::swap(_M_start, __x._M_start);
00650 std::swap(_M_finish, __x._M_finish);
00651 std::swap(_M_map, __x._M_map);
00652 std::swap(_M_map_size, __x._M_map_size);
00653 }
00654
00655 public:
00656
00657
00658
00659
00660
00661 void _M_fill_assign(size_type __n, const _Tp& __val) {
00662 if (__n > size()) {
00663 fill(begin(), end(), __val);
00664 insert(end(), __n - size(), __val);
00665 }
00666 else {
00667 erase(begin() + __n, end());
00668 fill(begin(), end(), __val);
00669 }
00670 }
00671
00672 void
00673 assign(size_type __n, const _Tp& __val)
00674 { _M_fill_assign(__n, __val); }
00675
00676 template<class _InputIterator>
00677 void
00678 assign(_InputIterator __first, _InputIterator __last)
00679 {
00680 typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
00681 _M_assign_dispatch(__first, __last, _Integral());
00682 }
00683
00684 private:
00685
00686 template<class _Integer>
00687 void
00688 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
00689 { _M_fill_assign(static_cast<size_type>(__n), static_cast<_Tp>(__val)); }
00690
00691 template<class _InputIterator>
00692 void
00693 _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type)
00694 {
00695 typedef typename iterator_traits<_InputIterator>::iterator_category _IterCategory;
00696 _M_assign_aux(__first, __last, _IterCategory());
00697 }
00698
00699 template <class _InputIterator>
00700 void _M_assign_aux(_InputIterator __first, _InputIterator __last,
00701 input_iterator_tag);
00702
00703 template <class _ForwardIterator>
00704 void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
00705 forward_iterator_tag) {
00706 size_type __len = distance(__first, __last);
00707 if (__len > size()) {
00708 _ForwardIterator __mid = __first;
00709 advance(__mid, size());
00710 copy(__first, __mid, begin());
00711 insert(end(), __mid, __last);
00712 }
00713 else
00714 erase(copy(__first, __last, begin()), end());
00715 }
00716
00717 public:
00718
00719 void
00720 push_back(const value_type& __t)
00721 {
00722 if (_M_finish._M_cur != _M_finish._M_last - 1) {
00723 _Construct(_M_finish._M_cur, __t);
00724 ++_M_finish._M_cur;
00725 }
00726 else
00727 _M_push_back_aux(__t);
00728 }
00729
00730 void
00731 push_back()
00732 {
00733 if (_M_finish._M_cur != _M_finish._M_last - 1) {
00734 _Construct(_M_finish._M_cur);
00735 ++_M_finish._M_cur;
00736 }
00737 else
00738 _M_push_back_aux();
00739 }
00740
00741 void
00742 push_front(const value_type& __t)
00743 {
00744 if (_M_start._M_cur != _M_start._M_first) {
00745 _Construct(_M_start._M_cur - 1, __t);
00746 --_M_start._M_cur;
00747 }
00748 else
00749 _M_push_front_aux(__t);
00750 }
00751
00752 void
00753 push_front()
00754 {
00755 if (_M_start._M_cur != _M_start._M_first) {
00756 _Construct(_M_start._M_cur - 1);
00757 --_M_start._M_cur;
00758 }
00759 else
00760 _M_push_front_aux();
00761 }
00762
00763
00764 void
00765 pop_back()
00766 {
00767 if (_M_finish._M_cur != _M_finish._M_first) {
00768 --_M_finish._M_cur;
00769 _Destroy(_M_finish._M_cur);
00770 }
00771 else
00772 _M_pop_back_aux();
00773 }
00774
00775 void
00776 pop_front()
00777 {
00778 if (_M_start._M_cur != _M_start._M_last - 1) {
00779 _Destroy(_M_start._M_cur);
00780 ++_M_start._M_cur;
00781 }
00782 else
00783 _M_pop_front_aux();
00784 }
00785
00786 public:
00787
00788 iterator
00789 insert(iterator position, const value_type& __x)
00790 {
00791 if (position._M_cur == _M_start._M_cur) {
00792 push_front(__x);
00793 return _M_start;
00794 }
00795 else if (position._M_cur == _M_finish._M_cur) {
00796 push_back(__x);
00797 iterator __tmp = _M_finish;
00798 --__tmp;
00799 return __tmp;
00800 }
00801 else {
00802 return _M_insert_aux(position, __x);
00803 }
00804 }
00805
00806 iterator
00807 insert(iterator __position)
00808 { return insert(__position, value_type()); }
00809
00810 void
00811 insert(iterator __pos, size_type __n, const value_type& __x)
00812 { _M_fill_insert(__pos, __n, __x); }
00813
00814 void
00815 _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
00816
00817
00818 template<class _InputIterator>
00819 void
00820 insert(iterator __pos, _InputIterator __first, _InputIterator __last)
00821 {
00822 typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
00823 _M_insert_dispatch(__pos, __first, __last, _Integral());
00824 }
00825
00826 template<class _Integer>
00827 void
00828 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, __true_type)
00829 { _M_fill_insert(__pos, static_cast<size_type>(__n), static_cast<value_type>(__x)); }
00830
00831 template<class _InputIterator>
00832 void
00833 _M_insert_dispatch(iterator __pos,
00834 _InputIterator __first, _InputIterator __last,
00835 __false_type)
00836 {
00837 typedef typename iterator_traits<_InputIterator>::iterator_category _IterCategory;
00838 insert(__pos, __first, __last, _IterCategory());
00839 }
00840
00841 void resize(size_type __new_size, const value_type& __x) {
00842 const size_type __len = size();
00843 if (__new_size < __len)
00844 erase(_M_start + __new_size, _M_finish);
00845 else
00846 insert(_M_finish, __new_size - __len, __x);
00847 }
00848
00849 void resize(size_type new_size) { resize(new_size, value_type()); }
00850
00851 public:
00852 iterator erase(iterator __pos) {
00853 iterator __next = __pos;
00854 ++__next;
00855 size_type __index = __pos - _M_start;
00856 if (__index < (size() >> 1)) {
00857 copy_backward(_M_start, __pos, __next);
00858 pop_front();
00859 }
00860 else {
00861 copy(__next, _M_finish, __pos);
00862 pop_back();
00863 }
00864 return _M_start + __index;
00865 }
00866
00867 iterator erase(iterator __first, iterator __last);
00868 void clear();
00869
00870 protected:
00871
00872 void _M_fill_initialize(const value_type& __value);
00873
00874 template <class _InputIterator>
00875 void _M_range_initialize(_InputIterator __first, _InputIterator __last,
00876 input_iterator_tag);
00877
00878 template <class _ForwardIterator>
00879 void _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
00880 forward_iterator_tag);
00881
00882 protected:
00883
00884 void _M_push_back_aux(const value_type&);
00885 void _M_push_back_aux();
00886 void _M_push_front_aux(const value_type&);
00887 void _M_push_front_aux();
00888 void _M_pop_back_aux();
00889 void _M_pop_front_aux();
00890
00891 protected:
00892
00893 template <class _InputIterator>
00894 void insert(iterator __pos, _InputIterator __first, _InputIterator __last,
00895 input_iterator_tag);
00896
00897 template <class _ForwardIterator>
00898 void insert(iterator __pos,
00899 _ForwardIterator __first, _ForwardIterator __last,
00900 forward_iterator_tag);
00901
00902 iterator _M_insert_aux(iterator __pos, const value_type& __x);
00903 iterator _M_insert_aux(iterator __pos);
00904 void _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
00905
00906 template <class _ForwardIterator>
00907 void _M_insert_aux(iterator __pos,
00908 _ForwardIterator __first, _ForwardIterator __last,
00909 size_type __n);
00910
00911 iterator _M_reserve_elements_at_front(size_type __n) {
00912 size_type __vacancies = _M_start._M_cur - _M_start._M_first;
00913 if (__n > __vacancies)
00914 _M_new_elements_at_front(__n - __vacancies);
00915 return _M_start - difference_type(__n);
00916 }
00917
00918 iterator _M_reserve_elements_at_back(size_type __n) {
00919 size_type __vacancies = (_M_finish._M_last - _M_finish._M_cur) - 1;
00920 if (__n > __vacancies)
00921 _M_new_elements_at_back(__n - __vacancies);
00922 return _M_finish + difference_type(__n);
00923 }
00924
00925 void _M_new_elements_at_front(size_type __new_elements);
00926 void _M_new_elements_at_back(size_type __new_elements);
00927
00928 protected:
00929
00930
00931
00932
00933
00934 void _M_reserve_map_at_back (size_type __nodes_to_add = 1) {
00935 if (__nodes_to_add + 1 > _M_map_size - (_M_finish._M_node - _M_map))
00936 _M_reallocate_map(__nodes_to_add, false);
00937 }
00938
00939 void _M_reserve_map_at_front (size_type __nodes_to_add = 1) {
00940 if (__nodes_to_add > size_type(_M_start._M_node - _M_map))
00941 _M_reallocate_map(__nodes_to_add, true);
00942 }
00943
00944 void _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
00945 };
00946
00947
00948
00949 template <class _Tp, class _Alloc>
00950 template <class _InputIter>
00951 void deque<_Tp, _Alloc>
00952 ::_M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag)
00953 {
00954 iterator __cur = begin();
00955 for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
00956 *__cur = *__first;
00957 if (__first == __last)
00958 erase(__cur, end());
00959 else
00960 insert(end(), __first, __last);
00961 }
00962
00963 template <class _Tp, class _Alloc>
00964 void deque<_Tp, _Alloc>::_M_fill_insert(iterator __pos,
00965 size_type __n, const value_type& __x)
00966 {
00967 if (__pos._M_cur == _M_start._M_cur) {
00968 iterator __new_start = _M_reserve_elements_at_front(__n);
00969 try {
00970 uninitialized_fill(__new_start, _M_start, __x);
00971 _M_start = __new_start;
00972 }
00973 catch(...)
00974 {
00975 _M_destroy_nodes(__new_start._M_node, _M_start._M_node);
00976 __throw_exception_again;
00977 }
00978 }
00979 else if (__pos._M_cur == _M_finish._M_cur) {
00980 iterator __new_finish = _M_reserve_elements_at_back(__n);
00981 try {
00982 uninitialized_fill(_M_finish, __new_finish, __x);
00983 _M_finish = __new_finish;
00984 }
00985 catch(...)
00986 {
00987 _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1);
00988 __throw_exception_again;
00989 }
00990 }
00991 else
00992 _M_insert_aux(__pos, __n, __x);
00993 }
00994
00995 template <class _Tp, class _Alloc>
00996 typename deque<_Tp,_Alloc>::iterator
00997 deque<_Tp,_Alloc>::erase(iterator __first, iterator __last)
00998 {
00999 if (__first == _M_start && __last == _M_finish) {
01000 clear();
01001 return _M_finish;
01002 }
01003 else {
01004 difference_type __n = __last - __first;
01005 difference_type __elems_before = __first - _M_start;
01006 if (static_cast<size_type>(__elems_before) < (size() - __n) / 2) {
01007 copy_backward(_M_start, __first, __last);
01008 iterator __new_start = _M_start + __n;
01009 _Destroy(_M_start, __new_start);
01010 _M_destroy_nodes(_M_start._M_node, __new_start._M_node);
01011 _M_start = __new_start;
01012 }
01013 else {
01014 copy(__last, _M_finish, __first);
01015 iterator __new_finish = _M_finish - __n;
01016 _Destroy(__new_finish, _M_finish);
01017 _M_destroy_nodes(__new_finish._M_node + 1, _M_finish._M_node + 1);
01018 _M_finish = __new_finish;
01019 }
01020 return _M_start + __elems_before;
01021 }
01022 }
01023
01024 template <class _Tp, class _Alloc>
01025 void deque<_Tp,_Alloc>::clear()
01026 {
01027 for (_Map_pointer __node = _M_start._M_node + 1;
01028 __node < _M_finish._M_node;
01029 ++__node) {
01030 _Destroy(*__node, *__node + _S_buffer_size());
01031 _M_deallocate_node(*__node);
01032 }
01033
01034 if (_M_start._M_node != _M_finish._M_node) {
01035 _Destroy(_M_start._M_cur, _M_start._M_last);
01036 _Destroy(_M_finish._M_first, _M_finish._M_cur);
01037 _M_deallocate_node(_M_finish._M_first);
01038 }
01039 else
01040 _Destroy(_M_start._M_cur, _M_finish._M_cur);
01041
01042 _M_finish = _M_start;
01043 }
01044
01057 template <class _Tp, class _Alloc>
01058 void deque<_Tp,_Alloc>::_M_fill_initialize(const value_type& __value)
01059 {
01060 _Map_pointer __cur;
01061 try {
01062 for (__cur = _M_start._M_node; __cur < _M_finish._M_node; ++__cur)
01063 uninitialized_fill(*__cur, *__cur + _S_buffer_size(), __value);
01064 uninitialized_fill(_M_finish._M_first, _M_finish._M_cur, __value);
01065 }
01066 catch(...)
01067 {
01068 _Destroy(_M_start, iterator(*__cur, __cur));
01069 __throw_exception_again;
01070 }
01071 }
01072
01085 template <class _Tp, class _Alloc> template <class _InputIterator>
01086 void deque<_Tp,_Alloc>::_M_range_initialize(_InputIterator __first,
01087 _InputIterator __last,
01088 input_iterator_tag)
01089 {
01090 _M_initialize_map(0);
01091 try {
01092 for ( ; __first != __last; ++__first)
01093 push_back(*__first);
01094 }
01095 catch(...)
01096 {
01097 clear();
01098 __throw_exception_again;
01099 }
01100 }
01101
01102 template <class _Tp, class _Alloc> template <class _ForwardIterator>
01103 void deque<_Tp,_Alloc>::_M_range_initialize(_ForwardIterator __first,
01104 _ForwardIterator __last,
01105 forward_iterator_tag)
01106 {
01107 size_type __n = distance(__first, __last);
01108 _M_initialize_map(__n);
01109
01110 _Map_pointer __cur_node;
01111 try {
01112 for (__cur_node = _M_start._M_node;
01113 __cur_node < _M_finish._M_node;
01114 ++__cur_node) {
01115 _ForwardIterator __mid = __first;
01116 advance(__mid, _S_buffer_size());
01117 uninitialized_copy(__first, __mid, *__cur_node);
01118 __first = __mid;
01119 }
01120 uninitialized_copy(__first, __last, _M_finish._M_first);
01121 }
01122 catch(...)
01123 {
01124 _Destroy(_M_start, iterator(*__cur_node, __cur_node));
01125 __throw_exception_again;
01126 }
01127 }
01130
01131 template <class _Tp, class _Alloc>
01132 void
01133 deque<_Tp,_Alloc>::_M_push_back_aux(const value_type& __t)
01134 {
01135 value_type __t_copy = __t;
01136 _M_reserve_map_at_back();
01137 *(_M_finish._M_node + 1) = _M_allocate_node();
01138 try {
01139 _Construct(_M_finish._M_cur, __t_copy);
01140 _M_finish._M_set_node(_M_finish._M_node + 1);
01141 _M_finish._M_cur = _M_finish._M_first;
01142 }
01143 catch(...)
01144 {
01145 _M_deallocate_node(*(_M_finish._M_node + 1));
01146 __throw_exception_again;
01147 }
01148 }
01149
01150
01151 template <class _Tp, class _Alloc>
01152 void
01153 deque<_Tp,_Alloc>::_M_push_back_aux()
01154 {
01155 _M_reserve_map_at_back();
01156 *(_M_finish._M_node + 1) = _M_allocate_node();
01157 try {
01158 _Construct(_M_finish._M_cur);
01159 _M_finish._M_set_node(_M_finish._M_node + 1);
01160 _M_finish._M_cur = _M_finish._M_first;
01161 }
01162 catch(...)
01163 {
01164 _M_deallocate_node(*(_M_finish._M_node + 1));
01165 __throw_exception_again;
01166 }
01167 }
01168
01169
01170 template <class _Tp, class _Alloc>
01171 void
01172 deque<_Tp,_Alloc>::_M_push_front_aux(const value_type& __t)
01173 {
01174 value_type __t_copy = __t;
01175 _M_reserve_map_at_front();
01176 *(_M_start._M_node - 1) = _M_allocate_node();
01177 try {
01178 _M_start._M_set_node(_M_start._M_node - 1);
01179 _M_start._M_cur = _M_start._M_last - 1;
01180 _Construct(_M_start._M_cur, __t_copy);
01181 }
01182 catch(...)
01183 {
01184 ++_M_start;
01185 _M_deallocate_node(*(_M_start._M_node - 1));
01186 __throw_exception_again;
01187 }
01188 }
01189
01190
01191 template <class _Tp, class _Alloc>
01192 void
01193 deque<_Tp,_Alloc>::_M_push_front_aux()
01194 {
01195 _M_reserve_map_at_front();
01196 *(_M_start._M_node - 1) = _M_allocate_node();
01197 try {
01198 _M_start._M_set_node(_M_start._M_node - 1);
01199 _M_start._M_cur = _M_start._M_last - 1;
01200 _Construct(_M_start._M_cur);
01201 }
01202 catch(...)
01203 {
01204 ++_M_start;
01205 _M_deallocate_node(*(_M_start._M_node - 1));
01206 __throw_exception_again;
01207 }
01208 }
01209
01210
01211 template <class _Tp, class _Alloc>
01212 void deque<_Tp,_Alloc>::_M_pop_back_aux()
01213 {
01214 _M_deallocate_node(_M_finish._M_first);
01215 _M_finish._M_set_node(_M_finish._M_node - 1);
01216 _M_finish._M_cur = _M_finish._M_last - 1;
01217 _Destroy(_M_finish._M_cur);
01218 }
01219
01220
01221
01222
01223
01224 template <class _Tp, class _Alloc>
01225 void deque<_Tp,_Alloc>::_M_pop_front_aux()
01226 {
01227 _Destroy(_M_start._M_cur);
01228 _M_deallocate_node(_M_start._M_first);
01229 _M_start._M_set_node(_M_start._M_node + 1);
01230 _M_start._M_cur = _M_start._M_first;
01231 }
01232
01233 template <class _Tp, class _Alloc> template <class _InputIterator>
01234 void deque<_Tp,_Alloc>::insert(iterator __pos,
01235 _InputIterator __first, _InputIterator __last,
01236 input_iterator_tag)
01237 {
01238 copy(__first, __last, inserter(*this, __pos));
01239 }
01240
01241 template <class _Tp, class _Alloc> template <class _ForwardIterator>
01242 void
01243 deque<_Tp,_Alloc>::insert(iterator __pos,
01244 _ForwardIterator __first, _ForwardIterator __last,
01245 forward_iterator_tag) {
01246 size_type __n = distance(__first, __last);
01247 if (__pos._M_cur == _M_start._M_cur) {
01248 iterator __new_start = _M_reserve_elements_at_front(__n);
01249 try {
01250 uninitialized_copy(__first, __last, __new_start);
01251 _M_start = __new_start;
01252 }
01253 catch(...)
01254 {
01255 _M_destroy_nodes(__new_start._M_node, _M_start._M_node);
01256 __throw_exception_again;
01257 }
01258 }
01259 else if (__pos._M_cur == _M_finish._M_cur) {
01260 iterator __new_finish = _M_reserve_elements_at_back(__n);
01261 try {
01262 uninitialized_copy(__first, __last, _M_finish);
01263 _M_finish = __new_finish;
01264 }
01265 catch(...)
01266 {
01267 _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1);
01268 __throw_exception_again;
01269 }
01270 }
01271 else
01272 _M_insert_aux(__pos, __first, __last, __n);
01273 }
01274
01275 template <class _Tp, class _Alloc>
01276 typename deque<_Tp, _Alloc>::iterator
01277 deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos, const value_type& __x)
01278 {
01279 difference_type __index = __pos - _M_start;
01280 value_type __x_copy = __x;
01281 if (static_cast<size_type>(__index) < size() / 2) {
01282 push_front(front());
01283 iterator __front1 = _M_start;
01284 ++__front1;
01285 iterator __front2 = __front1;
01286 ++__front2;
01287 __pos = _M_start + __index;
01288 iterator __pos1 = __pos;
01289 ++__pos1;
01290 copy(__front2, __pos1, __front1);
01291 }
01292 else {
01293 push_back(back());
01294 iterator __back1 = _M_finish;
01295 --__back1;
01296 iterator __back2 = __back1;
01297 --__back2;
01298 __pos = _M_start + __index;
01299 copy_backward(__pos, __back2, __back1);
01300 }
01301 *__pos = __x_copy;
01302 return __pos;
01303 }
01304
01305 template <class _Tp, class _Alloc>
01306 typename deque<_Tp,_Alloc>::iterator
01307 deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos)
01308 {
01309 difference_type __index = __pos - _M_start;
01310 if (static_cast<size_type>(__index) < size() / 2) {
01311 push_front(front());
01312 iterator __front1 = _M_start;
01313 ++__front1;
01314 iterator __front2 = __front1;
01315 ++__front2;
01316 __pos = _M_start + __index;
01317 iterator __pos1 = __pos;
01318 ++__pos1;
01319 copy(__front2, __pos1, __front1);
01320 }
01321 else {
01322 push_back(back());
01323 iterator __back1 = _M_finish;
01324 --__back1;
01325 iterator __back2 = __back1;
01326 --__back2;
01327 __pos = _M_start + __index;
01328 copy_backward(__pos, __back2, __back1);
01329 }
01330 *__pos = value_type();
01331 return __pos;
01332 }
01333
01334 template <class _Tp, class _Alloc>
01335 void deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos,
01336 size_type __n,
01337 const value_type& __x)
01338 {
01339 const difference_type __elems_before = __pos - _M_start;
01340 size_type __length = this->size();
01341 value_type __x_copy = __x;
01342 if (__elems_before < difference_type(__length / 2)) {
01343 iterator __new_start = _M_reserve_elements_at_front(__n);
01344 iterator __old_start = _M_start;
01345 __pos = _M_start + __elems_before;
01346 try {
01347 if (__elems_before >= difference_type(__n)) {
01348 iterator __start_n = _M_start + difference_type(__n);
01349 uninitialized_copy(_M_start, __start_n, __new_start);
01350 _M_start = __new_start;
01351 copy(__start_n, __pos, __old_start);
01352 fill(__pos - difference_type(__n), __pos, __x_copy);
01353 }
01354 else {
01355 __uninitialized_copy_fill(_M_start, __pos, __new_start,
01356 _M_start, __x_copy);
01357 _M_start = __new_start;
01358 fill(__old_start, __pos, __x_copy);
01359 }
01360 }
01361 catch(...)
01362 {
01363 _M_destroy_nodes(__new_start._M_node, _M_start._M_node);
01364 __throw_exception_again;
01365 }
01366 }
01367 else {
01368 iterator __new_finish = _M_reserve_elements_at_back(__n);
01369 iterator __old_finish = _M_finish;
01370 const difference_type __elems_after =
01371 difference_type(__length) - __elems_before;
01372 __pos = _M_finish - __elems_after;
01373 try {
01374 if (__elems_after > difference_type(__n)) {
01375 iterator __finish_n = _M_finish - difference_type(__n);
01376 uninitialized_copy(__finish_n, _M_finish, _M_finish);
01377 _M_finish = __new_finish;
01378 copy_backward(__pos, __finish_n, __old_finish);
01379 fill(__pos, __pos + difference_type(__n), __x_copy);
01380 }
01381 else {
01382 __uninitialized_fill_copy(_M_finish, __pos + difference_type(__n),
01383 __x_copy, __pos, _M_finish);
01384 _M_finish = __new_finish;
01385 fill(__pos, __old_finish, __x_copy);
01386 }
01387 }
01388 catch(...)
01389 {
01390 _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1);
01391 __throw_exception_again;
01392 }
01393 }
01394 }
01395
01396 template <class _Tp, class _Alloc> template <class _ForwardIterator>
01397 void deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos,
01398 _ForwardIterator __first,
01399 _ForwardIterator __last,
01400 size_type __n)
01401 {
01402 const difference_type __elemsbefore = __pos - _M_start;
01403 size_type __length = size();
01404 if (static_cast<size_type>(__elemsbefore) < __length / 2) {
01405 iterator __new_start = _M_reserve_elements_at_front(__n);
01406 iterator __old_start = _M_start;
01407 __pos = _M_start + __elemsbefore;
01408 try {
01409 if (__elemsbefore >= difference_type(__n)) {
01410 iterator __start_n = _M_start + difference_type(__n);
01411 uninitialized_copy(_M_start, __start_n, __new_start);
01412 _M_start = __new_start;
01413 copy(__start_n, __pos, __old_start);
01414 copy(__first, __last, __pos - difference_type(__n));
01415 }
01416 else {
01417 _ForwardIterator __mid = __first;
01418 advance(__mid, difference_type(__n) - __elemsbefore);
01419 __uninitialized_copy_copy(_M_start, __pos, __first, __mid,
01420 __new_start);
01421 _M_start = __new_start;
01422 copy(__mid, __last, __old_start);
01423 }
01424 }
01425 catch(...)
01426 {
01427 _M_destroy_nodes(__new_start._M_node, _M_start._M_node);
01428 __throw_exception_again;
01429 }
01430 }
01431 else {
01432 iterator __new_finish = _M_reserve_elements_at_back(__n);
01433 iterator __old_finish = _M_finish;
01434 const difference_type __elemsafter =
01435 difference_type(__length) - __elemsbefore;
01436 __pos = _M_finish - __elemsafter;
01437 try {
01438 if (__elemsafter > difference_type(__n)) {
01439 iterator __finish_n = _M_finish - difference_type(__n);
01440 uninitialized_copy(__finish_n, _M_finish, _M_finish);
01441 _M_finish = __new_finish;
01442 copy_backward(__pos, __finish_n, __old_finish);
01443 copy(__first, __last, __pos);
01444 }
01445 else {
01446 _ForwardIterator __mid = __first;
01447 advance(__mid, __elemsafter);
01448 __uninitialized_copy_copy(__mid, __last, __pos, _M_finish, _M_finish);
01449 _M_finish = __new_finish;
01450 copy(__first, __mid, __pos);
01451 }
01452 }
01453 catch(...)
01454 {
01455 _M_destroy_nodes(_M_finish._M_node + 1, __new_finish._M_node + 1);
01456 __throw_exception_again;
01457 }
01458 }
01459 }
01460
01461 template <class _Tp, class _Alloc>
01462 void deque<_Tp,_Alloc>::_M_new_elements_at_front(size_type __new_elems)
01463 {
01464 size_type __new_nodes
01465 = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
01466 _M_reserve_map_at_front(__new_nodes);
01467 size_type __i;
01468 try {
01469 for (__i = 1; __i <= __new_nodes; ++__i)
01470 *(_M_start._M_node - __i) = _M_allocate_node();
01471 }
01472 catch(...) {
01473 for (size_type __j = 1; __j < __i; ++__j)
01474 _M_deallocate_node(*(_M_start._M_node - __j));
01475 __throw_exception_again;
01476 }
01477 }
01478
01479 template <class _Tp, class _Alloc>
01480 void deque<_Tp,_Alloc>::_M_new_elements_at_back(size_type __new_elems)
01481 {
01482 size_type __new_nodes
01483 = (__new_elems + _S_buffer_size() - 1) / _S_buffer_size();
01484 _M_reserve_map_at_back(__new_nodes);
01485 size_type __i;
01486 try {
01487 for (__i = 1; __i <= __new_nodes; ++__i)
01488 *(_M_finish._M_node + __i) = _M_allocate_node();
01489 }
01490 catch(...) {
01491 for (size_type __j = 1; __j < __i; ++__j)
01492 _M_deallocate_node(*(_M_finish._M_node + __j));
01493 __throw_exception_again;
01494 }
01495 }
01496
01497 template <class _Tp, class _Alloc>
01498 void deque<_Tp,_Alloc>::_M_reallocate_map(size_type __nodes_to_add,
01499 bool __add_at_front)
01500 {
01501 size_type __old_num_nodes = _M_finish._M_node - _M_start._M_node + 1;
01502 size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
01503
01504 _Map_pointer __new_nstart;
01505 if (_M_map_size > 2 * __new_num_nodes) {
01506 __new_nstart = _M_map + (_M_map_size - __new_num_nodes) / 2
01507 + (__add_at_front ? __nodes_to_add : 0);
01508 if (__new_nstart < _M_start._M_node)
01509 copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);
01510 else
01511 copy_backward(_M_start._M_node, _M_finish._M_node + 1,
01512 __new_nstart + __old_num_nodes);
01513 }
01514 else {
01515 size_type __new_map_size =
01516 _M_map_size + max(_M_map_size, __nodes_to_add) + 2;
01517
01518 _Map_pointer __new_map = _M_allocate_map(__new_map_size);
01519 __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
01520 + (__add_at_front ? __nodes_to_add : 0);
01521 copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);
01522 _M_deallocate_map(_M_map, _M_map_size);
01523
01524 _M_map = __new_map;
01525 _M_map_size = __new_map_size;
01526 }
01527
01528 _M_start._M_set_node(__new_nstart);
01529 _M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
01530 }
01531
01532
01533
01534
01535 template <class _Tp, class _Alloc>
01536 inline bool operator==(const deque<_Tp, _Alloc>& __x,
01537 const deque<_Tp, _Alloc>& __y) {
01538 return __x.size() == __y.size() &&
01539 equal(__x.begin(), __x.end(), __y.begin());
01540 }
01541
01542 template <class _Tp, class _Alloc>
01543 inline bool operator<(const deque<_Tp, _Alloc>& __x,
01544 const deque<_Tp, _Alloc>& __y) {
01545 return lexicographical_compare(__x.begin(), __x.end(),
01546 __y.begin(), __y.end());
01547 }
01548
01549 template <class _Tp, class _Alloc>
01550 inline bool operator!=(const deque<_Tp, _Alloc>& __x,
01551 const deque<_Tp, _Alloc>& __y) {
01552 return !(__x == __y);
01553 }
01554
01555 template <class _Tp, class _Alloc>
01556 inline bool operator>(const deque<_Tp, _Alloc>& __x,
01557 const deque<_Tp, _Alloc>& __y) {
01558 return __y < __x;
01559 }
01560
01561 template <class _Tp, class _Alloc>
01562 inline bool operator<=(const deque<_Tp, _Alloc>& __x,
01563 const deque<_Tp, _Alloc>& __y) {
01564 return !(__y < __x);
01565 }
01566 template <class _Tp, class _Alloc>
01567 inline bool operator>=(const deque<_Tp, _Alloc>& __x,
01568 const deque<_Tp, _Alloc>& __y) {
01569 return !(__x < __y);
01570 }
01571
01572 template <class _Tp, class _Alloc>
01573 inline void swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y) {
01574 __x.swap(__y);
01575 }
01576
01577 }
01578
01579 #endif
01580