Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

614 lines
18 KiB

// vector standard header
#ifndef _VECTOR_
#define _VECTOR_
#include <climits>
#include <memory>
#include <stdexcept>
#include <xutility>
#ifdef _MSC_VER
#pragma pack(push,8)
#endif /* _MSC_VER */
_STD_BEGIN
// TEMPLATE CLASS vector
template<class _Ty, class _A = allocator<_Ty> >
class vector {
public:
typedef vector<_Ty, _A> _Myt;
typedef _A allocator_type;
typedef typename _A::size_type size_type;
typedef typename _A::difference_type difference_type;
typedef typename _A::pointer _Tptr;
typedef typename _A::const_pointer _Ctptr;
typedef typename _A::reference reference;
typedef typename _A::const_reference const_reference;
typedef typename _A::value_type value_type;
typedef _Tptr iterator;
typedef _Ctptr const_iterator;
typedef reverse_iterator<const_iterator, value_type,
const_reference, _Ctptr, difference_type>
const_reverse_iterator;
typedef reverse_iterator<iterator, value_type,
reference, _Tptr, difference_type>
reverse_iterator;
explicit vector(const _A& _Al = _A())
: allocator(_Al), _First(0), _Last(0), _End(0) {}
explicit vector(size_type _N, const _Ty& _V = _Ty(),
const _A& _Al = _A())
: allocator(_Al)
{_First = allocator.allocate(_N, (void *)0);
_Ufill(_First, _N, _V);
_Last = _First + _N;
_End = _Last; }
vector(const _Myt& _X)
: allocator(_X.allocator)
{_First = allocator.allocate(_X.size(), (void *)0);
_Last = _Ucopy(_X.begin(), _X.end(), _First);
_End = _Last; }
typedef const_iterator _It;
vector(_It _F, _It _L, const _A& _Al = _A())
: allocator(_Al), _First(0), _Last(0), _End(0)
{insert(begin(), _F, _L); }
~vector()
{_Destroy(_First, _Last);
allocator.deallocate(_First, _End - _First);
_First = 0, _Last = 0, _End = 0; }
_Myt& operator=(const _Myt& _X)
{if (this == &_X)
;
else if (_X.size() <= size())
{iterator _S = copy(_X.begin(), _X.end(), _First);
_Destroy(_S, _Last);
_Last = _First + _X.size(); }
else if (_X.size() <= capacity())
{const_iterator _S = _X.begin() + size();
copy(_X.begin(), _S, _First);
_Ucopy(_S, _X.end(), _Last);
_Last = _First + _X.size(); }
else
{_Destroy(_First, _Last);
allocator.deallocate(_First, _End - _First);
_First = allocator.allocate(_X.size(), (void *)0);
_Last = _Ucopy(_X.begin(), _X.end(),
_First);
_End = _Last; }
return (*this); }
void reserve(size_type _N)
{if (capacity() < _N)
{iterator _S = allocator.allocate(_N, (void *)0);
_Ucopy(_First, _Last, _S);
_Destroy(_First, _Last);
allocator.deallocate(_First, _End - _First);
_End = _S + _N;
_Last = _S + size();
_First = _S; }}
size_type capacity() const
{return (_First == 0 ? 0 : _End - _First); }
iterator begin()
{return (_First); }
const_iterator begin() const
{return ((const_iterator)_First); }
iterator end()
{return (_Last); }
const_iterator end() const
{return ((const_iterator)_Last); }
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())); }
void resize(size_type _N, const _Ty& _X = _Ty())
{if (size() < _N)
insert(end(), _N - size(), _X);
else if (_N < size())
erase(begin() + _N, end()); }
size_type size() const
{return (_First == 0 ? 0 : _Last - _First); }
size_type max_size() const
{return (allocator.max_size()); }
bool empty() const
{return (size() == 0); }
_A get_allocator() const
{return (allocator); }
const_reference at(size_type _P) const
{if (size() <= _P)
_Xran();
return (*(begin() + _P)); }
reference at(size_type _P)
{if (size() <= _P)
_Xran();
return (*(begin() + _P)); }
const_reference operator[](size_type _P) const
{return (*(begin() + _P)); }
reference operator[](size_type _P)
{return (*(begin() + _P)); }
reference front()
{return (*begin()); }
const_reference front() const
{return (*begin()); }
reference back()
{return (*(end() - 1)); }
const_reference back() const
{return (*(end() - 1)); }
void push_back(const _Ty& _X)
{insert(end(), _X); }
void pop_back()
{erase(end() - 1); }
void assign(_It _F, _It _L)
{erase(begin(), end());
insert(begin(), _F, _L); }
void assign(size_type _N, const _Ty& _X = _Ty())
{erase(begin(), end());
insert(begin(), _N, _X); }
iterator insert(iterator _P, const _Ty& _X = _Ty())
{size_type _O = _P - begin();
insert(_P, 1, _X);
return (begin() + _O); }
void insert(iterator _P, size_type _M, const _Ty& _X)
{if (_End - _Last < _M)
{size_type _N = size() + (_M < size() ? size() : _M);
iterator _S = allocator.allocate(_N, (void *)0);
iterator _Q = _Ucopy(_First, _P, _S);
_Ufill(_Q, _M, _X);
_Ucopy(_P, _Last, _Q + _M);
_Destroy(_First, _Last);
allocator.deallocate(_First, _End - _First);
_End = _S + _N;
_Last = _S + size() + _M;
_First = _S; }
else if (_Last - _P < _M)
{_Ucopy(_P, _Last, _P + _M);
_Ufill(_Last, _M - (_Last - _P), _X);
fill(_P, _Last, _X);
_Last += _M; }
else if (0 < _M)
{_Ucopy(_Last - _M, _Last, _Last);
copy_backward(_P, _Last - _M, _Last);
fill(_P, _P + _M, _X);
_Last += _M; }}
void insert(iterator _P, _It _F, _It _L)
{size_type _M = 0;
_Distance(_F, _L, _M);
if (_End - _Last < _M)
{size_type _N = size() + (_M < size() ? size() : _M);
iterator _S = allocator.allocate(_N, (void *)0);
iterator _Q = _Ucopy(_First, _P, _S);
_Q = _Ucopy(_F, _L, _Q);
_Ucopy(_P, _Last, _Q);
_Destroy(_First, _Last);
allocator.deallocate(_First, _End - _First);
_End = _S + _N;
_Last = _S + size() + _M;
_First = _S; }
else if (_Last - _P < _M)
{_Ucopy(_P, _Last, _P + _M);
_Ucopy(_F + (_Last - _P), _L, _Last);
copy(_F, _F + (_Last - _P), _P);
_Last += _M; }
else if (0 < _M)
{_Ucopy(_Last - _M, _Last, _Last);
copy_backward(_P, _Last - _M, _Last);
copy(_F, _L, _P);
_Last += _M; }}
iterator erase(iterator _P)
{copy(_P + 1, end(), _P);
_Destroy(_Last - 1, _Last);
--_Last;
return (_P); }
iterator erase(iterator _F, iterator _L)
{iterator _S = copy(_L, end(), _F);
_Destroy(_S, end());
_Last = _S;
return (_F); }
void clear()
{erase(begin(), end()); }
bool _Eq(const _Myt& _X) const
{return (size() == _X.size()
&& equal(begin(), end(), _X.begin())); }
bool _Lt(const _Myt& _X) const
{return (lexicographical_compare(begin(), end(),
_X.begin(), _X.end())); }
void swap(_Myt& _X)
{if (allocator == _X.allocator)
{std::swap(_First, _X._First);
std::swap(_Last, _X._Last);
std::swap(_End, _X._End); }
else
{_Myt _Ts = *this; *this = _X, _X = _Ts; }}
friend void swap(_Myt& _X, _Myt& _Y)
{_X.swap(_Y); }
protected:
void _Destroy(iterator _F, iterator _L)
{for (; _F != _L; ++_F)
allocator.destroy(_F); }
iterator _Ucopy(const_iterator _F, const_iterator _L,
iterator _P)
{for (; _F != _L; ++_P, ++_F)
allocator.construct(_P, *_F);
return (_P); }
void _Ufill(iterator _F, size_type _N, const _Ty &_X)
{for (; 0 < _N; --_N, ++_F)
allocator.construct(_F, _X); }
void _Xran() const
{_THROW(out_of_range, "invalid vector<T> subscript"); }
_A allocator;
iterator _First, _Last, _End;
};
// CLASS vector<_Bool, allocator>
typedef unsigned int _Vbase;
const int _VBITS = CHAR_BIT * sizeof (_Vbase);
typedef allocator<_Vbase> _Bool_allocator;
class vector<_Bool, _Bool_allocator> {
public:
typedef _Bool_allocator _A;
typedef _Bool _Ty;
typedef vector<_Ty, _A> _Myt;
typedef vector<_Vbase, _A> _Vbtype;
typedef _A allocator_type;
typedef _A::size_type size_type;
typedef _A::difference_type difference_type;
// CLASS reference
class reference {
public:
reference()
: _Mask(0), _Ptr(0) {}
reference(size_t _O, _Vbase *_P)
: _Mask((_Vbase)1 << _O), _Ptr(_P) {}
reference& operator=(const reference& _X)
{return (*this = bool(_X)); }
reference& operator=(bool _V)
{if (_V)
*_Ptr |= _Mask;
else
*_Ptr &= ~_Mask;
return (*this); }
void flip()
{*_Ptr ^= _Mask; }
bool operator~() const
{return (!bool(*this)); }
operator bool() const
{return ((*_Ptr & _Mask) != 0); }
protected:
_Vbase _Mask, *_Ptr;
};
typedef const reference const_reference;
typedef bool value_type;
// CLASS iterator
class iterator : public _Ranit<_Bool, difference_type> {
public:
iterator()
: _Off(0), _Ptr(0) {}
iterator(size_t _O, _Vbase *_P)
: _Off(_O), _Ptr(_P) {}
reference operator*() const
{return (reference(_Off, _Ptr)); }
iterator& operator++()
{_Inc();
return (*this); }
iterator operator++(int)
{iterator _Tmp = *this;
_Inc();
return (_Tmp); }
iterator& operator--()
{_Dec();
return (*this); }
iterator operator--(int)
{iterator _Tmp = *this;
_Dec();
return (_Tmp); }
iterator& operator+=(difference_type _N)
{_Off += (size_t) _N;
_Ptr += _Off / _VBITS;
_Off %= _VBITS;
return (*this); }
iterator& operator-=(difference_type _N)
{return (*this += -_N); }
iterator operator+(difference_type _N) const
{iterator _Tmp = *this;
return (_Tmp += _N); }
iterator operator-(difference_type _N) const
{iterator _Tmp = *this;
return (_Tmp -= _N); }
difference_type operator-(const iterator _X) const
{return (_VBITS * (_Ptr - _X._Ptr)
+ (difference_type)_Off
- (difference_type)_X._Off); }
reference operator[](difference_type _N) const
{return (*(*this + _N)); }
bool operator==(const iterator& _X) const
{return (_Ptr == _X._Ptr && _Off == _X._Off); }
bool operator!=(const iterator& _X) const
{return (!(*this == _X)); }
bool operator<(const iterator& _X) const
{return (_Ptr < _X._Ptr
|| _Ptr == _X._Ptr && _Off < _X._Off); }
bool operator>(const iterator& _X) const
{return (_X < *this); }
bool operator<=(const iterator& _X) const
{return (!(_X < *this)); }
bool operator>=(const iterator& _X) const
{return (!(*this < _X)); }
protected:
void _Dec()
{if (_Off != 0)
--_Off;
else
_Off = _VBITS - 1, --_Ptr; }
void _Inc()
{if (_Off < _VBITS - 1)
++_Off;
else
_Off = 0, ++_Ptr; }
size_t _Off;
_Vbase *_Ptr;
};
// CLASS const_iterator
class const_iterator : public iterator {
public:
const_iterator()
: iterator() {}
const_iterator(size_t _O, const _Vbase *_P)
: iterator(_O, (_Vbase *)_P) {}
const_iterator(const iterator& _X)
: iterator(_X) {}
const_reference operator*() const
{return (reference(_Off, _Ptr)); }
const_iterator& operator++()
{_Inc();
return (*this); }
const_iterator operator++(int)
{const_iterator _Tmp = *this;
_Inc();
return (_Tmp); }
const_iterator& operator--()
{_Dec();
return (*this); }
const_iterator operator--(int)
{const_iterator _Tmp = *this;
_Dec();
return (_Tmp); }
const_iterator& operator+=(difference_type _N)
{_Off += (size_t) _N;
_Ptr += _Off / _VBITS;
_Off %= _VBITS;
return (*this); }
const_iterator& operator-=(difference_type _N)
{return (*this += -_N); }
const_iterator operator+(difference_type _N) const
{const_iterator _Tmp = *this;
return (_Tmp += _N); }
const_iterator operator-(difference_type _N) const
{const_iterator _Tmp = *this;
return (_Tmp -= _N); }
difference_type operator-(const const_iterator _X) const
{return (_VBITS * (_Ptr - _X._Ptr)
+ (difference_type)_Off
- (difference_type)_X._Off); }
const_reference operator[](difference_type _N) const
{return (*(*this + _N)); }
bool operator==(const const_iterator& _X) const
{return (_Ptr == _X._Ptr && _Off == _X._Off); }
bool operator!=(const const_iterator& _X) const
{return (!(*this == _X)); }
bool operator<(const const_iterator& _X) const
{return (_Ptr < _X._Ptr
|| _Ptr == _X._Ptr && _Off < _X._Off); }
bool operator>(const const_iterator& _X) const
{return (_X < *this); }
bool operator<=(const const_iterator& _X) const
{return (!(_X < *this)); }
bool operator>=(const const_iterator& _X) const
{return (!(*this < _X)); }
};
typedef reverse_iterator<const_iterator, value_type,
const_reference, const_reference *, difference_type>
const_reverse_iterator;
typedef reverse_iterator<iterator, value_type,
reference, reference *, difference_type>
reverse_iterator;
explicit vector(const _A& _Al = _A())
: _Size(0), _Vec(_Al) {}
explicit vector(size_type _N, const bool _V = false,
const _A& _Al = _A())
: _Vec(_Nw(_N), _V ? -1 : 0, _Al) {_Trim(_N); }
typedef const_iterator _It;
vector(_It _F, _It _L, const _A& _Al = _A())
: _Size(0), _Vec(_Al)
{insert(begin(), _F, _L); }
~vector()
{_Size = 0; }
void reserve(size_type _N)
{_Vec.reserve(_Nw(_N)); }
size_type capacity() const
{return (_Vec.capacity() * _VBITS); }
iterator begin()
{return (iterator(0, _Vec.begin())); }
const_iterator begin() const
{return (const_iterator(0, _Vec.begin())); }
iterator end()
{iterator _Tmp = begin();
if (0 < _Size)
_Tmp += _Size;
return (_Tmp); }
const_iterator end() const
{const_iterator _Tmp = begin();
if (0 < _Size)
_Tmp += _Size;
return (_Tmp); }
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())); }
void resize(size_type _N, bool _X = false)
{if (size() < _N)
insert(end(), _N - size(), _X);
else if (_N < size())
erase(begin() + _N, end()); }
size_type size() const
{return (_Size); }
size_type max_size() const
{return (_Vec.max_size() * _VBITS); }
bool empty() const
{return (size() == 0); }
_A get_allocator() const
{return (_Vec.get_allocator()); }
const_reference at(size_type _P) const
{if (size() <= _P)
_Xran();
return (*(begin() + _P)); }
reference at(size_type _P)
{if (size() <= _P)
_Xran();
return (*(begin() + _P)); }
const_reference operator[](size_type _P) const
{return (*(begin() + _P)); }
reference operator[](size_type _P)
{return (*(begin() + _P)); }
reference front()
{return (*begin()); }
const_reference front() const
{return (*begin()); }
reference back()
{return (*(end() - 1)); }
const_reference back() const
{return (*(end() - 1)); }
void push_back(const bool _X)
{insert(end(), _X); }
void pop_back()
{erase(end() - 1); }
void assign(_It _F, _It _L)
{erase(begin(), end());
insert(begin(), _F, _L); }
void assign(size_type _N, const bool _X = false)
{erase(begin(), end());
insert(begin(), _N, _X); }
iterator insert(iterator _P, const bool _X = false)
{size_type _O = _P - begin();
insert(_P, 1, _X);
return (begin() + _O); }
void insert(iterator _P, size_type _M, const bool _X)
{if (0 < _M)
{if (capacity() - size() < _M)
{size_type _O = _P - begin();
_Vec.resize(_Nw(size() + _M), 0);
_P = begin() + _O; }
copy_backward(_P, end(), end() + _M);
fill(_P, _P + _M, _X);
_Size += _M; }}
void insert(iterator _P, _It _F, _It _L)
{size_type _M = 0;
_Distance(_F, _L, _M);
if (0 < _M)
{if (capacity() - size() < _M)
{size_type _O = _P - begin();
_Vec.resize(_Nw(size() + _M), 0);
_P = begin() + _O; }
copy_backward(_P, end(), end() + _M);
copy(_F, _L, _P);
_Size += _M; }}
iterator erase(iterator _P)
{copy(_P + 1, end(), _P);
_Trim(_Size - 1);
return (_P); }
iterator erase(iterator _F, iterator _L)
{iterator _S = copy(_L, end(), _F);
_Trim(_S - begin());
return (_F); }
void clear()
{erase(begin(), end()); }
void flip()
{for (_Vbtype::iterator _S = _Vec.begin();
_S != _Vec.end(); ++_S)
*_S = ~*_S;
_Trim(_Size); }
bool _Eq(const _Myt& _X) const
{return (_Size == _X._Size && _Vec._Eq(_X._Vec)); }
bool _Lt(const _Myt& _X) const
{return (_Size < _X._Size
|| _Size == _X._Size && _Vec._Lt(_X._Vec)); }
void swap(_Myt& _X)
{std::swap(_Size, _X._Size);
_Vec.swap(_X._Vec); }
friend void swap(_Myt& _X, _Myt& _Y)
{_X.swap(_Y); }
static void swap(reference _X, reference _Y)
{bool _V = _X;
_X = _Y;
_Y = _V; }
protected:
static size_type _Nw(size_type _N)
{return ((_N + _VBITS - 1) / _VBITS); }
void _Trim(size_type _N)
{size_type _M = _Nw(_N);
if (_M < _Vec.size())
_Vec.erase(_Vec.begin() + _M, _Vec.end());
_Size = _N;
_N %= _VBITS;
if (0 < _N)
_Vec[_M - 1] &= ((_Vbase)1 << _N) - 1; }
void _Xran() const
{_THROW(out_of_range, "invalid vector<bool> subscript"); }
size_type _Size;
_Vbtype _Vec;
};
typedef vector<_Bool, _Bool_allocator> _Bvector;
// vector TEMPLATE OPERATORS
template<class _Ty, class _A> inline
bool operator==(const vector<_Ty, _A>& _X,
const vector<_Ty, _A>& _Y)
{return (_X._Eq(_Y)); }
template<class _Ty, class _A> inline
bool operator!=(const vector<_Ty, _A>& _X,
const vector<_Ty, _A>& _Y)
{return (!(_X == _Y)); }
template<class _Ty, class _A> inline
bool operator<(const vector<_Ty, _A>& _X,
const vector<_Ty, _A>& _Y)
{return (_X._Lt(_Y)); }
template<class _Ty, class _A> inline
bool operator>(const vector<_Ty, _A>& _X,
const vector<_Ty, _A>& _Y)
{return (_Y < _X); }
template<class _Ty, class _A> inline
bool operator<=(const vector<_Ty, _A>& _X,
const vector<_Ty, _A>& _Y)
{return (!(_Y < _X)); }
template<class _Ty, class _A> inline
bool operator>=(const vector<_Ty, _A>& _X,
const vector<_Ty, _A>& _Y)
{return (!(_X < _Y)); }
_STD_END
#ifdef _MSC_VER
#pragma pack(pop)
#endif /* _MSC_VER */
#endif /* _VECTOR_ */
/*
* Copyright (c) 1995 by P.J. Plauger. ALL RIGHTS RESERVED.
* Consult your license regarding permissions and restrictions.
*/
/*
* This file is derived from software bearing the following
* restrictions:
*
* 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.
*/