/*

 *

 * Copyright (c) 1996,1997

 * Silicon Graphics Computer Systems, Inc.

 *

 * 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.

 *

 */

#ifndef _STLP_SLIST_C

#define _STLP_SLIST_C

#ifndef _STLP_INTERNAL_SLIST_H

# include <stl/_slist.h>

#endif

# undef slist

# define  slist  __WORKAROUND_DBG_RENAME(slist)

# if defined (_STLP_NESTED_TYPE_PARAM_BUG) 

#  define size_type          size_t

# endif

_STLP_BEGIN_NAMESPACE

template <class _Tp, class _Alloc> 

_Slist_node_base*

_Slist_base<_Tp,_Alloc>::_M_erase_after(_Slist_node_base* __before_first,

                                        _Slist_node_base* __last_node) {

  _Slist_node<_Tp>* __cur = (_Slist_node<_Tp>*) (__before_first->_M_next);

  while (__cur != __last_node) {

    _Slist_node<_Tp>* __tmp = __cur;

    __cur = (_Slist_node<_Tp>*) __cur->_M_next;

    _STLP_STD::_Destroy(&__tmp->_M_data);

    _M_head.deallocate(__tmp,1);

  }

  __before_first->_M_next = __last_node;

  return __last_node;

}

template <class _Tp, class _Alloc>

slist<_Tp,_Alloc>& slist<_Tp,_Alloc>::operator=(const slist<_Tp,_Alloc>& __x)

{

  if (&__x != this) {

    _Node_base* __p1 = &this->_M_head._M_data;

    _Node* __n1 = (_Node*) this->_M_head._M_data._M_next;

    const _Node* __n2 = (const _Node*) __x._M_head._M_data._M_next;

    while (__n1 && __n2) {

      __n1->_M_data = __n2->_M_data;

      __p1 = __n1;

      __n1 = (_Node*) __n1->_M_next;

      __n2 = (const _Node*) __n2->_M_next;

    }

    if (__n2 == 0)

      this->_M_erase_after(__p1, 0);

    else

      _M_insert_after_range(__p1, const_iterator((_Node*)__n2), 

                                  const_iterator(0));

  }

  return *this;

}

template <class _Tp, class _Alloc>

void slist<_Tp, _Alloc>::_M_fill_assign(size_type __n, const _Tp& __val) {

  _Node_base* __prev = &this->_M_head._M_data;

  _Node* __node = (_Node*) this->_M_head._M_data._M_next;

  for ( ; __node != 0 && __n > 0 ; --__n) {

    __node->_M_data = __val;

    __prev = __node;

    __node = (_Node*) __node->_M_next;

  }

  if (__n > 0)

    _M_insert_after_fill(__prev, __n, __val);

  else

    this->_M_erase_after(__prev, 0);

}

template <class _Tp, class _Alloc>

void slist<_Tp,_Alloc>::resize(size_type __len, const _Tp& __x)

{

  _Node_base* __cur = &this->_M_head._M_data;

  while (__cur->_M_next != 0 && __len > 0) {

    --__len;

    __cur = __cur->_M_next;

  }

  if (__cur->_M_next) 

    this->_M_erase_after(__cur, 0);

  else

    _M_insert_after_fill(__cur, __len, __x);

}

template <class _Tp, class _Alloc>

void slist<_Tp,_Alloc>::remove(const _Tp& __val)

{

  _Node_base* __cur = &this->_M_head._M_data;

  while (__cur && __cur->_M_next) {

    if (((_Node*) __cur->_M_next)->_M_data == __val)

      this->_M_erase_after(__cur);

    else

      __cur = __cur->_M_next;

  }

}

template <class _Tp, class _Alloc> 

void slist<_Tp,_Alloc>::unique()

{

  _Node_base* __cur = this->_M_head._M_data._M_next;

  if (__cur) {

    while (__cur->_M_next) {

      if (((_Node*)__cur)->_M_data == 

          ((_Node*)(__cur->_M_next))->_M_data)

        this->_M_erase_after(__cur);

      else

        __cur = __cur->_M_next;

    }

  }

}

template <class _Tp, class _Alloc>

void slist<_Tp,_Alloc>::merge(slist<_Tp,_Alloc>& __x)

{

  _Node_base* __n1 = &this->_M_head._M_data;

  while (__n1->_M_next && __x._M_head._M_data._M_next) {

    if (((_Node*) __x._M_head._M_data._M_next)->_M_data < 

        ((_Node*)       __n1->_M_next)->_M_data) 

      _Sl_global_inst::__splice_after(__n1, &__x._M_head._M_data, __x._M_head._M_data._M_next);

    __n1 = __n1->_M_next;

  }

  if (__x._M_head._M_data._M_next) {

    __n1->_M_next = __x._M_head._M_data._M_next;

    __x._M_head._M_data._M_next = 0;

  }

}

template <class _Tp, class _Alloc>

void slist<_Tp,_Alloc>::sort()

{

  if (this->_M_head._M_data._M_next && this->_M_head._M_data._M_next->_M_next) {

    _Self __carry;

    _Self __counter[64];

    int __fill = 0;

    while (!empty()) {

      _Sl_global_inst::__splice_after(&__carry._M_head._M_data, &this->_M_head._M_data, this->_M_head._M_data._M_next);

      int __i = 0;

      while (__i < __fill && !__counter[__i].empty()) {

        __counter[__i].merge(__carry);

        __carry.swap(__counter[__i]);

        ++__i;

      }

      __carry.swap(__counter[__i]);

      if (__i == __fill)

        ++__fill;

    }

    for (int __i = 1; __i < __fill; ++__i)

      __counter[__i].merge(__counter[__i-1]);

    this->swap(__counter[__fill-1]);

  }

}

# undef slist

# undef size_type

_STLP_END_NAMESPACE

#endif /*  _STLP_SLIST_C */

// Local Variables:

// mode:C++

// End: