OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

stl_bvector.h: Wrap overlong lines...

Browse Source 
2004-02-01  Paolo Carlini  <pcarlini@suse.de>

	* include/bits/stl_bvector.h: Wrap overlong lines, constify
	a few variables, reformat according to the coding standards.
	* include/bits/stl_tree.h: Likewise.

From-SVN: r77065
This commit is contained in:
Paolo Carlini 2004-02-01 11:25:21 +00:00 committed by Paolo Carlini
parent 2efe20337f
commit 62e6765158
3 changed files with 351 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,9 @@
2004-02-01 Paolo Carlini <pcarlini@suse.de>
* include/bits/stl_bvector.h: Wrap overlong lines, constify
a few variables, reformat according to the coding standards.
* include/bits/stl_tree.h: Likewise.
2004-01-31 Paolo Carlini <pcarlini@suse.de>
* include/bits/stl_algo.h: Minor additional reformat, add

422
libstdc++-v3/include/bits/stl_bvector.h
View File

@ -154,8 +154,8 @@ namespace __gnu_norm
bool
operator<(const _Bit_iterator_base& __i) const
{
return _M_p < __i._M_p
|| (_M_p == __i._M_p && _M_offset < __i._M_offset);
return _M_p < __i._M_p
|| (_M_p == __i._M_p && _M_offset < __i._M_offset);
}
bool
@ -181,7 +181,6 @@ namespace __gnu_norm
return _S_word_bit * (__x._M_p - __y._M_p) + __x._M_offset - __y._M_offset;
}
struct _Bit_iterator : public _Bit_iterator_base
{
typedef _Bit_reference reference;
@ -254,7 +253,8 @@ namespace __gnu_norm
}
reference
operator[](difference_type __i) { return *(*this + __i); }
operator[](difference_type __i)
{ return *(*this + __i); }
};
inline _Bit_iterator
@ -347,12 +347,13 @@ namespace __gnu_norm
class _Bvector_base
: public _Alloc::template rebind<_Bit_type>::other
{
typedef typename _Alloc::template rebind<_Bit_type>::other _Bit_alloc_type;
typedef typename _Alloc::template rebind<_Bit_type>::other
_Bit_alloc_type;
public:
typedef _Alloc allocator_type;
allocator_type
allocator_type
get_allocator() const
{ return *static_cast<const _Bit_alloc_type*>(this); }
@ -364,7 +365,8 @@ namespace __gnu_norm
protected:
_Bit_type*
_M_bit_alloc(size_t __n)
{ return _Bit_alloc_type::allocate((__n + _S_word_bit - 1)/_S_word_bit);}
{ return _Bit_alloc_type::allocate((__n + _S_word_bit - 1)
/ _S_word_bit); }
void
_M_deallocate()
@ -422,9 +424,9 @@ template<typename _Alloc>
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef typename _Bvector_base<_Alloc>::allocator_type allocator_type;
allocator_type get_allocator() const {
return _Bvector_base<_Alloc>::get_allocator();
}
allocator_type get_allocator() const
{ return _Bvector_base<_Alloc>::get_allocator(); }
protected:
using _Bvector_base<_Alloc>::_M_bit_alloc;
@ -434,34 +436,41 @@ template<typename _Alloc>
using _Bvector_base<_Alloc>::_M_end_of_storage;
protected:
void _M_initialize(size_type __n) {
_Bit_type * __q = this->_M_bit_alloc(__n);
this->_M_end_of_storage = __q + (__n + _S_word_bit - 1)/_S_word_bit;
void _M_initialize(size_type __n)
{
_Bit_type* __q = this->_M_bit_alloc(__n);
this->_M_end_of_storage = __q + (__n + _S_word_bit - 1) / _S_word_bit;
this->_M_start = iterator(__q, 0);
this->_M_finish = this->_M_start + difference_type(__n);
}
void _M_insert_aux(iterator __position, bool __x) {
if (this->_M_finish._M_p != this->_M_end_of_storage) {
std::copy_backward(__position, this->_M_finish, this->_M_finish + 1);
*__position = __x;
++this->_M_finish;
}
else {
size_type __len = size()
? 2 * size() : static_cast<size_type>(_S_word_bit);
_Bit_type * __q = this->_M_bit_alloc(__len);
iterator __i = std::copy(begin(), __position, iterator(__q, 0));
*__i++ = __x;
this->_M_finish = std::copy(__position, end(), __i);
this->_M_deallocate();
this->_M_end_of_storage = __q + (__len + _S_word_bit - 1)/_S_word_bit;
this->_M_start = iterator(__q, 0);
}
void _M_insert_aux(iterator __position, bool __x)
{
if (this->_M_finish._M_p != this->_M_end_of_storage)
{
std::copy_backward(__position, this->_M_finish, this->_M_finish + 1);
*__position = __x;
++this->_M_finish;
}
else
{
const size_type __len = size() ? 2 * size()
: static_cast<size_type>(_S_word_bit);
_Bit_type * __q = this->_M_bit_alloc(__len);
iterator __i = std::copy(begin(), __position, iterator(__q, 0));
*__i++ = __x;
this->_M_finish = std::copy(__position, end(), __i);
this->_M_deallocate();
this->_M_end_of_storage = __q + (__len + _S_word_bit - 1)
/ _S_word_bit;
this->_M_start = iterator(__q, 0);
}
}
template<class _InputIterator>
void _M_initialize_range(_InputIterator __first, _InputIterator __last,
input_iterator_tag) {
input_iterator_tag)
{
this->_M_start = iterator();
this->_M_finish = iterator();
this->_M_end_of_storage = 0;
@ -471,8 +480,9 @@ template<typename _Alloc>
template<class _ForwardIterator>
void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
forward_iterator_tag) {
size_type __n = std::distance(__first, __last);
forward_iterator_tag)
{
const size_type __n = std::distance(__first, __last);
_M_initialize(__n);
std::copy(__first, __last, this->_M_start);
}
@ -480,81 +490,105 @@ template<typename _Alloc>
template<class _InputIterator>
void _M_insert_range(iterator __pos,
_InputIterator __first, _InputIterator __last,
input_iterator_tag) {
for ( ; __first != __last; ++__first) {
__pos = insert(__pos, *__first);
++__pos;
}
input_iterator_tag)
{
for ( ; __first != __last; ++__first)
{
__pos = insert(__pos, *__first);
++__pos;
}
}
template<class _ForwardIterator>
void _M_insert_range(iterator __position,
_ForwardIterator __first, _ForwardIterator __last,
forward_iterator_tag) {
if (__first != __last) {
size_type __n = std::distance(__first, __last);
if (capacity() - size() >= __n) {
std::copy_backward(__position, end(),
this->_M_finish + difference_type(__n));
std::copy(__first, __last, __position);
this->_M_finish += difference_type(__n);
}
else {
size_type __len = size() + std::max(size(), __n);
_Bit_type * __q = this->_M_bit_alloc(__len);
iterator __i = std::copy(begin(), __position, iterator(__q, 0));
__i = std::copy(__first, __last, __i);
this->_M_finish = std::copy(__position, end(), __i);
this->_M_deallocate();
this->_M_end_of_storage
= __q + (__len + _S_word_bit - 1)/_S_word_bit;
this->_M_start = iterator(__q, 0);
}
}
}
forward_iterator_tag)
{
if (__first != __last)
{
size_type __n = std::distance(__first, __last);
if (capacity() - size() >= __n)
{
std::copy_backward(__position, end(),
this->_M_finish + difference_type(__n));
std::copy(__first, __last, __position);
this->_M_finish += difference_type(__n);
}
else
{
const size_type __len = size() + std::max(size(), __n);
_Bit_type * __q = this->_M_bit_alloc(__len);
iterator __i = std::copy(begin(), __position, iterator(__q, 0));
__i = std::copy(__first, __last, __i);
this->_M_finish = std::copy(__position, end(), __i);
this->_M_deallocate();
this->_M_end_of_storage = __q + (__len + _S_word_bit - 1)
/ _S_word_bit;
this->_M_start = iterator(__q, 0);
}
}
}
public:
iterator begin() { return this->_M_start; }
const_iterator begin() const { return this->_M_start; }
iterator end() { return this->_M_finish; }
const_iterator end() const { return this->_M_finish; }
iterator begin()
{ return this->_M_start; }
const_iterator begin() const
{ return this->_M_start; }
iterator end()
{ return this->_M_finish; }
const_iterator end() const
{ return this->_M_finish; }
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());
}
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()); }
size_type size() const { return size_type(end() - begin()); }
size_type max_size() const { return size_type(-1); }
size_type capacity() const {
return size_type(const_iterator(this->_M_end_of_storage, 0) - begin());
}
bool empty() const { return begin() == end(); }
size_type size() const
{ return size_type(end() - begin()); }
size_type max_size() const
{ return size_type(-1); }
size_type capacity() const
{ return size_type(const_iterator(this->_M_end_of_storage, 0)
- begin()); }
bool empty() const
{ return begin() == end(); }
reference operator[](size_type __n)
{ return *(begin() + difference_type(__n)); }
{ return *(begin() + difference_type(__n)); }
const_reference operator[](size_type __n) const
{ return *(begin() + difference_type(__n)); }
{ return *(begin() + difference_type(__n)); }
void _M_range_check(size_type __n) const {
void _M_range_check(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range(__N("vector<bool>::_M_range_check"));
}
reference at(size_type __n)
{ _M_range_check(__n); return (*this)[__n]; }
{ _M_range_check(__n); return (*this)[__n]; }
const_reference at(size_type __n) const
{ _M_range_check(__n); return (*this)[__n]; }
{ _M_range_check(__n); return (*this)[__n]; }
explicit vector(const allocator_type& __a = allocator_type())
: _Bvector_base<_Alloc>(__a) { }
vector(size_type __n, bool __value,
const allocator_type& __a = allocator_type())
const allocator_type& __a = allocator_type())
: _Bvector_base<_Alloc>(__a)
{
_M_initialize(__n);
@ -568,7 +602,8 @@ template<typename _Alloc>
std::fill(this->_M_start._M_p, this->_M_end_of_storage, 0);
}
vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator()) {
vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator())
{
_M_initialize(__x.size());
std::copy(__x.begin(), __x.end(), this->_M_start);
}
@ -576,16 +611,16 @@ template<typename _Alloc>
// Check whether it's an integral type. If so, it's not an iterator.
template<class _Integer>
void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) {
void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
{
_M_initialize(__n);
std::fill(this->_M_start._M_p, this->_M_end_of_storage, __x ? ~0 : 0);
}
template<class _InputIterator>
void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
__false_type) {
_M_initialize_range(__first, __last, std::__iterator_category(__first));
}
__false_type)
{ _M_initialize_range(__first, __last, std::__iterator_category(__first)); }
template<class _InputIterator>
vector(_InputIterator __first, _InputIterator __last,
@ -598,12 +633,15 @@ template<typename _Alloc>
~vector() { }
vector& operator=(const vector& __x) {
if (&__x == this) return *this;
if (__x.size() > capacity()) {
this->_M_deallocate();
_M_initialize(__x.size());
}
vector& operator=(const vector& __x)
{
if (&__x == this)
return *this;
if (__x.size() > capacity())
{
this->_M_deallocate();
_M_initialize(__x.size());
}
std::copy(__x.begin(), __x.end(), begin());
this->_M_finish = begin() + difference_type(__x.size());
return *this;
@ -614,36 +652,43 @@ template<typename _Alloc>
// The range version is a member template, so we dispatch on whether
// or not the type is an integer.
void _M_fill_assign(size_t __n, bool __x) {
if (__n > size()) {
std::fill(this->_M_start._M_p, this->_M_end_of_storage, __x ? ~0 : 0);
insert(end(), __n - size(), __x);
}
else {
erase(begin() + __n, end());
std::fill(this->_M_start._M_p, this->_M_end_of_storage, __x ? ~0 : 0);
}
void _M_fill_assign(size_t __n, bool __x)
{
if (__n > size())
{
std::fill(this->_M_start._M_p, this->_M_end_of_storage, __x ? ~0 : 0);
insert(end(), __n - size(), __x);
}
else
{
erase(begin() + __n, end());
std::fill(this->_M_start._M_p, this->_M_end_of_storage, __x ? ~0 : 0);
}
}
void assign(size_t __n, bool __x) { _M_fill_assign(__n, __x); }
void assign(size_t __n, bool __x)
{ _M_fill_assign(__n, __x); }
template<class _InputIterator>
void assign(_InputIterator __first, _InputIterator __last) {
void assign(_InputIterator __first, _InputIterator __last)
{
typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
_M_assign_dispatch(__first, __last, _Integral());
}
template<class _Integer>
void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
{ _M_fill_assign((size_t) __n, (bool) __val); }
{ _M_fill_assign((size_t) __n, (bool) __val); }
template<class _InputIterator>
void _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type)
{ _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{ _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
template<class _InputIterator>
void _M_assign_aux(_InputIterator __first, _InputIterator __last,
input_iterator_tag) {
input_iterator_tag)
{
iterator __cur = begin();
for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
*__cur = *__first;
@ -655,55 +700,72 @@ template<typename _Alloc>
template<class _ForwardIterator>
void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
forward_iterator_tag) {
size_type __len = std::distance(__first, __last);
forward_iterator_tag)
{
const size_type __len = std::distance(__first, __last);
if (__len < size())
erase(std::copy(__first, __last, begin()), end());
else {
_ForwardIterator __mid = __first;
std::advance(__mid, size());
std::copy(__first, __mid, begin());
insert(end(), __mid, __last);
}
else
{
_ForwardIterator __mid = __first;
std::advance(__mid, size());
std::copy(__first, __mid, begin());
insert(end(), __mid, __last);
}
}
void reserve(size_type __n) {
void reserve(size_type __n)
{
if (__n > this->max_size())
__throw_length_error(__N("vector::reserve"));
if (this->capacity() < __n) {
_Bit_type * __q = this->_M_bit_alloc(__n);
this->_M_finish = std::copy(begin(), end(), iterator(__q, 0));
this->_M_deallocate();
this->_M_start = iterator(__q, 0);
this->_M_end_of_storage = __q + (__n + _S_word_bit - 1)/_S_word_bit;
}
if (this->capacity() < __n)
{
_Bit_type* __q = this->_M_bit_alloc(__n);
this->_M_finish = std::copy(begin(), end(), iterator(__q, 0));
this->_M_deallocate();
this->_M_start = iterator(__q, 0);
this->_M_end_of_storage = __q + (__n + _S_word_bit - 1) / _S_word_bit;
}
}
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(bool __x) {
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(bool __x)
{
if (this->_M_finish._M_p != this->_M_end_of_storage)
*this->_M_finish++ = __x;
else
_M_insert_aux(end(), __x);
}
void swap(vector<bool, _Alloc>& __x) {
void swap(vector<bool, _Alloc>& __x)
{
std::swap(this->_M_start, __x._M_start);
std::swap(this->_M_finish, __x._M_finish);
std::swap(this->_M_end_of_storage, __x._M_end_of_storage);
}
// [23.2.5]/1, third-to-last entry in synopsis listing
static void swap(reference __x, reference __y) {
static void swap(reference __x, reference __y)
{
bool __tmp = __x;
__x = __y;
__y = __tmp;
}
iterator insert(iterator __position, bool __x = bool()) {
difference_type __n = __position - begin();
iterator insert(iterator __position, bool __x = bool())
{
const difference_type __n = __position - begin();
if (this->_M_finish._M_p != this->_M_end_of_storage
&& __position == end())
*this->_M_finish++ = __x;
@ -716,74 +778,88 @@ template<typename _Alloc>
template<class _Integer>
void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
__true_type) {
_M_fill_insert(__pos, __n, __x);
}
__true_type)
{ _M_fill_insert(__pos, __n, __x); }
template<class _InputIterator>
void _M_insert_dispatch(iterator __pos,
_InputIterator __first, _InputIterator __last,
__false_type) {
_M_insert_range(__pos, __first, __last, std::__iterator_category(__first));
}
__false_type)
{ _M_insert_range(__pos, __first, __last,
std::__iterator_category(__first)); }
template<class _InputIterator>
void insert(iterator __position,
_InputIterator __first, _InputIterator __last) {
_InputIterator __first, _InputIterator __last)
{
typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
_M_insert_dispatch(__position, __first, __last, _Integral());
}
void _M_fill_insert(iterator __position, size_type __n, bool __x) {
if (__n == 0) return;
if (capacity() - size() >= __n) {
std::copy_backward(__position, end(),
this->_M_finish + difference_type(__n));
std::fill(__position, __position + difference_type(__n), __x);
this->_M_finish += difference_type(__n);
}
else {
size_type __len = size() + std::max(size(), __n);
_Bit_type * __q = this->_M_bit_alloc(__len);
iterator __i = std::copy(begin(), __position, iterator(__q, 0));
std::fill_n(__i, __n, __x);
this->_M_finish = std::copy(__position, end(), __i + difference_type(__n));
this->_M_deallocate();
this->_M_end_of_storage = __q + (__len + _S_word_bit - 1)/_S_word_bit;
this->_M_start = iterator(__q, 0);
}
void _M_fill_insert(iterator __position, size_type __n, bool __x)
{
if (__n == 0)
return;
if (capacity() - size() >= __n)
{
std::copy_backward(__position, end(),
this->_M_finish + difference_type(__n));
std::fill(__position, __position + difference_type(__n), __x);
this->_M_finish += difference_type(__n);
}
else
{
const size_type __len = size() + std::max(size(), __n);
_Bit_type * __q = this->_M_bit_alloc(__len);
iterator __i = std::copy(begin(), __position, iterator(__q, 0));
std::fill_n(__i, __n, __x);
this->_M_finish = std::copy(__position, end(),
__i + difference_type(__n));
this->_M_deallocate();
this->_M_end_of_storage = __q + (__len + _S_word_bit - 1)
/ _S_word_bit;
this->_M_start = iterator(__q, 0);
}
}
void insert(iterator __position, size_type __n, bool __x) {
_M_fill_insert(__position, __n, __x);
}
void insert(iterator __position, size_type __n, bool __x)
{ _M_fill_insert(__position, __n, __x); }
void pop_back() { --this->_M_finish; }
iterator erase(iterator __position) {
void pop_back()
{ --this->_M_finish; }
iterator erase(iterator __position)
{
if (__position + 1 != end())
std::copy(__position + 1, end(), __position);
--this->_M_finish;
--this->_M_finish;
return __position;
}
iterator erase(iterator __first, iterator __last) {
iterator erase(iterator __first, iterator __last)
{
this->_M_finish = std::copy(__last, end(), __first);
return __first;
}
void resize(size_type __new_size, bool __x = bool()) {
void resize(size_type __new_size, bool __x = bool())
{
if (__new_size < size())
erase(begin() + difference_type(__new_size), end());
else
insert(end(), __new_size - size(), __x);
}
void flip() {
void flip()
{
for (_Bit_type * __p = this->_M_start._M_p;
__p != this->_M_end_of_storage;
++__p)
__p != this->_M_end_of_storage; ++__p)
*__p = ~*__p;
}
void clear() { erase(begin(), end()); }
void clear()
{ erase(begin(), end()); }
};
} // namespace __gnu_norm
#endif
#endif

161
libstdc++-v3/include/bits/stl_tree.h
View File

@ -1,6 +1,6 @@
// RB tree implementation -*- C++ -*-
// Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@ -348,16 +348,17 @@ namespace std
typedef ptrdiff_t difference_type;
typedef _Alloc allocator_type;
allocator_type get_allocator() const {
return *static_cast<const _Node_allocator*>(this);
}
allocator_type get_allocator() const
{ return *static_cast<const _Node_allocator*>(this); }
protected:
_Rb_tree_node*
_M_get_node() { return _Node_allocator::allocate(1); }
_M_get_node()
{ return _Node_allocator::allocate(1); }
void
_M_put_node(_Rb_tree_node* __p) { _Node_allocator::deallocate(__p, 1); }
_M_put_node(_Rb_tree_node* __p)
{ _Node_allocator::deallocate(__p, 1); }
_Link_type
_M_create_node(const value_type& __x)
@ -367,8 +368,8 @@ namespace std
{ std::_Construct(&__tmp->_M_value_field, __x); }
catch(...)
{
_M_put_node(__tmp);
__throw_exception_again;
_M_put_node(__tmp);
__throw_exception_again;
}
return __tmp;
}
@ -397,58 +398,76 @@ namespace std
protected:
_Base_ptr&
_M_root() { return this->_M_header._M_parent; }
_M_root()
{ return this->_M_header._M_parent; }
_Const_Base_ptr
_M_root() const { return this->_M_header._M_parent; }
_M_root() const
{ return this->_M_header._M_parent; }
_Base_ptr&
_M_leftmost() { return this->_M_header._M_left; }
_M_leftmost()
{ return this->_M_header._M_left; }
_Const_Base_ptr
_M_leftmost() const { return this->_M_header._M_left; }
_M_leftmost() const
{ return this->_M_header._M_left; }
_Base_ptr&
_M_rightmost() { return this->_M_header._M_right; }
_M_rightmost()
{ return this->_M_header._M_right; }
_Const_Base_ptr
_M_rightmost() const { return this->_M_header._M_right; }
_M_rightmost() const
{ return this->_M_header._M_right; }
_Link_type
_M_begin() { return static_cast<_Link_type>(this->_M_header._M_parent); }
_M_begin()
{ return static_cast<_Link_type>(this->_M_header._M_parent); }
_Const_Link_type
_M_begin() const { return static_cast<_Const_Link_type>(this->_M_header._M_parent); }
_M_begin() const
{ return static_cast<_Const_Link_type>(this->_M_header._M_parent); }
_Link_type
_M_end() { return static_cast<_Link_type>(&this->_M_header); }
_M_end()
{ return static_cast<_Link_type>(&this->_M_header); }
_Const_Link_type
_M_end() const { return static_cast<_Const_Link_type>(&this->_M_header); }
_M_end() const
{ return static_cast<_Const_Link_type>(&this->_M_header); }
static const_reference
_S_value(_Const_Link_type __x) { return __x->_M_value_field; }
_S_value(_Const_Link_type __x)
{ return __x->_M_value_field; }
static const _Key&
_S_key(_Const_Link_type __x) { return _KeyOfValue()(_S_value(__x)); }
_S_key(_Const_Link_type __x)
{ return _KeyOfValue()(_S_value(__x)); }
static _Link_type
_S_left(_Base_ptr __x) { return static_cast<_Link_type>(__x->_M_left); }
_S_left(_Base_ptr __x)
{ return static_cast<_Link_type>(__x->_M_left); }
static _Const_Link_type
_S_left(_Const_Base_ptr __x) { return static_cast<_Const_Link_type>(__x->_M_left); }
_S_left(_Const_Base_ptr __x)
{ return static_cast<_Const_Link_type>(__x->_M_left); }
static _Link_type
_S_right(_Base_ptr __x) { return static_cast<_Link_type>(__x->_M_right); }
_S_right(_Base_ptr __x)
{ return static_cast<_Link_type>(__x->_M_right); }
static _Const_Link_type
_S_right(_Const_Base_ptr __x) { return static_cast<_Const_Link_type>(__x->_M_right); }
_S_right(_Const_Base_ptr __x)
{ return static_cast<_Const_Link_type>(__x->_M_right); }
static const_reference
_S_value(_Const_Base_ptr __x) { return static_cast<_Const_Link_type>(__x)->_M_value_field; }
_S_value(_Const_Base_ptr __x)
{ return static_cast<_Const_Link_type>(__x)->_M_value_field; }
static const _Key&
_S_key(_Const_Base_ptr __x) { return _KeyOfValue()(_S_value(__x)); }
_S_key(_Const_Base_ptr __x)
{ return _KeyOfValue()(_S_value(__x)); }
static _Base_ptr
_S_minimum(_Base_ptr __x)
@ -538,40 +557,52 @@ namespace std
public:
// Accessors.
_Compare
key_comp() const { return _M_key_compare; }
key_comp() const
{ return _M_key_compare; }
iterator
begin() { return static_cast<_Link_type>(this->_M_header._M_left); }
begin()
{ return static_cast<_Link_type>(this->_M_header._M_left); }
const_iterator
begin() const { return static_cast<_Const_Link_type>(this->_M_header._M_left); }
begin() const
{ return static_cast<_Const_Link_type>(this->_M_header._M_left); }
iterator
end() { return static_cast<_Link_type>(&this->_M_header); }
end()
{ return static_cast<_Link_type>(&this->_M_header); }
const_iterator
end() const { return static_cast<_Const_Link_type>(&this->_M_header); }
end() const
{ return static_cast<_Const_Link_type>(&this->_M_header); }
reverse_iterator
rbegin() { return reverse_iterator(end()); }
rbegin()
{ return reverse_iterator(end()); }
const_reverse_iterator
rbegin() const { return const_reverse_iterator(end()); }
rbegin() const
{ return const_reverse_iterator(end()); }
reverse_iterator
rend() { return reverse_iterator(begin()); }
rend()
{ return reverse_iterator(begin()); }
const_reverse_iterator
rend() const { return const_reverse_iterator(begin()); }
rend() const
{ return const_reverse_iterator(begin()); }
bool
empty() const { return _M_node_count == 0; }
empty() const
{ return _M_node_count == 0; }
size_type
size() const { return _M_node_count; }
size() const
{ return _M_node_count; }
size_type
max_size() const { return size_type(-1); }
max_size() const
{ return size_type(-1); }
void
swap(_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __t);
@ -658,8 +689,8 @@ namespace std
operator==(const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __x,
const _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>& __y)
{
return __x.size() == __y.size() &&
equal(__x.begin(), __x.end(), __y.begin());
return __x.size() == __y.size()
&& equal(__x.begin(), __x.end(), __y.begin());
}
template<typename _Key, typename _Val, typename _KeyOfValue,
@ -738,8 +769,8 @@ namespace std
_Link_type __z = _M_create_node(__v);
bool __insert_left;
__insert_left = __x != 0 || __p == _M_end() ||
_M_key_compare(_KeyOfValue()(__v), _S_key(__p));
__insert_left = __x != 0 || __p == _M_end()
|| _M_key_compare(_KeyOfValue()(__v), _S_key(__p));
_Rb_tree_insert_and_rebalance(__insert_left, __z, __p, this->_M_header);
++_M_node_count;
@ -757,8 +788,8 @@ namespace std
while (__x != 0)
{
__y = __x;
__x = _M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
_S_left(__x) : _S_right(__x);
__x = _M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
_S_left(__x) : _S_right(__x);
}
return _M_insert(__x, __y, __v);
}
@ -818,15 +849,15 @@ namespace std
_Link_type __x = _M_begin();
_Link_type __y = _M_end();
bool __comp = true;
while (__x != 0)
while (__x != 0)
{
__y = __x;
__comp = _M_key_compare(_KeyOfValue()(__v), _S_key(__x));
__x = __comp ? _S_left(__x) : _S_right(__x);
}
iterator __j = iterator(__y);
iterator __j = iterator(__y);
if (__comp)
if (__j == begin())
if (__j == begin())
return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
else
--__j;
@ -835,7 +866,6 @@ namespace std
return pair<iterator,bool>(__j, false);
}
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
@ -845,8 +875,8 @@ namespace std
if (__position._M_node == _M_leftmost())
{
// begin()
if (size() > 0 &&
_M_key_compare(_KeyOfValue()(__v), _S_key(__position._M_node)))
if (size() > 0
&& _M_key_compare(_KeyOfValue()(__v), _S_key(__position._M_node)))
return _M_insert(__position._M_node, __position._M_node, __v);
// first argument just needs to be non-null
else
@ -887,8 +917,9 @@ namespace std
if (__position._M_node == _M_leftmost())
{
// begin()
if (size() > 0 &&
!_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v)))
if (size() > 0
&& !_M_key_compare(_S_key(__position._M_node),
_KeyOfValue()(__v)))
return _M_insert(__position._M_node, __position._M_node, __v);
// first argument just needs to be non-null
else
@ -1060,7 +1091,7 @@ namespace std
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::const_iterator
typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::const_iterator
_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
find(const _Key& __k) const
{
@ -1086,7 +1117,7 @@ namespace std
count(const _Key& __k) const
{
pair<const_iterator, const_iterator> __p = equal_range(__k);
size_type __n = std::distance(__p.first, __p.second);
const size_type __n = std::distance(__p.first, __p.second);
return __n;
}
@ -1165,8 +1196,9 @@ namespace std
template<typename _Key, typename _Val, typename _KeyOfValue,
typename _Compare, typename _Alloc>
inline
pair<typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator,
typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator>
pair<typename _Rb_tree<_Key,_Val,_KeyOfValue,
_Compare,_Alloc>::iterator,
typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator>
_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::
equal_range(const _Key& __k)
{ return pair<iterator, iterator>(lower_bound(__k), upper_bound(__k)); }
@ -1174,14 +1206,13 @@ namespace std
template<typename _Key, typename _Val, typename _KoV,
typename _Compare, typename _Alloc>
inline
pair<typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::const_iterator,
typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::const_iterator>
pair<typename _Rb_tree<_Key, _Val, _KoV,
_Compare, _Alloc>::const_iterator,
typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::const_iterator>
_Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>
::equal_range(const _Key& __k) const
{
return pair<const_iterator,const_iterator>(lower_bound(__k),
upper_bound(__k));
}
{ return pair<const_iterator, const_iterator>(lower_bound(__k),
upper_bound(__k)); }
unsigned int
_Rb_tree_black_count(const _Rb_tree_node_base* __node,
@ -1193,9 +1224,9 @@ namespace std
_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
{
if (_M_node_count == 0 || begin() == end())
return _M_node_count == 0 && begin() == end() &&
this->_M_header._M_left == _M_end() &&
this->_M_header._M_right == _M_end();
return _M_node_count == 0 && begin() == end()
&& this->_M_header._M_left == _M_end()
&& this->_M_header._M_right == _M_end();
unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
for (const_iterator __it = begin(); __it != end(); ++__it)