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 #ifndef _STL_DEQUE_H
00058 #define _STL_DEQUE_H 1
00059
00060 #include <bits/concept_check.h>
00061 #include <bits/stl_iterator_base_types.h>
00062 #include <bits/stl_iterator_base_funcs.h>
00063 #include <initializer_list>
00064
00065 _GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081 #ifndef _GLIBCXX_DEQUE_BUF_SIZE
00082 #define _GLIBCXX_DEQUE_BUF_SIZE 512
00083 #endif
00084
00085 inline size_t
00086 __deque_buf_size(size_t __size)
00087 { return (__size < _GLIBCXX_DEQUE_BUF_SIZE
00088 ? size_t(_GLIBCXX_DEQUE_BUF_SIZE / __size) : size_t(1)); }
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102 template<typename _Tp, typename _Ref, typename _Ptr>
00103 struct _Deque_iterator
00104 {
00105 typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
00106 typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
00107
00108 static size_t _S_buffer_size()
00109 { return __deque_buf_size(sizeof(_Tp)); }
00110
00111 typedef std::random_access_iterator_tag iterator_category;
00112 typedef _Tp value_type;
00113 typedef _Ptr pointer;
00114 typedef _Ref reference;
00115 typedef size_t size_type;
00116 typedef ptrdiff_t difference_type;
00117 typedef _Tp** _Map_pointer;
00118 typedef _Deque_iterator _Self;
00119
00120 _Tp* _M_cur;
00121 _Tp* _M_first;
00122 _Tp* _M_last;
00123 _Map_pointer _M_node;
00124
00125 _Deque_iterator(_Tp* __x, _Map_pointer __y)
00126 : _M_cur(__x), _M_first(*__y),
00127 _M_last(*__y + _S_buffer_size()), _M_node(__y) { }
00128
00129 _Deque_iterator()
00130 : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) { }
00131
00132 _Deque_iterator(const iterator& __x)
00133 : _M_cur(__x._M_cur), _M_first(__x._M_first),
00134 _M_last(__x._M_last), _M_node(__x._M_node) { }
00135
00136 reference
00137 operator*() const
00138 { return *_M_cur; }
00139
00140 pointer
00141 operator->() const
00142 { return _M_cur; }
00143
00144 _Self&
00145 operator++()
00146 {
00147 ++_M_cur;
00148 if (_M_cur == _M_last)
00149 {
00150 _M_set_node(_M_node + 1);
00151 _M_cur = _M_first;
00152 }
00153 return *this;
00154 }
00155
00156 _Self
00157 operator++(int)
00158 {
00159 _Self __tmp = *this;
00160 ++*this;
00161 return __tmp;
00162 }
00163
00164 _Self&
00165 operator--()
00166 {
00167 if (_M_cur == _M_first)
00168 {
00169 _M_set_node(_M_node - 1);
00170 _M_cur = _M_last;
00171 }
00172 --_M_cur;
00173 return *this;
00174 }
00175
00176 _Self
00177 operator--(int)
00178 {
00179 _Self __tmp = *this;
00180 --*this;
00181 return __tmp;
00182 }
00183
00184 _Self&
00185 operator+=(difference_type __n)
00186 {
00187 const difference_type __offset = __n + (_M_cur - _M_first);
00188 if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
00189 _M_cur += __n;
00190 else
00191 {
00192 const difference_type __node_offset =
00193 __offset > 0 ? __offset / difference_type(_S_buffer_size())
00194 : -difference_type((-__offset - 1)
00195 / _S_buffer_size()) - 1;
00196 _M_set_node(_M_node + __node_offset);
00197 _M_cur = _M_first + (__offset - __node_offset
00198 * difference_type(_S_buffer_size()));
00199 }
00200 return *this;
00201 }
00202
00203 _Self
00204 operator+(difference_type __n) const
00205 {
00206 _Self __tmp = *this;
00207 return __tmp += __n;
00208 }
00209
00210 _Self&
00211 operator-=(difference_type __n)
00212 { return *this += -__n; }
00213
00214 _Self
00215 operator-(difference_type __n) const
00216 {
00217 _Self __tmp = *this;
00218 return __tmp -= __n;
00219 }
00220
00221 reference
00222 operator[](difference_type __n) const
00223 { return *(*this + __n); }
00224
00225
00226
00227
00228
00229
00230 void
00231 _M_set_node(_Map_pointer __new_node)
00232 {
00233 _M_node = __new_node;
00234 _M_first = *__new_node;
00235 _M_last = _M_first + difference_type(_S_buffer_size());
00236 }
00237 };
00238
00239
00240
00241
00242 template<typename _Tp, typename _Ref, typename _Ptr>
00243 inline bool
00244 operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
00245 const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
00246 { return __x._M_cur == __y._M_cur; }
00247
00248 template<typename _Tp, typename _RefL, typename _PtrL,
00249 typename _RefR, typename _PtrR>
00250 inline bool
00251 operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
00252 const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
00253 { return __x._M_cur == __y._M_cur; }
00254
00255 template<typename _Tp, typename _Ref, typename _Ptr>
00256 inline bool
00257 operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
00258 const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
00259 { return !(__x == __y); }
00260
00261 template<typename _Tp, typename _RefL, typename _PtrL,
00262 typename _RefR, typename _PtrR>
00263 inline bool
00264 operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
00265 const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
00266 { return !(__x == __y); }
00267
00268 template<typename _Tp, typename _Ref, typename _Ptr>
00269 inline bool
00270 operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
00271 const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
00272 { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
00273 : (__x._M_node < __y._M_node); }
00274
00275 template<typename _Tp, typename _RefL, typename _PtrL,
00276 typename _RefR, typename _PtrR>
00277 inline bool
00278 operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
00279 const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
00280 { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
00281 : (__x._M_node < __y._M_node); }
00282
00283 template<typename _Tp, typename _Ref, typename _Ptr>
00284 inline bool
00285 operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
00286 const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
00287 { return __y < __x; }
00288
00289 template<typename _Tp, typename _RefL, typename _PtrL,
00290 typename _RefR, typename _PtrR>
00291 inline bool
00292 operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
00293 const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
00294 { return __y < __x; }
00295
00296 template<typename _Tp, typename _Ref, typename _Ptr>
00297 inline bool
00298 operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
00299 const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
00300 { return !(__y < __x); }
00301
00302 template<typename _Tp, typename _RefL, typename _PtrL,
00303 typename _RefR, typename _PtrR>
00304 inline bool
00305 operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
00306 const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
00307 { return !(__y < __x); }
00308
00309 template<typename _Tp, typename _Ref, typename _Ptr>
00310 inline bool
00311 operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
00312 const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
00313 { return !(__x < __y); }
00314
00315 template<typename _Tp, typename _RefL, typename _PtrL,
00316 typename _RefR, typename _PtrR>
00317 inline bool
00318 operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
00319 const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
00320 { return !(__x < __y); }
00321
00322
00323
00324
00325
00326 template<typename _Tp, typename _Ref, typename _Ptr>
00327 inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
00328 operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
00329 const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
00330 {
00331 return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
00332 (_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size())
00333 * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
00334 + (__y._M_last - __y._M_cur);
00335 }
00336
00337 template<typename _Tp, typename _RefL, typename _PtrL,
00338 typename _RefR, typename _PtrR>
00339 inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
00340 operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
00341 const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
00342 {
00343 return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
00344 (_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
00345 * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
00346 + (__y._M_last - __y._M_cur);
00347 }
00348
00349 template<typename _Tp, typename _Ref, typename _Ptr>
00350 inline _Deque_iterator<_Tp, _Ref, _Ptr>
00351 operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
00352 { return __x + __n; }
00353
00354 template<typename _Tp>
00355 void
00356 fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>&,
00357 const _Deque_iterator<_Tp, _Tp&, _Tp*>&, const _Tp&);
00358
00359 template<typename _Tp>
00360 _Deque_iterator<_Tp, _Tp&, _Tp*>
00361 copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
00362 _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
00363 _Deque_iterator<_Tp, _Tp&, _Tp*>);
00364
00365 template<typename _Tp>
00366 inline _Deque_iterator<_Tp, _Tp&, _Tp*>
00367 copy(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
00368 _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
00369 _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
00370 { return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
00371 _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
00372 __result); }
00373
00374 template<typename _Tp>
00375 _Deque_iterator<_Tp, _Tp&, _Tp*>
00376 copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
00377 _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
00378 _Deque_iterator<_Tp, _Tp&, _Tp*>);
00379
00380 template<typename _Tp>
00381 inline _Deque_iterator<_Tp, _Tp&, _Tp*>
00382 copy_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
00383 _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
00384 _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
00385 { return std::copy_backward(_Deque_iterator<_Tp,
00386 const _Tp&, const _Tp*>(__first),
00387 _Deque_iterator<_Tp,
00388 const _Tp&, const _Tp*>(__last),
00389 __result); }
00390
00391 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00392 template<typename _Tp>
00393 _Deque_iterator<_Tp, _Tp&, _Tp*>
00394 move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
00395 _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
00396 _Deque_iterator<_Tp, _Tp&, _Tp*>);
00397
00398 template<typename _Tp>
00399 inline _Deque_iterator<_Tp, _Tp&, _Tp*>
00400 move(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
00401 _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
00402 _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
00403 { return std::move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
00404 _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
00405 __result); }
00406
00407 template<typename _Tp>
00408 _Deque_iterator<_Tp, _Tp&, _Tp*>
00409 move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
00410 _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
00411 _Deque_iterator<_Tp, _Tp&, _Tp*>);
00412
00413 template<typename _Tp>
00414 inline _Deque_iterator<_Tp, _Tp&, _Tp*>
00415 move_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
00416 _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
00417 _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
00418 { return std::move_backward(_Deque_iterator<_Tp,
00419 const _Tp&, const _Tp*>(__first),
00420 _Deque_iterator<_Tp,
00421 const _Tp&, const _Tp*>(__last),
00422 __result); }
00423 #endif
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435 template<typename _Tp, typename _Alloc>
00436 class _Deque_base
00437 {
00438 public:
00439 typedef _Alloc allocator_type;
00440
00441 allocator_type
00442 get_allocator() const
00443 { return allocator_type(_M_get_Tp_allocator()); }
00444
00445 typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
00446 typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
00447
00448 _Deque_base()
00449 : _M_impl()
00450 { _M_initialize_map(0); }
00451
00452 _Deque_base(size_t __num_elements)
00453 : _M_impl()
00454 { _M_initialize_map(__num_elements); }
00455
00456 _Deque_base(const allocator_type& __a, size_t __num_elements)
00457 : _M_impl(__a)
00458 { _M_initialize_map(__num_elements); }
00459
00460 _Deque_base(const allocator_type& __a)
00461 : _M_impl(__a)
00462 { }
00463
00464 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00465 _Deque_base(_Deque_base&& __x)
00466 : _M_impl(__x._M_get_Tp_allocator())
00467 {
00468 _M_initialize_map(0);
00469 if (__x._M_impl._M_map)
00470 {
00471 std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
00472 std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
00473 std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
00474 std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
00475 }
00476 }
00477 #endif
00478
00479 ~_Deque_base();
00480
00481 protected:
00482
00483
00484
00485 typedef typename _Alloc::template rebind<_Tp*>::other _Map_alloc_type;
00486
00487 typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
00488
00489 struct _Deque_impl
00490 : public _Tp_alloc_type
00491 {
00492 _Tp** _M_map;
00493 size_t _M_map_size;
00494 iterator _M_start;
00495 iterator _M_finish;
00496
00497 _Deque_impl()
00498 : _Tp_alloc_type(), _M_map(0), _M_map_size(0),
00499 _M_start(), _M_finish()
00500 { }
00501
00502 _Deque_impl(const _Tp_alloc_type& __a)
00503 : _Tp_alloc_type(__a), _M_map(0), _M_map_size(0),
00504 _M_start(), _M_finish()
00505 { }
00506 };
00507
00508 _Tp_alloc_type&
00509 _M_get_Tp_allocator()
00510 { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
00511
00512 const _Tp_alloc_type&
00513 _M_get_Tp_allocator() const
00514 { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
00515
00516 _Map_alloc_type
00517 _M_get_map_allocator() const
00518 { return _Map_alloc_type(_M_get_Tp_allocator()); }
00519
00520 _Tp*
00521 _M_allocate_node()
00522 {
00523 return _M_impl._Tp_alloc_type::allocate(__deque_buf_size(sizeof(_Tp)));
00524 }
00525
00526 void
00527 _M_deallocate_node(_Tp* __p)
00528 {
00529 _M_impl._Tp_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
00530 }
00531
00532 _Tp**
00533 _M_allocate_map(size_t __n)
00534 { return _M_get_map_allocator().allocate(__n); }
00535
00536 void
00537 _M_deallocate_map(_Tp** __p, size_t __n)
00538 { _M_get_map_allocator().deallocate(__p, __n); }
00539
00540 protected:
00541 void _M_initialize_map(size_t);
00542 void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
00543 void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
00544 enum { _S_initial_map_size = 8 };
00545
00546 _Deque_impl _M_impl;
00547 };
00548
00549 template<typename _Tp, typename _Alloc>
00550 _Deque_base<_Tp, _Alloc>::
00551 ~_Deque_base()
00552 {
00553 if (this->_M_impl._M_map)
00554 {
00555 _M_destroy_nodes(this->_M_impl._M_start._M_node,
00556 this->_M_impl._M_finish._M_node + 1);
00557 _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
00558 }
00559 }
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569 template<typename _Tp, typename _Alloc>
00570 void
00571 _Deque_base<_Tp, _Alloc>::
00572 _M_initialize_map(size_t __num_elements)
00573 {
00574 const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
00575 + 1);
00576
00577 this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
00578 size_t(__num_nodes + 2));
00579 this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
00580
00581
00582
00583
00584
00585
00586 _Tp** __nstart = (this->_M_impl._M_map
00587 + (this->_M_impl._M_map_size - __num_nodes) / 2);
00588 _Tp** __nfinish = __nstart + __num_nodes;
00589
00590 __try
00591 { _M_create_nodes(__nstart, __nfinish); }
00592 __catch(...)
00593 {
00594 _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
00595 this->_M_impl._M_map = 0;
00596 this->_M_impl._M_map_size = 0;
00597 __throw_exception_again;
00598 }
00599
00600 this->_M_impl._M_start._M_set_node(__nstart);
00601 this->_M_impl._M_finish._M_set_node(__nfinish - 1);
00602 this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
00603 this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
00604 + __num_elements
00605 % __deque_buf_size(sizeof(_Tp)));
00606 }
00607
00608 template<typename _Tp, typename _Alloc>
00609 void
00610 _Deque_base<_Tp, _Alloc>::
00611 _M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
00612 {
00613 _Tp** __cur;
00614 __try
00615 {
00616 for (__cur = __nstart; __cur < __nfinish; ++__cur)
00617 *__cur = this->_M_allocate_node();
00618 }
00619 __catch(...)
00620 {
00621 _M_destroy_nodes(__nstart, __cur);
00622 __throw_exception_again;
00623 }
00624 }
00625
00626 template<typename _Tp, typename _Alloc>
00627 void
00628 _Deque_base<_Tp, _Alloc>::
00629 _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish)
00630 {
00631 for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
00632 _M_deallocate_node(*__n);
00633 }
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716 template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
00717 class deque : protected _Deque_base<_Tp, _Alloc>
00718 {
00719
00720 typedef typename _Alloc::value_type _Alloc_value_type;
00721 __glibcxx_class_requires(_Tp, _SGIAssignableConcept)
00722 __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)
00723
00724 typedef _Deque_base<_Tp, _Alloc> _Base;
00725 typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
00726
00727 public:
00728 typedef _Tp value_type;
00729 typedef typename _Tp_alloc_type::pointer pointer;
00730 typedef typename _Tp_alloc_type::const_pointer const_pointer;
00731 typedef typename _Tp_alloc_type::reference reference;
00732 typedef typename _Tp_alloc_type::const_reference const_reference;
00733 typedef typename _Base::iterator iterator;
00734 typedef typename _Base::const_iterator const_iterator;
00735 typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00736 typedef std::reverse_iterator<iterator> reverse_iterator;
00737 typedef size_t size_type;
00738 typedef ptrdiff_t difference_type;
00739 typedef _Alloc allocator_type;
00740
00741 protected:
00742 typedef pointer* _Map_pointer;
00743
00744 static size_t _S_buffer_size()
00745 { return __deque_buf_size(sizeof(_Tp)); }
00746
00747
00748 using _Base::_M_initialize_map;
00749 using _Base::_M_create_nodes;
00750 using _Base::_M_destroy_nodes;
00751 using _Base::_M_allocate_node;
00752 using _Base::_M_deallocate_node;
00753 using _Base::_M_allocate_map;
00754 using _Base::_M_deallocate_map;
00755 using _Base::_M_get_Tp_allocator;
00756
00757
00758
00759
00760
00761 using _Base::_M_impl;
00762
00763 public:
00764
00765
00766
00767
00768
00769 deque()
00770 : _Base() { }
00771
00772
00773
00774
00775
00776 explicit
00777 deque(const allocator_type& __a)
00778 : _Base(__a, 0) { }
00779
00780 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00781
00782
00783
00784
00785
00786
00787
00788 explicit
00789 deque(size_type __n)
00790 : _Base(__n)
00791 { _M_default_initialize(); }
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801 deque(size_type __n, const value_type& __value,
00802 const allocator_type& __a = allocator_type())
00803 : _Base(__a, __n)
00804 { _M_fill_initialize(__value); }
00805 #else
00806
00807
00808
00809
00810
00811
00812
00813
00814 explicit
00815 deque(size_type __n, const value_type& __value = value_type(),
00816 const allocator_type& __a = allocator_type())
00817 : _Base(__a, __n)
00818 { _M_fill_initialize(__value); }
00819 #endif
00820
00821
00822
00823
00824
00825
00826
00827
00828 deque(const deque& __x)
00829 : _Base(__x._M_get_Tp_allocator(), __x.size())
00830 { std::__uninitialized_copy_a(__x.begin(), __x.end(),
00831 this->_M_impl._M_start,
00832 _M_get_Tp_allocator()); }
00833
00834 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00835
00836
00837
00838
00839
00840
00841
00842 deque(deque&& __x)
00843 : _Base(std::move(__x)) { }
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856 deque(initializer_list<value_type> __l,
00857 const allocator_type& __a = allocator_type())
00858 : _Base(__a)
00859 {
00860 _M_range_initialize(__l.begin(), __l.end(),
00861 random_access_iterator_tag());
00862 }
00863 #endif
00864
00865
00866
00867
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880 template<typename _InputIterator>
00881 deque(_InputIterator __first, _InputIterator __last,
00882 const allocator_type& __a = allocator_type())
00883 : _Base(__a)
00884 {
00885
00886 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
00887 _M_initialize_dispatch(__first, __last, _Integral());
00888 }
00889
00890
00891
00892
00893
00894
00895 ~deque()
00896 { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
00897
00898
00899
00900
00901
00902
00903
00904
00905 deque&
00906 operator=(const deque& __x);
00907
00908 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00909
00910
00911
00912
00913
00914
00915
00916 deque&
00917 operator=(deque&& __x)
00918 {
00919
00920
00921 this->clear();
00922 this->swap(__x);
00923 return *this;
00924 }
00925
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937 deque&
00938 operator=(initializer_list<value_type> __l)
00939 {
00940 this->assign(__l.begin(), __l.end());
00941 return *this;
00942 }
00943 #endif
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955 void
00956 assign(size_type __n, const value_type& __val)
00957 { _M_fill_assign(__n, __val); }
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971 template<typename _InputIterator>
00972 void
00973 assign(_InputIterator __first, _InputIterator __last)
00974 {
00975 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
00976 _M_assign_dispatch(__first, __last, _Integral());
00977 }
00978
00979 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00980
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991 void
00992 assign(initializer_list<value_type> __l)
00993 { this->assign(__l.begin(), __l.end()); }
00994 #endif
00995
00996
00997 allocator_type
00998 get_allocator() const
00999 { return _Base::get_allocator(); }
01000
01001
01002
01003
01004
01005
01006 iterator
01007 begin()
01008 { return this->_M_impl._M_start; }
01009
01010
01011
01012
01013
01014 const_iterator
01015 begin() const
01016 { return this->_M_impl._M_start; }
01017
01018
01019
01020
01021
01022
01023 iterator
01024 end()
01025 { return this->_M_impl._M_finish; }
01026
01027
01028
01029
01030
01031
01032 const_iterator
01033 end() const
01034 { return this->_M_impl._M_finish; }
01035
01036
01037
01038
01039
01040
01041 reverse_iterator
01042 rbegin()
01043 { return reverse_iterator(this->_M_impl._M_finish); }
01044
01045
01046
01047
01048
01049
01050 const_reverse_iterator
01051 rbegin() const
01052 { return const_reverse_iterator(this->_M_impl._M_finish); }
01053
01054
01055
01056
01057
01058
01059 reverse_iterator
01060 rend()
01061 { return reverse_iterator(this->_M_impl._M_start); }
01062
01063
01064
01065
01066
01067
01068 const_reverse_iterator
01069 rend() const
01070 { return const_reverse_iterator(this->_M_impl._M_start); }
01071
01072 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01073
01074
01075
01076
01077 const_iterator
01078 cbegin() const
01079 { return this->_M_impl._M_start; }
01080
01081
01082
01083
01084
01085
01086 const_iterator
01087 cend() const
01088 { return this->_M_impl._M_finish; }
01089
01090
01091
01092
01093
01094
01095 const_reverse_iterator
01096 crbegin() const
01097 { return const_reverse_iterator(this->_M_impl._M_finish); }
01098
01099
01100
01101
01102
01103
01104 const_reverse_iterator
01105 crend() const
01106 { return const_reverse_iterator(this->_M_impl._M_start); }
01107 #endif
01108
01109
01110
01111 size_type
01112 size() const
01113 { return this->_M_impl._M_finish - this->_M_impl._M_start; }
01114
01115
01116 size_type
01117 max_size() const
01118 { return _M_get_Tp_allocator().max_size(); }
01119
01120 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01121
01122
01123
01124
01125
01126
01127
01128
01129
01130 void
01131 resize(size_type __new_size)
01132 {
01133 const size_type __len = size();
01134 if (__new_size > __len)
01135 _M_default_append(__new_size - __len);
01136 else if (__new_size < __len)
01137 _M_erase_at_end(this->_M_impl._M_start
01138 + difference_type(__new_size));
01139 }
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150
01151
01152 void
01153 resize(size_type __new_size, const value_type& __x)
01154 {
01155 const size_type __len = size();
01156 if (__new_size > __len)
01157 insert(this->_M_impl._M_finish, __new_size - __len, __x);
01158 else if (__new_size < __len)
01159 _M_erase_at_end(this->_M_impl._M_start
01160 + difference_type(__new_size));
01161 }
01162 #else
01163
01164
01165
01166
01167
01168
01169
01170
01171
01172
01173
01174 void
01175 resize(size_type __new_size, value_type __x = value_type())
01176 {
01177 const size_type __len = size();
01178 if (__new_size > __len)
01179 insert(this->_M_impl._M_finish, __new_size - __len, __x);
01180 else if (__new_size < __len)
01181 _M_erase_at_end(this->_M_impl._M_start
01182 + difference_type(__new_size));
01183 }
01184 #endif
01185
01186 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01187
01188 void
01189 shrink_to_fit()
01190 { std::__shrink_to_fit<deque>::_S_do_it(*this); }
01191 #endif
01192
01193
01194
01195
01196
01197 bool
01198 empty() const
01199 { return this->_M_impl._M_finish == this->_M_impl._M_start; }
01200
01201
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211
01212
01213 reference
01214 operator[](size_type __n)
01215 { return this->_M_impl._M_start[difference_type(__n)]; }
01216
01217
01218
01219
01220
01221
01222
01223
01224
01225
01226
01227
01228 const_reference
01229 operator[](size_type __n) const
01230 { return this->_M_impl._M_start[difference_type(__n)]; }
01231
01232 protected:
01233
01234 void
01235 _M_range_check(size_type __n) const
01236 {
01237 if (__n >= this->size())
01238 __throw_out_of_range(__N("deque::_M_range_check"));
01239 }
01240
01241 public:
01242
01243
01244
01245
01246
01247
01248
01249
01250
01251
01252
01253 reference
01254 at(size_type __n)
01255 {
01256 _M_range_check(__n);
01257 return (*this)[__n];
01258 }
01259
01260
01261
01262
01263
01264
01265
01266
01267
01268
01269
01270
01271 const_reference
01272 at(size_type __n) const
01273 {
01274 _M_range_check(__n);
01275 return (*this)[__n];
01276 }
01277
01278
01279
01280
01281
01282 reference
01283 front()
01284 { return *begin(); }
01285
01286
01287
01288
01289
01290 const_reference
01291 front() const
01292 { return *begin(); }
01293
01294
01295
01296
01297
01298 reference
01299 back()
01300 {
01301 iterator __tmp = end();
01302 --__tmp;
01303 return *__tmp;
01304 }
01305
01306
01307
01308
01309
01310 const_reference
01311 back() const
01312 {
01313 const_iterator __tmp = end();
01314 --__tmp;
01315 return *__tmp;
01316 }
01317
01318
01319
01320
01321
01322
01323
01324
01325
01326
01327
01328 void
01329 push_front(const value_type& __x)
01330 {
01331 if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
01332 {
01333 this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, __x);
01334 --this->_M_impl._M_start._M_cur;
01335 }
01336 else
01337 _M_push_front_aux(__x);
01338 }
01339
01340 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01341 void
01342 push_front(value_type&& __x)
01343 { emplace_front(std::move(__x)); }
01344
01345 template<typename... _Args>
01346 void
01347 emplace_front(_Args&&... __args);
01348 #endif
01349
01350
01351
01352
01353
01354
01355
01356
01357
01358
01359 void
01360 push_back(const value_type& __x)
01361 {
01362 if (this->_M_impl._M_finish._M_cur
01363 != this->_M_impl._M_finish._M_last - 1)
01364 {
01365 this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __x);
01366 ++this->_M_impl._M_finish._M_cur;
01367 }
01368 else
01369 _M_push_back_aux(__x);
01370 }
01371
01372 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01373 void
01374 push_back(value_type&& __x)
01375 { emplace_back(std::move(__x)); }
01376
01377 template<typename... _Args>
01378 void
01379 emplace_back(_Args&&... __args);
01380 #endif
01381
01382
01383
01384
01385
01386
01387
01388
01389
01390 void
01391 pop_front()
01392 {
01393 if (this->_M_impl._M_start._M_cur
01394 != this->_M_impl._M_start._M_last - 1)
01395 {
01396 this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
01397 ++this->_M_impl._M_start._M_cur;
01398 }
01399 else
01400 _M_pop_front_aux();
01401 }
01402
01403
01404
01405
01406
01407
01408
01409
01410
01411 void
01412 pop_back()
01413 {
01414 if (this->_M_impl._M_finish._M_cur
01415 != this->_M_impl._M_finish._M_first)
01416 {
01417 --this->_M_impl._M_finish._M_cur;
01418 this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
01419 }
01420 else
01421 _M_pop_back_aux();
01422 }
01423
01424 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01425
01426
01427
01428
01429
01430
01431
01432
01433
01434 template<typename... _Args>
01435 iterator
01436 emplace(iterator __position, _Args&&... __args);
01437 #endif
01438
01439
01440
01441
01442
01443
01444
01445
01446
01447
01448 iterator
01449 insert(iterator __position, const value_type& __x);
01450
01451 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01452
01453
01454
01455
01456
01457
01458
01459
01460
01461 iterator
01462 insert(iterator __position, value_type&& __x)
01463 { return emplace(__position, std::move(__x)); }
01464
01465
01466
01467
01468
01469
01470
01471
01472
01473
01474 void
01475 insert(iterator __p, initializer_list<value_type> __l)
01476 { this->insert(__p, __l.begin(), __l.end()); }
01477 #endif
01478
01479
01480
01481
01482
01483
01484
01485
01486
01487
01488 void
01489 insert(iterator __position, size_type __n, const value_type& __x)
01490 { _M_fill_insert(__position, __n, __x); }
01491
01492
01493
01494
01495
01496
01497
01498
01499
01500
01501
01502 template<typename _InputIterator>
01503 void
01504 insert(iterator __position, _InputIterator __first,
01505 _InputIterator __last)
01506 {
01507
01508 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
01509 _M_insert_dispatch(__position, __first, __last, _Integral());
01510 }
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523
01524
01525 iterator
01526 erase(iterator __position);
01527
01528
01529
01530
01531
01532
01533
01534
01535
01536
01537
01538
01539
01540
01541
01542
01543
01544 iterator
01545 erase(iterator __first, iterator __last);
01546
01547
01548
01549
01550
01551
01552
01553
01554
01555
01556 void
01557 swap(deque& __x)
01558 {
01559 std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
01560 std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
01561 std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
01562 std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
01563
01564
01565
01566 std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
01567 __x._M_get_Tp_allocator());
01568 }
01569
01570
01571
01572
01573
01574
01575
01576 void
01577 clear()
01578 { _M_erase_at_end(begin()); }
01579
01580 protected:
01581
01582
01583
01584
01585
01586
01587 template<typename _Integer>
01588 void
01589 _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
01590 {
01591 _M_initialize_map(static_cast<size_type>(__n));
01592 _M_fill_initialize(__x);
01593 }
01594
01595
01596 template<typename _InputIterator>
01597 void
01598 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
01599 __false_type)
01600 {
01601 typedef typename std::iterator_traits<_InputIterator>::
01602 iterator_category _IterCategory;
01603 _M_range_initialize(__first, __last, _IterCategory());
01604 }
01605
01606
01607
01608
01609
01610
01611
01612
01613
01614
01615
01616
01617
01618 template<typename _InputIterator>
01619 void
01620 _M_range_initialize(_InputIterator __first, _InputIterator __last,
01621 std::input_iterator_tag);
01622
01623
01624 template<typename _ForwardIterator>
01625 void
01626 _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
01627 std::forward_iterator_tag);
01628
01629
01630
01631
01632
01633
01634
01635
01636
01637
01638
01639
01640 void
01641 _M_fill_initialize(const value_type& __value);
01642
01643 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01644
01645 void
01646 _M_default_initialize();
01647 #endif
01648
01649
01650
01651
01652
01653
01654
01655
01656 template<typename _Integer>
01657 void
01658 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
01659 { _M_fill_assign(__n, __val); }
01660
01661
01662 template<typename _InputIterator>
01663 void
01664 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
01665 __false_type)
01666 {
01667 typedef typename std::iterator_traits<_InputIterator>::
01668 iterator_category _IterCategory;
01669 _M_assign_aux(__first, __last, _IterCategory());
01670 }
01671
01672
01673 template<typename _InputIterator>
01674 void
01675 _M_assign_aux(_InputIterator __first, _InputIterator __last,
01676 std::input_iterator_tag);
01677
01678
01679 template<typename _ForwardIterator>
01680 void
01681 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
01682 std::forward_iterator_tag)
01683 {
01684 const size_type __len = std::distance(__first, __last);
01685 if (__len > size())
01686 {
01687 _ForwardIterator __mid = __first;
01688 std::advance(__mid, size());
01689 std::copy(__first, __mid, begin());
01690 insert(end(), __mid, __last);
01691 }
01692 else
01693 _M_erase_at_end(std::copy(__first, __last, begin()));
01694 }
01695
01696
01697
01698 void
01699 _M_fill_assign(size_type __n, const value_type& __val)
01700 {
01701 if (__n > size())
01702 {
01703 std::fill(begin(), end(), __val);
01704 insert(end(), __n - size(), __val);
01705 }
01706 else
01707 {
01708 _M_erase_at_end(begin() + difference_type(__n));
01709 std::fill(begin(), end(), __val);
01710 }
01711 }
01712
01713
01714
01715 #ifndef __GXX_EXPERIMENTAL_CXX0X__
01716 void _M_push_back_aux(const value_type&);
01717
01718 void _M_push_front_aux(const value_type&);
01719 #else
01720 template<typename... _Args>
01721 void _M_push_back_aux(_Args&&... __args);
01722
01723 template<typename... _Args>
01724 void _M_push_front_aux(_Args&&... __args);
01725 #endif
01726
01727 void _M_pop_back_aux();
01728
01729 void _M_pop_front_aux();
01730
01731
01732
01733
01734
01735
01736
01737
01738
01739 template<typename _Integer>
01740 void
01741 _M_insert_dispatch(iterator __pos,
01742 _Integer __n, _Integer __x, __true_type)
01743 { _M_fill_insert(__pos, __n, __x); }
01744
01745
01746 template<typename _InputIterator>
01747 void
01748 _M_insert_dispatch(iterator __pos,
01749 _InputIterator __first, _InputIterator __last,
01750 __false_type)
01751 {
01752 typedef typename std::iterator_traits<_InputIterator>::
01753 iterator_category _IterCategory;
01754 _M_range_insert_aux(__pos, __first, __last, _IterCategory());
01755 }
01756
01757
01758 template<typename _InputIterator>
01759 void
01760 _M_range_insert_aux(iterator __pos, _InputIterator __first,
01761 _InputIterator __last, std::input_iterator_tag);
01762
01763
01764 template<typename _ForwardIterator>
01765 void
01766 _M_range_insert_aux(iterator __pos, _ForwardIterator __first,
01767 _ForwardIterator __last, std::forward_iterator_tag);
01768
01769
01770
01771
01772 void
01773 _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
01774
01775
01776 #ifndef __GXX_EXPERIMENTAL_CXX0X__
01777 iterator
01778 _M_insert_aux(iterator __pos, const value_type& __x);
01779 #else
01780 template<typename... _Args>
01781 iterator
01782 _M_insert_aux(iterator __pos, _Args&&... __args);
01783 #endif
01784
01785
01786 void
01787 _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
01788
01789
01790 template<typename _ForwardIterator>
01791 void
01792 _M_insert_aux(iterator __pos,
01793 _ForwardIterator __first, _ForwardIterator __last,
01794 size_type __n);
01795
01796
01797
01798
01799 void
01800 _M_destroy_data_aux(iterator __first, iterator __last);
01801
01802
01803
01804 template<typename _Alloc1>
01805 void
01806 _M_destroy_data(iterator __first, iterator __last, const _Alloc1&)
01807 { _M_destroy_data_aux(__first, __last); }
01808
01809 void
01810 _M_destroy_data(iterator __first, iterator __last,
01811 const std::allocator<_Tp>&)
01812 {
01813 if (!__has_trivial_destructor(value_type))
01814 _M_destroy_data_aux(__first, __last);
01815 }
01816
01817
01818 void
01819 _M_erase_at_begin(iterator __pos)
01820 {
01821 _M_destroy_data(begin(), __pos, _M_get_Tp_allocator());
01822 _M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node);
01823 this->_M_impl._M_start = __pos;
01824 }
01825
01826
01827
01828 void
01829 _M_erase_at_end(iterator __pos)
01830 {
01831 _M_destroy_data(__pos, end(), _M_get_Tp_allocator());
01832 _M_destroy_nodes(__pos._M_node + 1,
01833 this->_M_impl._M_finish._M_node + 1);
01834 this->_M_impl._M_finish = __pos;
01835 }
01836
01837 #ifdef __GXX_EXPERIMENTAL_CXX0X__
01838
01839 void
01840 _M_default_append(size_type __n);
01841 #endif
01842
01843
01844
01845 iterator
01846 _M_reserve_elements_at_front(size_type __n)
01847 {
01848 const size_type __vacancies = this->_M_impl._M_start._M_cur
01849 - this->_M_impl._M_start._M_first;
01850 if (__n > __vacancies)
01851 _M_new_elements_at_front(__n - __vacancies);
01852 return this->_M_impl._M_start - difference_type(__n);
01853 }
01854
01855 iterator
01856 _M_reserve_elements_at_back(size_type __n)
01857 {
01858 const size_type __vacancies = (this->_M_impl._M_finish._M_last
01859 - this->_M_impl._M_finish._M_cur) - 1;
01860 if (__n > __vacancies)
01861 _M_new_elements_at_back(__n - __vacancies);
01862 return this->_M_impl._M_finish + difference_type(__n);
01863 }
01864
01865 void
01866 _M_new_elements_at_front(size_type __new_elements);
01867
01868 void
01869 _M_new_elements_at_back(size_type __new_elements);
01870
01871
01872
01873
01874
01875
01876
01877
01878
01879
01880
01881 void
01882 _M_reserve_map_at_back(size_type __nodes_to_add = 1)
01883 {
01884 if (__nodes_to_add + 1 > this->_M_impl._M_map_size
01885 - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
01886 _M_reallocate_map(__nodes_to_add, false);
01887 }
01888
01889 void
01890 _M_reserve_map_at_front(size_type __nodes_to_add = 1)
01891 {
01892 if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
01893 - this->_M_impl._M_map))
01894 _M_reallocate_map(__nodes_to_add, true);
01895 }
01896
01897 void
01898 _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
01899
01900 };
01901
01902
01903
01904
01905
01906
01907
01908
01909
01910
01911
01912
01913 template<typename _Tp, typename _Alloc>
01914 inline bool
01915 operator==(const deque<_Tp, _Alloc>& __x,
01916 const deque<_Tp, _Alloc>& __y)
01917 { return __x.size() == __y.size()
01918 && std::equal(__x.begin(), __x.end(), __y.begin()); }
01919
01920
01921
01922
01923
01924
01925
01926
01927
01928
01929
01930
01931 template<typename _Tp, typename _Alloc>
01932 inline bool
01933 operator<(const deque<_Tp, _Alloc>& __x,
01934 const deque<_Tp, _Alloc>& __y)
01935 { return std::lexicographical_compare(__x.begin(), __x.end(),
01936 __y.begin(), __y.end()); }
01937
01938
01939 template<typename _Tp, typename _Alloc>
01940 inline bool
01941 operator!=(const deque<_Tp, _Alloc>& __x,
01942 const deque<_Tp, _Alloc>& __y)
01943 { return !(__x == __y); }
01944
01945
01946 template<typename _Tp, typename _Alloc>
01947 inline bool
01948 operator>(const deque<_Tp, _Alloc>& __x,
01949 const deque<_Tp, _Alloc>& __y)
01950 { return __y < __x; }
01951
01952
01953 template<typename _Tp, typename _Alloc>
01954 inline bool
01955 operator<=(const deque<_Tp, _Alloc>& __x,
01956 const deque<_Tp, _Alloc>& __y)
01957 { return !(__y < __x); }
01958
01959
01960 template<typename _Tp, typename _Alloc>
01961 inline bool
01962 operator>=(const deque<_Tp, _Alloc>& __x,
01963 const deque<_Tp, _Alloc>& __y)
01964 { return !(__x < __y); }
01965
01966
01967 template<typename _Tp, typename _Alloc>
01968 inline void
01969 swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
01970 { __x.swap(__y); }
01971
01972 #undef _GLIBCXX_DEQUE_BUF_SIZE
01973
01974 _GLIBCXX_END_NESTED_NAMESPACE
01975
01976 #endif