_slist.h

来自「C++类模版库实现」· C头文件 代码 · 共 872 行 · 第 1/3 页

  typedef value_type&       reference;
  typedef value_type        const_reference;
  typedef size_t            size_type;
  typedef ptrdiff_t         difference_type;
  typedef forward_iterator_tag _Iterator_category;

  typedef _Slist_iterator<value_type, _Nonconst_traits<value_type> >  iterator;
  typedef _Slist_iterator<value_type, _Const_traits<value_type> >     const_iterator;

  _STLP_FORCE_ALLOCATORS(value_type, _Alloc)
  typedef typename _Base::allocator_type allocator_type;

public:
  allocator_type get_allocator() const { return _M_container.get_allocator(); }

  explicit slist(const allocator_type& __a = allocator_type()) : _M_container(__a) {}

#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
  explicit slist(size_type __n, const_reference __x = 0,
#else
  slist(size_type __n, const_reference __x,
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
        const allocator_type& __a =  allocator_type()) : _M_container(__n, cast_traits::cast(__x), __a) {}

#if defined(_STLP_DONT_SUP_DFLT_PARAM)
  explicit slist(size_type __n) : _M_container(__n) {}
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/

#ifdef _STLP_MEMBER_TEMPLATES
  // We don't need any dispatching tricks here, because _M_insert_after_range
  // already does them.
  template <class _InputIte>
  slist(_InputIte __first, _InputIte __last,
        const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL) :
    _M_container(__iterator_wrapper<_Tp, _InputIte>(__first), __iterator_wrapper<_Tp, _InputIte>(__last), __a) {}
# ifdef _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
  // VC++ needs this crazyness
  template <class _InputIte>
  slist(_InputIte __first, _InputIte __last) :
    _M_container(__iterator_wrapper<_Tp, _InputIte>(__first), __iterator_wrapper<_Tp, _InputIte>(__last)) {}
# endif
#else /* _STLP_MEMBER_TEMPLATES */
  slist(const_iterator __first, const_iterator __last,
        const allocator_type& __a =  allocator_type() ) :
    _M_container(const_void_iterator(__first._M_node), const_void_iterator(__last._M_node), __a) {}
  slist(const value_type* __first, const value_type* __last,
        const allocator_type& __a =  allocator_type()) :
    _M_container(__first, __last, __a) {}
#endif /* _STLP_MEMBER_TEMPLATES */

  slist(const _Self& __x) : _M_container(__x._M_container) {}

  /*explicit slist(__full_move_source<_Self> src)
    : _Slist_base<void*, _Alloc>(_FullMoveSource<_Slist_base<void*, _Alloc> >(src.get())) {
  }*/

  explicit slist(__partial_move_source<_Self> src)
    : _M_container(__partial_move_source<_Base>(src.get()._M_container)) {}

  _Self& operator= (const _Self& __x) {
    _M_container = __x._M_container;
    return *this;
  }

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 assign(size_type __n, const_reference __val) { _M_container.assign(__n, cast_traits::cast(__val)); }

#ifdef _STLP_MEMBER_TEMPLATES
  template <class _InputIte>
  void assign(_InputIte __first, _InputIte __last) {
    _M_container.assign(__iterator_wrapper<_Tp, _InputIte>(__first), __iterator_wrapper<_Tp, _InputIte>(__last));
  }
#endif /* _STLP_MEMBER_TEMPLATES */

  iterator before_begin()             { return iterator(_M_container.before_begin()._M_node); }
  const_iterator before_begin() const { return const_iterator(const_cast<_Slist_node_base*>(_M_container.before_begin()._M_node)); }

  iterator begin()                    { return iterator(_M_container.begin()._M_node); }
  const_iterator begin() const        { return const_iterator(const_cast<_Slist_node_base*>(_M_container.begin()._M_node));}

  iterator end()                      { return iterator(0); }
  const_iterator end() const          { return const_iterator(0); }

  size_type size() const      { return _M_container.size(); }
  size_type max_size() const  { return size_type(-1); }

  bool empty() const { return _M_container.empty(); }

  void swap(_Self& __x) { _M_container.swap(__x._M_container); }

public:
  reference front()             { return *begin(); }
  const_reference front() const { return *begin(); }
#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
  void push_front(const_reference __x = 0)   {
#else
  void push_front(const_reference __x)   {
#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
    _M_container.push_front(cast_traits::cast(__x));
  }

# if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
  void push_front() { _M_container.push_front();}
# endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/

  void pop_front() { _M_container.pop_front(); }

  iterator previous(const_iterator __pos) { return iterator(_M_container.previous(const_void_iterator(__pos._M_node))._M_node); }
  const_iterator previous(const_iterator __pos) const
    { return const_iterator(const_cast<_Slist_node_base*>(_M_container.previous(const_void_iterator(__pos._M_node))._M_node)); }

#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
  iterator insert_after(iterator __pos, const_reference __x = 0) {
#else
  iterator insert_after(iterator __pos, const_reference __x) {
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
    return iterator(_M_container.insert_after(void_iterator(__pos._M_node), cast_traits::cast(__x))._M_node);
  }

#if defined(_STLP_DONT_SUP_DFLT_PARAM)
  iterator insert_after(iterator __pos) { return iterator(_M_container.insert_after(void_iterator(__pos._M_node))._M_node);}
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/

  void insert_after(iterator __pos, size_type __n, const_reference __x) {
    _M_container.insert_after(void_iterator(__pos._M_node), __n, cast_traits::cast(__x));
  }

#ifdef _STLP_MEMBER_TEMPLATES

  // We don't need any dispatching tricks here, because _M_insert_after_range
  // already does them.
  template <class _InIter>
  void insert_after(iterator __pos, _InIter __first, _InIter __last) {
    _M_container.insert_after(void_iterator(__pos._M_node), __iterator_wrapper<_Tp, _InIter>(__first),
                                                            __iterator_wrapper<_Tp, _InIter>(__last));
  }

#else /* _STLP_MEMBER_TEMPLATES */

  void insert_after(iterator __pos,
                    const_iterator __first, const_iterator __last) {
    _M_container.insert_after(void_iterator(__pos._M_node),
                              const_void_iterator(__first._M_node), const_void_iterator(__last._M_node));
  }
  void insert_after(iterator __pos,
                    const value_type* __first, const value_type* __last) {
    _M_container.insert_after(void_iterator(__pos._M_node), __first, __last);
  }

#endif /* _STLP_MEMBER_TEMPLATES */

#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
  iterator insert(iterator __pos, const_reference __x = 0) {
#else
  iterator insert(iterator __pos, const_reference __x) {
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
    return iterator(_M_container.insert(void_iterator(__pos._M_node), cast_traits::cast(__x))._M_node);
  }

#if defined(_STLP_DONT_SUP_DFLT_PARAM)
  iterator insert(iterator __pos) {
    return iterator(_M_container.insert(void_iterator(__pos._M_node)));
  }
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/

  void insert(iterator __pos, size_type __n, const_reference __x) {
    _M_container.insert(void_iterator(__pos._M_node), __n, cast_traits::cast(__x));
  }

#ifdef _STLP_MEMBER_TEMPLATES

  // We don't need any dispatching tricks here, because _M_insert_after_range
  // already does them.
  template <class _InIter>
  void insert(iterator __pos, _InIter __first, _InIter __last) {
    _M_container.insert(void_iterator(__pos._M_node), __iterator_wrapper<_Tp, _InIter>(__first),
                                                      __iterator_wrapper<_Tp, _InIter>(__last));
  }

#else /* _STLP_MEMBER_TEMPLATES */

  void insert(iterator __pos, const_iterator __first, const_iterator __last) {
    _M_container.insert(void_iterator(__pos._M_node),
                        const_void_iterator(__first._M_node), const_void_iterator(__last._M_node));
  }
  void insert(iterator __pos, const value_type* __first, const value_type* __last) {
    _M_container.insert(void_iterator(__pos._M_node), __first, __last);
  }

#endif /* _STLP_MEMBER_TEMPLATES */


public:
  iterator erase_after(iterator __pos) {
    return iterator(_M_container.erase_after(void_iterator(__pos._M_node))._M_node);
  }
  iterator erase_after(iterator __before_first, iterator __last) {
    return iterator(_M_container.erase_after(void_iterator(__before_first._M_node),
                                             void_iterator(__last._M_node))._M_node);
  }

  iterator erase(iterator __pos) {
    return iterator(_M_container.erase(void_iterator(__pos._M_node))._M_node);
  }
  iterator erase(iterator __first, iterator __last) {
    return iterator(_M_container.erase(void_iterator(__first._M_node),
                                       void_iterator(__last._M_node))._M_node);
  }

#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
  void resize(size_type __new_size, const_reference __x = 0)
#else
  void resize(size_type __new_size, const_reference __x)
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
  { _M_container.resize(__new_size, cast_traits::cast(__x));}

#if defined(_STLP_DONT_SUP_DFLT_PARAM)
  void resize(size_type __new_size) { _M_container.resize(__new_size); }
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/

  void clear() { _M_container.clear(); }

  void splice_after(iterator __pos,
                    iterator __before_first, iterator __before_last) {
    _M_container.splice_after(void_iterator(__pos._M_node),
                              void_iterator(__before_first._M_node), void_iterator(__before_last._M_node));
  }
  void splice_after(iterator __pos, iterator __prev) {
    _M_container.splice_after(void_iterator(__pos._M_node), void_iterator(__prev._M_node));
  }
  void splice_after(iterator __pos, _Self& __x) {
    _M_container.splice_after(void_iterator(__pos._M_node), __x._M_container);
  }
  void splice(iterator __pos, _Self& __x) {
    _M_container.splice(void_iterator(__pos._M_node), __x._M_container);
  }
  void splice(iterator __pos, _Self& __x, iterator __i) {
    _M_container.splice(void_iterator(__pos._M_node), __x._M_container, void_iterator(__i._M_node));
  }
  void splice(iterator __pos, _Self& __x, iterator __first, iterator __last) {
    _M_container.splice(void_iterator(__pos._M_node), __x._M_container,
                        void_iterator(__first._M_node), void_iterator(__last._M_node));
  }

public:
  void reverse() { _M_container.reverse(); }

  void remove(const_reference __val) { _M_container.remove(cast_traits::cast(__val)); }
  void unique() { _M_container.unique(); }
  void merge(_Self& __x) { _M_container.merge(__x._M_container); }
  void sort() {_M_container.sort(); }

#ifdef _STLP_MEMBER_TEMPLATES
  template <class _Predicate>
  void remove_if(_Predicate __pred) {
    _M_container.remove_if(__unary_pred_wrapper<_Tp, _Predicate>(__pred));
  }

  template <class _BinaryPredicate>
  void unique(_BinaryPredicate __pred) {
    _M_container.unique(__binary_pred_wrapper<_Tp, _BinaryPredicate>(__pred));
  }

  template <class _StrictWeakOrdering>

  void merge(_Self& __x, _StrictWeakOrdering __comp) {
    _M_container.merge(__x._M_container, __binary_pred_wrapper<_Tp, _StrictWeakOrdering>(__comp));
  }

  template <class _StrictWeakOrdering>
  void sort(_StrictWeakOrdering __comp) {
    _M_container.sort(__binary_pred_wrapper<_Tp, _StrictWeakOrdering>(__comp));
  }
#endif /* _STLP_MEMBER_TEMPLATES */

};


#endif /* _STLP_SPECIALIZED_SLIST_H */

// Local Variables:
// mode:C++
// End: