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
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;
}
reference
- operator[](difference_type __i) { return *(*this + __i); }
+ operator[](difference_type __i)
+ { return *(*this + __i); }
};
inline _Bit_iterator
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); }
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()
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;
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;
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);
}
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);
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);
}
// 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,
~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;
// 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;
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;
- }
- }
-
- 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->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)
+ {
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;
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 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 _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 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
// 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
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)
{ std::_Construct(&__tmp->_M_value_field, __x); }
catch(...)
{
- _M_put_node(__tmp);
- __throw_exception_again;
+ _M_put_node(__tmp);
+ __throw_exception_again;
}
return __tmp;
}
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)
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);
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,
_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;
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);
}
_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;
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
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
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
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
{
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;
}
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)); }
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,
_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)
projects / platform / upstream / gcc.git / commitdiff