ReactOS: deque< _Tp, > Class Template Reference

#define _STLP_PRIV

Definition: _dm.h:70

Definition: _deque.h:340

◆ deque() [3/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque ( size_type __n )

inlineexplicit

Definition at line 497 of file _deque.h.

498 : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), __n)

499 { _M_initialize(__n); }

deque::allocator_type

_Base::allocator_type allocator_type

Definition: _deque.h:417

return __n

Definition: _algo.h:75

#define _STLP_PRIV

Definition: _dm.h:70

deque::_M_initialize

void _M_initialize(size_type __n, const value_type &__val=_STLP_DEFAULT_CONSTRUCTED(_Tp))

Definition: _deque.h:492

Definition: _deque.h:340

◆ deque() [4/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque	(	size_type	__n,
		const value_type &	__val,
		const allocator_type &	__a = `allocator_type()`
	)

inline

Definition at line 500 of file _deque.h.

     : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), __n) {
     typedef typename _TrivialInit<_Tp>::_Ret _TrivialInit;
     _M_fill_initialize(_STLP_DEFAULT_CONSTRUCTED(_Tp), _TrivialInit());
   }
   deque(size_type __n, const value_type& __val)
     : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), __n)
   { _M_fill_initialize(__val, __false_type()); }
   deque(size_type __n, const value_type& __val, const allocator_type& __a)
 #endif
     : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, __n)
   { _M_fill_initialize(__val, __false_type()); }

◆ deque() [5/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque	(	const value_type *	__first,
		const value_type *	__last,
		const allocator_type &	__a = `allocator_type()`
	)

inline

Definition at line 549 of file _deque.h.

551 : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, __last - __first)

552 { _STLP_PRIV __ucopy(__first, __last, this->_M_start); }

_STLP_INLINE_LOOP _InputIter __last

Definition: _algo.h:68

__ucopy

_STLP_BEGIN_NAMESPACE _STLP_MOVE_TO_PRIV_NAMESPACE _OutputIter __ucopy(_InputIter __first, _InputIter __last, _OutputIter __result, _Distance *)

Definition: _uninitialized.h:52

#define _STLP_PRIV

Definition: _dm.h:70

Definition: _deque.h:340

◆ deque() [6/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque	(	const_iterator	__first,
		const_iterator	__last,
		const allocator_type &	__a = `allocator_type()`
	)

inline

Definition at line 554 of file _deque.h.

556 : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, __last - __first)

557 { _STLP_PRIV __ucopy(__first, __last, this->_M_start); }

_STLP_INLINE_LOOP _InputIter __last

Definition: _algo.h:68

__ucopy

_STLP_BEGIN_NAMESPACE _STLP_MOVE_TO_PRIV_NAMESPACE _OutputIter __ucopy(_InputIter __first, _InputIter __last, _OutputIter __result, _Distance *)

Definition: _uninitialized.h:52

#define _STLP_PRIV

Definition: _dm.h:70

Definition: _deque.h:340

◆ deque() [7/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque ( __move_source< _Self > src )

inline

Definition at line 561 of file _deque.h.

562 : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__move_source<_Base>(src.get()))

563 {}

#define _STLP_PRIV

Definition: _dm.h:70

src

GLenum src

Definition: glext.h:6340

__move_source

Definition: _move_construct_fwk.h:35

Definition: _deque.h:340

◆ ~deque()

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::~deque ( )

inline

Definition at line 566 of file _deque.h.

567 { _STLP_STD::_Destroy_Range(this->_M_start, this->_M_finish); }

_Destroy_Range

void _Destroy_Range(_ForwardIterator __first, _ForwardIterator __last)

Definition: _construct.h:219

◆ deque() [8/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque ( const allocator_type & __a = allocator_type() )

inlineexplicit

Definition at line 129 of file _deque.h.

129 :

130 _M_non_dbg_impl(__a), _M_iter_list(&_M_non_dbg_impl) {}

_STLP_PRIV __owned_list _M_iter_list

Definition: _deque.h:76

_Base _M_non_dbg_impl

Definition: _deque.h:75

◆ deque() [9/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque ( const _Self & __x )

inline

Definition at line 131 of file _deque.h.

                           :
     _ConstructCheck(__x), _M_non_dbg_impl(__x._M_non_dbg_impl),
     _M_iter_list(&_M_non_dbg_impl) {}

◆ deque() [10/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque	(	size_type	__n,
		const value_type &	__x = `_Tp()`,
		const allocator_type &	__a = `allocator_type()`
	)

inlineexplicit

Definition at line 136 of file _deque.h.

140 :

141 _M_non_dbg_impl(__n, __x, __a), _M_iter_list(&_M_non_dbg_impl) {}

return __n

Definition: _algo.h:75

_STLP_PRIV __owned_list _M_iter_list

Definition: _deque.h:76

_Base _M_non_dbg_impl

Definition: _deque.h:75

◆ deque() [11/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque ( __move_source< _Self > src )

inline

Definition at line 148 of file _deque.h.

     : _M_non_dbg_impl(__move_source<_Base>(src.get()._M_non_dbg_impl)),
       _M_iter_list(&_M_non_dbg_impl) {
 #  if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
     src.get()._M_iter_list._Invalidate_all();
 #  else
     src.get()._M_iter_list._Set_owner(_M_iter_list);
 #  endif
   }

◆ deque() [12/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque	(	const value_type *	__first,
		const value_type *	__last,
		const allocator_type &	__a = `allocator_type()`
	)

inline

Definition at line 176 of file _deque.h.

     : _ConstructCheck(__first, __last),
       _M_non_dbg_impl(__first, __last, __a),
       _M_iter_list(&_M_non_dbg_impl) {
     }

◆ deque() [13/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque	(	const_iterator	__first,
		const_iterator	__last,
		const allocator_type &	__a = `allocator_type()`
	)

inline

Definition at line 183 of file _deque.h.

     : _ConstructCheck(__first, __last),
       _M_non_dbg_impl(__first._M_iterator, __last._M_iterator, __a),
       _M_iter_list(&_M_non_dbg_impl) {
     }

◆ deque() [14/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque ( const allocator_type & __a = allocator_type() )

inlineexplicit

Definition at line 159 of file _deque.h.

160 : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}

_STLP_CONVERT_ALLOCATOR

#define _STLP_CONVERT_ALLOCATOR(__a, _Tp)

Definition: _alloc.h:183

_StorageType

Definition: _tools.h:142

_Base _M_impl

Definition: _deque.h:371

◆ deque() [15/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque ( const _Self & __x )

inline

Definition at line 162 of file _deque.h.

162 : _M_impl(__x._M_impl) {}

_Base _M_impl

Definition: _deque.h:371

◆ deque() [16/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque	(	size_type	__n,
		const value_type &	__val = `_STLP_DEFAULT_CONSTRUCTED(value_type)`,
		const allocator_type &	__a = `allocator_type()`
	)

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)) {}

_STLP_CONVERT_ALLOCATOR

#define _STLP_CONVERT_ALLOCATOR(__a, _Tp)

Definition: _alloc.h:183

return __n

Definition: _algo.h:75

_StorageType

Definition: _tools.h:142

__val

_STLP_INLINE_LOOP _InputIter const _Tp & __val

Definition: _algobase.h:656

_Base _M_impl

Definition: _deque.h:371

◆ deque() [17/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque	(	const_pointer	__first,
		const_pointer	__last,
		const allocator_type &	__a = `allocator_type()`
	)

inline

Definition at line 202 of file _deque.h.

     : _M_impl(cast_traits::to_storage_type_cptr(__first),
               cast_traits::to_storage_type_cptr(__last),
               _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}

◆ deque() [18/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque	(	const_iterator	__first,
		const_iterator	__last,
		const allocator_type &	__a = `allocator_type()`
	)

inline

Definition at line 208 of file _deque.h.

     : _M_impl(ite_cast_traits::to_storage_type_cite(__first),
               ite_cast_traits::to_storage_type_cite(__last),
               _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}

◆ deque() [19/19]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

deque< _Tp, >::deque ( __move_source< _Self > src )

inline

Definition at line 216 of file _deque.h.

217 : _M_impl(__move_source<_Base>(src.get()._M_impl)) {}

src

GLenum src

Definition: glext.h:6340

__move_source

Definition: _move_construct_fwk.h:35

_Base _M_impl

Definition: _deque.h:371

Member Function Documentation

◆ _Invalidate_all()

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::_Invalidate_all ( )

inlineprotected

Definition at line 78 of file _deque.h.

79 { _M_iter_list._Invalidate_all(); }

_STLP_PRIV __owned_list _M_iter_list

Definition: _deque.h:76

Referenced by deque< IncompleteClass >::assign(), deque< IncompleteClass >::clear(), deque< IncompleteClass >::erase(), deque< IncompleteClass >::insert(), deque< IncompleteClass >::operator=(), deque< IncompleteClass >::push_back(), deque< IncompleteClass >::push_front(), and deque< IncompleteClass >::resize().

◆ _Invalidate_iterator()

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::_Invalidate_iterator ( const iterator & __it )

inlineprotected

Definition at line 80 of file _deque.h.

81 { _STLP_PRIV __invalidate_iterator(&_M_iter_list,__it); }

__it

_STLP_MOVE_TO_PRIV_NAMESPACE const _InputIterator const input_iterator_tag &_InputIterator __it(__first)

#define _STLP_PRIV

Definition: _dm.h:70

_STLP_PRIV __owned_list _M_iter_list

Definition: _deque.h:76

Referenced by deque< IncompleteClass >::erase(), deque< IncompleteClass >::pop_back(), deque< IncompleteClass >::pop_front(), and deque< IncompleteClass >::resize().

◆ _Invalidate_iterators()

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::_Invalidate_iterators	(	const iterator &	__first,
		const iterator &	__last
	)

inlineprotected

Definition at line 82 of file _deque.h.

83 { _STLP_PRIV __invalidate_range(&_M_iter_list, __first, __last); }

_STLP_INLINE_LOOP _InputIter __last

Definition: _algo.h:68

#define _STLP_PRIV

Definition: _dm.h:70

_STLP_PRIV __owned_list _M_iter_list

Definition: _deque.h:76

Referenced by deque< IncompleteClass >::erase().

◆ _M_erase() [1/4]

template<class _Tp , class _Alloc >

__iterator__ deque< _Tp, _Alloc >::_M_erase	(	iterator	__pos,
		const __true_type &
	)

protected

Definition at line 208 of file _deque.c.

                                                                {
   difference_type __index = __pos - this->_M_start;
   if (size_type(__index) < this->size() >> 1) {
     //We move the start of the deque one position to the right
     //starting from the rightmost element to move.
     iterator __src = __pos, __dst = __pos;
     _STLP_STD::_Destroy(&(*__dst));
     if (__src != this->_M_start) {
       for (--__src; __dst != this->_M_start; --__src, --__dst) {
         _STLP_STD::_Move_Construct(&(*__dst), *__src);
         _STLP_STD::_Destroy_Moved(&(*__src));
       }
     }
     _M_pop_front_aux();
   }
   else {
     iterator __src = __pos, __dst = __pos;
     _STLP_STD::_Destroy(&(*__dst));
     for (++__src; __src != this->_M_finish; ++__src, ++__dst) {
       _STLP_STD::_Move_Construct(&(*__dst), *__src);
       _STLP_STD::_Destroy_Moved(&(*__src));
     }
     //Duplication of the pop_back code without the destroy which has already been done:
     if (this->_M_finish._M_cur != this->_M_finish._M_first) {
       --this->_M_finish._M_cur;
     }
     else {
       _M_pop_back_aux();
     }
   }
   return this->_M_start + __index;
 }

Referenced by deque< IncompleteClass >::erase(), and deque< IncompleteClass >::resize().

◆ _M_erase() [2/4]

template<class _Tp , class _Alloc >

__iterator__ deque< _Tp, _Alloc >::_M_erase	(	iterator	__pos,
		const __false_type &
	)

protected

Definition at line 243 of file _deque.c.

                                                                 {
   iterator __next = __pos;
   ++__next;
   difference_type __index = __pos - this->_M_start;
   if (size_type(__index) < this->size() >> 1) {
     copy_backward(this->_M_start, __pos, __next);
     pop_front();
   }
   else {
     _STLP_STD::copy(__next, this->_M_finish, __pos);
     pop_back();
   }
   return this->_M_start + __index;
 }

◆ _M_erase() [3/4]

template<class _Tp , class _Alloc >

__iterator__ deque< _Tp, _Alloc >::_M_erase	(	iterator	__first,
		iterator	__last,
		const __true_type &
	)

protected

Definition at line 260 of file _deque.c.

                                                                {
   difference_type __n = __last - __first;
   difference_type __elems_before = __first - this->_M_start;
   if (__elems_before <= difference_type(this->size() - __n) / 2) {
     iterator __src = __first, __dst = __last;
     if (__src != this->_M_start) {
       for (--__src, --__dst; (__src >= this->_M_start) && (__dst >= __first); --__src, --__dst) {
         _STLP_STD::_Destroy(&(*__dst));
         _STLP_STD::_Move_Construct(&(*__dst), *__src);
       }
       if (__dst >= __first) {
         //There are more elements to erase than elements to move
         _STLP_STD::_Destroy_Range(__first, ++__dst);
         _STLP_STD::_Destroy_Moved_Range(this->_M_start, __first);
       }
       else {
         //There are more elements to move than elements to erase
         for (; __src >= this->_M_start; --__src, --__dst) {
           _STLP_STD::_Destroy_Moved(&(*__dst));
           _STLP_STD::_Move_Construct(&(*__dst), *__src);
         }
         _STLP_STD::_Destroy_Moved_Range(this->_M_start, ++__dst);
       }
     }
     else {
       _STLP_STD::_Destroy_Range(this->_M_start, __last);
     }
     iterator __new_start = this->_M_start + __n;
     this->_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
     this->_M_start = __new_start;
   }
   else {
     if (__last != this->_M_finish) {
       iterator __src = __last, __dst = __first;
       for (; (__src != this->_M_finish) && (__dst != __last); ++__src, ++__dst) {
         _STLP_STD::_Destroy(&(*__dst));
         _STLP_STD::_Move_Construct(&(*__dst), *__src);
       }
       if (__dst != __last) {
         //There are more elements to erase than elements to move
         _STLP_STD::_Destroy_Range(__dst, __last);
         _STLP_STD::_Destroy_Moved_Range(__last, this->_M_finish);
       }
       else {
         //There are more elements to move than elements to erase
         for (; __src != this->_M_finish; ++__src, ++__dst) {
           _STLP_STD::_Destroy_Moved(&(*__dst));
           _STLP_STD::_Move_Construct(&(*__dst), *__src);
         }
         _STLP_STD::_Destroy_Moved_Range(__dst, this->_M_finish);
       }
     }
     else {
       _STLP_STD::_Destroy_Range(__first, this->_M_finish);
     }
     iterator __new_finish = this->_M_finish - __n;
     this->_M_destroy_nodes(__new_finish._M_node + 1, this->_M_finish._M_node + 1);
     this->_M_finish = __new_finish;
   }
   return this->_M_start + __elems_before;
 }

◆ _M_erase() [4/4]

template<class _Tp , class _Alloc >

__iterator__ deque< _Tp, _Alloc >::_M_erase	(	iterator	__first,
		iterator	__last,
		const __false_type &
	)

protected

Definition at line 324 of file _deque.c.

                                                                 {
   difference_type __n = __last - __first;
   difference_type __elems_before = __first - this->_M_start;
   if (__elems_before <= difference_type(this->size() - __n) / 2) {
     copy_backward(this->_M_start, __first, __last);
     iterator __new_start = this->_M_start + __n;
     _STLP_STD::_Destroy_Range(this->_M_start, __new_start);
     this->_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
     this->_M_start = __new_start;
   }
   else {
     _STLP_STD::copy(__last, this->_M_finish, __first);
     iterator __new_finish = this->_M_finish - __n;
     _STLP_STD::_Destroy_Range(__new_finish, this->_M_finish);
     this->_M_destroy_nodes(__new_finish._M_node + 1, this->_M_finish._M_node + 1);
     this->_M_finish = __new_finish;
   }
   return this->_M_start + __elems_before;
 }

◆ _M_fill_assign()

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::_M_fill_assign	(	size_type	__n,
		const _Tp &	__val
	)

inline

Definition at line 587 of file _deque.h.

                                                        {
     if (__n > size()) {
       _STLP_STD::fill(begin(), end(), __val);
       insert(end(), __n - size(), __val);
     }
     else {
       erase(begin() + __n, end());
       _STLP_STD::fill(begin(), end(), __val);
     }
   }

Referenced by deque< IncompleteClass >::assign().

◆ _M_fill_initialize() [1/2]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::_M_fill_initialize	(	const value_type &	__val,
		const __true_type &
	)

inlineprotected

Definition at line 859 of file _deque.h.

860 {}

Referenced by deque< IncompleteClass >::_M_initialize(), and deque< IncompleteClass >::deque().

◆ _M_fill_initialize() [2/2]

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_fill_initialize	(	const value_type &	__val,
		const __false_type &
	)

protected

Definition at line 368 of file _deque.c.

                                                                   {
   _Map_pointer __cur = this->_M_start._M_node;
   _STLP_TRY {
     for (; __cur < this->_M_finish._M_node; ++__cur)
       uninitialized_fill(*__cur, *__cur + this->buffer_size(), __val);
     uninitialized_fill(this->_M_finish._M_first, this->_M_finish._M_cur, __val);
   }
   _STLP_UNWIND(_STLP_STD::_Destroy_Range(this->_M_start, iterator(*__cur, __cur)))
 }

◆ _M_fill_insert()

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_fill_insert	(	iterator	__pos,
		size_type	__n,
		const value_type &	__x
	)

protected

Definition at line 122 of file _deque.c.

                                                                                {
 #if !defined (_STLP_NO_MOVE_SEMANTIC)
   typedef typename __move_traits<_Tp>::implemented _Movable;
 #endif
   if (__pos._M_cur == this->_M_start._M_cur) {
     iterator __new_start = _M_reserve_elements_at_front(__n);
     _STLP_TRY {
       uninitialized_fill(__new_start, this->_M_start, __x);
     }
     _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
     this->_M_start = __new_start;
   }
   else if (__pos._M_cur == this->_M_finish._M_cur) {
     iterator __new_finish = _M_reserve_elements_at_back(__n);
     _STLP_TRY {
       uninitialized_fill(this->_M_finish, __new_finish, __x);
     }
     _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node+1, __new_finish._M_node+1))
     this->_M_finish = __new_finish;
   }
   else
     _M_fill_insert_aux(__pos, __n, __x, _Movable());
 }

Referenced by deque< IncompleteClass >::insert().

◆ _M_fill_insert_aux() [1/2]

template<class _Tp , class _Alloc >

__iterator__ deque< _Tp, _Alloc >::_M_fill_insert_aux	(	iterator	__pos,
		size_type	__n,
		const value_type &	__x,
		const __true_type &
	)

protected

Definition at line 464 of file _deque.c.

                                                                          {
   const difference_type __elems_before = __pos - this->_M_start;
   size_type __length = this->size();
   value_type __x_copy = __x;
   if (__elems_before <= difference_type(__length / 2)) {
     iterator __new_start = _M_reserve_elements_at_front(__n);
     __pos = this->_M_start + __elems_before;
     _STLP_TRY {
       iterator __dst = __new_start;
       iterator __src = this->_M_start;
       for (; __src != __pos; ++__dst, ++__src) {
         _STLP_STD::_Move_Construct(&(*__dst), *__src);
         _STLP_STD::_Destroy_Moved(&(*__src));
       }
       this->_M_start = __new_start;
       uninitialized_fill(__dst, __src, __x_copy);
       __pos = __dst;
     }
     _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
   }
   else {
     iterator __new_finish = _M_reserve_elements_at_back(__n);
     const difference_type __elems_after = difference_type(__length) - __elems_before;
     __pos = this->_M_finish - __elems_after;
     _STLP_TRY {
       iterator __dst = __new_finish;
       iterator __src = this->_M_finish;
       for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
         _STLP_STD::_Move_Construct(&(*__dst), *__src);
         _STLP_STD::_Destroy_Moved(&(*__src));
       }
       this->_M_finish = __new_finish;
       uninitialized_fill(__pos, __pos + __n, __x_copy);
     }
     _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
   }
   return __pos;
 }

Referenced by deque< IncompleteClass >::insert().

◆ _M_fill_insert_aux() [2/2]

template<class _Tp , class _Alloc >

__iterator__ deque< _Tp, _Alloc >::_M_fill_insert_aux	(	iterator	__pos,
		size_type	__n,
		const value_type &	__x,
		const __false_type &
	)

protected

Definition at line 506 of file _deque.c.

                                                                           {
   const difference_type __elems_before = __pos - this->_M_start;
   size_type __length = this->size();
   value_type __x_copy = __x;
   if (__elems_before <= difference_type(__length / 2)) {
     iterator __new_start = _M_reserve_elements_at_front(__n);
     iterator __old_start = this->_M_start;
     __pos = this->_M_start + __elems_before;
     _STLP_TRY {
       if (__elems_before >= difference_type(__n)) {
         iterator __start_n = this->_M_start + difference_type(__n);
         _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
         this->_M_start = __new_start;
         _STLP_STD::copy(__start_n, __pos, __old_start);
         _STLP_STD::fill(__pos - difference_type(__n), __pos, __x_copy);
         __pos -= difference_type(__n);
       }
       else {
         _STLP_PRIV __uninitialized_copy_fill(this->_M_start, __pos, __new_start,
                                              this->_M_start, __x_copy);
         this->_M_start = __new_start;
         fill(__old_start, __pos, __x_copy);
       }
     }
     _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
   }
   else {
     iterator __new_finish = _M_reserve_elements_at_back(__n);
     iterator __old_finish = this->_M_finish;
     const difference_type __elems_after =
       difference_type(__length) - __elems_before;
     __pos = this->_M_finish - __elems_after;
     _STLP_TRY {
       if (__elems_after > difference_type(__n)) {
         iterator __finish_n = this->_M_finish - difference_type(__n);
         _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
         this->_M_finish = __new_finish;
         copy_backward(__pos, __finish_n, __old_finish);
         fill(__pos, __pos + difference_type(__n), __x_copy);
       }
       else {
         _STLP_PRIV __uninitialized_fill_copy(this->_M_finish, __pos + difference_type(__n),
                                              __x_copy, __pos, this->_M_finish);
         this->_M_finish = __new_finish;
         fill(__pos, __old_finish, __x_copy);
       }
     }
     _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
   }
   return __pos;
 }

◆ _M_initialize()

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::_M_initialize	(	size_type	__n,
		const value_type &	__val = `_STLP_DEFAULT_CONSTRUCTED(_Tp)`
	)

inlineprivate

Definition at line 492 of file _deque.h.

                                                                                               {
     typedef typename _TrivialInit<_Tp>::_Ret _TrivialInit;
     _M_fill_initialize(__val, _TrivialInit());
   }

Referenced by deque< IncompleteClass >::deque().

◆ _M_insert_range_aux() [1/4]

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_insert_range_aux	(	iterator	__pos,
		const value_type *	__first,
		const value_type *	__last,
		size_type	__n,
		const __true_type &
	)

protected

Definition at line 562 of file _deque.c.

                                                                                  {
   const difference_type __elems_before = __pos - this->_M_start;
   size_type __length = size();
   if (__elems_before <= difference_type(__length / 2)) {
     iterator __new_start = _M_reserve_elements_at_front(__n);
     __pos = this->_M_start + __elems_before;
     _STLP_TRY {
       iterator __dst = __new_start;
       iterator __src = this->_M_start;
       for (; __src != __pos; ++__dst, ++__src) {
         _STLP_STD::_Move_Construct(&(*__dst), *__src);
         _STLP_STD::_Destroy_Moved(&(*__src));
       }
       this->_M_start = __new_start;
       _STLP_PRIV __ucopy(__first, __last, __dst);
     }
     _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
   }
   else {
     iterator __new_finish = _M_reserve_elements_at_back(__n);
     const difference_type __elems_after = difference_type(__length) - __elems_before;
     __pos = this->_M_finish - __elems_after;
     _STLP_TRY {
       iterator __dst = __new_finish;
       iterator __src = this->_M_finish;
       for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
         _STLP_STD::_Move_Construct(&(*__dst), *__src);
         _STLP_STD::_Destroy_Moved(&(*__src));
       }
       this->_M_finish = __new_finish;
       _STLP_PRIV __ucopy(__first, __last, __pos);
     }
     _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
   }
 }

◆ _M_insert_range_aux() [2/4]

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_insert_range_aux	(	iterator	__pos,
		const value_type *	__first,
		const value_type *	__last,
		size_type	__n,
		const __false_type &
	)

protected

Definition at line 601 of file _deque.c.

                                                                                   {
   const difference_type __elems_before = __pos - this->_M_start;
   size_type __length = size();
   if (__elems_before <= difference_type(__length / 2)) {
     iterator __new_start = _M_reserve_elements_at_front(__n);
     iterator __old_start = this->_M_start;
     __pos = this->_M_start + __elems_before;
     _STLP_TRY {
       if (__elems_before >= difference_type(__n)) {
         iterator __start_n = this->_M_start + difference_type(__n);
         _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
         this->_M_start = __new_start;
         _STLP_STD::copy(__start_n, __pos, __old_start);
         _STLP_STD::copy(__first, __last, __pos - difference_type(__n));
       }
       else {
         const value_type* __mid = __first + (difference_type(__n) - __elems_before);
         _STLP_PRIV __uninitialized_copy_copy(this->_M_start, __pos, __first, __mid, __new_start);
         this->_M_start = __new_start;
         _STLP_STD::copy(__mid, __last, __old_start);
       }
     }
     _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
   }
   else {
     iterator __new_finish = _M_reserve_elements_at_back(__n);
     iterator __old_finish = this->_M_finish;
     const difference_type __elems_after =
       difference_type(__length) - __elems_before;
     __pos = this->_M_finish - __elems_after;
     _STLP_TRY {
 
       if (__elems_after > difference_type(__n)) {
         iterator __finish_n = this->_M_finish - difference_type(__n);
         _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
         this->_M_finish = __new_finish;
         _STLP_STD::copy_backward(__pos, __finish_n, __old_finish);
         _STLP_STD::copy(__first, __last, __pos);
       }
       else {
         const value_type* __mid = __first + __elems_after;
         _STLP_PRIV __uninitialized_copy_copy(__mid, __last, __pos, this->_M_finish, this->_M_finish);
         this->_M_finish = __new_finish;
         _STLP_STD::copy(__first, __mid, __pos);
       }
     }
     _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
   }
 }

◆ _M_insert_range_aux() [3/4]

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_insert_range_aux	(	iterator	__pos,
		const_iterator	__first,
		const_iterator	__last,
		size_type	__n,
		const __true_type &
	)

protected

Definition at line 654 of file _deque.c.

                                                                                  {
   const difference_type __elems_before = __pos - this->_M_start;
   size_type __length = size();
   if (__elems_before <= difference_type(__length / 2)) {
     iterator __new_start = _M_reserve_elements_at_front(__n);
     __pos = this->_M_start + __elems_before;
     _STLP_TRY {
       iterator __dst = __new_start;
       iterator __src = this->_M_start;
       for (; __src != __pos; ++__dst, ++__src) {
         _STLP_STD::_Move_Construct(&(*__dst), *__src);
         _STLP_STD::_Destroy_Moved(&(*__src));
       }
       this->_M_start = __new_start;
       _STLP_PRIV __ucopy(__first, __last, __dst);
     }
     _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
   }
   else {
     iterator __new_finish = _M_reserve_elements_at_back(__n);
     const difference_type __elems_after = difference_type(__length) - __elems_before;
     __pos = this->_M_finish - __elems_after;
     _STLP_TRY {
       iterator __dst = __new_finish;
       iterator __src = this->_M_finish;
       for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
         _STLP_STD::_Move_Construct(&(*__dst), *__src);
         _STLP_STD::_Destroy_Moved(&(*__src));
       }
       this->_M_finish = __new_finish;
       _STLP_PRIV __ucopy(__first, __last, __pos);
     }
     _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
   }
 }

◆ _M_insert_range_aux() [4/4]

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_insert_range_aux	(	iterator	__pos,
		const_iterator	__first,
		const_iterator	__last,
		size_type	__n,
		const __false_type &
	)

protected

Definition at line 693 of file _deque.c.

                                                                                   {
   const difference_type __elems_before = __pos - this->_M_start;
   size_type __length = size();
   if (__elems_before < difference_type(__length / 2)) {
     iterator __new_start = _M_reserve_elements_at_front(__n);
     iterator __old_start = this->_M_start;
     __pos = this->_M_start + __elems_before;
     _STLP_TRY {
       if (__elems_before >= difference_type(__n)) {
         iterator __start_n = this->_M_start + __n;
         _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
         this->_M_start = __new_start;
         _STLP_STD::copy(__start_n, __pos, __old_start);
         _STLP_STD::copy(__first, __last, __pos - difference_type(__n));
       }
       else {
         const_iterator __mid = __first + (__n - __elems_before);
         _STLP_PRIV __uninitialized_copy_copy(this->_M_start, __pos, __first, __mid, __new_start);
         this->_M_start = __new_start;
         _STLP_STD::copy(__mid, __last, __old_start);
       }
     }
     _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
   }
   else {
     iterator __new_finish = _M_reserve_elements_at_back(__n);
     iterator __old_finish = this->_M_finish;
     const difference_type __elems_after = __length - __elems_before;
     __pos = this->_M_finish - __elems_after;
     _STLP_TRY {
       if (__elems_after > difference_type(__n)) {
         iterator __finish_n = this->_M_finish - difference_type(__n);
         _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
         this->_M_finish = __new_finish;
         _STLP_STD::copy_backward(__pos, __finish_n, __old_finish);
         _STLP_STD::copy(__first, __last, __pos);
       }
       else {
         const_iterator __mid = __first + __elems_after;
         _STLP_PRIV __uninitialized_copy_copy(__mid, __last, __pos, this->_M_finish, this->_M_finish);
         this->_M_finish = __new_finish;
         _STLP_STD::copy(__first, __mid, __pos);
       }
     }
     _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
   }
 }

◆ _M_new_elements_at_back()

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_new_elements_at_back ( size_type __new_elements )

protected

Definition at line 759 of file _deque.c.

                                                                      {
   size_type __new_nodes
       = (__new_elems + this->buffer_size() - 1) / this->buffer_size();
   _M_reserve_map_at_back(__new_nodes);
   size_type __i = 1;
   _STLP_TRY {
     for (; __i <= __new_nodes; ++__i)
       *(this->_M_finish._M_node + __i) = this->_M_map_size.allocate(this->buffer_size());
   }
   _STLP_UNWIND(for (size_type __j = 1; __j < __i; ++__j)
                  this->_M_map_size.deallocate(*(this->_M_finish._M_node + __j), this->buffer_size()))
 }

Referenced by deque< IncompleteClass >::_M_reserve_elements_at_back().

◆ _M_new_elements_at_front()

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_new_elements_at_front ( size_type __new_elements )

protected

Definition at line 745 of file _deque.c.

                                                                       {
   size_type __new_nodes
       = (__new_elems + this->buffer_size() - 1) / this->buffer_size();
   _M_reserve_map_at_front(__new_nodes);
   size_type __i = 1;
   _STLP_TRY {
     for (; __i <= __new_nodes; ++__i)
       *(this->_M_start._M_node - __i) = this->_M_map_size.allocate(this->buffer_size());
   }
   _STLP_UNWIND(for (size_type __j = 1; __j < __i; ++__j)
                  this->_M_map_size.deallocate(*(this->_M_start._M_node - __j), this->buffer_size()))
 }

Referenced by deque< IncompleteClass >::_M_reserve_elements_at_front().

◆ _M_pop_back_aux()

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_pop_back_aux ( )

protected

Definition at line 443 of file _deque.c.

                                         {
   this->_M_map_size.deallocate(this->_M_finish._M_first, this->buffer_size());
   this->_M_finish._M_set_node(this->_M_finish._M_node - 1);
   this->_M_finish._M_cur = this->_M_finish._M_last - 1;
 }

Referenced by deque< IncompleteClass >::pop_back().

◆ _M_pop_front_aux()

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_pop_front_aux ( )

protected

Definition at line 453 of file _deque.c.

                                          {
   if (this->_M_start._M_cur != this->_M_start._M_last - 1)
     ++this->_M_start._M_cur;
   else {
     this->_M_map_size.deallocate(this->_M_start._M_first, this->buffer_size());
     this->_M_start._M_set_node(this->_M_start._M_node + 1);
     this->_M_start._M_cur = this->_M_start._M_first;
   }
 }

Referenced by deque< IncompleteClass >::pop_front().

◆ _M_push_back_aux_v()

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_push_back_aux_v ( const value_type & __t )

protected

Definition at line 382 of file _deque.c.

                                                                 {
   _M_reserve_map_at_back();
   *(this->_M_finish._M_node + 1) = this->_M_map_size.allocate(this->buffer_size());
   _STLP_TRY {
     _Copy_Construct(this->_M_finish._M_cur, __t);
     this->_M_finish._M_set_node(this->_M_finish._M_node + 1);
     this->_M_finish._M_cur = this->_M_finish._M_first;
   }
   _STLP_UNWIND(this->_M_map_size.deallocate(*(this->_M_finish._M_node + 1),
                                             this->buffer_size()))
 }

Referenced by deque< IncompleteClass >::push_back().

◆ _M_push_front_aux_v()

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_push_front_aux_v ( const value_type & __t )

protected

Definition at line 412 of file _deque.c.

                                                                  {
   _M_reserve_map_at_front();
   *(this->_M_start._M_node - 1) = this->_M_map_size.allocate(this->buffer_size());
   _STLP_TRY {
     this->_M_start._M_set_node(this->_M_start._M_node - 1);
     this->_M_start._M_cur = this->_M_start._M_last - 1;
     _Copy_Construct(this->_M_start._M_cur, __t);
   }
   _STLP_UNWIND((++this->_M_start,
                 this->_M_map_size.deallocate(*(this->_M_start._M_node - 1), this->buffer_size())))
 }

Referenced by deque< IncompleteClass >::push_front().

◆ _M_range_check()

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::_M_range_check ( size_type __n ) const

inline

Definition at line 449 of file _deque.h.

                                            {
     if (__n >= this->size())
       __stl_throw_out_of_range("deque");
   }

Referenced by deque< IncompleteClass >::at().

◆ _M_reallocate_map()

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::_M_reallocate_map	(	size_type	__nodes_to_add,
		bool	__add_at_front
	)

protected

Definition at line 773 of file _deque.c.

                                                                {
   size_type __old_num_nodes = this->_M_finish._M_node - this->_M_start._M_node + 1;
   size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
 
   _Map_pointer __new_nstart;
   if (this->_M_map_size._M_data > 2 * __new_num_nodes) {
     __new_nstart = this->_M_map._M_data + (this->_M_map_size._M_data - __new_num_nodes) / 2
                      + (__add_at_front ? __nodes_to_add : 0);
     if (__new_nstart < this->_M_start._M_node)
       _STLP_STD::copy(this->_M_start._M_node, this->_M_finish._M_node + 1, __new_nstart);
     else
       _STLP_STD::copy_backward(this->_M_start._M_node, this->_M_finish._M_node + 1,
                                __new_nstart + __old_num_nodes);
   }
   else {
     size_type __new_map_size =
       this->_M_map_size._M_data + (max)((size_t)this->_M_map_size._M_data, __nodes_to_add) + 2;
 
     _Map_pointer __new_map = this->_M_map.allocate(__new_map_size);
     __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
                              + (__add_at_front ? __nodes_to_add : 0);
     _STLP_STD::copy(this->_M_start._M_node, this->_M_finish._M_node + 1, __new_nstart);
     this->_M_map.deallocate(this->_M_map._M_data, this->_M_map_size._M_data);
 
     this->_M_map._M_data = __new_map;
     this->_M_map_size._M_data = __new_map_size;
   }
 
   this->_M_start._M_set_node(__new_nstart);
   this->_M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
 }

Referenced by deque< IncompleteClass >::_M_reserve_map_at_back(), and deque< IncompleteClass >::_M_reserve_map_at_front().

◆ _M_reserve_elements_at_back()

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::_M_reserve_elements_at_back ( size_type __n )

inlineprotected

Definition at line 1044 of file _deque.h.

                                                       {
     size_type __vacancies = (this->_M_finish._M_last - this->_M_finish._M_cur) - 1;
     if (__n > __vacancies)
       _M_new_elements_at_back(__n - __vacancies);
     return this->_M_finish + difference_type(__n);
   }

◆ _M_reserve_elements_at_front()

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::_M_reserve_elements_at_front ( size_type __n )

inlineprotected

Definition at line 1037 of file _deque.h.

                                                        {
     size_type __vacancies = this->_M_start._M_cur - this->_M_start._M_first;
     if (__n > __vacancies)
       _M_new_elements_at_front(__n - __vacancies);
     return this->_M_start - difference_type(__n);
   }

◆ _M_reserve_map_at_back()

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::_M_reserve_map_at_back ( size_type __nodes_to_add = 1 )

inlineprotected

Definition at line 1060 of file _deque.h.

                                                              {
     if (__nodes_to_add + 1 > this->_M_map_size._M_data - (this->_M_finish._M_node - this->_M_map._M_data))
       _M_reallocate_map(__nodes_to_add, false);
   }

◆ _M_reserve_map_at_front()

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::_M_reserve_map_at_front ( size_type __nodes_to_add = 1 )

inlineprotected

Definition at line 1065 of file _deque.h.

                                                               {
     if (__nodes_to_add > size_type(this->_M_start._M_node - this->_M_map._M_data))
       _M_reallocate_map(__nodes_to_add, true);
   }

◆ assign() [1/9]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::assign	(	size_type	__n,
		const _Tp &	__val
	)

inline

Definition at line 212 of file _deque.h.

                                                {
     _Invalidate_all();
     _M_non_dbg_impl.assign(__n, __val);
   }

◆ assign() [2/9]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::assign	(	const_iterator	__first,
		const_iterator	__last
	)

inline

Definition at line 225 of file _deque.h.

                                                              {
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
     _Invalidate_all();
     _M_non_dbg_impl.assign(__first._M_iterator, __last._M_iterator);
   }

◆ assign() [3/9]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::assign	(	size_type	__n,
		const value_type &	__val
	)

inline

Definition at line 227 of file _deque.h.

                                                       {
     _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val));
   }

◆ assign() [4/9]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::assign	(	const value_type *	__first,
		const value_type *	__last
	)

inline

Definition at line 230 of file _deque.h.

                                                                    {
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
     _Invalidate_all();
     _M_non_dbg_impl.assign(__first, __last);
   }

◆ assign() [5/9]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::assign	(	const_pointer	__first,
		const_pointer	__last
	)

inline

Definition at line 258 of file _deque.h.

259 { _M_impl.assign(cast_traits::to_storage_type_cptr(__first),

260 cast_traits::to_storage_type_cptr(__last)); }

_STLP_INLINE_LOOP _InputIter __last

Definition: _algo.h:68

_Base _M_impl

Definition: _deque.h:371

◆ assign() [6/9]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::assign	(	const_iterator	__first,
		const_iterator	__last
	)

inline

Definition at line 261 of file _deque.h.

262 { _M_impl.assign(ite_cast_traits::to_storage_type_cite(__first),

263 ite_cast_traits::to_storage_type_cite(__last)); }

_STLP_INLINE_LOOP _InputIter __last

Definition: _algo.h:68

_Base _M_impl

Definition: _deque.h:371

◆ assign() [7/9]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::assign	(	size_type	__n,
		const _Tp &	__val
	)

inline

Definition at line 598 of file _deque.h.

                                                {
     _M_fill_assign(__n, __val);
   }

Referenced by MoveConstructorTest::deque_test(), and PtrSpecTest::ptr_specialization_test().

◆ assign() [8/9]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::assign	(	const value_type *	__first,
		const value_type *	__last
	)

inline

Definition at line 637 of file _deque.h.

                                                                    {
     size_type __size = size();
     size_type __len = __last - __first;
     if (__len > __size) {
       const value_type *__mid = __first + __size;
       _STLP_STD::copy(__first, __mid, begin());
       insert(end(), __mid, __last);
     }
     else {
       erase(_STLP_STD::copy(__first, __last, begin()), end());
     }
   }

◆ assign() [9/9]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::assign	(	const_iterator	__first,
		const_iterator	__last
	)

inline

Definition at line 649 of file _deque.h.

                                                              {
     typedef const_iterator _ForwardIterator;
 #endif /* _STLP_MEMBER_TEMPLATES */
     size_type __len = _STLP_STD::distance(__first, __last);
     if (__len > size()) {
       _ForwardIterator __mid = __first;
       _STLP_STD::advance(__mid, size());
       _STLP_STD::copy(__first, __mid, begin());
       insert(end(), __mid, __last);
     }
     else {
       erase(_STLP_STD::copy(__first, __last, begin()), end());
     }
   }

◆ at() [1/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::at ( size_type __n )

inline

Definition at line 108 of file _deque.h.

108 { return _M_non_dbg_impl.at(__n); }

return __n

Definition: _algo.h:75

_Base _M_non_dbg_impl

Definition: _deque.h:75

◆ at() [2/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::at ( size_type __n ) const

inline

Definition at line 109 of file _deque.h.

109 { return _M_non_dbg_impl.at(__n); }

return __n

Definition: _algo.h:75

_Base _M_non_dbg_impl

Definition: _deque.h:75

◆ at() [3/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::at ( size_type __n )

inline

Definition at line 144 of file _deque.h.

145 { return cast_traits::to_value_type_ref(_M_impl.at(__n)); }

return __n

Definition: _algo.h:75

_Base _M_impl

Definition: _deque.h:371

◆ at() [4/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::at ( size_type __n ) const

inline

Definition at line 146 of file _deque.h.

147 { return cast_traits::to_value_type_cref(_M_impl.at(__n)); }

return __n

Definition: _algo.h:75

_Base _M_impl

Definition: _deque.h:371

◆ at() [5/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::at ( size_type __n )

inline

Definition at line 453 of file _deque.h.

454 { _M_range_check(__n); return (*this)[__n]; }

return __n

Definition: _algo.h:75

deque::_M_range_check

void _M_range_check(size_type __n) const

Definition: _deque.h:449

◆ at() [6/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::at ( size_type __n ) const

inline

Definition at line 455 of file _deque.h.

456 { _M_range_check(__n); return (*this)[__n]; }

return __n

Definition: _algo.h:75

deque::_M_range_check

void _M_range_check(size_type __n) const

Definition: _deque.h:449

◆ back() [1/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::back ( )

inline

Definition at line 119 of file _deque.h.

                    {
     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
     return *(--end());
   }

◆ back() [2/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::back ( ) const

inline

Definition at line 123 of file _deque.h.

                                {
     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
     return *(--end());
   }

◆ back() [3/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::back ( )

inline

Definition at line 150 of file _deque.h.

150 { return cast_traits::to_value_type_ref(_M_impl.back()); }

_Base _M_impl

Definition: _deque.h:371

◆ back() [4/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::back ( ) const

inline

Definition at line 152 of file _deque.h.

152 { return cast_traits::to_value_type_cref(_M_impl.back()); }

_Base _M_impl

Definition: _deque.h:371

◆ back() [5/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::back ( )

inline

Definition at line 459 of file _deque.h.

                    {
     iterator __tmp = this->_M_finish;
     --__tmp;
     return *__tmp;
   }

◆ back() [6/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::back ( ) const

inline

Definition at line 465 of file _deque.h.

                                {
     const_iterator __tmp = this->_M_finish;
     --__tmp;
     return *__tmp;
   }

◆ begin() [1/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::begin ( )

inline

Definition at line 89 of file _deque.h.

89 { return iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }

_STLP_PRIV __owned_list _M_iter_list

Definition: _deque.h:76

_Base _M_non_dbg_impl

Definition: _deque.h:75

deque::iterator

_Base::iterator iterator

Definition: _deque.h:420

◆ begin() [2/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_iterator deque< _Tp, >::begin ( ) const

inline

Definition at line 91 of file _deque.h.

91 { return const_iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }

_Base::const_iterator const_iterator

Definition: _deque.h:421

_STLP_PRIV __owned_list _M_iter_list

Definition: _deque.h:76

_Base _M_non_dbg_impl

Definition: _deque.h:75

◆ begin() [3/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::begin ( )

inline

Definition at line 127 of file _deque.h.

127 { return ite_cast_traits::to_value_type_ite(_M_impl.begin()); }

_Base _M_impl

Definition: _deque.h:371

◆ begin() [4/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_iterator deque< _Tp, >::begin ( ) const

inline

Definition at line 129 of file _deque.h.

129 { return ite_cast_traits::to_value_type_cite(_M_impl.begin()); }

_Base _M_impl

Definition: _deque.h:371

◆ begin() [5/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::begin ( )

inline

◆ begin() [6/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_iterator deque< _Tp, >::begin ( ) const

inline

Definition at line 434 of file _deque.h.

434 { return const_iterator(this->_M_start); }

_Base::const_iterator const_iterator

Definition: _deque.h:421

◆ clear() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::clear ( void )

inline

Definition at line 368 of file _deque.h.

368 { _M_impl.clear(); }

_Base _M_impl

Definition: _deque.h:371

◆ clear() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::clear ( void )

inline

Definition at line 400 of file _deque.h.

                {
     _Invalidate_all();
     _M_non_dbg_impl.clear();
   }

◆ clear() [3/3]

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::clear ( void )

Definition at line 346 of file _deque.c.

                               {
   for (_Map_pointer __node = this->_M_start._M_node + 1;
        __node < this->_M_finish._M_node;
        ++__node) {
     _STLP_STD::_Destroy_Range(*__node, *__node + this->buffer_size());
     this->_M_map_size.deallocate(*__node, this->buffer_size());
   }
 
   if (this->_M_start._M_node != this->_M_finish._M_node) {
     _STLP_STD::_Destroy_Range(this->_M_start._M_cur, this->_M_start._M_last);
     _STLP_STD::_Destroy_Range(this->_M_finish._M_first, this->_M_finish._M_cur);
     this->_M_map_size.deallocate(this->_M_finish._M_first, this->buffer_size());
   }
   else
     _STLP_STD::_Destroy_Range(this->_M_start._M_cur, this->_M_finish._M_cur);
 
   this->_M_finish = this->_M_start;
 }

Referenced by deque< IncompleteClass >::erase().

◆ empty() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

bool deque< _Tp, >::empty ( ) const

inline

Definition at line 156 of file _deque.h.

156 { return _M_impl.empty(); }

_Base _M_impl

Definition: _deque.h:371

◆ empty() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

bool deque< _Tp, >::empty ( ) const

inline

Definition at line 199 of file _deque.h.

199 { return _M_non_dbg_impl.empty(); }

_Base _M_non_dbg_impl

Definition: _deque.h:75

◆ empty() [3/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

bool deque< _Tp, >::empty ( ) const

inline

Definition at line 473 of file _deque.h.

473 { return this->_M_finish == this->_M_start; }

Referenced by deque< IncompleteClass >::back(), deque< IncompleteClass >::erase(), deque< IncompleteClass >::front(), deque< IncompleteClass >::pop_back(), deque< IncompleteClass >::pop_front(), and BtrfsPropSheet::search_list_thread().

◆ end() [1/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::end ( )

inline

Definition at line 90 of file _deque.h.

90 { return iterator(&_M_iter_list, _M_non_dbg_impl.end()); }

_STLP_PRIV __owned_list _M_iter_list

Definition: _deque.h:76

_Base _M_non_dbg_impl

Definition: _deque.h:75

deque::iterator

_Base::iterator iterator

Definition: _deque.h:420

◆ end() [2/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_iterator deque< _Tp, >::end ( ) const

inline

Definition at line 92 of file _deque.h.

92 { return const_iterator(&_M_iter_list, _M_non_dbg_impl.end()); }

_Base::const_iterator const_iterator

Definition: _deque.h:421

_STLP_PRIV __owned_list _M_iter_list

Definition: _deque.h:76

_Base _M_non_dbg_impl

Definition: _deque.h:75

◆ end() [3/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::end ( )

inline

Definition at line 128 of file _deque.h.

128 { return ite_cast_traits::to_value_type_ite(_M_impl.end()); }

_Base _M_impl

Definition: _deque.h:371

◆ end() [4/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_iterator deque< _Tp, >::end ( ) const

inline

Definition at line 130 of file _deque.h.

130 { return ite_cast_traits::to_value_type_cite(_M_impl.end()); }

_Base _M_impl

Definition: _deque.h:371

◆ end() [5/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::end ( )

inline

◆ end() [6/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_iterator deque< _Tp, >::end ( ) const

inline

Definition at line 435 of file _deque.h.

435 { return const_iterator(this->_M_finish); }

_Base::const_iterator const_iterator

Definition: _deque.h:421

◆ erase() [1/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::erase ( iterator __pos )

inline

Definition at line 362 of file _deque.h.

363 { return ite_cast_traits::to_value_type_ite(_M_impl.erase(ite_cast_traits::to_storage_type_ite(__pos))); }

_Base _M_impl

Definition: _deque.h:371

◆ erase() [2/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::erase	(	iterator	__first,
		iterator	__last
	)

inline

Definition at line 365 of file _deque.h.

366 { return ite_cast_traits::to_value_type_ite(_M_impl.erase(ite_cast_traits::to_storage_type_ite(__first),

367 ite_cast_traits::to_storage_type_ite(__last))); }

_STLP_INLINE_LOOP _InputIter __last

Definition: _algo.h:68

_Base _M_impl

Definition: _deque.h:371

◆ erase() [3/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::erase ( iterator __pos )

inline

Definition at line 373 of file _deque.h.

                                  {
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
     _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
     if (__pos._M_iterator == _M_non_dbg_impl.begin()) {
       _Invalidate_iterator(__pos);
     } else {
       typename _Base::iterator tmp = --(_M_non_dbg_impl.end());
       if (__pos._M_iterator == tmp)
         _Invalidate_iterator(__pos);
       else
         _Invalidate_all();
     }
     return iterator (&_M_iter_list, _M_non_dbg_impl.erase(__pos._M_iterator));
   }

◆ erase() [4/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::erase	(	iterator	__first,
		iterator	__last
	)

inline

Definition at line 388 of file _deque.h.

                                                     {
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
     if (!empty()) {
       if (__first._M_iterator == _M_non_dbg_impl.begin() ||
           __last._M_iterator == _M_non_dbg_impl.end())
         _Invalidate_iterators(__first, __last);
       else
         _Invalidate_all();
     }
     return iterator (&_M_iter_list, _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator));
   }

◆ erase() [5/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::erase ( iterator __pos )

inline

Definition at line 835 of file _deque.h.

                                  {
 #if !defined (_STLP_NO_MOVE_SEMANTIC)
     typedef typename __move_traits<_Tp>::implemented _Movable;
 #endif
     return _M_erase(__pos, _Movable());
   }

Referenced by deque< IncompleteClass >::_M_fill_assign(), deque< IncompleteClass >::assign(), MoveConstructorTest::deque_test(), DequeTest::erase(), MoveConstructorTest::move_traits_deq(), MoveConstructorTest::move_traits_deq_complete(), and deque< IncompleteClass >::resize().

◆ erase() [6/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::erase	(	iterator	__first,
		iterator	__last
	)

inline

Definition at line 841 of file _deque.h.

                                                     {
 #if !defined (_STLP_NO_MOVE_SEMANTIC)
     typedef typename __move_traits<_Tp>::implemented _Movable;
 #endif
     if (__first == this->_M_start && __last == this->_M_finish) {
       clear();
       return this->_M_finish;
     }
     else {
       if (__first == __last)
         return __first;
       return _M_erase(__first, __last, _Movable());
     }
   }

◆ front() [1/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::front ( )

inline

Definition at line 111 of file _deque.h.

                     {
     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
     return *begin();
   }

◆ front() [2/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::front ( ) const

inline

Definition at line 115 of file _deque.h.

                                 {
     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
     return *begin();
   }

◆ front() [3/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::front ( )

inline

Definition at line 149 of file _deque.h.

149 { return cast_traits::to_value_type_ref(_M_impl.front()); }

_Base _M_impl

Definition: _deque.h:371

◆ front() [4/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::front ( ) const

inline

Definition at line 151 of file _deque.h.

151 { return cast_traits::to_value_type_cref(_M_impl.front()); }

_Base _M_impl

Definition: _deque.h:371

◆ front() [5/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::front ( )

inline

Definition at line 458 of file _deque.h.

458 { return *this->_M_start; }

Referenced by MoveConstructorTest::deque_test(), and BtrfsPropSheet::search_list_thread().

◆ front() [6/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::front ( ) const

inline

Definition at line 464 of file _deque.h.

464 { return *this->_M_start; }

◆ get_allocator() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

allocator_type deque< _Tp, >::get_allocator ( ) const

inline

Definition at line 87 of file _deque.h.

87 { return _M_non_dbg_impl.get_allocator(); }

_Base _M_non_dbg_impl

Definition: _deque.h:75

◆ get_allocator() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

allocator_type deque< _Tp, >::get_allocator ( ) const

inline

Definition at line 157 of file _deque.h.

157 { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); }

_STLP_CONVERT_ALLOCATOR

#define _STLP_CONVERT_ALLOCATOR(__a, _Tp)

Definition: _alloc.h:183

deque::value_type

_Tp value_type

Definition: _deque.h:408

_Base _M_impl

Definition: _deque.h:371

◆ get_allocator() [3/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

allocator_type deque< _Tp, >::get_allocator ( ) const

inline

Definition at line 474 of file _deque.h.

474 { return this->_M_map_size; }

◆ insert() [1/13]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::insert	(	iterator	__pos,
		const value_type &	__x = `_Tp()`
	)

inline

Definition at line 286 of file _deque.h.

                                                                  {
 #else
   iterator insert(iterator __pos, const value_type& __x) {
 #endif
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
     _Invalidate_all();
     return iterator(&_M_iter_list, _M_non_dbg_impl.insert(__pos._M_iterator, __x));
   }

◆ insert() [2/13]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::insert	(	iterator	__pos,
		const value_type &	__x = `_STLP_DEFAULT_CONSTRUCTED(value_type)`
	)

inline

_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS

Definition at line 289 of file _deque.h.

293 { return ite_cast_traits::to_value_type_ite(_M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos),

294 cast_traits::to_storage_type_cref(__x))); }

_Base _M_impl

Definition: _deque.h:371

◆ insert() [3/13]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::insert	(	iterator	__pos,
		size_type	__n,
		const value_type &	__x
	)

inline

Definition at line 300 of file _deque.h.

301 { _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), __n, cast_traits::to_storage_type_cref(__x)); }

return __n

Definition: _algo.h:75

Referenced by deque< IncompleteClass >::_M_fill_assign(), deque< IncompleteClass >::assign(), MoveConstructorTest::deque_test(), deque< IncompleteClass >::insert(), MoveConstructorTest::move_traits_deq(), MoveConstructorTest::move_traits_deq_complete(), PtrSpecTest::ptr_specialization_test(), and deque< IncompleteClass >::resize().

_Base _M_impl

Definition: _deque.h:371

◆ insert() [4/13]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::insert	(	iterator	__pos,
		size_type	__n,
		const value_type &	__x
	)

inline

Definition at line 303 of file _deque.h.

                                                                     {
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
     if (__n != 0) _Invalidate_all();
     _M_non_dbg_impl.insert(__pos._M_iterator, __n, __x);
   }

◆ insert() [5/13]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::insert	(	iterator	__pos,
		const value_type *	__first,
		const value_type *	__last
	)

inline

Definition at line 323 of file _deque.h.

                                                                    {
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
     if (__first != __last) _Invalidate_all();
     _M_non_dbg_impl.insert(__pos._M_iterator, __first, __last);
   }

◆ insert() [6/13]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::insert	(	iterator	__pos,
		const_iterator	__first,
		const_iterator	__last
	)

inline

Definition at line 333 of file _deque.h.

                                                              {
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
     //Sequence requirements 23.1.1 Table 67:
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_not_owner(&_M_iter_list, __first));
     if (__first != __last) _Invalidate_all();
     _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
   }

◆ insert() [7/13]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::insert	(	iterator	__pos,
		const_pointer	__first,
		const_pointer	__last
	)

inline

Definition at line 336 of file _deque.h.

                                                            {
     _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos),
                    cast_traits::to_storage_type_cptr(__first),
                    cast_traits::to_storage_type_cptr(__last));
   }

◆ insert() [8/13]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::insert	(	iterator	__pos,
		const_iterator	__first,
		const_iterator	__last
	)

inline

Definition at line 342 of file _deque.h.

                                                              {
     _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos),
                    ite_cast_traits::to_storage_type_cite(__first),
                    ite_cast_traits::to_storage_type_cite(__last));
   }

◆ insert() [9/13]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::insert	(	iterator	__pos,
		iterator	__first,
		iterator	__last
	)

inline

Definition at line 343 of file _deque.h.

                                                  {
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
     //Sequence requirements 23.1.1 Table 67:
     _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_not_owner(&_M_iter_list, __first));
     if (__first != __last) _Invalidate_all();
     _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
   }

◆ insert() [10/13]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

iterator deque< _Tp, >::insert	(	iterator	__pos,
		const value_type &	__x = `_STLP_DEFAULT_CONSTRUCTED(_Tp)`
	)

inline

_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS

Definition at line 730 of file _deque.h.

                                                                                           {
 #else
   iterator insert(iterator __pos, const value_type& __x) {
 #endif 
 #if !defined (_STLP_NO_MOVE_SEMANTIC)
     typedef typename __move_traits<_Tp>::implemented _Movable;
 #endif
     if (__pos._M_cur == this->_M_start._M_cur) {
       push_front(__x);
       return this->_M_start;
     }
     else if (__pos._M_cur == this->_M_finish._M_cur) {
       push_back(__x);
       iterator __tmp = this->_M_finish;
       --__tmp;
       return __tmp;
     }
     else {
       return _M_fill_insert_aux(__pos, 1, __x, _Movable());
     }
   }

◆ insert() [11/13]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::insert	(	iterator	__pos,
		size_type	__n,
		const value_type &	__x
	)

inline

Definition at line 757 of file _deque.h.

758 { _M_fill_insert(__pos, __n, __x); }

return __n

Definition: _algo.h:75

deque::_M_fill_insert

void _M_fill_insert(iterator __pos, size_type __n, const value_type &__x)

Definition: _deque.c:122

◆ insert() [12/13]

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::insert	(	iterator	__pos,
		const value_type *	__first,
		const value_type *	__last
	)

Definition at line 150 of file _deque.c.

                                                                                      {
 #if !defined (_STLP_NO_MOVE_SEMANTIC)
   typedef typename __move_traits<_Tp>::implemented _Movable;
 #endif
   size_type __n = __last - __first;
   if (__pos._M_cur == this->_M_start._M_cur) {
     iterator __new_start = _M_reserve_elements_at_front(__n);
     _STLP_TRY {
       _STLP_PRIV __ucopy(__first, __last, __new_start);
     }
     _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
     this->_M_start = __new_start;
   }
   else if (__pos._M_cur == this->_M_finish._M_cur) {
     iterator __new_finish = _M_reserve_elements_at_back(__n);
     _STLP_TRY {
       _STLP_PRIV __ucopy(__first, __last, this->_M_finish);
     }
     _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1,
                                         __new_finish._M_node + 1))
     this->_M_finish = __new_finish;
   }
   else
     _M_insert_range_aux(__pos, __first, __last, __n, _Movable());
 }

◆ insert() [13/13]

template<class _Tp , class _Alloc >

void deque< _Tp, _Alloc >::insert	(	iterator	__pos,
		const_iterator	__first,
		const_iterator	__last
	)

Definition at line 178 of file _deque.c.

                                                                               {
 #if !defined (_STLP_NO_MOVE_SEMANTIC)
   typedef typename __move_traits<_Tp>::implemented _Movable;
 #endif
   size_type __n = __last - __first;
   if (__pos._M_cur == this->_M_start._M_cur) {
     iterator __new_start = _M_reserve_elements_at_front(__n);
     _STLP_TRY {
       _STLP_PRIV __ucopy(__first, __last, __new_start);
     }
     _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
     this->_M_start = __new_start;
   }
   else if (__pos._M_cur == this->_M_finish._M_cur) {
     iterator __new_finish = _M_reserve_elements_at_back(__n);
     _STLP_TRY {
       _STLP_PRIV __ucopy(__first, __last, this->_M_finish);
     }
     _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1,
                                         __new_finish._M_node + 1))
     this->_M_finish = __new_finish;
   }
   else
     _M_insert_range_aux(__pos, __first, __last, __n, _Movable());
 }

◆ max_size() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

size_type deque< _Tp, >::max_size ( ) const

inline

Definition at line 155 of file _deque.h.

155 { return _M_impl.max_size(); }

_Base _M_impl

Definition: _deque.h:371

◆ max_size() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

size_type deque< _Tp, >::max_size ( ) const

inline

Definition at line 201 of file _deque.h.

201 { return _M_non_dbg_impl.max_size(); }

_Base _M_non_dbg_impl

Definition: _deque.h:75

◆ max_size() [3/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

size_type deque< _Tp, >::max_size ( ) const

inline

Definition at line 472 of file _deque.h.

472 { return size_type(-1); }

deque::size_type

size_t size_type

Definition: _deque.h:413

◆ operator=() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

_Self& deque< _Tp, >::operator= ( const _Self & __x )

inline

Definition at line 191 of file _deque.h.

                                      {
     if (this != &__x) {
       _Invalidate_all();
       _M_non_dbg_impl = __x._M_non_dbg_impl;
     }
     return *this;
   }

◆ operator=() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

_Self& deque< _Tp, >::operator= ( const _Self & __x )

inline

Definition at line 220 of file _deque.h.

220 { _M_impl = __x._M_impl; return *this; }

_Base _M_impl

Definition: _deque.h:371

◆ operator=() [3/3]

template<class _Tp , class _Alloc >

deque< _Tp, _Alloc > & deque< _Tp, _Alloc >::operator= ( const _Self & __x )

Definition at line 107 of file _deque.c.

                                                               {
   const size_type __len = size();
   if (&__x != this) {
     if (__len >= __x.size())
       erase(_STLP_STD::copy(__x.begin(), __x.end(), this->_M_start), this->_M_finish);
     else {
       const_iterator __mid = __x.begin() + difference_type(__len);
       _STLP_STD::copy(__x.begin(), __mid, this->_M_start);
       insert(this->_M_finish, __mid, __x.end());
     }
   }
   return *this;
 }

◆ operator[]() [1/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::operator[] ( size_type __n )

inline

Definition at line 99 of file _deque.h.

                                       {
     _STLP_VERBOSE_ASSERT(__n < size(), _StlMsg_OUT_OF_BOUNDS)
     return _M_non_dbg_impl[__n];
   }

◆ operator[]() [2/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::operator[] ( size_type __n ) const

inline

Definition at line 103 of file _deque.h.

                                                   {
     _STLP_VERBOSE_ASSERT(__n < size(), _StlMsg_OUT_OF_BOUNDS)
     return _M_non_dbg_impl[__n];
   }

◆ operator[]() [3/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::operator[] ( size_type __n )

inline

Definition at line 139 of file _deque.h.

140 { return cast_traits::to_value_type_ref(_M_impl[__n]); }

return __n

Definition: _algo.h:75

_Base _M_impl

Definition: _deque.h:371

◆ operator[]() [4/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::operator[] ( size_type __n ) const

inline

Definition at line 141 of file _deque.h.

142 { return cast_traits::to_value_type_cref(_M_impl[__n]); }

return __n

Definition: _algo.h:75

_Base _M_impl

Definition: _deque.h:371

◆ operator[]() [5/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reference deque< _Tp, >::operator[] ( size_type __n )

inline

Definition at line 444 of file _deque.h.

445 { return this->_M_start[difference_type(__n)]; }

deque::difference_type

ptrdiff_t difference_type

Definition: _deque.h:414

return __n

Definition: _algo.h:75

◆ operator[]() [6/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reference deque< _Tp, >::operator[] ( size_type __n ) const

inline

Definition at line 446 of file _deque.h.

447 { return this->_M_start[difference_type(__n)]; }

deque::difference_type

ptrdiff_t difference_type

Definition: _deque.h:414

return __n

Definition: _algo.h:75

◆ pop_back() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::pop_back ( )

inline

Definition at line 271 of file _deque.h.

                   {
     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
     _Invalidate_iterator(end());
     _M_non_dbg_impl.pop_back();
   }

◆ pop_back() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::pop_back ( )

inline

Definition at line 285 of file _deque.h.

285 { _M_impl.pop_back(); }

_Base _M_impl

Definition: _deque.h:371

◆ pop_back() [3/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::pop_back ( )

inline

Definition at line 711 of file _deque.h.

                   {
     if (this->_M_finish._M_cur != this->_M_finish._M_first) {
       --this->_M_finish._M_cur;
       _STLP_STD::_Destroy(this->_M_finish._M_cur);
     }
     else {
       _M_pop_back_aux();
       _STLP_STD::_Destroy(this->_M_finish._M_cur);
     }
   }

◆ pop_front() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::pop_front ( )

inline

Definition at line 277 of file _deque.h.

                    {
     _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
     _Invalidate_iterator(begin());
     _M_non_dbg_impl.pop_front();
   }

◆ pop_front() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::pop_front ( )

inline

Definition at line 286 of file _deque.h.

286 { _M_impl.pop_front(); }

_Base _M_impl

Definition: _deque.h:371

◆ pop_front() [3/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::pop_front ( )

inline

Definition at line 722 of file _deque.h.

                    {
     _STLP_STD::_Destroy(this->_M_start._M_cur);
     _M_pop_front_aux();
   }

Referenced by BtrfsPropSheet::search_list_thread().

◆ push_back() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::push_back ( const value_type & __t = _Tp() )

inline

Definition at line 240 of file _deque.h.

                                                 {
 #else
   void push_back(const value_type& __t) {
 #endif
     _Invalidate_all();
     _M_non_dbg_impl.push_back(__t);
   }

◆ push_back() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::push_back ( const value_type & __t = _STLP_DEFAULT_CONSTRUCTED(value_type) )

inline

_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS

Definition at line 267 of file _deque.h.

271 { _M_impl.push_back(cast_traits::to_storage_type_cref(__t)); }

_Base _M_impl

Definition: _deque.h:371

◆ push_back() [3/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::push_back ( const value_type & __t = _STLP_DEFAULT_CONSTRUCTED(_Tp) )

inline

_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS

Definition at line 668 of file _deque.h.

                                                                          {
 #else
   void push_back(const value_type& __t) {
 #endif 
     if (this->_M_finish._M_cur != this->_M_finish._M_last - 1) {
       _Copy_Construct(this->_M_finish._M_cur, __t);
       ++this->_M_finish._M_cur;
     }
     else
       _M_push_back_aux_v(__t);
   }

Referenced by DequeTest::auto_ref(), BtrfsPropSheet::check_file(), BtrfsPropSheet::do_search(), DequeTest::erase(), deque< IncompleteClass >::insert(), MoveConstructorTest::move_traits_deq(), MoveConstructorTest::move_traits_deq_complete(), deque< IncompleteClass >::push_back(), StringTest::replace(), BtrfsPropSheet::set_cmdline(), and AlgTest::sort_test().

◆ push_front() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::push_front ( const value_type & __t = _Tp() )

inline

Definition at line 256 of file _deque.h.

                                                  {
 #else
   void push_front(const value_type& __t) {
 #endif
     _Invalidate_all();
     _M_non_dbg_impl.push_front(__t);
   }

◆ push_front() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::push_front ( const value_type & __t = _STLP_DEFAULT_CONSTRUCTED(value_type) )

inline

_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS

Definition at line 274 of file _deque.h.

278 { _M_impl.push_front(cast_traits::to_storage_type_cref(__t)); }

_Base _M_impl

Definition: _deque.h:371

◆ push_front() [3/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::push_front ( const value_type & __t = _STLP_DEFAULT_CONSTRUCTED(_Tp) )

inline

_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS

Definition at line 680 of file _deque.h.

                                                                             {
 #else
   void push_front(const value_type& __t)   {
 #endif 
     if (this->_M_start._M_cur != this->_M_start._M_first) {
       _Copy_Construct(this->_M_start._M_cur - 1, __t);
       --this->_M_start._M_cur;
     }
     else
       _M_push_front_aux_v(__t);
   }

Referenced by DequeTest::erase(), deque< IncompleteClass >::insert(), and deque< IncompleteClass >::push_front().

◆ rbegin() [1/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reverse_iterator deque< _Tp, >::rbegin ( )

inline

Definition at line 94 of file _deque.h.

94 { return reverse_iterator(end()); }

iterator end()

Definition: _deque.h:433

#define reverse_iterator

Definition: _abbrevs.h:34

◆ rbegin() [2/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reverse_iterator deque< _Tp, >::rbegin ( ) const

inline

Definition at line 96 of file _deque.h.

96 { return const_reverse_iterator(end()); }

iterator end()

Definition: _deque.h:433

◆ rbegin() [3/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reverse_iterator deque< _Tp, >::rbegin ( )

inline

Definition at line 132 of file _deque.h.

132 { return reverse_iterator(end()); }

iterator end()

Definition: _deque.h:433

#define reverse_iterator

Definition: _abbrevs.h:34

◆ rbegin() [4/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reverse_iterator deque< _Tp, >::rbegin ( ) const

inline

Definition at line 134 of file _deque.h.

135 { return const_reverse_iterator(end()); }

iterator end()

Definition: _deque.h:433

◆ rbegin() [5/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reverse_iterator deque< _Tp, >::rbegin ( )

inline

Definition at line 437 of file _deque.h.

437 { return reverse_iterator(this->_M_finish); }

#define reverse_iterator

Definition: _abbrevs.h:34

◆ rbegin() [6/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reverse_iterator deque< _Tp, >::rbegin ( ) const

inline

Definition at line 439 of file _deque.h.

440 { return const_reverse_iterator(this->_M_finish); }

◆ rend() [1/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reverse_iterator deque< _Tp, >::rend ( )

inline

Definition at line 95 of file _deque.h.

95 { return reverse_iterator(begin()); }

#define reverse_iterator

Definition: _abbrevs.h:34

iterator begin()

Definition: _deque.h:432

◆ rend() [2/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reverse_iterator deque< _Tp, >::rend ( ) const

inline

Definition at line 97 of file _deque.h.

97 { return const_reverse_iterator(begin()); }

iterator begin()

Definition: _deque.h:432

◆ rend() [3/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reverse_iterator deque< _Tp, >::rend ( )

inline

Definition at line 133 of file _deque.h.

133 { return reverse_iterator(begin()); }

#define reverse_iterator

Definition: _abbrevs.h:34

iterator begin()

Definition: _deque.h:432

◆ rend() [4/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reverse_iterator deque< _Tp, >::rend ( ) const

inline

Definition at line 136 of file _deque.h.

137 { return const_reverse_iterator(begin()); }

iterator begin()

Definition: _deque.h:432

◆ rend() [5/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

reverse_iterator deque< _Tp, >::rend ( )

inline

Definition at line 438 of file _deque.h.

438 { return reverse_iterator(this->_M_start); }

#define reverse_iterator

Definition: _abbrevs.h:34

◆ rend() [6/6]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

const_reverse_iterator deque< _Tp, >::rend ( ) const

inline

Definition at line 441 of file _deque.h.

442 { return const_reverse_iterator(this->_M_start); }

◆ resize() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::resize	(	size_type	__new_size,
		const value_type &	__x = `_STLP_DEFAULT_CONSTRUCTED(value_type)`
	)

inline

Definition at line 352 of file _deque.h.

356 { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x)); }

_Base _M_impl

Definition: _deque.h:371

◆ resize() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::resize	(	size_type	__new_size,
		const value_type &	__x = `_Tp()`
	)

inline

Definition at line 355 of file _deque.h.

                                                                    {
 #else
   void resize(size_type __new_size, const value_type& __x) {
 #endif
     if (__new_size != size()) {
       if ((__new_size > size()) || (__new_size < size() - 1))
         _Invalidate_all();
       else
         _Invalidate_iterator(end());
     }
     _M_non_dbg_impl.resize(__new_size, __x);
   }

◆ resize() [3/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::resize	(	size_type	__new_size,
		const value_type &	__x = `_STLP_DEFAULT_CONSTRUCTED(_Tp)`
	)

inline

Definition at line 811 of file _deque.h.

                                                                       {
 #else
   void resize(size_type __new_size, const value_type& __x) {
 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/
     const size_type __len = size();
     if (__new_size < __len)
       erase(this->_M_start + __new_size, this->_M_finish);
     else
       insert(this->_M_finish, __new_size - __len, __x);
   }

Referenced by deque< IncompleteClass >::resize().

◆ size() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

size_type deque< _Tp, >::size ( ) const

inline

Definition at line 154 of file _deque.h.

154 { return _M_impl.size(); }

_Base _M_impl

Definition: _deque.h:371

◆ size() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

size_type deque< _Tp, >::size ( ) const

inline

Definition at line 200 of file _deque.h.

200 { return _M_non_dbg_impl.size(); }

Referenced by deque< IncompleteClass >::_M_fill_assign(), deque< IncompleteClass >::_M_range_check(), deque< IncompleteClass >::assign(), MoveConstructorTest::deque_test(), BtrfsPropSheet::Initialize(), deque< IncompleteClass >::operator=(), deque< IncompleteClass >::operator[](), DequeTest::optimizations_check(), deque< IncompleteClass >::resize(), and BtrfsPropSheet::set_cmdline().

_Base _M_non_dbg_impl

Definition: _deque.h:75

◆ size() [3/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

size_type deque< _Tp, >::size ( ) const

inline

Definition at line 471 of file _deque.h.

471 { return this->_M_finish - this->_M_start; }

◆ swap() [1/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::swap ( _Self & __x )

inline

Definition at line 203 of file _deque.h.

                         {
     _M_iter_list._Swap_owners(__x._M_iter_list);
     _M_non_dbg_impl.swap(__x._M_non_dbg_impl);
   }

◆ swap() [2/3]

template<class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >) >

void deque< _Tp, >::swap ( _Self & __x )

inline

Definition at line 222 of file _deque.h.

222 { _M_impl.swap(__x._M_impl); }