_M_insert_aux() [1/3]

template<typename _Tp, typename _Alloc>

template<typename _ForwardIterator>

void deque::_M_insert_aux ( iterator __pos, _ForwardIterator __first, _ForwardIterator __last, size_type __n )

protected

Definition at line 797 of file deque.tcc.

      {
      const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
      const size_type __length = size();
      if (static_cast<size_type>(__elemsbefore) < __length / 2)
        {
          iterator __new_start = _M_reserve_elements_at_front(__n);
          iterator __old_start = this->_M_impl._M_start;
          __pos = this->_M_impl._M_start + __elemsbefore;
          __try
            {
            if (__elemsbefore >= difference_type(__n))
              {
                iterator __start_n = (this->_M_impl._M_start
                                + difference_type(__n));
                std::__uninitialized_move_a(this->_M_impl._M_start,
                                    __start_n, __new_start,
                                    _M_get_Tp_allocator());
                this->_M_impl._M_start = __new_start;
                _GLIBCXX_MOVE3(__start_n, __pos, __old_start);
                std::copy(__first, __last, __pos - difference_type(__n));
              }
            else
              {
                _ForwardIterator __mid = __first;
                std::advance(__mid, difference_type(__n) - __elemsbefore);
                std::__uninitialized_move_copy(this->_M_impl._M_start,
                                       __pos, __first, __mid,
                                       __new_start,
                                       _M_get_Tp_allocator());
                this->_M_impl._M_start = __new_start;
                std::copy(__mid, __last, __old_start);
              }
            }
          __catch(...)
            {
            _M_destroy_nodes(__new_start._M_node,
                         this->_M_impl._M_start._M_node);
            __throw_exception_again;
            }
        }
      else
      {
        iterator __new_finish = _M_reserve_elements_at_back(__n);
        iterator __old_finish = this->_M_impl._M_finish;
        const difference_type __elemsafter =
          difference_type(__length) - __elemsbefore;
        __pos = this->_M_impl._M_finish - __elemsafter;
        __try
          {
            if (__elemsafter > difference_type(__n))
            {
              iterator __finish_n = (this->_M_impl._M_finish
                               - difference_type(__n));
              std::__uninitialized_move_a(__finish_n,
                                    this->_M_impl._M_finish,
                                    this->_M_impl._M_finish,
                                    _M_get_Tp_allocator());
              this->_M_impl._M_finish = __new_finish;
              _GLIBCXX_MOVE_BACKWARD3(__pos, __finish_n, __old_finish);
              std::copy(__first, __last, __pos);
            }
            else
            {
              _ForwardIterator __mid = __first;
              std::advance(__mid, __elemsafter);
              std::__uninitialized_copy_move(__mid, __last, __pos,
                                     this->_M_impl._M_finish,
                                     this->_M_impl._M_finish,
                                     _M_get_Tp_allocator());
              this->_M_impl._M_finish = __new_finish;
              std::copy(__first, __mid, __pos);
            }
          }
        __catch(...)
          {
            _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
                         __new_finish._M_node + 1);
            __throw_exception_again;
          }
      }
      }

References deque(), __catch, __throw_exception_again, __try, std::__uninitialized_move_a(), _GLIBCXX_MOVE3, _GLIBCXX_MOVE_BACKWARD3, _M_destroy_nodes(), _M_get_Tp_allocator(), _M_impl, std::_Deque_iterator< _Tp, _Ref, _Ptr >::_M_node, _M_reserve_elements_at_back(), _M_reserve_elements_at_front(), std::advance(), std::copy(), and size().

Here is the call graph for this function: