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