MichaelAgarkov/CodeBlocksPortable
MichaelAgarkov/CodeBlocksPortable
Archived
1
1
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
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/vector.h

1458 lines
42 KiB
C
Raw Normal View History

My portable distribution of Code::Blocks
2024-07-04 16:52:56 +00:00
#ifndef __VECTOR_H
#define __VECTOR_H
#pragma option push -b -a8 -pc -Vx- -Ve- -A- -w-inl -w-aus -w-sig
// -*- C++ -*-
/***************************************************************************
*
* vector - declarations for the Standard Library vector class
*
***************************************************************************
*
* 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 <EFBFBD> Restricted Rights at 48 CFR 52.227-19,
* as applicable. Manufacturer is Rogue Wave Software, Inc., 5500
* Flatiron Parkway, Boulder, Colorado 80301 USA.
*
**************************************************************************/
#ifndef __STD_VECTOR__
#define __STD_VECTOR__
#include <stdcomp.h>
#include <rw/stddefs.h>
#include <rw/rwdispatch.h>
#include <algorithm>
#include <iterator>
#include <memory>
#include <stdexcept>
#ifndef vector
#define vector vector
#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 vector
{
private:
#if defined( _RWSTD_ALLOCATOR) && !defined(_HPACC_)
typedef _TYPENAME Allocator::template rebind<T>::other __value_alloc_type;
#else
typedef allocator_interface<Allocator,T> __value_alloc_type;
#endif
public:
//
// Types.
//
typedef T value_type;
typedef Allocator allocator_type;
#ifndef _RWSTD_NO_COMPLICATED_TYPEDEF
typedef _TYPENAME _RWSTD_ALLOC_SIZE_TYPE size_type;
typedef _TYPENAME _RWSTD_ALLOC_DIFF_TYPE difference_type;
typedef _TYPENAME __value_alloc_type::pointer iterator;
typedef _TYPENAME __value_alloc_type::const_pointer const_iterator;
typedef _TYPENAME __value_alloc_type::reference reference;
typedef _TYPENAME __value_alloc_type::const_reference const_reference;
typedef _TYPENAME __value_alloc_type::pointer pointer;
typedef _TYPENAME __value_alloc_type::const_pointer const_pointer;
#else
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T* iterator;
typedef const T* const_iterator;
typedef T& reference;
typedef const T& const_reference;
typedef T* pointer;
typedef const T* const_pointer;
#endif //_RWSTD_NO_COMPLICATED_TYPEDEF
#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 _RW_STD::reverse_iterator<const_iterator,
random_access_iterator_tag, value_type,
const_reference, const_pointer, difference_type>
const_reverse_iterator;
typedef _RW_STD::reverse_iterator<iterator,
random_access_iterator_tag, value_type,
reference, pointer, difference_type>
reverse_iterator;
#endif
protected:
size_type __buffer_size;
iterator __start;
iterator __finish;
__RWSTD::__rw_basis<iterator,allocator_type> __end_of_storage;
void __insert_aux (iterator position, const T& x);
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);
#else
void __insert_aux2 (iterator position, const_iterator first, const_iterator last);
#endif
void __destroy(iterator start, iterator finish)
{
while ( start != finish)
__value_alloc_type(__end_of_storage).destroy(start++);
}
//
// Allocate buffers and fill with n values
//
void __initn(size_type n, const T& value)
{
__init();
__start = __value_alloc_type(__end_of_storage).allocate(n,0);
#ifndef _RWSTD_NO_EXCEPTIONS
try {
uninitialized_fill_n(__start, n, value);
} catch(...) {
__value_alloc_type(__end_of_storage).deallocate(__start,n);
throw;
}
#else
uninitialized_fill_n(__start, n, value);
#endif // _RWSTD_NO_EXCEPTIONS
__finish = __start + n;
__end_of_storage = __finish;
}
void __init()
{
__buffer_size =
max((size_type)1,__RWSTD::__rw_allocation_size((value_type*)0,(size_type)0,(size_type)0));
}
public:
//
// construct/copy/destroy
//
_EXPLICIT vector (const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __start(0), __finish(0), __end_of_storage(0,alloc)
{
__init();
}
#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
vector (void)
: __start(0), __finish(0), __end_of_storage(0,Allocator())
{ ; }
vector (size_type n, const T& value)
: __start(0), __finish(0), __end_of_storage(0,Allocator())
{
__initn(n,value);
}
#endif
_EXPLICIT vector (size_type n)
: __start(0), __finish(0), __end_of_storage(0,Allocator())
{
T value = T();
__initn(n,value);
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class InputIterator>
void __init_aux (InputIterator first, InputIterator last, _RW_is_not_integer)
{
if (__is_input_iterator(__iterator_category(first))) {
copy(first, last, back_inserter(*this));
} else {
size_type n;
__init();
__initialize(n, size_type(0));
distance(first, last, n);
__start = __value_alloc_type(__end_of_storage).allocate(n,0);
#ifndef _RWSTD_NO_EXCEPTIONS
try {
__finish = uninitialized_copy(first, last, __start);
} catch(...) {
__value_alloc_type(__end_of_storage).deallocate(__start,n);
throw;
}
#else
__finish = uninitialized_copy(first, last, __start);
#endif // _RWSTD_NO_EXCEPTIONS
__end_of_storage = __finish;
}
}
template<class InputIterator>
void __init_aux (InputIterator first, InputIterator last, _RW_is_integer)
{ __initn((size_type)first,last); }
template<class InputIterator>
vector (InputIterator first, InputIterator last,
const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __start(0), __finish(0), __end_of_storage(0,alloc)
{
typedef _TYPENAME _RWdispatch<InputIterator>::_RWtype _RWtype;
__init_aux(first, last, _RWtype());
}
vector (size_type n, const T& value,
const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __start(0), __finish(0), __end_of_storage(0,alloc)
{ __initn((size_type)n,value); }
#else
//
// Build a vector of size n with each element set to copy of value.
//
vector (size_type n, const T& value,
const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __start(0), __finish(0), __end_of_storage(0,alloc)
{
__initn(n,value);
}
vector (const_iterator first, const_iterator last,
const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __start(0), __finish(0), __end_of_storage(0,alloc)
{
size_type n;
__init();
__initialize(n, size_type(0));
distance(first, last, n);
__start = __value_alloc_type(__end_of_storage).allocate(n,0);
#ifndef _RWSTD_NO_EXCEPTIONS
try {
__finish = uninitialized_copy(first, last, __start);
} catch(...) {
__value_alloc_type(__end_of_storage).deallocate(__start,n);
throw;
}
#else
__finish = uninitialized_copy(first, last, __start);
#endif // _RWSTD_NO_EXCEPTIONS
__end_of_storage = __finish;
}
#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
vector (const_iterator first, const_iterator last)
: __start(0), __finish(0), __end_of_storage(0,Allocator())
{
size_type n;
__init();
__initialize(n, size_type(0));
distance(first, last, n);
__start = __value_alloc_type(__end_of_storage).allocate(n,0);
#ifndef _RWSTD_NO_EXCEPTIONS
try {
__finish = uninitialized_copy(first, last, __start);
} catch(...) {
__value_alloc_type(__end_of_storage).deallocate(__start,n);
throw;
}
#else
__finish = uninitialized_copy(first, last, __start);
#endif // _RWSTD_NO_EXCEPTIONS
__end_of_storage = __finish;
}
#endif // _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
#endif // _RWSTD_NO_MEMBER_TEMPLATES
vector (const vector<T,Allocator>& x)
: __start(0), __finish(0), __end_of_storage(0,x.get_allocator())
{
__init();
__start = __value_alloc_type(__end_of_storage).allocate(x.end() - x.begin(),0);
__finish = uninitialized_copy(x.begin(), x.end(), __start);
__end_of_storage = __finish;
}
~vector ()
{
__destroy(__start, __finish);
__value_alloc_type(__end_of_storage).deallocate(__start,__end_of_storage.data()-__start);
}
vector<T,Allocator>& operator= (const vector<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); }
//
// Assign n copies of t to this vector.
//
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)__end_of_storage;
}
//
// Iterators.
//
iterator begin () { return __start; }
const_iterator begin () const { return __start; }
iterator end () { return __finish; }
const_iterator end () const { return __finish; }
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.
//
size_type size () const { return size_type(end() - begin()); }
size_type max_size () const { return __value_alloc_type(__end_of_storage).max_size(); }
void resize (size_type new_size);
void resize (size_type new_size, T value);
size_type capacity () const { return size_type(__end_of_storage.data() - begin()); }
bool empty () const { return begin() == end(); }
void reserve (size_type n)
{
_RWSTD_THROW(n > max_size(), length_error,
__RWSTD::except_msg_string(__RWSTD::__rwse_InvalidSizeParam,
"vector::reserve(size_t)",n,max_size()).msgstr());
if (capacity() < n)
{
__value_alloc_type va(__end_of_storage);
iterator tmp = va.allocate(n,__start);
#ifndef _RWSTD_NO_EXCEPTIONS
try {
uninitialized_copy(begin(), end(), tmp);
} catch(...) {
__value_alloc_type(__end_of_storage).deallocate(tmp,n);
throw;
}
#else
uninitialized_copy(begin(), end(), tmp);
#endif // _RWSTD_NO_EXCEPTIONS
int tmp_size = size(); // RW_BUG: Fix for bts-78394
__destroy(__start, __finish);
va.deallocate(__start,__end_of_storage.data()-__start);
__finish = tmp + tmp_size; // RW_BUG: Fix for bts-78394
__start = tmp;
__end_of_storage = begin() + n;
}
}
//
// Element access.
//
reference operator[] (size_type n)
{
#ifdef _RWSTD_BOUNDS_CHECKING
_RWSTD_THROW(n >= size(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
"vector::operator[](size_t)",n,size()).msgstr());
#endif
return *(begin() + n);
}
const_reference operator[] (size_type n) const
{
#ifdef _RWSTD_BOUNDS_CHECKING
_RWSTD_THROW(n >= size(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
"vector::operator[](size_t) const",n,size()).msgstr());
#endif
return *(begin() + n);
}
reference at (size_type n)
{
_RWSTD_THROW(n >= size(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
"vector:: at(size_t)",n,size()).msgstr());
return *(begin() + n);
}
const_reference at (size_type n) const
{
_RWSTD_THROW(n >= size(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
"vector:: at(size_t) const",n,size()).msgstr());
return *(begin() + n);
}
reference front () { return *begin(); }
const_reference front () const { return *begin(); }
reference back () { return *(end() - 1); }
const_reference back () const { return *(end() - 1); }
//
// Modifiers.
//
void push_back (const T& x)
{
if (__finish != __end_of_storage.data())
{
__value_alloc_type(__end_of_storage).construct(__finish, x);
__finish++;
}
else
__insert_aux(end(), x);
}
void pop_back()
{
--__finish;
__value_alloc_type(__end_of_storage).destroy(__finish);
}
//
// Insert x at position.
//
iterator insert (iterator position, const T& x)
{
size_type n = position - begin();
if (__finish != __end_of_storage.data() && position == end())
{
__value_alloc_type(__end_of_storage).construct(__finish, x); __finish++;
}
else
__insert_aux(position, x);
return begin() + n;
}
#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_iterator first, const_iterator last)
{ __insert_aux2(position, first, last); }
#endif // _RWSTD_NO_MEMBER_TEMPLATES
iterator erase (iterator position)
{
if (position + 1 != end())
copy(position + 1, end(), position);
--__finish;
__value_alloc_type(__end_of_storage).destroy(__finish);
return position;
}
iterator erase (iterator first, iterator last)
{
iterator i = copy(last, end(), first);
iterator tmp = __finish;
__finish = __finish - (last - first);
__destroy(i, tmp);
return first;
}
void swap (vector<T,Allocator>& x)
{
if((allocator_type)__end_of_storage==(allocator_type)x.__end_of_storage)
{
#ifndef _RWSTD_NO_NAMESPACE
std::swap(__start, x.__start);
std::swap(__finish, x.__finish);
std::swap(__end_of_storage, x.__end_of_storage);
#else
::swap(__start, x.__start);
::swap(__finish, x.__finish);
::swap(__end_of_storage, x.__end_of_storage);
#endif // _RWSTD_NO_NAMESPACE
}
else
{
vector<T,Allocator> _x = *this;
*this = x;
x=_x;
}
}
void clear()
{
erase(begin(),end());
}
#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 vector<T,Allocator>& x, const vector<T,Allocator>& y)
{
return x.size() == y.size() && equal(x.begin(), x.end(), y.begin());
}
template <class T, class Allocator>
inline bool operator< (const vector<T,Allocator>& x, const vector<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 vector<T,Allocator>& x, const vector<T,Allocator>& y)
{
return !(x == y);
}
template <class T, class Allocator>
inline bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
{
return y < x;
}
template <class T, class Allocator>
inline bool operator>= (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
{
return !(x < y);
}
template <class T, class Allocator>
inline bool operator<= (const vector<T,Allocator>& x, const vector<T,Allocator>& y)
{
return !(y < x);
}
template <class T, class Allocator>
inline void swap(vector<T,Allocator>& a, vector<T,Allocator>& b)
{
a.swap(b);
}
#endif // !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
#if defined (_RWSTD_NO_TEMPLATE_REPOSITORY) && defined (__BORLANDC__) && (__TURBOC__ < 0x540)
#ifndef _RWSTD_NO_NAMESPACE
}
#endif
#include <vector.cc>
#ifndef _RWSTD_NO_NAMESPACE
namespace std {
#endif
#endif // (_RWSTD_NO_TEMPLATE_REPOSITORY) && defined (__BORLANDC__)
//
// If bool is a builtin type, we provide a vector<bool,allocator> specialization.
// We do not provide the allocator interface for this specialization.
//
#ifndef _RWSTD_NO_BOOL
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
template <class Allocator>
class _RWSTDExport vector<bool, Allocator >
{
#else
// Use a macro to mutate Allocator into allocator<bool>
#define Allocator allocator<bool>
_RWSTD_TEMPLATE
class _RWSTDExport vector<bool, allocator<bool> >
{
#endif // _RWSTD_NO_CLASS_PARTIAL_SPEC
public:
//
// types
//
typedef Allocator allocator_type;
typedef bool value_type;
private:
#if defined ( _RWSTD_ALLOCATOR) && !defined(_HPACC_)
#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
typedef _TYPENAME allocator_type::template rebind<unsigned int>::other __value_alloc_type;
#else
typedef allocator_type::template rebind<unsigned int>::other __value_alloc_type;
#endif
#else
typedef allocator_interface<allocator_type,unsigned int> __value_alloc_type;
#endif
public:
#ifdef _RWSTD_NO_EMBEDDED_TYPEDEF
typedef allocator<bool>::size_type size_type;
typedef allocator<bool>::difference_type difference_type;
#else
#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
typedef allocator_type::size_type size_type;
typedef allocator_type::difference_type difference_type;
#else
typedef _TYPENAME allocator_type::size_type size_type;
typedef _TYPENAME allocator_type::difference_type difference_type;
#endif
#endif
protected:
#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
typedef __value_alloc_type::pointer pointer;
typedef __value_alloc_type::const_pointer const_pointer;
#else
typedef _TYPENAME __value_alloc_type::pointer pointer;
typedef _TYPENAME __value_alloc_type::const_pointer const_pointer;
#endif
public:
//
// forward declarations
//
class iterator;
class const_iterator;
//
// bit reference
//
class reference
{
friend class iterator;
friend class const_iterator;
protected:
unsigned int* p;
unsigned int mask;
reference (unsigned int* x, unsigned int y) : p(x), mask(y) {}
public:
reference () : p(0), mask(0) {}
operator bool () const { return !(!(*p & mask)); }
reference& operator= (bool x)
{
if (x)
*p |= mask;
else
*p &= ~mask;
return *this;
}
reference& operator= (const reference& x) { return *this = bool(x); }
#ifndef _RWSTD_STRICT_ANSI
bool operator== (const reference& x) const
{
return bool(*this) == bool(x);
}
bool operator< (const reference& x) const
{
#if !defined(_MSC_VER) || defined(__BORLANDC__)
return bool(*this) < bool(x);
#else
return int(*this) < int(x);
#endif
}
bool operator!= (const reference& x) const
{
return !(*this == x);
}
bool operator> (const reference& x) const
{
return x < *this;
}
bool operator>= (const reference& x) const
{
return !(*this < x);
}
bool operator<= (const reference& x) const
{
return !(*this > x);
}
#endif // _RWSTD_STRICT_ANSI
void flip () { *p ^= mask; }
};
typedef bool const_reference;
//
// Definition of our iterator.
//
class iterator : public _RW_STD::iterator<random_access_iterator_tag,
value_type, difference_type,
pointer,reference>
{
#if !defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
friend class vector<bool,Allocator>;
#else
friend class vector<bool,allocator<bool> >;
#endif
friend class const_iterator;
protected:
unsigned int* p;
unsigned int offset;
void __bump_up ()
{
if (offset++ == _RWSTD_WORD_BIT - 1)
{
offset = 0; ++p;
}
}
void __bump_down ()
{
if (offset-- == 0)
{
offset = _RWSTD_WORD_BIT - 1; --p;
}
}
public:
iterator () : p(0), offset(0) {}
iterator (unsigned int* x, unsigned int y) : p(x), offset(y) {}
reference operator* () const { return reference(p, 1U << offset); }
iterator& operator++ ()
{
__bump_up(); return *this;
}
iterator operator++ (int)
{
iterator tmp = *this; __bump_up(); return tmp;
}
iterator& operator-- ()
{
__bump_down(); return *this;
}
iterator operator-- (int)
{
iterator tmp = *this; __bump_down(); return tmp;
}
iterator& operator+= (difference_type i)
{
difference_type n = i + offset;
p += n / _RWSTD_WORD_BIT;
n = n % _RWSTD_WORD_BIT;
if (n < 0)
{
offset = n + _RWSTD_WORD_BIT; --p;
}
else
offset = n;
return *this;
}
iterator& operator-= (difference_type i)
{
*this += -i; return *this;
}
iterator operator+ (difference_type i) const
{
iterator tmp = *this; return tmp += i;
}
iterator operator- (difference_type i) const
{
iterator tmp = *this; return tmp -= i;
}
difference_type operator- (iterator x) const
{
return _RWSTD_WORD_BIT * (p - x.p) + offset - x.offset;
}
reference operator[] (difference_type i)
{
return *(*this + i);
}
bool operator== (const iterator& x) const
{
return p == x.p && offset == x.offset;
}
bool operator< (const iterator& x) const
{
return p < x.p || (p == x.p && offset < x.offset);
}
bool operator!= (const iterator& x) const
{
return !(*this == x);
}
bool operator> (const iterator& x) const
{
return x < *this;
}
bool operator>= (const iterator& x) const
{
return !(*this < x);
}
bool operator<= (const iterator& x) const
{
return !(*this > x);
}
};
//
// Definition of our const_iterator.
//
class const_iterator
: public _RW_STD::iterator<random_access_iterator_tag,
value_type, difference_type,
const_pointer, const_reference>
{
#if !defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
friend class vector<bool,Allocator>;
#else
friend class vector<bool,allocator<bool> >;
#endif
protected:
unsigned int* p;
unsigned int offset;
void __bump_up ()
{
if (offset++ == _RWSTD_WORD_BIT - 1)
{
offset = 0; ++p;
}
}
void __bump_down()
{
if (offset-- == 0)
{
offset = _RWSTD_WORD_BIT - 1; --p;
}
}
public:
const_iterator () : p(0), offset(0) {}
const_iterator (unsigned int* x, unsigned int y) : p(x), offset(y) {}
#if !defined(_MSC_VER) || defined(__BORLANDC__)
#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
const_iterator (const vector<bool,Allocator>::iterator& x) : p(x.p), offset(x.offset) {}
#else
const_iterator (const _TYPENAME vector<bool,Allocator>::iterator& x) : p(x.p), offset(x.offset) {}
#endif
#else
const_iterator (const iterator& x) : p(x.p), offset(x.offset) {}
#endif
const_reference operator* () const
{
return vector<bool,Allocator>::reference(p, 1U << offset);
}
const_iterator& operator++ ()
{
__bump_up(); return *this;
}
const_iterator operator++ (int)
{
const_iterator tmp = *this; __bump_up(); return tmp;
}
const_iterator& operator-- ()
{
__bump_down(); return *this;
}
const_iterator operator-- (int)
{
const_iterator tmp = *this; __bump_down(); return tmp;
}
const_iterator& operator+= (difference_type i)
{
difference_type n = i + offset;
p += n / _RWSTD_WORD_BIT;
n = n % _RWSTD_WORD_BIT;
if (n < 0)
{
offset = n + _RWSTD_WORD_BIT; --p;
}
else
offset = n;
return *this;
}
const_iterator& operator-= (difference_type i)
{
*this += -i; return *this;
}
const_iterator operator+ (difference_type i) const
{
const_iterator tmp = *this; return tmp += i;
}
const_iterator operator- (difference_type i) const
{
const_iterator tmp = *this; return tmp -= i;
}
difference_type operator- (const_iterator x) const
{
return _RWSTD_WORD_BIT * (p - x.p) + offset - x.offset;
}
const_reference operator[] (difference_type i)
{
return *(*this + i);
}
bool operator== (const const_iterator& x) const
{
return p == x.p && offset == x.offset;
}
bool operator< (const const_iterator& x) const
{
return p < x.p || (p == x.p && offset < x.offset);
}
bool operator!= (const const_iterator& x) const
{
return !(*this == x);
}
bool operator> (const const_iterator& x) const
{
return x < *this;
}
bool operator>= (const const_iterator& x) const
{
return !(*this < x);
}
bool operator<= (const const_iterator& x) const
{
return !(*this > x);
}
};
//
// types
//
#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 _RW_STD::reverse_iterator<const_iterator,
random_access_iterator_tag, value_type,
const_reference, const_pointer, difference_type>
const_reverse_iterator;
typedef _RW_STD::reverse_iterator<iterator,
random_access_iterator_tag, value_type,
reference, pointer, difference_type>
reverse_iterator;
#endif
private:
//
// These private functions are replicas of generic algorithms.
// We provide them here to avoid putting instantiations of
// the generic algorithms into an archive or shared library.
// This gives you full flexibilty in deciding where you want
// to put particular instantiations of the generic
// algorithms.
//
void __fill (iterator first, iterator last,
const bool& value)
{
while (first != last) *first++ = value;
}
void __fill_n (iterator first, size_type n,
const bool& value)
{
while (n-- > 0) *first++ = value;
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template <class Iterator>
iterator __copy (Iterator first, Iterator last,
iterator result)
{
while (first != last) *result++ = *first++;
return result;
}
template <class Iterator>
iterator __copy_backward (Iterator first, Iterator last,
iterator result)
{
while (first != last) *--result = *--last;
return result;
}
#else
iterator __copy (const_iterator first, const_iterator last,
iterator result)
{
while (first != last) *result++ = *first++;
return result;
}
iterator __copy (const bool* first, const bool* last,
iterator result)
{
while (first != last) *result++ = *first++;
return result;
}
iterator __copy_backward (const_iterator first, const_iterator last,
iterator result)
{
while (first != last) *--result = *--last;
return result;
}
iterator __copy_backward (const bool* first, const bool* last,
iterator result)
{
while (first != last) *--result = *--last;
return result;
}
#endif
protected:
iterator __start;
iterator __finish;
__RWSTD::__rw_basis<unsigned int*,allocator_type> __end_of_storage;
unsigned int* __bit_alloc (size_type n)
{
return __value_alloc_type(__end_of_storage).allocate((n + _RWSTD_WORD_BIT - 1)/_RWSTD_WORD_BIT,__start.p);
}
void __init (size_type n)
{
unsigned int* q = __bit_alloc(n);
__end_of_storage = q + (n + _RWSTD_WORD_BIT - 1)/_RWSTD_WORD_BIT;
__start = iterator(q, 0);
__finish = __start + n;
}
void __insert_aux (iterator position, bool x);
public:
//
// construct/copy/destroy
//
vector<bool,Allocator> (const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __start(iterator()), __finish(iterator()),
__end_of_storage(0,alloc)
{ ; }
_EXPLICIT vector<bool,Allocator> (size_type n, bool value = bool(),
const Allocator& alloc _RWSTD_DEFAULT_ARG(Allocator()))
: __end_of_storage(0,alloc)
{
__init(n);
unsigned int * first = __start.p;
size_type m = (n + _RWSTD_WORD_BIT - 1)/_RWSTD_WORD_BIT;
while (m-- > 0) *first++ = value ? ~0 : 0;
}
vector<bool,Allocator> (const vector<bool,Allocator >& x)
: __end_of_storage(0,x.get_allocator())
{
__init(x.size());
__copy(x.begin(), x.end(), __start);
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class InputIterator>
vector<bool,Allocator> (InputIterator first, InputIterator last)
: __end_of_storage(0,Allocator())
{
size_type n;
__initialize(n, size_type(0));
distance(first, last, n);
__init(n);
__copy(first, last, __start);
}
#else
vector<bool,Allocator> (const_iterator first, const_iterator last)
: __end_of_storage(0,Allocator())
{
size_type n;
__initialize(n, size_type(0));
distance(first, last, n);
__init(n);
__copy(first, last, __start);
}
vector<bool,Allocator> (const bool* first, const bool* last)
: __end_of_storage(0,Allocator())
{
size_type n;
__initialize(n, size_type(0));
distance(first, last, n);
__init(n);
__copy(first, last, __start);
}
#endif
~vector<bool,Allocator> () {
__value_alloc_type(__end_of_storage).deallocate(__start.p,
__end_of_storage.data()-__start.p);
}
vector<bool,Allocator>& operator= (const vector<bool, Allocator>& x)
{
if (&x == this) return *this;
if (x.size() > capacity())
{
__value_alloc_type(__end_of_storage).deallocate(__start.p,
__end_of_storage.data()-__start.p);
__init(x.size());
}
__copy(x.begin(), x.end(), begin());
__finish = begin() + x.size();
return *this;
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class InputIterator>
void assign (InputIterator first, InputIterator last)
{ erase(begin(), end()); insert(begin(), first, last); }
#else
void assign (const_iterator first, const_iterator last)
{ erase(begin(), end()); insert(begin(), first, last); }
#endif
void assign (size_type n, const bool& t = bool())
{ erase(begin(), end()); insert(begin(), n, t); }
allocator_type get_allocator() const
{
return (allocator_type)__end_of_storage;
}
//
// iterators
//
iterator begin () { return __start; }
const_iterator begin () const
{ return const_iterator(__start.p,__start.offset); }
iterator end () { return __finish; }
const_iterator end () const
{ return const_iterator(__finish.p,__finish.offset); }
reverse_iterator rbegin () { return reverse_iterator(end()); }
const_reverse_iterator rbegin () const
{
return const_reverse_iterator(end());
}
reverse_iterator rend () { return reverse_iterator(begin()); }
const_reverse_iterator rend () const
{
return const_reverse_iterator(begin());
}
//
// capacity
//
size_type size () const { return size_type(end() - begin()); }
size_type max_size () const { return __value_alloc_type(__end_of_storage).max_size(); }
void resize (size_type new_size, bool c = false);
size_type capacity () const
{
return size_type(const_iterator(__end_of_storage.data(), 0) - begin());
}
bool empty () const { return begin() == end(); }
void reserve (size_type n)
{
_RWSTD_THROW(n > max_size(), length_error,
__RWSTD::except_msg_string(__RWSTD::__rwse_InvalidSizeParam,
"vector<bool>::reserve(size_t)",n,max_size()).msgstr());
if (capacity() < n)
{
unsigned int* q = __bit_alloc(n);
__finish = __copy(begin(), end(), iterator(q, 0));
__value_alloc_type(__end_of_storage).deallocate(__start.p,
__end_of_storage.data()-__start.p);
__start = iterator(q, 0);
__end_of_storage = q + (n + _RWSTD_WORD_BIT - 1)/_RWSTD_WORD_BIT;
}
}
//
// element access
//
reference operator[] (size_type n)
{
#ifdef _RWSTD_BOUNDS_CHECKING
_RWSTD_THROW(n >= size(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
"vector<bool>::[](size_t)",n,size()).msgstr());
#endif
return *(begin() + n);
}
const_reference operator[] (size_type n) const
{
#ifdef _RWSTD_BOUNDS_CHECKING
_RWSTD_THROW(n >= size(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
"vector<bool>::[](size_t)",n,size()).msgstr());
#endif
return *(begin() + n);
}
reference at (size_type n)
{
_RWSTD_THROW(n >= size(), out_of_range,
__RWSTD::except_msg_string(__RWSTD::rwse_OutOfRange,
"vector<bool>:: at(size_t)",n,size()).msgstr());
return *(begin() + n);
}
const_reference at (size_type n) const
{
_RWSTD_THROW(n >= size(), out_of_range,
__RWSTD::except_msg_string( __RWSTD::rwse_OutOfRange,
"vector<bool>:: at(size_t) const",n,size()).msgstr());
return *(begin() + n);
}
reference front () { return *begin(); }
const_reference front () const { return *begin(); }
reference back () { return *(end() - 1); }
const_reference back () const { return *(end() - 1); }
//
// modifiers
//
void push_back (const bool& x)
{
if (__finish.p != __end_of_storage.data())
*__finish++ = x;
else
__insert_aux(end(), x);
}
void pop_back () { --__finish; }
iterator insert (iterator position, const bool& x = bool())
{
size_type n = position - begin();
if (__finish.p != __end_of_storage.data() && position == end())
*__finish++ = x;
else
__insert_aux(position, x);
return begin() + n;
}
void insert (iterator position, size_type n, const bool& x);
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class InputIterator>
void insert (iterator position, InputIterator first, InputIterator last);
#else
void insert (iterator position, const_iterator first,
const_iterator last);
#endif
iterator erase (iterator position)
{
if (!(position + 1 == end()))
__copy(position + 1, end(), position);
--__finish;
return position;
}
iterator erase(iterator first, iterator last)
{
__finish = __copy(last, end(), first);
return first;
}
void swap (vector<bool,Allocator >& x)
{
if((allocator_type)__end_of_storage==(allocator_type)x.__end_of_storage)
{
#ifndef _RWSTD_NO_NAMESPACE
std::swap(__start, x.__start);
std::swap(__finish, x.__finish);
std::swap(__end_of_storage, x.__end_of_storage);
#else
::swap(__start, x.__start);
::swap(__finish, x.__finish);
::swap(__end_of_storage, x.__end_of_storage);
#endif // _RWSTD_NO_NAMESPACE
}
else
{
vector<bool,Allocator> _x = *this;
*this = x;
x=_x;
}
}
static void swap(reference x, reference y);
void flip ();
void clear()
{
erase(begin(),end());
}
};
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
template <class Allocator>
#endif
inline bool operator== (const vector<bool,Allocator >& x,
const vector<bool,Allocator >& y)
{
if (x.size() == y.size())
{
#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
vector<bool,Allocator >::const_iterator first1 = x.begin(),
#else
_TYPENAME vector<bool,Allocator >::const_iterator first1 = x.begin(),
#endif
last1 =x.end(),
first2 = y.begin();
while (first1 != last1 && *first1 == *first2)
{
++first1;
++first2;
}
return first1 == last1;
}
return false;
}
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
template <class Allocator>
#endif
inline bool operator< (const vector<bool,Allocator >& x,
const vector<bool,Allocator >& y)
{
#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
vector<bool,Allocator >::const_iterator first1 = x.begin(),
#else
_TYPENAME vector<bool,Allocator >::const_iterator first1 = x.begin(),
#endif
last1 =x.end(),
first2 = y.begin(),
last2 = y.end();
while (first1 != last1 && first2 != last2)
{
if ((int)*first1 < (int)*first2) return true;
if ((int)*first2++ < (int)*first1++) return false;
}
return first1 == last1 && first2 != last2;
}
#if !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
template <class Allocator>
#endif
inline bool operator!= (const vector<bool,Allocator >& x,
const vector<bool,Allocator >& y)
{
return !(x == y);
}
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
template <class Allocator>
#endif
inline bool operator> (const vector<bool,Allocator >& x,
const vector<bool,Allocator >& y)
{
return y < x;
}
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
template <class Allocator>
#endif
inline bool operator>= (const vector<bool,Allocator >& x,
const vector<bool,Allocator >& y)
{
return !(x < y);
}
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
template <class Allocator>
#endif
inline bool operator<= (const vector<bool,Allocator >& x,
const vector<bool,Allocator >& y)
{
return !(y < x);
}
#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC
template <class Allocator>
#endif
inline void swap(vector<bool,Allocator >& a, vector<bool,Allocator >& b)
{
a.swap(b);
}
#endif
#ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
#undef Allocator
#endif
#endif /*_RWSTD_NO_BOOL*/
#ifndef _RWSTD_NO_NAMESPACE
}
#endif
#if defined (_RWSTD_NO_TEMPLATE_REPOSITORY) && (!defined (__TURBOC__) || (__TURBOC__ > 0x530))
#include <vector.cc>
#endif
#undef vector
#endif /*__STD_VECTOR__*/
#ifndef __USING_STD_NAMES__
using namespace std;
#endif
#pragma option pop
#endif /* __VECTOR_H */
Reference in a new issue Copy permalink