852 lines
25 KiB
C++
852 lines
25 KiB
C++
#ifndef __LIST_H
|
||
#define __LIST_H
|
||
#pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
|
||
// -*- C++ -*-
|
||
#ifndef __STD_LIST__
|
||
#define __STD_LIST__
|
||
|
||
/***************************************************************************
|
||
*
|
||
* list - list declarations for the Standard Library
|
||
*
|
||
***************************************************************************
|
||
*
|
||
* Copyright (c) 1994
|
||
* Hewlett-Packard Company
|
||
*
|
||
* Permission to use, copy, modify, distribute and sell this software
|
||
* and its documentation for any purpose is hereby granted without fee,
|
||
* provided that the above copyright notice appear in all copies and
|
||
* that both that copyright notice and this permission notice appear
|
||
* in supporting documentation. Hewlett-Packard Company makes no
|
||
* representations about the suitability of this software for any
|
||
* purpose. It is provided "as is" without express or implied warranty.
|
||
*
|
||
*
|
||
***************************************************************************
|
||
*
|
||
* Copyright (c) 1994-1999 Rogue Wave Software, Inc. All Rights Reserved.
|
||
*
|
||
* This computer software is owned by Rogue Wave Software, Inc. and is
|
||
* protected by U.S. copyright laws and other laws and by international
|
||
* treaties. This computer software is furnished by Rogue Wave Software,
|
||
* Inc. pursuant to a written license agreement and may be used, copied,
|
||
* transmitted, and stored only in accordance with the terms of such
|
||
* license and with the inclusion of the above copyright notice. This
|
||
* computer software or any other copies thereof may not be provided or
|
||
* otherwise made available to any other person.
|
||
*
|
||
* U.S. Government Restricted Rights. This computer software is provided
|
||
* with Restricted Rights. Use, duplication, or disclosure by the
|
||
* Government is subject to restrictions as set forth in subparagraph (c)
|
||
* (1) (ii) of The Rights in Technical Data and Computer Software clause
|
||
* at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
|
||
* Commercial Computer Software – Restricted Rights at 48 CFR 52.227-19,
|
||
* as applicable. Manufacturer is Rogue Wave Software, Inc., 5500
|
||
* Flatiron Parkway, Boulder, Colorado 80301 USA.
|
||
*
|
||
**************************************************************************/
|
||
#include <stdcomp.h>
|
||
|
||
#include <algorithm>
|
||
#include <iterator>
|
||
#include <memory>
|
||
#include <stdexcept>
|
||
#include <rw/rwdispatch.h>
|
||
|
||
#ifndef list
|
||
#define list list
|
||
#endif
|
||
#ifndef _RWSTD_NO_NAMESPACE
|
||
namespace std {
|
||
#endif
|
||
|
||
//
|
||
// Note that _RWSTD_COMPLEX_DEFAULT(x)
|
||
// will expand to: ' = x', or nothing,
|
||
// depending on your compiler's capabilities and/or
|
||
// flag settings (see stdcomp.h).
|
||
//
|
||
template <class T, class Allocator _RWSTD_COMPLEX_DEFAULT(allocator<T>) >
|
||
class list
|
||
{
|
||
protected:
|
||
struct __list_node;
|
||
struct __list_node_buffer;
|
||
friend struct __list_node;
|
||
friend struct __list_node_buffer;
|
||
|
||
#ifdef _RWSTD_ALLOCATOR
|
||
typedef _TYPENAME Allocator::template rebind<__list_node>::other __list_node_alloc_type;
|
||
typedef _TYPENAME Allocator::template rebind<T>::other __value_alloc_type;
|
||
typedef _TYPENAME Allocator::template rebind<__list_node_buffer>::other __buffer_alloc_type;
|
||
#else
|
||
typedef allocator_interface<Allocator,__list_node> __list_node_alloc_type;
|
||
typedef allocator_interface<Allocator,T> __value_alloc_type;
|
||
typedef allocator_interface<Allocator,__list_node_buffer> __buffer_alloc_type;
|
||
#endif // _RWSTD_ALLOCATOR
|
||
|
||
public:
|
||
//
|
||
// types
|
||
//
|
||
typedef _TYPENAME __value_alloc_type::reference reference;
|
||
typedef _TYPENAME __value_alloc_type::const_reference const_reference;
|
||
typedef _TYPENAME __value_alloc_type::size_type size_type;
|
||
typedef _TYPENAME __value_alloc_type::difference_type difference_type;
|
||
typedef T value_type;
|
||
typedef Allocator allocator_type;
|
||
typedef _TYPENAME __value_alloc_type::pointer pointer;
|
||
typedef _TYPENAME __value_alloc_type::const_pointer const_pointer;
|
||
|
||
protected:
|
||
typedef _TYPENAME __list_node_alloc_type::pointer __link_type;
|
||
typedef _TYPENAME __buffer_alloc_type::pointer __buffer_pointer;
|
||
|
||
struct __list_node
|
||
{
|
||
__link_type next;
|
||
__link_type prev;
|
||
T data;
|
||
};
|
||
|
||
struct __list_node_buffer
|
||
{
|
||
__buffer_pointer next_buffer;
|
||
size_type size;
|
||
__link_type buffer;
|
||
};
|
||
|
||
size_type __buffer_size;
|
||
__RWSTD::__rw_basis<__buffer_pointer,allocator_type> __buffer_list;
|
||
__link_type __free_list;
|
||
__link_type __next_avail;
|
||
__link_type __last;
|
||
__link_type __node;
|
||
size_type __length;
|
||
|
||
void __add_new_buffer (size_type n)
|
||
{
|
||
__buffer_pointer tmp =
|
||
__buffer_alloc_type(__buffer_list).allocate(
|
||
_RWSTD_STATIC_CAST(size_type,1),__buffer_list.data());
|
||
#ifndef _RWSTD_NO_EXCEPTIONS
|
||
try {
|
||
tmp->buffer = __list_node_alloc_type(__buffer_list).allocate(n,__last);
|
||
} catch(...) {
|
||
__buffer_alloc_type(__buffer_list).deallocate(tmp,1);
|
||
throw;
|
||
}
|
||
#else
|
||
tmp->buffer = __list_node_alloc_type(__buffer_list).allocate(n,__last);
|
||
#endif // _RWSTD_NO_EXCEPTIONS
|
||
tmp->next_buffer = __buffer_list;
|
||
tmp->size = n;
|
||
__buffer_list = tmp;
|
||
__next_avail = __buffer_list.data()->buffer;
|
||
__last = __next_avail + n;
|
||
}
|
||
void __deallocate_buffers ();
|
||
__link_type __get_node (size_type n)
|
||
{
|
||
__link_type tmp = __free_list;
|
||
return __free_list ? (__free_list = (__link_type)(__free_list->next), tmp)
|
||
: (__next_avail == __last ? (__add_new_buffer(n), __next_avail++)
|
||
: __next_avail++);
|
||
}
|
||
void __put_node (__link_type p) { p->next = __free_list; __free_list = p; }
|
||
|
||
void __init(size_type n = 0)
|
||
{
|
||
__buffer_size = max((size_type)1,
|
||
__RWSTD::__rw_allocation_size((value_type*)0,
|
||
(size_type)0,
|
||
(size_type)0));
|
||
__node = __get_node(n == 0 ? __buffer_size : n + 1);
|
||
(*__node).next = __node;
|
||
(*__node).prev = __node;
|
||
}
|
||
void __init(size_type n, value_type value)
|
||
{
|
||
__init(n);
|
||
#ifndef _RWSTD_NO_EXCEPTIONS
|
||
try {
|
||
insert(begin(), n, value);
|
||
} catch(...) {
|
||
__deallocate_buffers();
|
||
throw;
|
||
}
|
||
#else
|
||
insert(begin(), n, value);
|
||
#endif
|
||
}
|
||
|
||
typedef _RW_STD::iterator<bidirectional_iterator_tag, value_type,
|
||
difference_type, pointer,reference> __it;
|
||
typedef _RW_STD::iterator<bidirectional_iterator_tag, value_type,
|
||
difference_type, const_pointer, const_reference> __cit;
|
||
|
||
public:
|
||
|
||
class iterator;
|
||
class const_iterator;
|
||
friend class iterator;
|
||
friend class const_iterator;
|
||
|
||
class iterator : public __it
|
||
{
|
||
friend class list<T,Allocator>;
|
||
friend class const_iterator;
|
||
|
||
protected:
|
||
|
||
__link_type node;
|
||
iterator (__link_type x) : node(x) {}
|
||
|
||
public:
|
||
|
||
iterator () {}
|
||
bool operator== (const iterator& x) const { return node == x.node; }
|
||
bool operator!= (const iterator& x) const { return !(*this == x); }
|
||
reference operator* () const { return (*node).data; }
|
||
#ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN
|
||
pointer operator-> () const { return &(node->data); }
|
||
#endif
|
||
iterator& operator++ ()
|
||
{
|
||
node = (__link_type)((*node).next); return *this;
|
||
}
|
||
iterator operator++ (int)
|
||
{
|
||
iterator tmp = *this; ++*this; return tmp;
|
||
}
|
||
iterator& operator-- ()
|
||
{
|
||
node = (__link_type)((*node).prev); return *this;
|
||
}
|
||
iterator operator-- (int)
|
||
{
|
||
iterator tmp = *this; --*this; return tmp;
|
||
}
|
||
}; // End of definition of iterator class.
|
||
|
||
class const_iterator : public __cit
|
||
{
|
||
friend class list<T,Allocator>;
|
||
|
||
protected:
|
||
|
||
__link_type node;
|
||
const_iterator (__link_type x) : node(x) {}
|
||
|
||
public:
|
||
|
||
const_iterator () {}
|
||
#if !defined(_MSC_VER) || defined(__BORLANDC__)
|
||
const_iterator (const _TYPENAME list<T,Allocator>::iterator& x) : node(x.node) {}
|
||
#else
|
||
const_iterator (const iterator& x) : node(x.node) {}
|
||
#endif
|
||
bool operator== (const const_iterator& x) const {return node==x.node;}
|
||
bool operator!= (const const_iterator x) const { return !(*this == x); }
|
||
const_reference operator* () const { return (*node).data; }
|
||
#ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN
|
||
const_pointer operator-> () const { return &(node->data); }
|
||
#endif
|
||
const_iterator& operator++ ()
|
||
{
|
||
node = (__link_type)((*node).next); return *this;
|
||
}
|
||
const_iterator operator++ (int)
|
||
{
|
||
const_iterator tmp = *this; ++*this; return tmp;
|
||
}
|
||
const_iterator& operator-- ()
|
||
{
|
||
node = (__link_type)((*node).prev); return *this;
|
||
}
|
||
const_iterator operator-- (int)
|
||
{
|
||
const_iterator tmp = *this;
|
||
--*this;
|
||
return tmp;
|
||
}
|
||
}; // End of definition of const_iterator class.
|
||
|
||
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
|
||
typedef _RW_STD::reverse_iterator<const_iterator> const_reverse_iterator;
|
||
typedef _RW_STD::reverse_iterator<iterator> reverse_iterator;
|
||
#else
|
||
typedef __reverse_bi_iterator<const_iterator,
|
||
bidirectional_iterator_tag, value_type,
|
||
const_reference, const_pointer, difference_type>
|
||
const_reverse_iterator;
|
||
typedef __reverse_bi_iterator<iterator,
|
||
bidirectional_iterator_tag, value_type,
|
||
reference, pointer, difference_type>
|
||
reverse_iterator;
|
||
#endif
|
||
|
||
//
|
||
// construct/copy/destroy
|
||
//
|
||
list (const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
|
||
: __length(0), __buffer_list(0,alloc),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{
|
||
__init(1);
|
||
}
|
||
|
||
#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
|
||
list (void)
|
||
: __length(0), __buffer_list(0,Allocator()),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{
|
||
__init(1);
|
||
}
|
||
|
||
list (size_type n, const T& value)
|
||
: __length(0), __buffer_list(0,Allocator()),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{
|
||
__init(n,value);
|
||
}
|
||
#endif // _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
|
||
_EXPLICIT list (size_type n)
|
||
: __length(0), __buffer_list(0,Allocator()),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{
|
||
T value = T();
|
||
__init(n,value);
|
||
}
|
||
|
||
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
|
||
|
||
template<class InputIterator>
|
||
void __init_aux (InputIterator first, InputIterator locallast, _RW_is_not_integer)
|
||
{
|
||
__init();
|
||
#ifndef _RWSTD_NO_EXCEPTIONS
|
||
try {
|
||
insert(begin(), first, locallast);
|
||
} catch(...) {
|
||
__deallocate_buffers();
|
||
throw;
|
||
}
|
||
#else
|
||
insert(begin(), first, locallast);
|
||
#endif
|
||
}
|
||
template<class InputIterator>
|
||
void __init_aux (InputIterator first, InputIterator last, _RW_is_integer)
|
||
{ __init(first, last); }
|
||
|
||
template<class InputIterator>
|
||
list (InputIterator first, InputIterator locallast,
|
||
const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
|
||
: __length(0), __buffer_list(0,alloc),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{
|
||
typedef _TYPENAME _RWdispatch<InputIterator>::_RWtype _RWtype;
|
||
__init_aux(first, locallast, _RWtype());
|
||
}
|
||
list (size_type n, const T& value,
|
||
const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
|
||
: __length(0), __buffer_list(0,alloc),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{ __init(n, value); }
|
||
#else
|
||
//
|
||
// Build a list of size n with each element set to a copy of value.
|
||
//
|
||
list (size_type n, const T& value,
|
||
const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
|
||
: __length(0), __buffer_list(0,alloc),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{
|
||
__init(n, value);
|
||
}
|
||
|
||
list (const_iterator first, const_iterator locallast,
|
||
const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
|
||
: __length(0), __buffer_list(0,alloc),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{
|
||
__init();
|
||
#ifndef _RWSTD_NO_EXCEPTIONS
|
||
try {
|
||
insert(begin(), first, locallast);
|
||
} catch(...) {
|
||
__deallocate_buffers();
|
||
throw;
|
||
}
|
||
#else
|
||
insert(begin(), first, locallast);
|
||
#endif
|
||
}
|
||
list (const T* first, const T* locallast,
|
||
const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
|
||
: __length(0), __buffer_list(0,alloc),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{
|
||
__init();
|
||
#ifndef _RWSTD_NO_EXCEPTIONS
|
||
try {
|
||
insert(begin(), first, locallast);
|
||
} catch(...) {
|
||
__deallocate_buffers();
|
||
throw;
|
||
}
|
||
#else
|
||
insert(begin(), first, locallast);
|
||
#endif
|
||
}
|
||
|
||
#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
|
||
list (const_iterator first, const_iterator locallast)
|
||
: __length(0), __buffer_list(0,Allocator()),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{
|
||
__init();
|
||
#ifndef _RWSTD_NO_EXCEPTIONS
|
||
try {
|
||
insert(begin(), first, locallast);
|
||
} catch(...) {
|
||
__deallocate_buffers();
|
||
throw;
|
||
}
|
||
#else
|
||
insert(begin(), first, locallast);
|
||
#endif
|
||
}
|
||
|
||
list (const T* first, const T* locallast)
|
||
: __length(0), __buffer_list(0,Allocator()),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{
|
||
__init();
|
||
#ifndef _RWSTD_NO_EXCEPTIONS
|
||
try {
|
||
insert(begin(), first, locallast);
|
||
} catch(...) {
|
||
__deallocate_buffers();
|
||
throw;
|
||
}
|
||
#else
|
||
insert(begin(), first, locallast);
|
||
#endif
|
||
}
|
||
#endif // _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
|
||
#endif // _RWSTD_NO_MEMBER_TEMPLATES
|
||
|
||
list (const list<T,Allocator>& x) : __length(0), __buffer_list(0,x.get_allocator()),
|
||
__free_list(0), __next_avail(0), __last(0), __node(0)
|
||
{
|
||
__init();
|
||
#ifndef _RWSTD_NO_EXCEPTIONS
|
||
try {
|
||
insert(begin(), x.begin(), x.end());
|
||
} catch(...) {
|
||
__deallocate_buffers();
|
||
throw;
|
||
}
|
||
#else
|
||
insert(begin(), x.begin(), x.end());
|
||
#endif
|
||
}
|
||
|
||
~list ()
|
||
{
|
||
if (__node)
|
||
{
|
||
erase(begin(), end());
|
||
__put_node(__node);
|
||
__deallocate_buffers();
|
||
}
|
||
}
|
||
list<T,Allocator>& operator= (const list<T,Allocator>& x);
|
||
|
||
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
|
||
template<class InputIterator>
|
||
void assign (InputIterator first, InputIterator last)
|
||
{
|
||
erase(begin(), end());
|
||
typedef _TYPENAME _RWdispatch<InputIterator>::_RWtype _RWtype;
|
||
__insert_aux(begin(), first, last, _RWtype());
|
||
}
|
||
void assign (size_type n, const T& t)
|
||
{
|
||
erase(begin(), end()); insert(begin(), n, t);
|
||
}
|
||
#else
|
||
void assign (const_iterator first, const_iterator last)
|
||
{ erase(begin(), end()); insert(begin(), first, last); }
|
||
void assign (const T* first, const T* last)
|
||
{ erase(begin(), end()); insert(begin(), first, last); }
|
||
//
|
||
// Assign n copies of t to this list.
|
||
//
|
||
void assign (size_type n, const T& t)
|
||
{ erase(begin(), end()); insert(begin(), n, t); }
|
||
#endif // _RWSTD_NO_MEMBER_TEMPLATES
|
||
|
||
allocator_type get_allocator() const
|
||
{
|
||
return (allocator_type)__buffer_list;
|
||
}
|
||
|
||
//
|
||
// Iterators.
|
||
//
|
||
iterator begin () { return _RWSTD_STATIC_CAST(__link_type,((*__node).next)); }
|
||
const_iterator begin () const { return _RWSTD_STATIC_CAST(__link_type,((*__node).next)); }
|
||
|
||
iterator end () { return __node; }
|
||
const_iterator end () const { return __node; }
|
||
reverse_iterator rbegin ()
|
||
{
|
||
reverse_iterator tmp(end()); return tmp;
|
||
}
|
||
const_reverse_iterator rbegin () const
|
||
{
|
||
const_reverse_iterator tmp(end()); return tmp;
|
||
}
|
||
reverse_iterator rend ()
|
||
{
|
||
reverse_iterator tmp(begin()); return tmp;
|
||
}
|
||
const_reverse_iterator rend () const
|
||
{
|
||
const_reverse_iterator tmp(begin()); return tmp;
|
||
}
|
||
|
||
//
|
||
// Capacity.
|
||
//
|
||
bool empty () const { return __length == 0; }
|
||
size_type size () const { return __length; }
|
||
size_type max_size () const
|
||
{ return __list_node_alloc_type(__buffer_list).max_size(); }
|
||
void resize (size_type new_size);
|
||
void resize (size_type new_size, T value);
|
||
|
||
//
|
||
// Element access.
|
||
//
|
||
reference front () { return *begin(); }
|
||
const_reference front () const { return *begin(); }
|
||
reference back () { return *(--end()); }
|
||
const_reference back () const { return *(--end()); }
|
||
|
||
//
|
||
// Modifiers.
|
||
//
|
||
//
|
||
void push_front (const T& x) { insert(begin(), x); }
|
||
void push_back (const T& x) { insert(end(), x); }
|
||
void pop_front () { erase(begin()); }
|
||
void pop_back () { iterator tmp = end(); erase(--tmp); }
|
||
|
||
//
|
||
// Insert x at position.
|
||
//
|
||
iterator insert (iterator position, const T& x)
|
||
{
|
||
__value_alloc_type va(__buffer_list);
|
||
__link_type tmp = __get_node(__buffer_size);
|
||
#ifndef _RWSTD_NO_EXCEPTIONS
|
||
try {
|
||
va.construct(va.address((*tmp).data),x);
|
||
} catch(...) {
|
||
__put_node(tmp);
|
||
throw;
|
||
}
|
||
#else
|
||
va.construct(va.address((*tmp).data),x);
|
||
#endif // _RWSTD_NO_EXCEPTIONS
|
||
(*tmp).next = position.node;
|
||
(*tmp).prev = (*position.node).prev;
|
||
(*(__link_type((*position.node).prev))).next = tmp;
|
||
(*position.node).prev = tmp;
|
||
++__length;
|
||
return tmp;
|
||
}
|
||
|
||
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
|
||
template<class InputIterator>
|
||
void insert (iterator position, InputIterator first,
|
||
InputIterator last)
|
||
{
|
||
typedef _TYPENAME _RWdispatch<InputIterator>::_RWtype _RWtype;
|
||
__insert_aux(position, first, last, _RWtype());
|
||
}
|
||
void insert (iterator position, size_type n, const T& value)
|
||
{ __insert_aux(position,n,value); }
|
||
#else
|
||
void insert (iterator position, size_type n, const T& x)
|
||
{ __insert_aux(position,n,x); }
|
||
void insert (iterator position, const T* first, const T* last);
|
||
void insert (iterator position, const_iterator first, const_iterator last);
|
||
#endif // _RWSTD_NO_MEMBER_TEMPLATES
|
||
|
||
iterator erase (iterator position)
|
||
{
|
||
if (position == end())
|
||
return end();
|
||
iterator tmp = (iterator)(__link_type((*position.node).next));
|
||
(*(__link_type((*position.node).prev))).next = (*position.node).next;
|
||
(*(__link_type((*position.node).next))).prev = (*position.node).prev;
|
||
--__length;
|
||
__value_alloc_type va(__buffer_list);
|
||
va.destroy(va.address((*position.node).data));
|
||
__put_node(position.node);
|
||
return tmp;
|
||
}
|
||
iterator erase (iterator first, iterator last);
|
||
void swap (list<T,Allocator>& x)
|
||
{
|
||
if((allocator_type)__buffer_list==(allocator_type)x.__buffer_list)
|
||
{
|
||
|
||
#ifndef _RWSTD_NO_NAMESPACE
|
||
std::swap(__node, x.__node);
|
||
std::swap(__length, x.__length);
|
||
std::swap(__buffer_list,x.__buffer_list);
|
||
std::swap(__free_list,x.__free_list);
|
||
std::swap(__next_avail,x.__next_avail);
|
||
std::swap(__last,x.__last);
|
||
#else
|
||
::swap(__node, x.__node);
|
||
::swap(__length, x.__length);
|
||
::swap(__buffer_list,x.__buffer_list);
|
||
::swap(__free_list,x.__free_list);
|
||
::swap(__next_avail,x.__next_avail);
|
||
::swap(__last,x.__last);
|
||
#endif // _RWSTD_NO_NAMESPACE
|
||
}
|
||
else
|
||
{
|
||
list<T,Allocator> _x = *this;
|
||
*this=x;
|
||
x=_x;
|
||
}
|
||
}
|
||
|
||
void clear()
|
||
{
|
||
erase(begin(),end());
|
||
}
|
||
|
||
protected:
|
||
|
||
void __transfer (iterator position, iterator first,
|
||
iterator last, list<T,Allocator>& x)
|
||
{
|
||
if (this == &x)
|
||
{
|
||
(*(__link_type((*last.node).prev))).next = position.node;
|
||
(*(__link_type((*first.node).prev))).next = last.node;
|
||
(*(__link_type((*position.node).prev))).next = first.node;
|
||
__link_type tmp = __link_type((*position.node).prev);
|
||
(*position.node).prev = (*last.node).prev;
|
||
(*last.node).prev = (*first.node).prev;
|
||
(*first.node).prev = tmp;
|
||
}
|
||
else
|
||
{
|
||
insert(position,first,last);
|
||
x.erase(first,last);
|
||
}
|
||
}
|
||
|
||
void __advance(iterator &i, difference_type n, iterator end)
|
||
{
|
||
for (int j = 0; j < (int) n; j++) {
|
||
if (i != end) ++i;
|
||
}
|
||
}
|
||
|
||
// uses transfer_node to merge in list by transfering nodes to list
|
||
void __adjacent_merge (iterator first1, iterator last1,
|
||
iterator last2)
|
||
{
|
||
iterator first2 = last1;
|
||
int n = 0;
|
||
distance(first1, last1, n);
|
||
int count = 0;
|
||
|
||
while (count <= n && first2 != last2)
|
||
{
|
||
if (*first2 < *first1)
|
||
{
|
||
iterator next = first2;
|
||
__transfer(first1, first2, ++next, *this);
|
||
first2 = next;
|
||
}
|
||
else {
|
||
first1++;
|
||
count++;
|
||
}
|
||
}
|
||
}
|
||
|
||
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
|
||
// uses transfer_node to merge in list by transfering nodes to list
|
||
template<class Compare>
|
||
void __adjacent_merge (iterator first1, iterator last1,
|
||
iterator last2, Compare comp)
|
||
{
|
||
iterator first2 = last1;
|
||
int n = 0;
|
||
distance(first1, last1, n);
|
||
int count = 0;
|
||
|
||
while (count <= n && first2 != last2)
|
||
{
|
||
if (comp(*first2,*first1))
|
||
{
|
||
iterator next = first2;
|
||
__transfer(first1, first2, ++next, *this);
|
||
first2 = next;
|
||
}
|
||
else {
|
||
first1++;
|
||
count++;
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
// used by the sort() member function
|
||
void __set_allocator(allocator_type a)
|
||
{
|
||
__buffer_list = a;
|
||
}
|
||
void __insert_aux (iterator position, size_type n, const T& x);
|
||
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
|
||
template<class InputIterator>
|
||
void __insert_aux (iterator position, InputIterator first, InputIterator last, _RW_is_not_integer)
|
||
{ __insert_aux2 (position, first, last); }
|
||
template<class InputIterator>
|
||
void __insert_aux (iterator position, InputIterator first, InputIterator last, _RW_is_integer)
|
||
{ __insert_aux (position, (size_type)first, last); }
|
||
template<class InputIterator>
|
||
void __insert_aux2 (iterator position, InputIterator first, InputIterator last);
|
||
#endif
|
||
|
||
public:
|
||
|
||
//
|
||
// list operations.
|
||
//
|
||
void splice (iterator position, list<T,Allocator>& x)
|
||
{
|
||
if (!x.empty())
|
||
__transfer(position, x.begin(), x.end(), x);
|
||
}
|
||
void splice (iterator position, list<T,Allocator>& x, iterator i)
|
||
{
|
||
iterator k = i;
|
||
if (k != position && ++k != position)
|
||
{
|
||
iterator j = i;
|
||
__transfer(position, i, ++j, x);
|
||
}
|
||
}
|
||
void splice (iterator position, list<T,Allocator>& x, iterator first, iterator last)
|
||
{
|
||
if (first != last)
|
||
{
|
||
difference_type n;
|
||
__initialize(n, difference_type(0));
|
||
distance(first, last, n);
|
||
__transfer(position, first, last, x);
|
||
}
|
||
}
|
||
void remove (const T& value);
|
||
void unique ();
|
||
void merge (list<T,Allocator>& x);
|
||
void reverse ();
|
||
void sort ();
|
||
|
||
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
|
||
template<class Predicate> void remove_if (Predicate pred);
|
||
template<class BinaryPredicate> void unique (BinaryPredicate pred);
|
||
template<class Compare> void merge (list<T,Allocator>& x, Compare comp);
|
||
template<class Compare> void sort (Compare comp);
|
||
#endif // _RWSTD_NO_MEMBER_TEMPLATES
|
||
|
||
#ifndef _RWSTD_STRICT_ANSI
|
||
// Non-standard function for setting buffer allocation size
|
||
size_type allocation_size() { return __buffer_size; }
|
||
size_type allocation_size(size_type new_size)
|
||
{
|
||
size_type tmp = __buffer_size;
|
||
__buffer_size = max((size_type)1,new_size);
|
||
return tmp;
|
||
}
|
||
#endif // _RWSTD_STRICT_ANSI
|
||
};
|
||
|
||
template <class T, class Allocator>
|
||
inline bool operator== (const list<T,Allocator>& x, const list<T,Allocator>& y)
|
||
{
|
||
return x.size() == y.size() && equal(x.begin(), x.end(), y.begin());
|
||
}
|
||
|
||
template <class T, class Allocator>
|
||
inline bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y)
|
||
{
|
||
return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
|
||
}
|
||
|
||
#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
|
||
template <class T, class Allocator>
|
||
inline bool operator!= (const list<T,Allocator>& x, const list<T,Allocator>& y)
|
||
{
|
||
return !(x == y);
|
||
}
|
||
|
||
template <class T, class Allocator>
|
||
inline bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y)
|
||
{
|
||
return y < x;
|
||
}
|
||
|
||
template <class T, class Allocator>
|
||
inline bool operator>= (const list<T,Allocator>& x, const list<T,Allocator>& y)
|
||
{
|
||
return !(x < y);
|
||
}
|
||
|
||
template <class T, class Allocator>
|
||
inline bool operator<= (const list<T,Allocator>& x, const list<T,Allocator>& y)
|
||
{
|
||
return !(y < x);
|
||
}
|
||
|
||
template <class T, class Allocator>
|
||
inline void swap(list<T,Allocator>& a, list<T,Allocator>& b)
|
||
{
|
||
a.swap(b);
|
||
}
|
||
#endif // !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
|
||
|
||
#ifndef _RWSTD_NO_NAMESPACE
|
||
}
|
||
#endif
|
||
|
||
#ifdef _RWSTD_NO_TEMPLATE_REPOSITORY
|
||
#include <list.cc>
|
||
#endif
|
||
|
||
#undef list
|
||
#endif /*__STD_LIST__*/
|
||
|
||
#ifndef __USING_STD_NAMES__
|
||
using namespace std;
|
||
#endif
|
||
|
||
#pragma option pop
|
||
#endif /* __LIST_H */
|