PageRenderTime 83ms CodeModel.GetById 14ms app.highlight 62ms RepoModel.GetById 1ms app.codeStats 0ms

/project/jni/stlport/stlport/stl/_deque.c

https://github.com/aichunyu/FFPlayer
C | 814 lines | 713 code | 54 blank | 47 comment | 106 complexity | df76862a5c589d482d50b83d844ea58b MD5 | raw file
  1/*
  2 *
  3 *
  4 * Copyright (c) 1994
  5 * Hewlett-Packard Company
  6 *
  7 * Copyright (c) 1996,1997
  8 * Silicon Graphics Computer Systems, Inc.
  9 *
 10 * Copyright (c) 1997
 11 * Moscow Center for SPARC Technology
 12 *
 13 * Copyright (c) 1999
 14 * Boris Fomitchev
 15 *
 16 * This material is provided "as is", with absolutely no warranty expressed
 17 * or implied. Any use is at your own risk.
 18 *
 19 * Permission to use or copy this software for any purpose is hereby granted
 20 * without fee, provided the above notices are retained on all copies.
 21 * Permission to modify the code and to distribute modified code is granted,
 22 * provided the above notices are retained, and a notice that the code was
 23 * modified is included with the above copyright notice.
 24 *
 25 */
 26#ifndef _STLP_DEQUE_C
 27#define _STLP_DEQUE_C
 28
 29#ifndef _STLP_INTERNAL_DEQUE_H
 30#  include <stl/_deque.h>
 31#endif
 32
 33_STLP_BEGIN_NAMESPACE
 34
 35_STLP_MOVE_TO_PRIV_NAMESPACE
 36
 37// Non-inline member functions from _Deque_base.
 38
 39template <class _Tp, class _Alloc >
 40_Deque_base<_Tp,_Alloc >::~_Deque_base() {
 41  if (_M_map._M_data) {
 42    _M_destroy_nodes(_M_start._M_node, this->_M_finish._M_node + 1);
 43    _M_map.deallocate(_M_map._M_data, _M_map_size._M_data);
 44  }
 45}
 46
 47template <class _Tp, class _Alloc >
 48void _Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements) {
 49  size_t __num_nodes = __num_elements / this->buffer_size() + 1 ;
 50
 51  _M_map_size._M_data = (max)((size_t) _S_initial_map_size, __num_nodes + 2);
 52  _M_map._M_data = _M_map.allocate(_M_map_size._M_data);
 53
 54  _Tp** __nstart = _M_map._M_data + (_M_map_size._M_data - __num_nodes) / 2;
 55  _Tp** __nfinish = __nstart + __num_nodes;
 56
 57  _STLP_TRY {
 58    _M_create_nodes(__nstart, __nfinish);
 59  }
 60  _STLP_UNWIND((_M_map.deallocate(_M_map._M_data, _M_map_size._M_data),
 61                _M_map._M_data = 0, _M_map_size._M_data = 0))
 62  _M_start._M_set_node(__nstart);
 63  this->_M_finish._M_set_node(__nfinish - 1);
 64  _M_start._M_cur = _M_start._M_first;
 65  this->_M_finish._M_cur = this->_M_finish._M_first + __num_elements % this->buffer_size();
 66}
 67
 68template <class _Tp, class _Alloc >
 69void _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart,
 70                                              _Tp** __nfinish) {
 71  _Tp** __cur = __nstart;
 72  _STLP_TRY {
 73    for (; __cur < __nfinish; ++__cur)
 74      *__cur = _M_map_size.allocate(this->buffer_size());
 75  }
 76  _STLP_UNWIND(_M_destroy_nodes(__nstart, __cur))
 77}
 78
 79template <class _Tp, class _Alloc >
 80void _Deque_base<_Tp,_Alloc>::_M_destroy_nodes(_Tp** __nstart,
 81                                               _Tp** __nfinish) {
 82  for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
 83    _M_map_size.deallocate(*__n, this->buffer_size());
 84}
 85
 86#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
 87#  define deque _STLP_PTR_IMPL_NAME(deque)
 88#elif defined (_STLP_DEBUG)
 89#  define deque _STLP_NON_DBG_NAME(deque)
 90#else
 91_STLP_MOVE_TO_STD_NAMESPACE
 92#endif
 93
 94#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
 95// qualified references
 96#  define __iterator__   _Deque_iterator<_Tp, _Nonconst_traits<_Tp> >
 97#  define const_iterator _Deque_iterator<_Tp, _Const_traits<_Tp>  >
 98#  define iterator       __iterator__
 99#  define size_type      size_t
100#  define value_type     _Tp
101#else
102#  define __iterator__   _STLP_TYPENAME_ON_RETURN_TYPE deque<_Tp, _Alloc>::iterator
103#endif
104
105template <class _Tp, class _Alloc >
106deque<_Tp, _Alloc >&
107deque<_Tp, _Alloc >::operator= (const deque<_Tp, _Alloc >& __x) {
108  const size_type __len = size();
109  if (&__x != this) {
110    if (__len >= __x.size())
111      erase(copy(__x.begin(), __x.end(), this->_M_start), this->_M_finish);
112    else {
113      const_iterator __mid = __x.begin() + difference_type(__len);
114      copy(__x.begin(), __mid, this->_M_start);
115      insert(this->_M_finish, __mid, __x.end());
116    }
117  }
118  return *this;
119}
120
121template <class _Tp, class _Alloc >
122void deque<_Tp, _Alloc >::_M_fill_insert(iterator __pos,
123                                         size_type __n, const value_type& __x) {
124  if (__pos._M_cur == this->_M_start._M_cur) {
125    iterator __new_start = _M_reserve_elements_at_front(__n);
126    _STLP_TRY {
127      uninitialized_fill(__new_start, this->_M_start, __x);
128    }
129    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
130    this->_M_start = __new_start;
131  }
132  else if (__pos._M_cur == this->_M_finish._M_cur) {
133    iterator __new_finish = _M_reserve_elements_at_back(__n);
134    _STLP_TRY {
135      uninitialized_fill(this->_M_finish, __new_finish, __x);
136    }
137    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node+1, __new_finish._M_node+1))
138    this->_M_finish = __new_finish;
139  }
140  else
141    _M_fill_insert_aux(__pos, __n, __x, _Movable());
142}
143
144#if !defined (_STLP_MEMBER_TEMPLATES)
145
146template <class _Tp, class _Alloc >
147void deque<_Tp, _Alloc>::insert(iterator __pos,
148                                const value_type* __first, const value_type* __last) {
149  size_type __n = __last - __first;
150  if (__pos._M_cur == this->_M_start._M_cur) {
151    iterator __new_start = _M_reserve_elements_at_front(__n);
152    _STLP_TRY {
153      _STLP_PRIV __ucopy(__first, __last, __new_start);
154    }
155    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
156    this->_M_start = __new_start;
157  }
158  else if (__pos._M_cur == this->_M_finish._M_cur) {
159    iterator __new_finish = _M_reserve_elements_at_back(__n);
160    _STLP_TRY {
161      _STLP_PRIV __ucopy(__first, __last, this->_M_finish);
162    }
163    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1,
164                                        __new_finish._M_node + 1))
165    this->_M_finish = __new_finish;
166  }
167  else
168    _M_insert_range_aux(__pos, __first, __last, __n, _Movable());
169}
170
171template <class _Tp, class _Alloc >
172void deque<_Tp,_Alloc>::insert(iterator __pos,
173                               const_iterator __first, const_iterator __last) {
174  size_type __n = __last - __first;
175  if (__pos._M_cur == this->_M_start._M_cur) {
176    iterator __new_start = _M_reserve_elements_at_front(__n);
177    _STLP_TRY {
178      _STLP_PRIV __ucopy(__first, __last, __new_start);
179    }
180    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
181    this->_M_start = __new_start;
182  }
183  else if (__pos._M_cur == this->_M_finish._M_cur) {
184    iterator __new_finish = _M_reserve_elements_at_back(__n);
185    _STLP_TRY {
186      _STLP_PRIV __ucopy(__first, __last, this->_M_finish);
187    }
188    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1,
189                                        __new_finish._M_node + 1))
190    this->_M_finish = __new_finish;
191  }
192  else
193    _M_insert_range_aux(__pos, __first, __last, __n, _Movable());
194}
195
196#endif /* _STLP_MEMBER_TEMPLATES */
197
198template <class _Tp, class _Alloc >
199__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __pos,
200                                         const __true_type& /*_Movable*/) {
201  difference_type __index = __pos - this->_M_start;
202  if (size_type(__index) < this->size() >> 1) {
203    //We move the start of the deque one position to the right
204    //starting from the rightmost element to move.
205    iterator __src = __pos, __dst = __pos;
206    _STLP_STD::_Destroy(&(*__dst));
207    if (__src != this->_M_start) {
208      for (--__src; __dst != this->_M_start; --__src, --__dst) {
209        _STLP_STD::_Move_Construct(&(*__dst), *__src);
210        _STLP_STD::_Destroy_Moved(&(*__src));
211      }
212    }
213    _M_pop_front_aux();
214  }
215  else {
216    iterator __src = __pos, __dst = __pos;
217    _STLP_STD::_Destroy(&(*__dst));
218    for (++__src; __src != this->_M_finish; ++__src, ++__dst) {
219      _STLP_STD::_Move_Construct(&(*__dst), *__src);
220      _STLP_STD::_Destroy_Moved(&(*__src));
221    }
222    //Duplication of the pop_back code without the destroy which has already been done:
223    if (this->_M_finish._M_cur != this->_M_finish._M_first) {
224      --this->_M_finish._M_cur;
225    }
226    else {
227      _M_pop_back_aux();
228    }
229  }
230  return this->_M_start + __index;
231}
232
233template <class _Tp, class _Alloc >
234__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __pos,
235                                         const __false_type& /*_Movable*/) {
236  iterator __next = __pos;
237  ++__next;
238  difference_type __index = __pos - this->_M_start;
239  if (size_type(__index) < this->size() >> 1) {
240    copy_backward(this->_M_start, __pos, __next);
241    pop_front();
242  }
243  else {
244    copy(__next, this->_M_finish, __pos);
245    pop_back();
246  }
247  return this->_M_start + __index;
248}
249
250template <class _Tp, class _Alloc >
251__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __first, iterator __last,
252                                         const __true_type& /*_Movable*/) {
253  difference_type __n = __last - __first;
254  difference_type __elems_before = __first - this->_M_start;
255  if (__elems_before <= difference_type(this->size() - __n) / 2) {
256    iterator __src = __first, __dst = __last;
257    if (__src != this->_M_start) {
258      for (--__src, --__dst; (__src >= this->_M_start) && (__dst >= __first); --__src, --__dst) {
259        _STLP_STD::_Destroy(&(*__dst));
260        _STLP_STD::_Move_Construct(&(*__dst), *__src);
261      }
262      if (__dst >= __first) {
263        //There are more elements to erase than elements to move
264        _STLP_STD::_Destroy_Range(__first, ++__dst);
265        _STLP_STD::_Destroy_Moved_Range(this->_M_start, __first);
266      }
267      else {
268        //There are more elements to move than elements to erase
269        for (; __src >= this->_M_start; --__src, --__dst) {
270          _STLP_STD::_Destroy_Moved(&(*__dst));
271          _STLP_STD::_Move_Construct(&(*__dst), *__src);
272        }
273        _STLP_STD::_Destroy_Moved_Range(this->_M_start, ++__dst);
274      }
275    }
276    else {
277      _STLP_STD::_Destroy_Range(this->_M_start, __last);
278    }
279    iterator __new_start = this->_M_start + __n;
280    this->_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
281    this->_M_start = __new_start;
282  }
283  else {
284    if (__last != this->_M_finish) {
285      iterator __src = __last, __dst = __first;
286      for (; (__src != this->_M_finish) && (__dst != __last); ++__src, ++__dst) {
287        _STLP_STD::_Destroy(&(*__dst));
288        _STLP_STD::_Move_Construct(&(*__dst), *__src);
289      }
290      if (__dst != __last) {
291        //There are more elements to erase than elements to move
292        _STLP_STD::_Destroy_Range(__dst, __last);
293        _STLP_STD::_Destroy_Moved_Range(__last, this->_M_finish);
294      }
295      else {
296        //There are more elements to move than elements to erase
297        for (; __src != this->_M_finish; ++__src, ++__dst) {
298          _STLP_STD::_Destroy_Moved(&(*__dst));
299          _STLP_STD::_Move_Construct(&(*__dst), *__src);
300        }
301        _STLP_STD::_Destroy_Moved_Range(__dst, this->_M_finish);
302      }
303    }
304    else {
305      _STLP_STD::_Destroy_Range(__first, this->_M_finish);
306    }
307    iterator __new_finish = this->_M_finish - __n;
308    this->_M_destroy_nodes(__new_finish._M_node + 1, this->_M_finish._M_node + 1);
309    this->_M_finish = __new_finish;
310  }
311  return this->_M_start + __elems_before;
312}
313
314template <class _Tp, class _Alloc >
315__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __first, iterator __last,
316                                         const __false_type& /*_Movable*/) {
317  difference_type __n = __last - __first;
318  difference_type __elems_before = __first - this->_M_start;
319  if (__elems_before <= difference_type(this->size() - __n) / 2) {
320    copy_backward(this->_M_start, __first, __last);
321    iterator __new_start = this->_M_start + __n;
322    _STLP_STD::_Destroy_Range(this->_M_start, __new_start);
323    this->_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
324    this->_M_start = __new_start;
325  }
326  else {
327    copy(__last, this->_M_finish, __first);
328    iterator __new_finish = this->_M_finish - __n;
329    _STLP_STD::_Destroy_Range(__new_finish, this->_M_finish);
330    this->_M_destroy_nodes(__new_finish._M_node + 1, this->_M_finish._M_node + 1);
331    this->_M_finish = __new_finish;
332  }
333  return this->_M_start + __elems_before;
334}
335
336template <class _Tp, class _Alloc >
337void deque<_Tp,_Alloc>::clear() {
338  for (_Map_pointer __node = this->_M_start._M_node + 1;
339       __node < this->_M_finish._M_node;
340       ++__node) {
341    _STLP_STD::_Destroy_Range(*__node, *__node + this->buffer_size());
342    this->_M_map_size.deallocate(*__node, this->buffer_size());
343  }
344
345  if (this->_M_start._M_node != this->_M_finish._M_node) {
346    _STLP_STD::_Destroy_Range(this->_M_start._M_cur, this->_M_start._M_last);
347    _STLP_STD::_Destroy_Range(this->_M_finish._M_first, this->_M_finish._M_cur);
348    this->_M_map_size.deallocate(this->_M_finish._M_first, this->buffer_size());
349  }
350  else
351    _STLP_STD::_Destroy_Range(this->_M_start._M_cur, this->_M_finish._M_cur);
352
353  this->_M_finish = this->_M_start;
354}
355
356// Precondition: this->_M_start and this->_M_finish have already been initialized,
357// but none of the deque's elements have yet been constructed.
358template <class _Tp, class _Alloc >
359void deque<_Tp,_Alloc>::_M_fill_initialize(const value_type& __val,
360                                           const __false_type& /*_TrivialInit*/) {
361  _Map_pointer __cur = this->_M_start._M_node;
362  _STLP_TRY {
363    for (; __cur < this->_M_finish._M_node; ++__cur)
364      uninitialized_fill(*__cur, *__cur + this->buffer_size(), __val);
365    uninitialized_fill(this->_M_finish._M_first, this->_M_finish._M_cur, __val);
366  }
367  _STLP_UNWIND(_STLP_STD::_Destroy_Range(this->_M_start, iterator(*__cur, __cur)))
368}
369
370
371// Called only if this->_M_finish._M_cur == this->_M_finish._M_last - 1.
372template <class _Tp, class _Alloc >
373void deque<_Tp,_Alloc>::_M_push_back_aux_v(const value_type& __t) {
374  _M_reserve_map_at_back();
375  *(this->_M_finish._M_node + 1) = this->_M_map_size.allocate(this->buffer_size());
376  _STLP_TRY {
377    _Copy_Construct(this->_M_finish._M_cur, __t);
378    this->_M_finish._M_set_node(this->_M_finish._M_node + 1);
379    this->_M_finish._M_cur = this->_M_finish._M_first;
380  }
381  _STLP_UNWIND(this->_M_map_size.deallocate(*(this->_M_finish._M_node + 1),
382                                            this->buffer_size()))
383}
384
385#if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
386// Called only if this->_M_finish._M_cur == this->_M_finish._M_last - 1.
387template <class _Tp, class _Alloc >
388void deque<_Tp,_Alloc>::_M_push_back_aux() {
389  _M_reserve_map_at_back();
390  *(this->_M_finish._M_node + 1) = this->_M_map_size.allocate(this->buffer_size());
391  _STLP_TRY {
392    _STLP_STD::_Construct(this->_M_finish._M_cur);
393    this->_M_finish._M_set_node(this->_M_finish._M_node + 1);
394    this->_M_finish._M_cur = this->_M_finish._M_first;
395  }
396  _STLP_UNWIND(this->_M_map_size.deallocate(*(this->_M_finish._M_node + 1),
397                                            this->buffer_size()))
398}
399#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
400
401// Called only if this->_M_start._M_cur == this->_M_start._M_first.
402template <class _Tp, class _Alloc >
403void deque<_Tp,_Alloc>::_M_push_front_aux_v(const value_type& __t) {
404  _M_reserve_map_at_front();
405  *(this->_M_start._M_node - 1) = this->_M_map_size.allocate(this->buffer_size());
406  _STLP_TRY {
407    this->_M_start._M_set_node(this->_M_start._M_node - 1);
408    this->_M_start._M_cur = this->_M_start._M_last - 1;
409    _Copy_Construct(this->_M_start._M_cur, __t);
410  }
411  _STLP_UNWIND((++this->_M_start,
412                this->_M_map_size.deallocate(*(this->_M_start._M_node - 1), this->buffer_size())))
413}
414
415
416#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
417// Called only if this->_M_start._M_cur == this->_M_start._M_first.
418template <class _Tp, class _Alloc >
419void deque<_Tp,_Alloc>::_M_push_front_aux() {
420  _M_reserve_map_at_front();
421  *(this->_M_start._M_node - 1) = this->_M_map_size.allocate(this->buffer_size());
422  _STLP_TRY {
423    this->_M_start._M_set_node(this->_M_start._M_node - 1);
424    this->_M_start._M_cur = this->_M_start._M_last - 1;
425    _STLP_STD::_Construct(this->_M_start._M_cur);
426  }
427  _STLP_UNWIND((++this->_M_start, this->_M_map_size.deallocate(*(this->_M_start._M_node - 1),
428                                                               this->buffer_size())))
429}
430#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
431
432// Called only if this->_M_finish._M_cur == this->_M_finish._M_first.
433template <class _Tp, class _Alloc >
434void deque<_Tp,_Alloc>::_M_pop_back_aux() {
435  this->_M_map_size.deallocate(this->_M_finish._M_first, this->buffer_size());
436  this->_M_finish._M_set_node(this->_M_finish._M_node - 1);
437  this->_M_finish._M_cur = this->_M_finish._M_last - 1;
438}
439
440// Note that if the deque has at least one element (a precondition for this member
441// function), and if this->_M_start._M_cur == this->_M_start._M_last, then the deque
442// must have at least two nodes.
443template <class _Tp, class _Alloc >
444void deque<_Tp,_Alloc>::_M_pop_front_aux() {
445  if (this->_M_start._M_cur != this->_M_start._M_last - 1)
446    ++this->_M_start._M_cur;
447  else {
448    this->_M_map_size.deallocate(this->_M_start._M_first, this->buffer_size());
449    this->_M_start._M_set_node(this->_M_start._M_node + 1);
450    this->_M_start._M_cur = this->_M_start._M_first;
451  }
452}
453
454template <class _Tp, class _Alloc >
455__iterator__ deque<_Tp,_Alloc>::_M_fill_insert_aux(iterator __pos, size_type __n,
456                                                   const value_type& __x,
457                                                   const __true_type& /*_Movable*/) {
458  const difference_type __elems_before = __pos - this->_M_start;
459  size_type __length = this->size();
460  value_type __x_copy = __x;
461  if (__elems_before <= difference_type(__length / 2)) {
462    iterator __new_start = _M_reserve_elements_at_front(__n);
463    __pos = this->_M_start + __elems_before;
464    _STLP_TRY {
465      iterator __dst = __new_start;
466      iterator __src = this->_M_start;
467      for (; __src != __pos; ++__dst, ++__src) {
468        _STLP_STD::_Move_Construct(&(*__dst), *__src);
469        _STLP_STD::_Destroy_Moved(&(*__src));
470      }
471      this->_M_start = __new_start;
472      uninitialized_fill(__dst, __src, __x_copy);
473      __pos = __dst;
474    }
475    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
476  }
477  else {
478    iterator __new_finish = _M_reserve_elements_at_back(__n);
479    const difference_type __elems_after = difference_type(__length) - __elems_before;
480    __pos = this->_M_finish - __elems_after;
481    _STLP_TRY {
482      iterator __dst = __new_finish;
483      iterator __src = this->_M_finish;
484      for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
485        _STLP_STD::_Move_Construct(&(*__dst), *__src);
486        _STLP_STD::_Destroy_Moved(&(*__src));
487      }
488      this->_M_finish = __new_finish;
489      uninitialized_fill(__pos, __pos + __n, __x_copy);
490    }
491    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
492  }
493  return __pos;
494}
495
496template <class _Tp, class _Alloc >
497__iterator__ deque<_Tp,_Alloc>::_M_fill_insert_aux(iterator __pos, size_type __n,
498                                                   const value_type& __x,
499                                                   const __false_type& /*_Movable*/) {
500  const difference_type __elems_before = __pos - this->_M_start;
501  size_type __length = this->size();
502  value_type __x_copy = __x;
503  if (__elems_before <= difference_type(__length / 2)) {
504    iterator __new_start = _M_reserve_elements_at_front(__n);
505    iterator __old_start = this->_M_start;
506    __pos = this->_M_start + __elems_before;
507    _STLP_TRY {
508      if (__elems_before >= difference_type(__n)) {
509        iterator __start_n = this->_M_start + difference_type(__n);
510        _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
511        this->_M_start = __new_start;
512        copy(__start_n, __pos, __old_start);
513        fill(__pos - difference_type(__n), __pos, __x_copy);
514        __pos -= difference_type(__n);
515      }
516      else {
517        _STLP_PRIV __uninitialized_copy_fill(this->_M_start, __pos, __new_start,
518                                             this->_M_start, __x_copy);
519        this->_M_start = __new_start;
520        fill(__old_start, __pos, __x_copy);
521      }
522    }
523    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
524  }
525  else {
526    iterator __new_finish = _M_reserve_elements_at_back(__n);
527    iterator __old_finish = this->_M_finish;
528    const difference_type __elems_after =
529      difference_type(__length) - __elems_before;
530    __pos = this->_M_finish - __elems_after;
531    _STLP_TRY {
532      if (__elems_after > difference_type(__n)) {
533        iterator __finish_n = this->_M_finish - difference_type(__n);
534        _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
535        this->_M_finish = __new_finish;
536        copy_backward(__pos, __finish_n, __old_finish);
537        fill(__pos, __pos + difference_type(__n), __x_copy);
538      }
539      else {
540        _STLP_PRIV __uninitialized_fill_copy(this->_M_finish, __pos + difference_type(__n),
541                                             __x_copy, __pos, this->_M_finish);
542        this->_M_finish = __new_finish;
543        fill(__pos, __old_finish, __x_copy);
544      }
545    }
546    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
547  }
548  return __pos;
549}
550
551#if !defined (_STLP_MEMBER_TEMPLATES)
552template <class _Tp, class _Alloc >
553void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
554                                            const value_type* __first, const value_type* __last,
555                                            size_type __n, const __true_type& /*_Movable*/) {
556  const difference_type __elems_before = __pos - this->_M_start;
557  size_type __length = size();
558  if (__elems_before <= difference_type(__length / 2)) {
559    iterator __new_start = _M_reserve_elements_at_front(__n);
560    __pos = this->_M_start + __elems_before;
561    _STLP_TRY {
562      iterator __dst = __new_start;
563      iterator __src = this->_M_start;
564      for (; __src != __pos; ++__dst, ++__src) {
565        _STLP_STD::_Move_Construct(&(*__dst), *__src);
566        _STLP_STD::_Destroy_Moved(&(*__src));
567      }
568      this->_M_start = __new_start;
569      _STLP_PRIV __ucopy(__first, __last, __dst);
570    }
571    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
572  }
573  else {
574    iterator __new_finish = _M_reserve_elements_at_back(__n);
575    const difference_type __elems_after = difference_type(__length) - __elems_before;
576    __pos = this->_M_finish - __elems_after;
577    _STLP_TRY {
578      iterator __dst = __new_finish;
579      iterator __src = this->_M_finish;
580      for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
581        _STLP_STD::_Move_Construct(&(*__dst), *__src);
582        _STLP_STD::_Destroy_Moved(&(*__src));
583      }
584      this->_M_finish = __new_finish;
585      _STLP_PRIV __ucopy(__first, __last, __pos);
586    }
587    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
588  }
589}
590
591template <class _Tp, class _Alloc >
592void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
593                                            const value_type* __first, const value_type* __last,
594                                            size_type __n, const __false_type& /*_Movable*/) {
595  const difference_type __elems_before = __pos - this->_M_start;
596  size_type __length = size();
597  if (__elems_before <= difference_type(__length / 2)) {
598    iterator __new_start = _M_reserve_elements_at_front(__n);
599    iterator __old_start = this->_M_start;
600    __pos = this->_M_start + __elems_before;
601    _STLP_TRY {
602      if (__elems_before >= difference_type(__n)) {
603        iterator __start_n = this->_M_start + difference_type(__n);
604        _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
605        this->_M_start = __new_start;
606        copy(__start_n, __pos, __old_start);
607        copy(__first, __last, __pos - difference_type(__n));
608      }
609      else {
610        const value_type* __mid = __first + (difference_type(__n) - __elems_before);
611        __uninitialized_copy_copy(this->_M_start, __pos, __first, __mid, __new_start);
612        this->_M_start = __new_start;
613        copy(__mid, __last, __old_start);
614      }
615    }
616    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
617  }
618  else {
619    iterator __new_finish = _M_reserve_elements_at_back(__n);
620    iterator __old_finish = this->_M_finish;
621    const difference_type __elems_after =
622      difference_type(__length) - __elems_before;
623    __pos = this->_M_finish - __elems_after;
624    _STLP_TRY {
625
626      if (__elems_after > difference_type(__n)) {
627        iterator __finish_n = this->_M_finish - difference_type(__n);
628        _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
629        this->_M_finish = __new_finish;
630        copy_backward(__pos, __finish_n, __old_finish);
631        copy(__first, __last, __pos);
632      }
633      else {
634        const value_type* __mid = __first + __elems_after;
635        __uninitialized_copy_copy(__mid, __last, __pos, this->_M_finish, this->_M_finish);
636        this->_M_finish = __new_finish;
637        copy(__first, __mid, __pos);
638      }
639    }
640    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
641  }
642}
643
644template <class _Tp, class _Alloc >
645void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
646                                            const_iterator __first, const_iterator __last,
647                                            size_type __n, const __true_type& /*_Movable*/) {
648  const difference_type __elems_before = __pos - this->_M_start;
649  size_type __length = size();
650  if (__elems_before <= difference_type(__length / 2)) {
651    iterator __new_start = _M_reserve_elements_at_front(__n);
652    __pos = this->_M_start + __elems_before;
653    _STLP_TRY {
654      iterator __dst = __new_start;
655      iterator __src = this->_M_start;
656      for (; __src != __pos; ++__dst, ++__src) {
657        _STLP_STD::_Move_Construct(&(*__dst), *__src);
658        _STLP_STD::_Destroy_Moved(&(*__src));
659      }
660      this->_M_start = __new_start;
661      _STLP_PRIV __ucopy(__first, __last, __dst);
662    }
663    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
664  }
665  else {
666    iterator __new_finish = _M_reserve_elements_at_back(__n);
667    const difference_type __elems_after = difference_type(__length) - __elems_before;
668    __pos = this->_M_finish - __elems_after;
669    _STLP_TRY {
670      iterator __dst = __new_finish;
671      iterator __src = this->_M_finish;
672      for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
673        _STLP_STD::_Move_Construct(&(*__dst), *__src);
674        _STLP_STD::_Destroy_Moved(&(*__src));
675      }
676      this->_M_finish = __new_finish;
677      _STLP_PRIV __ucopy(__first, __last, __pos);
678    }
679    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
680  }
681}
682
683template <class _Tp, class _Alloc >
684void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
685                                            const_iterator __first, const_iterator __last,
686                                            size_type __n, const __false_type& /*_Movable*/) {
687  const difference_type __elems_before = __pos - this->_M_start;
688  size_type __length = size();
689  if (__elems_before < difference_type(__length / 2)) {
690    iterator __new_start = _M_reserve_elements_at_front(__n);
691    iterator __old_start = this->_M_start;
692    __pos = this->_M_start + __elems_before;
693    _STLP_TRY {
694      if (__elems_before >= difference_type(__n)) {
695        iterator __start_n = this->_M_start + __n;
696        _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
697        this->_M_start = __new_start;
698        copy(__start_n, __pos, __old_start);
699        copy(__first, __last, __pos - difference_type(__n));
700      }
701      else {
702        const_iterator __mid = __first + (__n - __elems_before);
703        __uninitialized_copy_copy(this->_M_start, __pos, __first, __mid, __new_start);
704        this->_M_start = __new_start;
705        copy(__mid, __last, __old_start);
706      }
707    }
708    _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
709  }
710  else {
711    iterator __new_finish = _M_reserve_elements_at_back(__n);
712    iterator __old_finish = this->_M_finish;
713    const difference_type __elems_after = __length - __elems_before;
714    __pos = this->_M_finish - __elems_after;
715    _STLP_TRY {
716      if (__elems_after > difference_type(__n)) {
717        iterator __finish_n = this->_M_finish - difference_type(__n);
718        _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
719        this->_M_finish = __new_finish;
720        copy_backward(__pos, __finish_n, __old_finish);
721        copy(__first, __last, __pos);
722      }
723      else {
724        const_iterator __mid = __first + __elems_after;
725        __uninitialized_copy_copy(__mid, __last, __pos, this->_M_finish, this->_M_finish);
726        this->_M_finish = __new_finish;
727        copy(__first, __mid, __pos);
728      }
729    }
730    _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
731  }
732}
733#endif /* _STLP_MEMBER_TEMPLATES */
734
735template <class _Tp, class _Alloc >
736void deque<_Tp,_Alloc>::_M_new_elements_at_front(size_type __new_elems) {
737  size_type __new_nodes
738      = (__new_elems + this->buffer_size() - 1) / this->buffer_size();
739  _M_reserve_map_at_front(__new_nodes);
740  size_type __i = 1;
741  _STLP_TRY {
742    for (; __i <= __new_nodes; ++__i)
743      *(this->_M_start._M_node - __i) = this->_M_map_size.allocate(this->buffer_size());
744  }
745  _STLP_UNWIND(for (size_type __j = 1; __j < __i; ++__j)
746                 this->_M_map_size.deallocate(*(this->_M_start._M_node - __j), this->buffer_size()))
747}
748
749template <class _Tp, class _Alloc >
750void deque<_Tp,_Alloc>::_M_new_elements_at_back(size_type __new_elems) {
751  size_type __new_nodes
752      = (__new_elems + this->buffer_size() - 1) / this->buffer_size();
753  _M_reserve_map_at_back(__new_nodes);
754  size_type __i = 1;
755  _STLP_TRY {
756    for (; __i <= __new_nodes; ++__i)
757      *(this->_M_finish._M_node + __i) = this->_M_map_size.allocate(this->buffer_size());
758  }
759  _STLP_UNWIND(for (size_type __j = 1; __j < __i; ++__j)
760                 this->_M_map_size.deallocate(*(this->_M_finish._M_node + __j), this->buffer_size()))
761}
762
763template <class _Tp, class _Alloc >
764void deque<_Tp,_Alloc>::_M_reallocate_map(size_type __nodes_to_add,
765                                          bool __add_at_front) {
766  size_type __old_num_nodes = this->_M_finish._M_node - this->_M_start._M_node + 1;
767  size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
768
769  _Map_pointer __new_nstart;
770  if (this->_M_map_size._M_data > 2 * __new_num_nodes) {
771    __new_nstart = this->_M_map._M_data + (this->_M_map_size._M_data - __new_num_nodes) / 2
772                     + (__add_at_front ? __nodes_to_add : 0);
773    if (__new_nstart < this->_M_start._M_node)
774      copy(this->_M_start._M_node, this->_M_finish._M_node + 1, __new_nstart);
775    else
776      copy_backward(this->_M_start._M_node, this->_M_finish._M_node + 1,
777                    __new_nstart + __old_num_nodes);
778  }
779  else {
780    size_type __new_map_size =
781      this->_M_map_size._M_data + (max)((size_t)this->_M_map_size._M_data, __nodes_to_add) + 2;
782
783    _Map_pointer __new_map = this->_M_map.allocate(__new_map_size);
784    __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
785                         + (__add_at_front ? __nodes_to_add : 0);
786    copy(this->_M_start._M_node, this->_M_finish._M_node + 1, __new_nstart);
787    this->_M_map.deallocate(this->_M_map._M_data, this->_M_map_size._M_data);
788
789    this->_M_map._M_data = __new_map;
790    this->_M_map_size._M_data = __new_map_size;
791  }
792
793  this->_M_start._M_set_node(__new_nstart);
794  this->_M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
795}
796
797#if defined (deque)
798#  undef deque
799_STLP_MOVE_TO_STD_NAMESPACE
800#endif
801
802_STLP_END_NAMESPACE
803
804#undef __iterator__
805#undef iterator
806#undef const_iterator
807#undef size_type
808#undef value_type
809
810#endif /*  _STLP_DEQUE_C */
811
812// Local Variables:
813// mode:C++
814// End: