Public Types |
Public Member Functions |
Public Attributes |
Protected Types |
Protected Member Functions |
Protected Attributes |
Private Types |
Private Member Functions |
Private Attributes |
List of all members
deque< _Tp, > Class Template Reference
#include <_deque.h>
Inheritance diagram for deque< _Tp, >:
Collaboration diagram for deque< _Tp, >:
Public Attributes | |
| _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS | |
Protected Types | |
| typedef pointer * | _Map_pointer |
Protected Attributes | |
| _Base | _M_non_dbg_impl |
| _STLP_PRIV __owned_list | _M_iter_list |
Private Types | |
| typedef _STLP_PRIV _Deque_base< _Tp, _Alloc > | _Base |
| typedef deque< _Tp, _Alloc > | _Self |
| typedef deque< _Tp, _Alloc > | _Self |
| typedef _STLP_NON_DBG_DEQUE | _Base |
| typedef _STLP_PRIV __construct_checker< _STLP_NON_DBG_DEQUE > | _ConstructCheck |
| typedef _STLP_TYPENAME _STLP_PRIV _StorageType< _Tp >::_Type | _StorageType |
| typedef _Alloc_traits< _StorageType, _Alloc >::allocator_type | _StorageTypeAlloc |
| typedef _STLP_PRIV DEQUE_IMPL< _StorageType, _StorageTypeAlloc > | _Base |
| typedef deque< _Tp, _Alloc > | _Self |
| typedef _STLP_PRIV _CastTraits< _StorageType, _Tp > | cast_traits |
| typedef _STLP_PRIV _DequeIteCast< _StorageType, _Tp > | ite_cast_traits |
Private Member Functions | |
| void | _M_initialize (size_type __n, const value_type &__val=_STLP_DEFAULT_CONSTRUCTED(_Tp)) |
Private Attributes | |
| _Base | _M_impl |
Detailed Description
Member Typedef Documentation
◆ _Base [1/3]
|
private |
◆ _Base [2/3]
|
private |
◆ _Base [3/3]
|
private |
◆ _ConstructCheck
|
private |
◆ _Iterator_category [1/2]
| typedef random_access_iterator_tag deque< _Tp, >::_Iterator_category |
◆ _Iterator_category [2/2]
| typedef random_access_iterator_tag deque< _Tp, >::_Iterator_category |
◆ _Map_pointer
◆ _Self [1/3]
◆ _Self [2/3]
◆ _Self [3/3]
◆ _StorageType
|
private |
◆ _StorageTypeAlloc
|
private |
◆ allocator_type [1/2]
| typedef _Base::allocator_type deque< _Tp, >::allocator_type |
◆ allocator_type [2/2]
| typedef _Alloc_traits<value_type,_Alloc>::allocator_type deque< _Tp, >::allocator_type |
◆ cast_traits
|
private |
◆ const_iterator [1/3]
| typedef _Base::const_iterator deque< _Tp, >::const_iterator |
◆ const_iterator [2/3]
| typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Const_traits<value_type> > > deque< _Tp, >::const_iterator |
◆ const_iterator [3/3]
| typedef _STLP_PRIV _Deque_iterator<value_type, _Const_traits<value_type> > deque< _Tp, >::const_iterator |
◆ const_pointer [1/2]
| typedef const value_type* deque< _Tp, >::const_pointer |
◆ const_pointer [2/2]
| typedef const value_type* deque< _Tp, >::const_pointer |
◆ const_reference [1/2]
| typedef const value_type& deque< _Tp, >::const_reference |
◆ const_reference [2/2]
| typedef const value_type& deque< _Tp, >::const_reference |
◆ difference_type [1/2]
◆ difference_type [2/2]
◆ ite_cast_traits
|
private |
◆ iterator [1/3]
| typedef _Base::iterator deque< _Tp, >::iterator |
◆ iterator [2/3]
| typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Nonconst_traits<value_type> > > deque< _Tp, >::iterator |
◆ iterator [3/3]
| typedef _STLP_PRIV _Deque_iterator<value_type, _Nonconst_traits<value_type> > deque< _Tp, >::iterator |
◆ pointer [1/2]
| typedef value_type* deque< _Tp, >::pointer |
◆ pointer [2/2]
| typedef value_type* deque< _Tp, >::pointer |
◆ reference [1/2]
| typedef value_type& deque< _Tp, >::reference |
◆ reference [2/2]
| typedef value_type& deque< _Tp, >::reference |
◆ size_type [1/2]
◆ size_type [2/2]
◆ value_type [1/2]
| typedef _Tp deque< _Tp, >::value_type |
◆ value_type [2/2]
| typedef _Tp deque< _Tp, >::value_type |
Constructor & Destructor Documentation
◆ deque() [1/19]
|
inlineexplicit |
◆ deque() [2/19]
Definition at line 486 of file _deque.h.
_STLP_BEGIN_NAMESPACE _STLP_MOVE_TO_PRIV_NAMESPACE _OutputIter __ucopy(_InputIter __first, _InputIter __last, _OutputIter __result, _Distance *)
Definition: _uninitialized.h:52
◆ deque() [3/19]
Definition at line 497 of file _deque.h.
void _M_initialize(size_type __n, const value_type &__val=_STLP_DEFAULT_CONSTRUCTED(_Tp))
Definition: _deque.h:492
◆ deque() [4/19]
|
inline |
Definition at line 500 of file _deque.h.
506 }
511#endif
void _M_fill_initialize(const value_type &__val, const __true_type &)
Definition: _deque.h:859
Definition: boost_type_traits.h:133
Definition: type_manips.h:24
◆ deque() [5/19]
|
inline |
◆ deque() [6/19]
|
inline |
◆ deque() [7/19]
|
inline |
Definition at line 561 of file _deque.h.
563 {}
Definition: _move_construct_fwk.h:35
◆ ~deque()
◆ deque() [8/19]
|
inlineexplicit |
◆ deque() [9/19]
Definition at line 131 of file _deque.h.
131 :
_STLP_PRIV __construct_checker< _STLP_NON_DBG_DEQUE > _ConstructCheck
Definition: _deque.h:62
◆ deque() [10/19]
|
inlineexplicit |
◆ deque() [11/19]
|
inline |
◆ deque() [12/19]
|
inline |
◆ deque() [13/19]
|
inline |
◆ deque() [14/19]
|
inlineexplicit |
Definition at line 159 of file _deque.h.
Definition: _tools.h:142
◆ deque() [15/19]
◆ deque() [16/19]
|
inlineexplicit |
Definition at line 165 of file _deque.h.
170 : _M_impl(__n, cast_traits::to_storage_type_cref(__val), _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
◆ deque() [17/19]
|
inline |
◆ deque() [18/19]
|
inline |
◆ deque() [19/19]
Member Function Documentation
◆ _Invalidate_all()
Definition at line 78 of file _deque.h.
79 { _M_iter_list._Invalidate_all(); }
Referenced by deque< _Tp, >::assign(), deque< _Tp, >::clear(), deque< _Tp, >::erase(), deque< _Tp, >::insert(), deque< _Tp, >::operator=(), deque< _Tp, >::push_back(), deque< _Tp, >::push_front(), and deque< _Tp, >::resize().
◆ _Invalidate_iterator()
Definition at line 80 of file _deque.h.
_STLP_MOVE_TO_PRIV_NAMESPACE const _InputIterator const input_iterator_tag &_InputIterator __it(__first)
Referenced by deque< _Tp, >::erase(), deque< _Tp, >::pop_back(), deque< _Tp, >::pop_front(), and deque< _Tp, >::resize().
◆ _Invalidate_iterators()
|
inlineprotected |
◆ _M_erase() [1/4]
|
protected |
Definition at line 324 of file _deque.c.
325 {
327 difference_type __elems_before = __first - this->_M_start;
331 _STLP_STD::_Destroy_Range(this->_M_start, __new_start);
332 this->_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
333 this->_M_start = __new_start;
334 }
335 else {
336 _STLP_STD::copy(__last, this->_M_finish, __first);
338 _STLP_STD::_Destroy_Range(__new_finish, this->_M_finish);
339 this->_M_destroy_nodes(__new_finish._M_node + 1, this->_M_finish._M_node + 1);
340 this->_M_finish = __new_finish;
341 }
342 return this->_M_start + __elems_before;
343}
_STLP_MOVE_TO_STD_NAMESPACE _OutputIter copy_backward(_InputIter __first, _InputIter __last, _OutputIter __result)
Definition: _algobase.h:328
Definition: _iterator_base.h:59
◆ _M_erase() [2/4]
|
protected |
Definition at line 260 of file _deque.c.
261 {
263 difference_type __elems_before = __first - this->_M_start;
266 if (__src != this->_M_start) {
267 for (--__src, --__dst; (__src >= this->_M_start) && (__dst >= __first); --__src, --__dst) {
268 _STLP_STD::_Destroy(&(*__dst));
269 _STLP_STD::_Move_Construct(&(*__dst), *__src);
270 }
271 if (__dst >= __first) {
272 //There are more elements to erase than elements to move
273 _STLP_STD::_Destroy_Range(__first, ++__dst);
274 _STLP_STD::_Destroy_Moved_Range(this->_M_start, __first);
275 }
276 else {
277 //There are more elements to move than elements to erase
278 for (; __src >= this->_M_start; --__src, --__dst) {
279 _STLP_STD::_Destroy_Moved(&(*__dst));
280 _STLP_STD::_Move_Construct(&(*__dst), *__src);
281 }
282 _STLP_STD::_Destroy_Moved_Range(this->_M_start, ++__dst);
283 }
284 }
285 else {
286 _STLP_STD::_Destroy_Range(this->_M_start, __last);
287 }
289 this->_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
290 this->_M_start = __new_start;
291 }
292 else {
296 _STLP_STD::_Destroy(&(*__dst));
297 _STLP_STD::_Move_Construct(&(*__dst), *__src);
298 }
300 //There are more elements to erase than elements to move
301 _STLP_STD::_Destroy_Range(__dst, __last);
302 _STLP_STD::_Destroy_Moved_Range(__last, this->_M_finish);
303 }
304 else {
305 //There are more elements to move than elements to erase
306 for (; __src != this->_M_finish; ++__src, ++__dst) {
307 _STLP_STD::_Destroy_Moved(&(*__dst));
308 _STLP_STD::_Move_Construct(&(*__dst), *__src);
309 }
310 _STLP_STD::_Destroy_Moved_Range(__dst, this->_M_finish);
311 }
312 }
313 else {
314 _STLP_STD::_Destroy_Range(__first, this->_M_finish);
315 }
317 this->_M_destroy_nodes(__new_finish._M_node + 1, this->_M_finish._M_node + 1);
318 this->_M_finish = __new_finish;
319 }
320 return this->_M_start + __elems_before;
321}
◆ _M_erase() [3/4]
|
protected |
Definition at line 243 of file _deque.c.
244 {
245 iterator __next = __pos;
246 ++__next;
247 difference_type __index = __pos - this->_M_start;
249 copy_backward(this->_M_start, __pos, __next);
250 pop_front();
251 }
252 else {
253 _STLP_STD::copy(__next, this->_M_finish, __pos);
254 pop_back();
255 }
256 return this->_M_start + __index;
257}
◆ _M_erase() [4/4]
|
protected |
Definition at line 208 of file _deque.c.
209 {
210 difference_type __index = __pos - this->_M_start;
212 //We move the start of the deque one position to the right
213 //starting from the rightmost element to move.
214 iterator __src = __pos, __dst = __pos;
215 _STLP_STD::_Destroy(&(*__dst));
216 if (__src != this->_M_start) {
217 for (--__src; __dst != this->_M_start; --__src, --__dst) {
218 _STLP_STD::_Move_Construct(&(*__dst), *__src);
219 _STLP_STD::_Destroy_Moved(&(*__src));
220 }
221 }
222 _M_pop_front_aux();
223 }
224 else {
225 iterator __src = __pos, __dst = __pos;
226 _STLP_STD::_Destroy(&(*__dst));
227 for (++__src; __src != this->_M_finish; ++__src, ++__dst) {
228 _STLP_STD::_Move_Construct(&(*__dst), *__src);
229 _STLP_STD::_Destroy_Moved(&(*__src));
230 }
231 //Duplication of the pop_back code without the destroy which has already been done:
232 if (this->_M_finish._M_cur != this->_M_finish._M_first) {
233 --this->_M_finish._M_cur;
234 }
235 else {
236 _M_pop_back_aux();
237 }
238 }
239 return this->_M_start + __index;
240}
Referenced by deque< _Tp, >::erase(), and deque< _Tp, >::resize().
◆ _M_fill_assign()
Definition at line 587 of file _deque.h.
587 {
591 }
592 else {
595 }
596 }
Referenced by deque< _Tp, >::assign().
◆ _M_fill_initialize() [1/2]
|
protected |
Definition at line 368 of file _deque.c.
369 {
370 _Map_pointer __cur = this->_M_start._M_node;
371 _STLP_TRY {
372 for (; __cur < this->_M_finish._M_node; ++__cur)
375 }
377}
_STLP_MOVE_TO_STD_NAMESPACE void uninitialized_fill(_ForwardIter __first, _ForwardIter __last, const _Tp &__x)
Definition: _uninitialized.h:258
◆ _M_fill_initialize() [2/2]
|
inlineprotected |
Definition at line 859 of file _deque.h.
860 {}
Referenced by deque< _Tp, >::_M_initialize(), and deque< _Tp, >::deque().
◆ _M_fill_insert()
|
protected |
Definition at line 122 of file _deque.c.
123 {
124#if !defined (_STLP_NO_MOVE_SEMANTIC)
126#endif
127 if (__pos._M_cur == this->_M_start._M_cur) {
129 _STLP_TRY {
130 uninitialized_fill(__new_start, this->_M_start, __x);
131 }
132 _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
133 this->_M_start = __new_start;
134 }
137 _STLP_TRY {
138 uninitialized_fill(this->_M_finish, __new_finish, __x);
139 }
140 _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node+1, __new_finish._M_node+1))
141 this->_M_finish = __new_finish;
142 }
143 else
145}
iterator _M_fill_insert_aux(iterator __pos, size_type __n, const value_type &__x, const __true_type &)
Definition: _deque.c:464
iterator _M_reserve_elements_at_back(size_type __n)
Definition: _deque.h:1044
iterator _M_reserve_elements_at_front(size_type __n)
Definition: _deque.h:1037
Referenced by deque< _Tp, >::insert().
◆ _M_fill_insert_aux() [1/2]
|
protected |
Definition at line 506 of file _deque.c.
508 {
511 value_type __x_copy = __x;
514 iterator __old_start = this->_M_start;
515 __pos = this->_M_start + __elems_before;
516 _STLP_TRY {
520 this->_M_start = __new_start;
521 _STLP_STD::copy(__start_n, __pos, __old_start);
524 }
525 else {
527 this->_M_start, __x_copy);
528 this->_M_start = __new_start;
529 fill(__old_start, __pos, __x_copy);
530 }
531 }
532 _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
533 }
534 else {
536 iterator __old_finish = this->_M_finish;
538 difference_type(__length) - __elems_before;
539 __pos = this->_M_finish - __elems_after;
540 _STLP_TRY {
544 this->_M_finish = __new_finish;
545 copy_backward(__pos, __finish_n, __old_finish);
547 }
548 else {
550 __x_copy, __pos, this->_M_finish);
551 this->_M_finish = __new_finish;
552 fill(__pos, __old_finish, __x_copy);
553 }
554 }
555 _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
556 }
557 return __pos;
558}
_STLP_MOVE_TO_STD_NAMESPACE void fill(_ForwardIter __first, _ForwardIter __last, const _Tp &__val)
Definition: _algobase.h:449
void __uninitialized_copy_fill(_Iter __first1, _Iter __last1, _Iter __first2, _Iter __last2, const _Tp &__x)
Definition: _uninitialized.h:404
_ForwardIter __uninitialized_fill_copy(_ForwardIter __result, _ForwardIter __mid, const _Tp &__x, _InputIter __first, _InputIter __last)
Definition: _uninitialized.h:389
◆ _M_fill_insert_aux() [2/2]
|
protected |
Definition at line 464 of file _deque.c.
466 {
469 value_type __x_copy = __x;
472 __pos = this->_M_start + __elems_before;
473 _STLP_TRY {
474 iterator __dst = __new_start;
475 iterator __src = this->_M_start;
476 for (; __src != __pos; ++__dst, ++__src) {
477 _STLP_STD::_Move_Construct(&(*__dst), *__src);
478 _STLP_STD::_Destroy_Moved(&(*__src));
479 }
480 this->_M_start = __new_start;
481 uninitialized_fill(__dst, __src, __x_copy);
482 __pos = __dst;
483 }
484 _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
485 }
486 else {
489 __pos = this->_M_finish - __elems_after;
490 _STLP_TRY {
491 iterator __dst = __new_finish;
492 iterator __src = this->_M_finish;
493 for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
494 _STLP_STD::_Move_Construct(&(*__dst), *__src);
495 _STLP_STD::_Destroy_Moved(&(*__src));
496 }
497 this->_M_finish = __new_finish;
499 }
500 _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
501 }
502 return __pos;
503}
Referenced by deque< _Tp, >::insert().
◆ _M_initialize()
|
inlineprivate |
◆ _M_insert_range_aux() [1/4]
|
protected |
Definition at line 601 of file _deque.c.
603 {
608 iterator __old_start = this->_M_start;
609 __pos = this->_M_start + __elems_before;
610 _STLP_TRY {
614 this->_M_start = __new_start;
615 _STLP_STD::copy(__start_n, __pos, __old_start);
617 }
618 else {
621 this->_M_start = __new_start;
622 _STLP_STD::copy(__mid, __last, __old_start);
623 }
624 }
625 _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
626 }
627 else {
629 iterator __old_finish = this->_M_finish;
631 difference_type(__length) - __elems_before;
632 __pos = this->_M_finish - __elems_after;
633 _STLP_TRY {
634
638 this->_M_finish = __new_finish;
639 _STLP_STD::copy_backward(__pos, __finish_n, __old_finish);
640 _STLP_STD::copy(__first, __last, __pos);
641 }
642 else {
645 this->_M_finish = __new_finish;
646 _STLP_STD::copy(__first, __mid, __pos);
647 }
648 }
649 _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
650 }
651}
_STLP_MOVE_TO_PRIV_NAMESPACE _ForwardIter __uninitialized_copy_copy(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _ForwardIter __result)
Definition: _uninitialized.h:373
◆ _M_insert_range_aux() [2/4]
|
protected |
Definition at line 562 of file _deque.c.
564 {
569 __pos = this->_M_start + __elems_before;
570 _STLP_TRY {
571 iterator __dst = __new_start;
572 iterator __src = this->_M_start;
573 for (; __src != __pos; ++__dst, ++__src) {
574 _STLP_STD::_Move_Construct(&(*__dst), *__src);
575 _STLP_STD::_Destroy_Moved(&(*__src));
576 }
577 this->_M_start = __new_start;
579 }
580 _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
581 }
582 else {
585 __pos = this->_M_finish - __elems_after;
586 _STLP_TRY {
587 iterator __dst = __new_finish;
588 iterator __src = this->_M_finish;
589 for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
590 _STLP_STD::_Move_Construct(&(*__dst), *__src);
591 _STLP_STD::_Destroy_Moved(&(*__src));
592 }
593 this->_M_finish = __new_finish;
595 }
596 _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
597 }
598}
◆ _M_insert_range_aux() [3/4]
|
protected |
Definition at line 693 of file _deque.c.
695 {
700 iterator __old_start = this->_M_start;
701 __pos = this->_M_start + __elems_before;
702 _STLP_TRY {
706 this->_M_start = __new_start;
707 _STLP_STD::copy(__start_n, __pos, __old_start);
709 }
710 else {
713 this->_M_start = __new_start;
714 _STLP_STD::copy(__mid, __last, __old_start);
715 }
716 }
717 _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
718 }
719 else {
721 iterator __old_finish = this->_M_finish;
723 __pos = this->_M_finish - __elems_after;
724 _STLP_TRY {
728 this->_M_finish = __new_finish;
729 _STLP_STD::copy_backward(__pos, __finish_n, __old_finish);
730 _STLP_STD::copy(__first, __last, __pos);
731 }
732 else {
733 const_iterator __mid = __first + __elems_after;
735 this->_M_finish = __new_finish;
736 _STLP_STD::copy(__first, __mid, __pos);
737 }
738 }
739 _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
740 }
741}
◆ _M_insert_range_aux() [4/4]
|
protected |
Definition at line 654 of file _deque.c.
656 {
661 __pos = this->_M_start + __elems_before;
662 _STLP_TRY {
663 iterator __dst = __new_start;
664 iterator __src = this->_M_start;
665 for (; __src != __pos; ++__dst, ++__src) {
666 _STLP_STD::_Move_Construct(&(*__dst), *__src);
667 _STLP_STD::_Destroy_Moved(&(*__src));
668 }
669 this->_M_start = __new_start;
671 }
672 _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
673 }
674 else {
677 __pos = this->_M_finish - __elems_after;
678 _STLP_TRY {
679 iterator __dst = __new_finish;
680 iterator __src = this->_M_finish;
681 for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
682 _STLP_STD::_Move_Construct(&(*__dst), *__src);
683 _STLP_STD::_Destroy_Moved(&(*__src));
684 }
685 this->_M_finish = __new_finish;
687 }
688 _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
689 }
690}
◆ _M_new_elements_at_back()
Definition at line 759 of file _deque.c.
759 {
760 size_type __new_nodes
762 _M_reserve_map_at_back(__new_nodes);
763 size_type __i = 1;
764 _STLP_TRY {
765 for (; __i <= __new_nodes; ++__i)
766 *(this->_M_finish._M_node + __i) = this->_M_map_size.allocate(this->buffer_size());
767 }
769 this->_M_map_size.deallocate(*(this->_M_finish._M_node + __j), this->buffer_size()))
770}
void _M_reserve_map_at_back(size_type __nodes_to_add=1)
Definition: _deque.h:1060
Referenced by deque< _Tp, >::_M_reserve_elements_at_back().
◆ _M_new_elements_at_front()
Definition at line 745 of file _deque.c.
745 {
746 size_type __new_nodes
748 _M_reserve_map_at_front(__new_nodes);
749 size_type __i = 1;
750 _STLP_TRY {
751 for (; __i <= __new_nodes; ++__i)
752 *(this->_M_start._M_node - __i) = this->_M_map_size.allocate(this->buffer_size());
753 }
755 this->_M_map_size.deallocate(*(this->_M_start._M_node - __j), this->buffer_size()))
756}
void _M_reserve_map_at_front(size_type __nodes_to_add=1)
Definition: _deque.h:1065
Referenced by deque< _Tp, >::_M_reserve_elements_at_front().
◆ _M_pop_back_aux()
Definition at line 443 of file _deque.c.
443 {
444 this->_M_map_size.deallocate(this->_M_finish._M_first, this->buffer_size());
445 this->_M_finish._M_set_node(this->_M_finish._M_node - 1);
446 this->_M_finish._M_cur = this->_M_finish._M_last - 1;
447}
Referenced by deque< _Tp, >::pop_back().
◆ _M_pop_front_aux()
Definition at line 453 of file _deque.c.
453 {
454 if (this->_M_start._M_cur != this->_M_start._M_last - 1)
455 ++this->_M_start._M_cur;
456 else {
457 this->_M_map_size.deallocate(this->_M_start._M_first, this->buffer_size());
458 this->_M_start._M_set_node(this->_M_start._M_node + 1);
459 this->_M_start._M_cur = this->_M_start._M_first;
460 }
461}
Referenced by deque< _Tp, >::pop_front().
◆ _M_push_back_aux_v()
|
protected |
Definition at line 382 of file _deque.c.
382 {
383 _M_reserve_map_at_back();
384 *(this->_M_finish._M_node + 1) = this->_M_map_size.allocate(this->buffer_size());
385 _STLP_TRY {
386 _Copy_Construct(this->_M_finish._M_cur, __t);
387 this->_M_finish._M_set_node(this->_M_finish._M_node + 1);
388 this->_M_finish._M_cur = this->_M_finish._M_first;
389 }
390 _STLP_UNWIND(this->_M_map_size.deallocate(*(this->_M_finish._M_node + 1),
391 this->buffer_size()))
392}
Referenced by deque< _Tp, >::push_back().
◆ _M_push_front_aux_v()
|
protected |
Definition at line 412 of file _deque.c.
412 {
413 _M_reserve_map_at_front();
414 *(this->_M_start._M_node - 1) = this->_M_map_size.allocate(this->buffer_size());
415 _STLP_TRY {
416 this->_M_start._M_set_node(this->_M_start._M_node - 1);
417 this->_M_start._M_cur = this->_M_start._M_last - 1;
418 _Copy_Construct(this->_M_start._M_cur, __t);
419 }
420 _STLP_UNWIND((++this->_M_start,
421 this->_M_map_size.deallocate(*(this->_M_start._M_node - 1), this->buffer_size())))
422}
Referenced by deque< _Tp, >::push_front().
◆ _M_range_check()
Definition at line 449 of file _deque.h.
449 {
452 }
_STLP_THROW_FUNCT_SPEC _STLP_CALL __stl_throw_out_of_range(const char *__msg)
Definition: _range_errors.c:69
Referenced by deque< _Tp, >::at().
◆ _M_reallocate_map()
|
protected |
Definition at line 773 of file _deque.c.
774 {
775 size_type __old_num_nodes = this->_M_finish._M_node - this->_M_start._M_node + 1;
776 size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
777
778 _Map_pointer __new_nstart;
779 if (this->_M_map_size._M_data > 2 * __new_num_nodes) {
780 __new_nstart = this->_M_map._M_data + (this->_M_map_size._M_data - __new_num_nodes) / 2
781 + (__add_at_front ? __nodes_to_add : 0);
782 if (__new_nstart < this->_M_start._M_node)
783 _STLP_STD::copy(this->_M_start._M_node, this->_M_finish._M_node + 1, __new_nstart);
784 else
785 _STLP_STD::copy_backward(this->_M_start._M_node, this->_M_finish._M_node + 1,
786 __new_nstart + __old_num_nodes);
787 }
788 else {
789 size_type __new_map_size =
791
792 _Map_pointer __new_map = this->_M_map.allocate(__new_map_size);
793 __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
794 + (__add_at_front ? __nodes_to_add : 0);
795 _STLP_STD::copy(this->_M_start._M_node, this->_M_finish._M_node + 1, __new_nstart);
796 this->_M_map.deallocate(this->_M_map._M_data, this->_M_map_size._M_data);
797
798 this->_M_map._M_data = __new_map;
799 this->_M_map_size._M_data = __new_map_size;
800 }
801
802 this->_M_start._M_set_node(__new_nstart);
803 this->_M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
804}
Referenced by deque< _Tp, >::_M_reserve_map_at_back(), and deque< _Tp, >::_M_reserve_map_at_front().
◆ _M_reserve_elements_at_back()
Definition at line 1044 of file _deque.h.
1044 {
1045 size_type __vacancies = (this->_M_finish._M_last - this->_M_finish._M_cur) - 1;
1049 }
void _M_new_elements_at_back(size_type __new_elements)
Definition: _deque.c:759
◆ _M_reserve_elements_at_front()
Definition at line 1037 of file _deque.h.
1037 {
1038 size_type __vacancies = this->_M_start._M_cur - this->_M_start._M_first;
1042 }
void _M_new_elements_at_front(size_type __new_elements)
Definition: _deque.c:745
◆ _M_reserve_map_at_back()
Definition at line 1060 of file _deque.h.
1060 {
1061 if (__nodes_to_add + 1 > this->_M_map_size._M_data - (this->_M_finish._M_node - this->_M_map._M_data))
1063 }
void _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
Definition: _deque.c:773
◆ _M_reserve_map_at_front()
◆ assign() [1/9]
|
inline |
◆ assign() [2/9]
|
inline |
◆ assign() [3/9]
|
inline |
◆ assign() [4/9]
|
inline |
◆ assign() [5/9]
|
inline |
◆ assign() [6/9]
|
inline |
◆ assign() [7/9]
Definition at line 598 of file _deque.h.
598 {
600 }
Referenced by MoveConstructorTest::deque_test(), and PtrSpecTest::ptr_specialization_test().
◆ assign() [8/9]
◆ assign() [9/9]
|
inline |
◆ at() [1/6]
◆ at() [2/6]
◆ at() [3/6]
◆ at() [4/6]
|
inline |
◆ at() [5/6]
|
inline |
◆ at() [6/6]
|
inline |
◆ back() [1/6]
◆ back() [2/6]
◆ back() [3/6]
◆ back() [4/6]
|
inline |
◆ back() [5/6]
|
inline |
◆ back() [6/6]
|
inline |
◆ begin() [1/6]
Definition at line 432 of file _deque.h.
432{ return this->_M_start; }
Referenced by deque< _Tp, >::_M_fill_assign(), deque< _Tp, >::assign(), deque< _Tp, >::deque(), MoveConstructorTest::deque_test(), DequeTest::erase(), deque< _Tp, >::erase(), deque< _Tp, >::front(), MoveConstructorTest::move_traits_deq(), MoveConstructorTest::move_traits_deq_complete(), deque< _Tp, >::operator=(), DequeTest::optimizations_check(), deque< _Tp, >::pop_front(), PtrSpecTest::ptr_specialization_test(), deque< _Tp, >::rend(), StringTest::replace(), AlgTest::search_n_test(), and AlgTest::sort_test().
◆ begin() [2/6]
◆ begin() [3/6]
◆ begin() [4/6]
|
inline |
◆ begin() [5/6]
|
inline |
◆ begin() [6/6]
|
inline |
◆ clear() [1/3]
Definition at line 346 of file _deque.c.
346 {
348 __node < this->_M_finish._M_node;
349 ++__node) {
350 _STLP_STD::_Destroy_Range(*__node, *__node + this->buffer_size());
351 this->_M_map_size.deallocate(*__node, this->buffer_size());
352 }
353
354 if (this->_M_start._M_node != this->_M_finish._M_node) {
355 _STLP_STD::_Destroy_Range(this->_M_start._M_cur, this->_M_start._M_last);
356 _STLP_STD::_Destroy_Range(this->_M_finish._M_first, this->_M_finish._M_cur);
357 this->_M_map_size.deallocate(this->_M_finish._M_first, this->buffer_size());
358 }
359 else
360 _STLP_STD::_Destroy_Range(this->_M_start._M_cur, this->_M_finish._M_cur);
361
362 this->_M_finish = this->_M_start;
363}
Referenced by deque< _Tp, >::erase().
◆ clear() [2/3]
◆ clear() [3/3]
◆ empty() [1/3]
Definition at line 473 of file _deque.h.
473{ return this->_M_finish == this->_M_start; }
Referenced by deque< _Tp, >::back(), deque< _Tp, >::erase(), deque< _Tp, >::front(), deque< _Tp, >::pop_back(), deque< _Tp, >::pop_front(), and BtrfsPropSheet::search_list_thread().
◆ empty() [2/3]
◆ empty() [3/3]
◆ end() [1/6]
Definition at line 433 of file _deque.h.
433{ return this->_M_finish; }
Referenced by deque< _Tp, >::_M_fill_assign(), deque< _Tp, >::assign(), deque< _Tp, >::back(), deque< _Tp, >::deque(), MoveConstructorTest::deque_test(), DequeTest::erase(), deque< _Tp, >::erase(), MoveConstructorTest::move_traits_deq(), MoveConstructorTest::move_traits_deq_complete(), deque< _Tp, >::operator=(), DequeTest::optimizations_check(), deque< _Tp, >::pop_back(), PtrSpecTest::ptr_specialization_test(), deque< _Tp, >::rbegin(), StringTest::replace(), deque< _Tp, >::resize(), AlgTest::search_n_test(), and AlgTest::sort_test().
◆ end() [2/6]
◆ end() [3/6]
◆ end() [4/6]
|
inline |
◆ end() [5/6]
|
inline |
◆ end() [6/6]
|
inline |
◆ erase() [1/6]
◆ erase() [2/6]
Definition at line 388 of file _deque.h.
388 {
394 else
395 _Invalidate_all();
396 }
397 return iterator (&_M_iter_list, _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator));
398 }
void _Invalidate_iterators(const iterator &__first, const iterator &__last)
Definition: _deque.h:82
◆ erase() [3/6]
◆ erase() [4/6]
Definition at line 835 of file _deque.h.
835 {
836#if !defined (_STLP_NO_MOVE_SEMANTIC)
838#endif
840 }
Referenced by deque< _Tp, >::_M_fill_assign(), deque< _Tp, >::assign(), MoveConstructorTest::deque_test(), DequeTest::erase(), MoveConstructorTest::move_traits_deq(), MoveConstructorTest::move_traits_deq_complete(), and deque< _Tp, >::resize().
◆ erase() [5/6]
Definition at line 373 of file _deque.h.
373 {
377 _Invalidate_iterator(__pos);
378 } else {
380 if (__pos._M_iterator == tmp)
381 _Invalidate_iterator(__pos);
382 else
383 _Invalidate_all();
384 }
386 }
◆ erase() [6/6]
◆ front() [1/6]
Definition at line 458 of file _deque.h.
458{ return *this->_M_start; }
Referenced by MoveConstructorTest::deque_test(), and BtrfsPropSheet::search_list_thread().
◆ front() [2/6]
◆ front() [3/6]
◆ front() [4/6]
|
inline |
◆ front() [5/6]
|
inline |
◆ front() [6/6]
|
inline |
◆ get_allocator() [1/3]
|
inline |
◆ get_allocator() [2/3]
|
inline |
◆ get_allocator() [3/3]
|
inline |
◆ insert() [1/13]
|
inline |
_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS
Definition at line 730 of file _deque.h.
730 {
731#else
733#endif
734#if !defined (_STLP_NO_MOVE_SEMANTIC)
736#endif
737 if (__pos._M_cur == this->_M_start._M_cur) {
738 push_front(__x);
739 return this->_M_start;
740 }
741 else if (__pos._M_cur == this->_M_finish._M_cur) {
742 push_back(__x);
743 iterator __tmp = this->_M_finish;
744 --__tmp;
745 return __tmp;
746 }
747 else {
749 }
750 }
void push_back(const value_type &__t=_STLP_DEFAULT_CONSTRUCTED(_Tp))
Definition: _deque.h:668
void push_front(const value_type &__t=_STLP_DEFAULT_CONSTRUCTED(_Tp))
Definition: _deque.h:680
Referenced by MoveConstructorTest::deque_test(), MoveConstructorTest::move_traits_deq(), MoveConstructorTest::move_traits_deq_complete(), DequeTest::optimizations_check(), and PtrSpecTest::ptr_specialization_test().
◆ insert() [2/13]
|
inline |
◆ insert() [3/13]
|
inline |
◆ insert() [4/13]
| void deque< _Tp, _Alloc >::insert | ( | iterator | __pos, |
| const value_type * | __first, | ||
| const value_type * | __last | ||
| ) |
Definition at line 150 of file _deque.c.
151 {
152#if !defined (_STLP_NO_MOVE_SEMANTIC)
154#endif
156 if (__pos._M_cur == this->_M_start._M_cur) {
158 _STLP_TRY {
160 }
161 _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
162 this->_M_start = __new_start;
163 }
166 _STLP_TRY {
168 }
169 _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1,
170 __new_finish._M_node + 1))
171 this->_M_finish = __new_finish;
172 }
173 else
175}
void _M_insert_range_aux(iterator __pos, const value_type *__first, const value_type *__last, size_type __n, const __true_type &)
Definition: _deque.c:562
◆ insert() [5/13]
|
inline |
◆ insert() [6/13]
| void deque< _Tp, _Alloc >::insert | ( | iterator | __pos, |
| const_iterator | __first, | ||
| const_iterator | __last | ||
| ) |
Definition at line 178 of file _deque.c.
179 {
180#if !defined (_STLP_NO_MOVE_SEMANTIC)
182#endif
184 if (__pos._M_cur == this->_M_start._M_cur) {
186 _STLP_TRY {
188 }
189 _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
190 this->_M_start = __new_start;
191 }
194 _STLP_TRY {
196 }
197 _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1,
198 __new_finish._M_node + 1))
199 this->_M_finish = __new_finish;
200 }
201 else
203}
◆ insert() [7/13]
|
inline |
◆ insert() [8/13]
|
inline |
◆ insert() [9/13]
|
inline |
◆ insert() [10/13]
◆ insert() [11/13]
Definition at line 757 of file _deque.h.
void _M_fill_insert(iterator __pos, size_type __n, const value_type &__x)
Definition: _deque.c:122
◆ insert() [12/13]
◆ insert() [13/13]
◆ max_size() [1/3]
◆ max_size() [2/3]
◆ max_size() [3/3]
◆ operator=() [1/3]
◆ operator=() [2/3]
|
inline |
Definition at line 191 of file _deque.h.
191 {
192 if (this != &__x) {
193 _Invalidate_all();
194 _M_non_dbg_impl = __x._M_non_dbg_impl;
195 }
196 return *this;
197 }
◆ operator=() [3/3]
|
inline |
◆ operator[]() [1/6]
|
inline |
◆ operator[]() [2/6]
|
inline |
◆ operator[]() [3/6]
|
inline |
◆ operator[]() [4/6]
|
inline |
◆ operator[]() [5/6]
|
inline |
◆ operator[]() [6/6]
|
inline |
◆ pop_back() [1/3]
Definition at line 711 of file _deque.h.
711 {
712 if (this->_M_finish._M_cur != this->_M_finish._M_first) {
713 --this->_M_finish._M_cur;
714 _STLP_STD::_Destroy(this->_M_finish._M_cur);
715 }
716 else {
717 _M_pop_back_aux();
718 _STLP_STD::_Destroy(this->_M_finish._M_cur);
719 }
720 }
◆ pop_back() [2/3]
◆ pop_back() [3/3]
◆ pop_front() [1/3]
Definition at line 722 of file _deque.h.
Referenced by BtrfsPropSheet::search_list_thread().
◆ pop_front() [2/3]
◆ pop_front() [3/3]
◆ push_back() [1/3]
|
inline |
_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS
Definition at line 668 of file _deque.h.
668 {
669#else
671#endif
672 if (this->_M_finish._M_cur != this->_M_finish._M_last - 1) {
673 _Copy_Construct(this->_M_finish._M_cur, __t);
674 ++this->_M_finish._M_cur;
675 }
676 else
677 _M_push_back_aux_v(__t);
678 }
Referenced by DequeTest::auto_ref(), BtrfsPropSheet::check_file(), BtrfsPropSheet::do_search(), DequeTest::erase(), deque< _Tp, >::insert(), MoveConstructorTest::move_traits_deq(), MoveConstructorTest::move_traits_deq_complete(), deque< _Tp, >::push_back(), deque< _Tp, >::push_front(), StringTest::replace(), BtrfsPropSheet::set_cmdline(), and AlgTest::sort_test().
◆ push_back() [2/3]
|
inline |
◆ push_back() [3/3]
|
inline |
◆ push_front() [1/3]
|
inline |
_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS
Definition at line 680 of file _deque.h.
680 {
681#else
683#endif
684 if (this->_M_start._M_cur != this->_M_start._M_first) {
685 _Copy_Construct(this->_M_start._M_cur - 1, __t);
686 --this->_M_start._M_cur;
687 }
688 else
689 _M_push_front_aux_v(__t);
690 }
Referenced by DequeTest::erase(), deque< _Tp, >::insert(), and deque< _Tp, >::push_front().
◆ push_front() [2/3]
|
inline |
◆ push_front() [3/3]
|
inline |
◆ rbegin() [1/6]
|
inline |
◆ rbegin() [2/6]
|
inline |
◆ rbegin() [3/6]
|
inline |
◆ rbegin() [4/6]
|
inline |
◆ rbegin() [5/6]
|
inline |
◆ rbegin() [6/6]
|
inline |
◆ rend() [1/6]
|
inline |
◆ rend() [2/6]
|
inline |
◆ rend() [3/6]
|
inline |
◆ rend() [4/6]
|
inline |
◆ rend() [5/6]
|
inline |
◆ rend() [6/6]
|
inline |
◆ resize() [1/3]
|
inline |
Definition at line 811 of file _deque.h.
812 {
813#else
815#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
817 if (__new_size < __len)
818 erase(this->_M_start + __new_size, this->_M_finish);
819 else
820 insert(this->_M_finish, __new_size - __len, __x);
821 }
void resize(size_type __new_size, const value_type &__x=_STLP_DEFAULT_CONSTRUCTED(_Tp))
Definition: _deque.h:811
Referenced by deque< _Tp, >::resize().
◆ resize() [2/3]
|
inline |
◆ resize() [3/3]
|
inline |
Definition at line 355 of file _deque.h.
355 {
356#else
358#endif
361 _Invalidate_all();
362 else
364 }
365 _M_non_dbg_impl.resize(__new_size, __x);
366 }
◆ size() [1/3]
Definition at line 471 of file _deque.h.
471{ return this->_M_finish - this->_M_start; }
Referenced by deque< _Tp, >::_M_fill_assign(), deque< _Tp, >::_M_range_check(), deque< _Tp, >::assign(), MoveConstructorTest::deque_test(), BtrfsPropSheet::Initialize(), deque< _Tp, >::operator=(), deque< _Tp, >::operator[](), DequeTest::optimizations_check(), deque< _Tp, >::resize(), and BtrfsPropSheet::set_cmdline().
◆ size() [2/3]
◆ size() [3/3]
◆ swap() [1/3]
◆ swap() [2/3]
Definition at line 203 of file _deque.h.
203 {
204 _M_iter_list._Swap_owners(__x._M_iter_list);
205 _M_non_dbg_impl.swap(__x._M_non_dbg_impl);
206 }
◆ swap() [3/3]
Member Data Documentation
◆ _M_impl
Definition at line 371 of file _deque.h.
Referenced by deque< _Tp, >::assign(), deque< _Tp, >::at(), deque< _Tp, >::back(), deque< _Tp, >::begin(), deque< _Tp, >::clear(), deque< _Tp, >::empty(), deque< _Tp, >::end(), deque< _Tp, >::erase(), deque< _Tp, >::front(), deque< _Tp, >::get_allocator(), deque< _Tp, >::insert(), deque< _Tp, >::max_size(), deque< _Tp, >::operator=(), deque< _Tp, >::operator[](), deque< _Tp, >::pop_back(), deque< _Tp, >::pop_front(), deque< _Tp, >::push_back(), deque< _Tp, >::push_front(), deque< _Tp, >::resize(), deque< _Tp, >::size(), and deque< _Tp, >::swap().
◆ _M_iter_list
|
protected |
Definition at line 76 of file _deque.h.
Referenced by deque< _Tp, >::_Invalidate_all(), deque< _Tp, >::_Invalidate_iterator(), deque< _Tp, >::_Invalidate_iterators(), deque< _Tp, >::begin(), deque< _Tp, >::deque(), deque< _Tp, >::end(), deque< _Tp, >::erase(), deque< _Tp, >::insert(), and deque< _Tp, >::swap().
◆ _M_non_dbg_impl
Definition at line 75 of file _deque.h.
Referenced by deque< _Tp, >::assign(), deque< _Tp, >::at(), deque< _Tp, >::begin(), deque< _Tp, >::clear(), deque< _Tp, >::empty(), deque< _Tp, >::end(), deque< _Tp, >::erase(), deque< _Tp, >::get_allocator(), deque< _Tp, >::insert(), deque< _Tp, >::max_size(), deque< _Tp, >::operator=(), deque< _Tp, >::operator[](), deque< _Tp, >::pop_back(), deque< _Tp, >::pop_front(), deque< _Tp, >::push_back(), deque< _Tp, >::push_front(), deque< _Tp, >::resize(), deque< _Tp, >::size(), and deque< _Tp, >::swap().
◆ _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS
| deque< _Tp, >::_STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS |
The documentation for this class was generated from the following files:
