This repository has been archived on 2024-12-16. You can view files and clone it, but cannot push or open issues or pull requests.
CodeBlocksPortable/Borland/BCC55/Include/list.cc

360 lines
10 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#ifndef __LIST_CC
#define __LIST_CC
#pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
/***************************************************************************
*
* list.cc - Non-nline list definitions 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 <limits>
#define _RWSTD_LIST_SORT_COUNTERS 64
#ifndef _RWSTD_NO_NAMESPACE
namespace std {
#endif
template <class T, class Allocator>
void list<T,Allocator>::__deallocate_buffers ()
{
while (__buffer_list.data())
{
__buffer_pointer tmp = __buffer_list;
__buffer_list = (__buffer_pointer)(__buffer_list.data()->next_buffer);
__list_node_alloc_type(__buffer_list).deallocate(tmp->buffer,tmp->size);
__buffer_alloc_type(__buffer_list).deallocate(tmp,1);
}
__free_list = 0;
__next_avail = 0;
__last = 0;
}
//
// This requires that T have a default constructor.
//
template <class T, class Allocator>
void list<T,Allocator>::resize (size_type new_size)
{
// T value; // RW_BUG: bts-78526
if (new_size > size())
insert(end(), new_size - size(), T() ); // RW_BUG: bts-78526
else if (new_size < size())
{
iterator tmp = begin();
advance(tmp, (difference_type) new_size);
erase(tmp, end());
}
}
template <class T, class Allocator>
void list<T,Allocator>::resize (size_type new_size, T value)
{
if (new_size > size())
insert(end(), new_size - size(), value);
else if (new_size < size())
{
iterator tmp = begin();
advance(tmp, (difference_type) new_size);
erase(tmp, end());
}
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template <class T, class Allocator>
template<class InputIterator>
void list<T,Allocator>::__insert_aux2 (iterator position, InputIterator first,
InputIterator locallast)
{
while (first != locallast) insert(position, *first++);
}
#endif // _RWSTD_NO_MEMBER_TEMPLATES
#ifdef _RWSTD_NO_MEMBER_TEMPLATES
template <class T, class Allocator>
void list<T, Allocator>::insert (iterator position,
const_iterator first,
const_iterator locallast)
{
while (first != locallast) insert(position, *first++);
}
template <class T, class Allocator>
void list<T, Allocator>::insert (iterator position,
const T* first, const T* locallast)
{
while (first != locallast) insert(position, *first++);
}
#endif // _RWSTD_NO_MEMBER_TEMPLATES
template <class T, class Allocator>
void list<T, Allocator>::__insert_aux (iterator position,
size_type n, const T& x)
{
while (n--) insert(position, x);
}
template <class T, class Allocator>
_TYPENAME list<T, Allocator>::iterator
list<T, Allocator>::erase (iterator first, iterator locallast)
{
iterator tmp = end();
while (first != locallast)
{
tmp = erase(first++);
}
return tmp;
}
template <class T, class Allocator>
list<T, Allocator>& list<T, Allocator>::operator= (const list<T, Allocator>& x)
{
if (this != &x)
{
iterator first1 = begin();
iterator last1 = end();
const_iterator first2 = x.begin();
const_iterator last2 = x.end();
while (first1 != last1 && first2 != last2) *first1++ = *first2++;
if (first2 == last2)
erase(first1, last1);
else
insert(last1, first2, last2);
}
return *this;
}
template <class T, class Allocator>
void list<T, Allocator>::remove (const T& value)
{
iterator first = begin();
iterator last = end();
while (first != last)
{
iterator next = first;
++next;
if (*first == value) erase(first);
first = next;
}
}
template <class T, class Allocator>
void list<T, Allocator>::unique ()
{
iterator first = begin();
iterator last = end();
if (first == last) return;
iterator next = first;
while (++next != last)
{
if (*first == *next)
erase(next);
else
first = next;
next = first;
}
}
template <class T, class Allocator>
void list<T, Allocator>::merge (list<T, Allocator>& x)
{
iterator first1 = begin();
iterator last1 = end();
iterator first2 = x.begin();
iterator last2 = x.end();
while (first1 != last1 && first2 != last2)
{
if (*first2 < *first1)
{
iterator next = first2;
__transfer(first1, first2, ++next, x);
first2 = next;
}
else
first1++;
}
if (first2 != last2)
__transfer(last1, first2, last2, x);
}
template <class T, class Allocator>
void list<T, Allocator>::reverse ()
{
if (size() < 2) return;
for (iterator first = ++begin(); first != end();)
{
iterator old = first++;
__transfer(begin(), old, first, *this);
}
}
// sorts list by moving nodes within list. This preserves iterators pointing to
// elements of the list.
template <class T, class Allocator>
void list<T, Allocator>::sort ()
{
for (unsigned int n = 1; n < size(); n *= 2) {
iterator i1 = begin(), i2 = begin(), i3 = begin();
__advance(i2, (difference_type) n, end());
__advance(i3, (difference_type) (2*n), end());
for (unsigned int m = 0; m < (size()+(2*n))/(n*2); m++) {
if (i1 != end() && i2 != end()) {
__adjacent_merge(i1, i2, i3);
i1 = i3;
i2 = i3;
__advance(i2, (difference_type) n, end());
__advance(i3, (difference_type) 2*n, end());
}
}
}
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class T, class Allocator>
template<class Predicate> void list<T, Allocator>::remove_if (Predicate pred)
{
iterator first = begin();
iterator last = end();
while (first != last)
{
iterator next = first;
++next;
if (pred(*first)) erase(first);
first = next;
}
}
template<class T, class Allocator>
template<class BinaryPredicate> void list<T, Allocator>::unique (BinaryPredicate pred)
{
iterator first = begin();
iterator last = end();
if (first == last) return;
iterator next = first;
while (++next != last)
{
if (pred(*first, *next))
erase(next);
else
first = next;
next = first;
}
}
template<class T, class Allocator>
template<class Compare> void list<T, Allocator>::merge (list<T, Allocator>& x, Compare comp)
{
iterator first1 = begin();
iterator last1 = end();
iterator first2 = x.begin();
iterator last2 = x.end();
while (first1 != last1 && first2 != last2)
{
if (comp(*first2, *first1))
{
iterator next = first2;
__transfer(first1, first2, ++next, x);
first2 = next;
}
else
first1++;
}
if (first2 != last2)
__transfer(last1, first2, last2, x);
}
template <class T, class Allocator>
template<class Compare> void list<T, Allocator>::sort (Compare comp)
{
for (int n = 1; n < size(); n *= 2) {
iterator i1 = begin(), i2 = begin(), i3 = begin();
__advance(i2, (difference_type) n, end());
__advance(i3, (difference_type) (2*n), end());
for (int m = 0; m < (size()+(2*n))/(n*2); m++) {
if (i1 != end() && i2 != end()) {
__adjacent_merge(i1, i2, i3, comp);
i1 = i3;
i2 = i3;
__advance(i2, (difference_type) n, end());
__advance(i3, (difference_type) 2*n, end());
}
}
}
}
/*
template<class T, class Allocator>
template<class Compare> void list<T, Allocator>::sort (Compare comp)
{
if (size() < 2) return;
list<T, Allocator> carry(get_allocator());
list<T, Allocator> counter[ _RWSTD_LIST_SORT_COUNTERS];
for (int i = 0; i < _RWSTD_LIST_SORT_COUNTERS; i++)
counter[i].__set_allocator(get_allocator());
int fill = 0;
while (!empty())
{
carry.splice(carry.begin(), *this, begin());
int i = 0;
while (i < fill && !counter[i].empty())
{
counter[i].merge(carry, comp);
carry.swap(counter[i++]);
}
carry.swap(counter[i]);
if (i == fill) ++fill;
}
while (fill--) merge(counter[fill], comp);
}
*/
#endif /*_RWSTD_NO_MEMBER_TEMPLATES*/
#undef _RWSTD_LIST_SORT_COUNTERS
#ifndef _RWSTD_NO_NAMESPACE
}
#endif
#pragma option pop
#endif /* __LIST_CC */