_deque.h

symbian 上的stl_port进过编译的。

      _M_map(__move_source<_Map_alloc_proxy>(src.get()._M_map)),
      _M_map_size(__move_source<_Alloc_proxy>(src.get()._M_map_size)) {
    src.get()._M_map._M_data = 0;
    src.get()._M_map_size._M_data = 0;
    src.get()._M_finish = src.get()._M_start;
  }

  ~_Deque_base();

protected:
  void _M_initialize_map(size_t);
  void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
  void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
  enum { _S_initial_map_size = 8 };

protected:
  iterator _M_start;
  iterator _M_finish;
  _Map_alloc_proxy  _M_map;
  _Alloc_proxy      _M_map_size;
};

#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
#  define deque _STLP_PTR_IMPL_NAME(deque)
#elif defined (_STLP_DEBUG)
#  define deque _STLP_NON_DBG_NAME(deque)
#else
_STLP_MOVE_TO_STD_NAMESPACE
#endif

template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) >
class deque : protected _STLP_PRIV _Deque_base<_Tp, _Alloc>
#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (deque)
            , public __stlport_class<deque<_Tp, _Alloc> >
#endif
{
  typedef _STLP_PRIV _Deque_base<_Tp, _Alloc> _Base;
  typedef deque<_Tp, _Alloc> _Self;
public:                         // Basic types
  typedef _Tp value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef random_access_iterator_tag _Iterator_category;
  _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
  typedef typename _Base::allocator_type allocator_type;

public:                         // Iterators
  typedef typename _Base::iterator       iterator;
  typedef typename _Base::const_iterator const_iterator;

  _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;

protected:                      // Internal typedefs
  typedef pointer* _Map_pointer;
  typedef typename __type_traits<_Tp>::has_trivial_assignment_operator _TrivialAss;
  typedef typename __type_traits<_Tp>::has_trivial_copy_constructor _TrivialCpy;
  typedef typename _TrivialInit<_Tp>::_Ret _TrivialInit;
#if !defined (_STLP_NO_MOVE_SEMANTIC)
  typedef typename __move_traits<_Tp>::implemented _Movable;
#else
  typedef __false_type _Movable;
#endif

public:                         // Basic accessors
  iterator begin() { return this->_M_start; }
  iterator end() { return this->_M_finish; }
  const_iterator begin() const { return const_iterator(this->_M_start); }
  const_iterator end() const { return const_iterator(this->_M_finish); }

  reverse_iterator rbegin() { return reverse_iterator(this->_M_finish); }
  reverse_iterator rend() { return reverse_iterator(this->_M_start); }
  const_reverse_iterator rbegin() const
    { return const_reverse_iterator(this->_M_finish); }
  const_reverse_iterator rend() const
    { return const_reverse_iterator(this->_M_start); }

  reference operator[](size_type __n)
    { return this->_M_start[difference_type(__n)]; }
  const_reference operator[](size_type __n) const
    { return this->_M_start[difference_type(__n)]; }

  void _M_range_check(size_type __n) const {
    if (__n >= this->size())
      __stl_throw_out_of_range("deque");
  }
  reference at(size_type __n)
    { _M_range_check(__n); return (*this)[__n]; }
  const_reference at(size_type __n) const
    { _M_range_check(__n); return (*this)[__n]; }

  reference front() { return *this->_M_start; }
  reference back() {
    iterator __tmp = this->_M_finish;
    --__tmp;
    return *__tmp;
  }
  const_reference front() const { return *this->_M_start; }
  const_reference back() const {
    const_iterator __tmp = this->_M_finish;
    --__tmp;
    return *__tmp;
  }

  size_type size() const { return this->_M_finish - this->_M_start; }
  size_type max_size() const { return size_type(-1); }
  bool empty() const { return this->_M_finish == this->_M_start; }
  allocator_type get_allocator() const { return this->_M_map_size; }

public:                         // Constructor, destructor.
#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
  explicit deque(const allocator_type& __a = allocator_type())
#else
  deque()
    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), 0) {}
  deque(const allocator_type& __a)
#endif
    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, 0) {}

  deque(const _Self& __x)
    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__x.get_allocator(), __x.size())
  { _STLP_PRIV __ucopy(__x.begin(), __x.end(), this->_M_start); }

#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
private:
  void _M_initialize(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(_Tp))
  { _M_fill_initialize(__val, _TrivialInit()); }
public:
  explicit deque(size_type __n)
    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), __n)
  { _M_initialize(__n); }
  deque(size_type __n, const value_type& __val, const allocator_type& __a = allocator_type())
#else
  explicit deque(size_type __n)
    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), __n)
  { _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()); }

#if defined (_STLP_MEMBER_TEMPLATES)
protected:
  template <class _Integer>
  void _M_initialize_dispatch(_Integer __n, _Integer __x, const __true_type&) {
    this->_M_initialize_map(__n);
    _M_fill_initialize(__x, __false_type());
  }

  template <class _InputIter>
  void _M_initialize_dispatch(_InputIter __first, _InputIter __last,
                              const __false_type&) {
    _M_range_initialize(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIter));
  }

public:
  // Check whether it's an integral type.  If so, it's not an iterator.
  template <class _InputIterator>
  deque(_InputIterator __first, _InputIterator __last,
        const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a) {
    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
    _M_initialize_dispatch(__first, __last, _Integral());
  }

#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
  template <class _InputIterator>
  deque(_InputIterator __first, _InputIterator __last)
    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type()) {
    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
    _M_initialize_dispatch(__first, __last, _Integral());
  }
#  endif

#else
  deque(const value_type* __first, const value_type* __last,
        const allocator_type& __a = allocator_type() )
    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, __last - __first)
  { _STLP_PRIV __ucopy(__first, __last, this->_M_start); }

  deque(const_iterator __first, const_iterator __last,
        const allocator_type& __a = allocator_type() )
    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, __last - __first)
  { _STLP_PRIV __ucopy(__first, __last, this->_M_start); }
#endif /* _STLP_MEMBER_TEMPLATES */

  deque(__move_source<_Self> src)
    : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__move_source<_Base>(src.get()))
  {}

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

  _Self& operator= (const _Self& __x);

  void swap(_Self& __x) {
    _STLP_STD::swap(this->_M_start, __x._M_start);
    _STLP_STD::swap(this->_M_finish, __x._M_finish);
    this->_M_map.swap(__x._M_map);
    this->_M_map_size.swap(__x._M_map_size);
  }

public:
  // assign(), a generalized assignment member function.  Two
  // versions: one that takes a count, and one that takes a range.
  // The range version is a member template, so we dispatch on whether
  // or not the type is an integer.

  void _M_fill_assign(size_type __n, const _Tp& __val) {
    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);
    }
  }

  void assign(size_type __n, const _Tp& __val) {
    _M_fill_assign(__n, __val);
  }

#if defined (_STLP_MEMBER_TEMPLATES)
  template <class _InputIterator>
  void assign(_InputIterator __first, _InputIterator __last) {
    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
    _M_assign_dispatch(__first, __last, _Integral());
  }

private:                        // helper functions for assign()

  template <class _Integer>
  void _M_assign_dispatch(_Integer __n, _Integer __val,
                          const __true_type& /*_IsIntegral*/)
  { _M_fill_assign((size_type) __n, (_Tp) __val); }

  template <class _InputIterator>
  void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
                          const __false_type& /*_IsIntegral*/) {
    _M_assign_aux(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
  }

  template <class _InputIter>
  void _M_assign_aux(_InputIter __first, _InputIter __last, const input_iterator_tag &) {
    iterator __cur = begin();
    for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
      *__cur = *__first;
    if (__first == __last)
      erase(__cur, end());
    else
      insert(end(), __first, __last);
  }

  template <class _ForwardIterator>
  void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                     const forward_iterator_tag &) {
#else
  void assign(const value_type *__first, const value_type *__last) {
    size_type __size = size();
    size_type __len = __last - __first;
    if (__len > __size) {
      const value_type *__mid = __first + __size;
      copy(__first, __mid, begin());
      insert(end(), __mid, __last);
    }
    else {
      erase(copy(__first, __last, begin()), end());
    }
  }
  void assign(const_iterator __first, const_iterator __last) {
    typedef const_iterator _ForwardIterator;
#endif /* _STLP_MEMBER_TEMPLATES */
    size_type __len = distance(__first, __last);
    if (__len > size()) {
      _ForwardIterator __mid = __first;
      advance(__mid, size());
      copy(__first, __mid, begin());
      insert(end(), __mid, __last);
    }
    else {
      erase(copy(__first, __last, begin()), end());
    }
  }


public:                         // push_* and pop_*

#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
  void push_back(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
#else
  void push_back(const value_type& __t) {
#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
    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);
  }
#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
  void push_front(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(_Tp))   {
#else
  void push_front(const value_type& __t)   {
#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
    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);
  }

#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
  void push_back() {
    if (this->_M_finish._M_cur != this->_M_finish._M_last - 1) {
      _STLP_STD::_Construct(this->_M_finish._M_cur);
      ++this->_M_finish._M_cur;
    }
    else
      _M_push_back_aux();
  }
  void push_front() {
    if (this->_M_start._M_cur != this->_M_start._M_first) {
      _STLP_STD::_Construct(this->_M_start._M_cur - 1);
      --this->_M_start._M_cur;
    }
    else
      _M_push_front_aux();
  }
#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/

  void pop_back() {
    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);
    }
  }

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

public:                         // Insert

#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
  iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
#else
  iterator insert(iterator __pos, const value_type& __x) {
#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
    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) {