_slist.h

来自「stl的源码」· C头文件 代码 · 共 915 行 · 第 1/3 页

/*
 *
 * Copyright (c) 1996,1997
 * Silicon Graphics Computer Systems, Inc.
 *
 * Copyright (c) 1997
 * Moscow Center for SPARC Technology
 *
 * Copyright (c) 1999
 * Boris Fomitchev
 *
 * This material is provided "as is", with absolutely no warranty expressed
 * or implied. Any use is at your own risk.
 *
 * Permission to use or copy this software for any purpose is hereby granted
 * without fee, provided the above notices are retained on all copies.
 * Permission to modify the code and to distribute modified code is granted,
 * provided the above notices are retained, and a notice that the code was
 * modified is included with the above copyright notice.
 *
 */

/* NOTE: This is an internal header file, included by other STL headers.
 *   You should not attempt to use it directly.
 */

#ifndef _STLP_INTERNAL_SLIST_H
#define _STLP_INTERNAL_SLIST_H

#ifndef _STLP_INTERNAL_ALGOBASE_H
#  include <stl/_algobase.h>
#endif

#ifndef _STLP_INTERNAL_ALLOC_H
#  include <stl/_alloc.h>
#endif

#ifndef _STLP_INTERNAL_ITERATOR_H
#  include <stl/_iterator.h>
#endif

#ifndef _STLP_INTERNAL_CONSTRUCT_H
#  include <stl/_construct.h>
#endif

#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
#  include <stl/_function_base.h>
#endif

#ifndef _STLP_INTERNAL_SLIST_BASE_H
#  include <stl/_slist_base.h>
#endif

_STLP_BEGIN_NAMESPACE

_STLP_MOVE_TO_PRIV_NAMESPACE

template <class _Tp>
class _Slist_node : public _Slist_node_base {
public:
  _Tp _M_data;
  __TRIVIAL_STUFF(_Slist_node)
};

struct _Slist_iterator_base {
  typedef size_t               size_type;
  typedef ptrdiff_t            difference_type;
  typedef forward_iterator_tag iterator_category;

  _Slist_node_base *_M_node;

  _Slist_iterator_base(_Slist_node_base *__x) : _M_node(__x) {}

  void _M_incr() {
    _M_node = _M_node->_M_next;
  }
};

template <class _Tp, class _Traits>
class _Slist_iterator : public _Slist_iterator_base {
public:
  typedef typename _Traits::value_type value_type;
  typedef typename _Traits::pointer    pointer;
  typedef typename _Traits::reference  reference;
  typedef forward_iterator_tag iterator_category;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef _Slist_iterator<_Tp, _Traits>         _Self;
  typedef typename _Traits::_NonConstTraits     _NonConstTraits;
  typedef _Slist_iterator<_Tp, _NonConstTraits> iterator;
  typedef typename _Traits::_ConstTraits        _ConstTraits;
  typedef _Slist_iterator<_Tp, _ConstTraits>    const_iterator;

  typedef _Slist_node<value_type> _Node;

  explicit _Slist_iterator(_Slist_node_base *__x) : _Slist_iterator_base(__x) {}
  _Slist_iterator() : _Slist_iterator_base(0) {}
  //copy constructor for iterator and constructor from iterator for const_iterator
  _Slist_iterator(const iterator& __x) : _Slist_iterator_base(__x._M_node) {}

  reference operator*() const { return __STATIC_CAST(_Node*, this->_M_node)->_M_data; }

  _STLP_DEFINE_ARROW_OPERATOR

  _Self& operator++() {
    _M_incr();
    return *this;
  }
  _Self operator++(int) {
    _Self __tmp = *this;
    _M_incr();
    return __tmp;
  }

  bool operator==(const_iterator __y ) const {
    return this->_M_node == __y._M_node;
  }
  bool operator!=(const_iterator __y ) const {
    return this->_M_node != __y._M_node;
  }
};

#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
_STLP_MOVE_TO_STD_NAMESPACE
template <class _Tp, class _Traits>
struct __type_traits<_STLP_PRIV _Slist_iterator<_Tp, _Traits> > {
  typedef __false_type   has_trivial_default_constructor;
  typedef __true_type    has_trivial_copy_constructor;
  typedef __true_type    has_trivial_assignment_operator;
  typedef __true_type    has_trivial_destructor;
  typedef __false_type   is_POD_type;
};
_STLP_MOVE_TO_PRIV_NAMESPACE
#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */

#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
_STLP_MOVE_TO_STD_NAMESPACE
template <class _Tp, class _Traits>
inline _Tp* _STLP_CALL value_type(const _STLP_PRIV _Slist_iterator<_Tp, _Traits>&) { return __STATIC_CAST(_Tp*, 0); }
inline ptrdiff_t* _STLP_CALL distance_type(const _STLP_PRIV _Slist_iterator_base&) { return 0; }
inline forward_iterator_tag _STLP_CALL iterator_category(const _STLP_PRIV _Slist_iterator_base&) { return forward_iterator_tag(); }
_STLP_MOVE_TO_PRIV_NAMESPACE
#endif /* OLD_QUERIES */

// Base class that encapsulates details of allocators and simplifies EH
template <class _Tp, class _Alloc>
class _Slist_base {
protected:
  typedef _Slist_node<_Tp> _Node;
  typedef typename _Alloc_traits<_Node,_Alloc>::allocator_type _M_node_allocator_type;
  typedef _Slist_base<_Tp, _Alloc> _Self;

public:
  typedef _STLP_alloc_proxy<_Slist_node_base, _Node, _M_node_allocator_type> _AllocProxy;

  _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
  typedef _Alloc allocator_type;

  _Slist_base(const allocator_type& __a) :
    _M_head(_STLP_CONVERT_ALLOCATOR(__a, _Node), _Slist_node_base() )
  { _M_head._M_data._M_next = 0; }

#if !defined (_STLP_NO_MOVE_SEMANTIC)
  _Slist_base(__move_source<_Self> src) :
    _M_head(__move_source<_AllocProxy>(src.get()._M_head))
  { src.get()._M_head._M_data._M_next = 0; }
#endif

  ~_Slist_base() { _M_erase_after(&_M_head._M_data, 0); }

protected:
  _Slist_node_base* _M_erase_after(_Slist_node_base* __pos) {
    _Node* __next = __STATIC_CAST(_Node*, __pos->_M_next);
    _Slist_node_base* __next_next = __next->_M_next;
    __pos->_M_next = __next_next;
    _STLP_STD::_Destroy(&__next->_M_data);
    _M_head.deallocate(__next,1);
    return __next_next;
  }
  _Slist_node_base* _M_erase_after(_Slist_node_base*, _Slist_node_base*);

public:
  allocator_type get_allocator() const
  { return _STLP_CONVERT_ALLOCATOR((const _M_node_allocator_type&)_M_head, _Tp); }
  _AllocProxy _M_head;
};

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

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

#if !defined (slist)
_STLP_MOVE_TO_PRIV_NAMESPACE
#endif

// helper functions to reduce code duplication
template <class _Tp, class _Alloc, class _BinaryPredicate>
void _Slist_unique(slist<_Tp, _Alloc>& __that, _BinaryPredicate __binary_pred);

template <class _Tp, class _Alloc, class _StrictWeakOrdering>
void _Slist_merge(slist<_Tp, _Alloc>& __that, slist<_Tp, _Alloc>& __x,
                  _StrictWeakOrdering __comp);

template <class _Tp, class _Alloc, class _StrictWeakOrdering>
void _Slist_sort(slist<_Tp, _Alloc>& __that, _StrictWeakOrdering __comp);

#if !defined (slist)
_STLP_MOVE_TO_STD_NAMESPACE
#endif

template <class _Tp, class _Alloc>
class slist : protected _STLP_PRIV _Slist_base<_Tp,_Alloc>
#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (slist)
            , public __stlport_class<slist<_Tp, _Alloc> >
#endif
{
private:
  typedef _STLP_PRIV _Slist_base<_Tp,_Alloc> _Base;
  typedef slist<_Tp,_Alloc> _Self;
public:
  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 forward_iterator_tag _Iterator_category;

  typedef _STLP_PRIV _Slist_iterator<_Tp, _Nonconst_traits<_Tp> > iterator;
  typedef _STLP_PRIV _Slist_iterator<_Tp, _Const_traits<_Tp> >    const_iterator;

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

private:
  typedef _STLP_PRIV _Slist_node<_Tp> _Node;
  typedef _STLP_PRIV _Slist_node_base _Node_base;

#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
  _Node* _M_create_node(const value_type& __x = _Tp()) {
#else
  _Node* _M_create_node(const value_type& __x) {
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
    _Node* __node = this->_M_head.allocate(1);
    _STLP_TRY {
      _Copy_Construct(&__node->_M_data, __x);
      __node->_M_next = 0;
    }
    _STLP_UNWIND(this->_M_head.deallocate(__node, 1))
    return __node;
  }

#if defined(_STLP_DONT_SUP_DFLT_PARAM)
  _Node* _M_create_node() {
    _Node* __node = this->_M_head.allocate(1);
    _STLP_TRY {
      _STLP_STD::_Construct(&__node->_M_data);
      __node->_M_next = 0;
    }
    _STLP_UNWIND(this->_M_head.deallocate(__node, 1))
    return __node;
  }
#endif /*_STLP_DONT_SUP_DFLT_PARAM*/

public:

  allocator_type get_allocator() const { return _Base::get_allocator(); }

#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
  explicit slist(const allocator_type& __a = allocator_type())
#else
  slist()
    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(allocator_type()) {}
  slist(const allocator_type& __a)
#endif
    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a) {}

#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
  explicit slist(size_type __n, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp),
                 const allocator_type& __a =  allocator_type())
#else
  explicit slist(size_type __n)
    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(allocator_type())
    { _M_insert_after_fill(&this->_M_head._M_data, __n, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
  slist(size_type __n, const value_type& __x)
    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(allocator_type())
    { _M_insert_after_fill(&this->_M_head._M_data, __n, __x); }
  slist(size_type __n, const value_type& __x, const allocator_type& __a)
#endif
    : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a)
    { _M_insert_after_fill(&this->_M_head._M_data, __n, __x); }

#if defined (_STLP_MEMBER_TEMPLATES)
  // We don't need any dispatching tricks here, because _M_insert_after_range
  // already does them.