headers/cpp/stl_deque.h

92 __deque_buf_size(size_t __n, size_t __size)
94   return __n != 0 ? __n : (__size < 512 ? size_t(512 / __size) : size_t(1));
174   _Self& operator+=(difference_type __n)
176     difference_type __offset = __n + (_M_cur - _M_first);
178       _M_cur += __n;
190   _Self operator+(difference_type __n) const
193     return __tmp += __n;
196   _Self& operator-=(difference_type __n) { return *this += -__n; }
198   _Self operator-(difference_type __n) const {
200     return __tmp -= __n;
203   reference operator[](difference_type __n) const { return *(*this + __n); }
296   _Tp** _M_allocate_map(size_t __n)
297     { return map_allocator.allocate(__n); }
298   void _M_deallocate_map(_Tp** __p, size_t __n)
299     { map_allocator.deallocate(__p, __n); }
325   _Tp** _M_allocate_map(size_t __n)
326     { return _Map_alloc_type::allocate(__n); }
327   void _M_deallocate_map(_Tp** __p, size_t __n)
328     { _Map_alloc_type::deallocate(__p, __n); }
410   _Tp** _M_allocate_map(size_t __n)
411     { return _Map_alloc_type::allocate(__n); }
412   void _M_deallocate_map(_Tp** __p, size_t __n)
413     { _Map_alloc_type::deallocate(__p, __n); }
471   for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
472     _M_deallocate_node(*__n);
543   reference operator[](size_type __n)
544     { return _M_start[difference_type(__n)]; }
545   const_reference operator[](size_type __n) const
546     { return _M_start[difference_type(__n)]; }
570   deque(size_type __n, const value_type& __value,
571         const allocator_type& __a = allocator_type()) : _Base(__a, __n)
573   explicit deque(size_type __n) : _Base(allocator_type(), __n)
587   void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) {
588     _M_initialize_map(__n);
640   void assign(size_type __n, const _Tp& __val) {
641     if (__n > size()) {
643       insert(end(), __n - size(), __val);
646       erase(begin() + __n, end());
662   void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
663     { assign((size_type) __n, (_Tp) __val); }
770   void insert(iterator __pos, size_type __n, const value_type& __x);
782   void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
784     insert(__pos, (size_type) __n, (value_type) __x);
874   void _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
881                      size_type __n);
887                      size_type __n);
891                      size_type __n);
895   iterator _M_reserve_elements_at_front(size_type __n) {
897     if (__n > __vacancies)
898       _M_new_elements_at_front(__n - __vacancies);
899     return _M_start - difference_type(__n);
902   iterator _M_reserve_elements_at_back(size_type __n) {
904     if (__n > __vacancies)
905       _M_new_elements_at_back(__n - __vacancies);
906     return _M_finish + difference_type(__n);
967                                       size_type __n, const value_type& __x)
970     iterator __new_start = _M_reserve_elements_at_front(__n);
975     iterator __new_finish = _M_reserve_elements_at_back(__n);
980     _M_insert_aux(__pos, __n, __x);
989   size_type __n = __last - __first;
991     iterator __new_start = _M_reserve_elements_at_front(__n);
999     iterator __new_finish = _M_reserve_elements_at_back(__n);
1008     _M_insert_aux(__pos, __first, __last, __n);
1016   size_type __n = __last - __first;
1018     iterator __new_start = _M_reserve_elements_at_front(__n);
1026     iterator __new_finish = _M_reserve_elements_at_back(__n);
1035     _M_insert_aux(__pos, __first, __last, __n);
1049     difference_type __n = __last - __first;
1051     if (static_cast<size_type>(__elems_before) < (size() - __n) / 2) {
1053       iterator __new_start = _M_start + __n;
1060       iterator __new_finish = _M_finish - __n;
1125   size_type __n = 0;
1126   distance(__first, __last, __n);
1127   _M_initialize_map(__n);
1253   size_type __n = 0;
1254   distance(__first, __last, __n);
1256     iterator __new_start = _M_reserve_elements_at_front(__n);
1264     iterator __new_finish = _M_reserve_elements_at_back(__n);
1273     _M_insert_aux(__pos, __first, __last, __n);
1341                                            size_type __n,
1348     iterator __new_start = _M_reserve_elements_at_front(__n);
1352       if (__elems_before >= difference_type(__n)) {
1353         iterator __start_n = _M_start + difference_type(__n);
1357         fill(__pos - difference_type(__n), __pos, __x_copy);
1369     iterator __new_finish = _M_reserve_elements_at_back(__n);
1375       if (__elems_after > difference_type(__n)) {
1376         iterator __finish_n = _M_finish - difference_type(__n);
1380         fill(__pos, __pos + difference_type(__n), __x_copy);
1383         __uninitialized_fill_copy(_M_finish, __pos + difference_type(__n),
1402                                            size_type __n)
1407     iterator __new_start = _M_reserve_elements_at_front(__n);
1411       if (__elemsbefore >= difference_type(__n)) {
1412         iterator __start_n = _M_start + difference_type(__n);
1416         copy(__first, __last, __pos - difference_type(__n));
1420         advance(__mid, difference_type(__n) - __elemsbefore);
1430     iterator __new_finish = _M_reserve_elements_at_back(__n);
1436       if (__elemsafter > difference_type(__n)) {
1437         iterator __finish_n = _M_finish - difference_type(__n);
1463                                            size_type __n)
1468     iterator __new_start = _M_reserve_elements_at_front(__n);
1472       if (__elemsbefore >= difference_type(__n)) {
1473         iterator __start_n = _M_start + difference_type(__n);
1477         copy(__first, __last, __pos - difference_type(__n));
1481 	  __first + (difference_type(__n) - __elemsbefore);
1491     iterator __new_finish = _M_reserve_elements_at_back(__n);
1497       if (__elemsafter > difference_type(__n)) {
1498         iterator __finish_n = _M_finish - difference_type(__n);
1521                                            size_type __n)
1526     iterator __new_start = _M_reserve_elements_at_front(__n);
1530       if (__elemsbefore >= __n) {
1531         iterator __start_n = _M_start + __n;
1535         copy(__first, __last, __pos - difference_type(__n));
1538         const_iterator __mid = __first + (__n - __elemsbefore);
1548     iterator __new_finish = _M_reserve_elements_at_back(__n);
1553       if (__elemsafter > __n) {
1554         iterator __finish_n = _M_finish - difference_type(__n);