deque.cc

realview22.rar

            copy (begin () + __n + __n, begin () + __n + __inx,
                  begin () + __n);
            fill (begin () + __inx, begin () + __n + __inx, __val);
        }
    }
    else {
        difference_type orig_len = __inx + __rem;
        if (__n > (size_type)__rem) {
            for (difference_type __i = __n - __rem; __i > 0; --__i)
                push_back (__val);

            for (difference_type __j = 0; __j < __rem; ++__j)
                push_back (*(begin () + __inx + __j));

            fill (begin () + __inx, begin () + orig_len, __val);
        }
        else {
            difference_type __i = 0;
            while ((size_type)__i < __n)
                push_back (*(begin () + orig_len - __n + __i++));
            copy_backward (begin () + __inx, begin () + orig_len - __n, 
                           begin () + orig_len);
            fill (begin () + __inx, begin () + __inx + __n, __val);
        }
    }
}


#ifndef _RWSTD_NO_MEMBER_TEMPLATES

template <class _TypeT, class _Allocator>
template <class _InputIter>
void deque<_TypeT, _Allocator>::
__insert_aux2 (iterator __pos, _InputIter __first, _InputIter __last)
{
    _RWSTD_ASSERT_RANGE (begin (), __pos);
    _RWSTD_ASSERT_RANGE (__first, __last);

    difference_type __inx = __pos - begin ();
    difference_type __rem = size () - __inx;
    size_type         __n = _DISTANCE (__first, __last, size_type);

    if (__rem > __inx)
    {
      if (__n > (size_type)__inx)
      {
        // FIXME: operator-() being applied to InputIterator
        //        assumes RandomAccessIterator
        _InputIter __m = __last - __inx;
        while (__m != __first)
            push_front (*--__m);
        difference_type __i = __inx;
        while (__i--)
            push_front (*(begin () + __n - 1));
        copy (__last - __inx, __last, begin () + __n);
      }
      else
      {
        difference_type __i = __n;
        while (__i--)
            push_front (*(begin () + __n - 1));
        copy (begin () + __n + __n, begin () + __n + __inx, begin () + __n);
        copy (__first, __last, begin () + __inx);
      }
    }
    else
    {
      difference_type orig_len = __inx + __rem;
      if (__n > (size_type)__rem)
      {
        _InputIter __m = __first + __rem;
        for ( ; __m != __last; ++__m )
            push_back (*__m);
        difference_type __i = 0;
        while (__i < __rem)
            push_back (*(begin () + __inx + __i++));
        copy (__first, __first + __rem, begin () + __inx);
      }
      else
      {
        difference_type __i = 0;
        while ((size_type)__i < __n)
            push_back (*(begin () + orig_len - __n + __i++));
        copy_backward (begin () + __inx, begin () + orig_len - __n, 
                      begin () + orig_len);
        copy (__first, __last, begin () + __inx);
      }
    }
  }

#endif
#ifdef _RWSTD_NO_MEMBER_TEMPLATES

template<class _TypeT, class _Allocator>
void deque<_TypeT, _Allocator>::
insert (iterator __pos, const_iterator __first, const_iterator __last)
{
    _RWSTD_ASSERT_RANGE (begin (), __pos);
    _RWSTD_ASSERT_RANGE (__first, __last);

    difference_type __inx = __pos - begin ();
    difference_type __rem = size () - __inx;
    size_type         __n = _DISTANCE (__first, __last, size_type);

    if (__rem > __inx)
    {
      if (__n > (size_type)__inx)
      {
        const_iterator __m = __last - __inx;
        while (__m != __first)
            push_front (*--__m);
        difference_type __i = __inx;
        while (__i--)
            push_front (*(begin () + __n - 1));
        copy (__last - __inx, __last, begin () + __n);
      }
      else
      {
        difference_type __i = __n;
        while (__i--)
            push_front (*(begin () + __n - 1));
        copy (begin () + __n + __n, begin () + __n + __inx, begin () + __n);
        copy (__first, __last, begin () + __inx);
      }
    }
    else
    {
      difference_type orig_len = __inx + __rem;
      if (__n > (size_type)__rem)
      {
        const_iterator __m = __first + __rem;
        for ( ; __m != __last; ++__m )
            push_back (*__m);
        difference_type __i = 0;
        while (__i < __rem)
            push_back (*(begin () + __inx + __i++));
        copy (__first, __first + __rem, begin () + __inx);
      }
      else
      {
        difference_type __i = 0;
        while ((size_type)__i < __n)
            push_back (*(begin () + orig_len - __n + __i++));
        copy_backward (begin () + __inx, begin () + orig_len - __n, 
                      begin () + orig_len);
        copy (__first, __last, begin () + __inx);
      }
    }
  }

template<class _TypeT, class _Allocator>
void deque<_TypeT, _Allocator>::
insert (iterator __pos, const_pointer __first, const_pointer __last)
{
    _RWSTD_ASSERT_RANGE (begin (), __pos);
    _RWSTD_ASSERT_RANGE (__first, __last);

    difference_type __inx = __pos - begin ();
    difference_type __rem = size () - __inx;
    size_type         __n = _DISTANCE (__first, __last, size_type);

    if (__rem > __inx)
    {
      if (__n > (size_type)__inx)
      {
        const_pointer __m = __last - __inx;
        while (__m != __first)
            push_front (*--__m);
        difference_type __i = __inx;
        while (__i--)
            push_front (*(begin () + __n - 1));
        copy (__last - __inx, __last, begin () + __n);
      }
      else
      {
        difference_type __i = __n;
        while (__i--) push_front (*(begin () + __n - 1));
        copy (begin () + __n + __n, begin () + __n + __inx, begin () + __n);
        copy (__first, __last, begin () + __inx);
      }
    }
    else
    {
      difference_type orig_len = __inx + __rem;
      if (__n > (size_type)__rem)
      {
        const_pointer __m = __first + __rem;
        for ( ; __m != __last; ++__m )
            push_back (*__m);
        difference_type __i = 0;
        while (__i < __rem)
            push_back (*(begin () + __inx + __i++));
        copy (__first, __first + __rem, begin () + __inx);
      }
      else
      {
        difference_type __i = 0;
        while ((size_type)__i < __n)
            push_back (*(begin () + orig_len - __n + __i++));
        copy_backward (begin () + __inx, begin () + orig_len - __n, 
                      begin () + orig_len);
        copy (__first, __last, begin () + __inx);
      }
    }
}

#endif /*_RWSTD_NO_MEMBER_TEMPLATES*/


template <class _TypeT, class _Allocator>
_TYPENAME deque<_TypeT, _Allocator>::iterator 
deque<_TypeT, _Allocator>::erase (iterator __pos)
{
    _RWSTD_ASSERT_RANGE (begin (), __pos);

    if (end () - __pos > __pos - begin ()) {
        copy_backward (begin (), __pos, __pos + 1); 
        pop_front ();

        return begin () == end () ? end () : __pos + 1;
    }

    copy (__pos + 1, end (), __pos); 
    pop_back ();
    return __pos;
}
    

template <class _TypeT, class _Allocator>
_TYPENAME deque<_TypeT, _Allocator>::iterator 
deque<_TypeT, _Allocator>::erase (iterator __first, iterator __last)
{
    _RWSTD_ASSERT_RANGE (__first, __last);
    _RWSTD_ASSERT_RANGE (begin (), __first);

    difference_type __n = __last - __first;

    if (end () - __last > __first - begin ()) {
        copy_backward (begin (), __first, __last);
        while (__n-- > 0)
            pop_front ();
        return __last;
    }

    copy (__last, end (), __first);
    while (__n-- > 0)
        pop_back ();
    return __first;
}


_RWSTD_NAMESPACE_END   // std