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

deque.tcc: Wrap overlong lines... 

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

	* include/bits/deque.tcc: Wrap overlong lines, constify
	a few variables, reformat according to the coding standards.
	* include/bits/list.tcc: Likewise.
	* include/bits/stl_deque.h: Likewise.
	* include/bits/stl_function.h: Likewise.
	* include/bits/stl_iterator.h: Likewise.
	* include/bits/stl_iterator_base_funcs.h: Likewise.
	* include/bits/stl_iterator_base_types.h: Likewise.
	* include/bits/stl_list.h: Likewise.
	* include/bits/stl_map.h: Likewise.
	* include/bits/stl_multimap.h: Likewise.
	* include/bits/stl_multiset.h: Likewise.
	* include/bits/stl_relops.h: Likewise.
	* include/bits/stl_set.h: Likewise.

From-SVN: r77077
This commit is contained in:
Paolo Carlini 2004-02-01 17:34:44 +00:00 committed by Paolo Carlini
parent e0a24727f2
commit f6592a9e2c
14 changed files with 3963 additions and 3535 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,20 @@
2004-02-01 Paolo Carlini <pcarlini@suse.de>
* include/bits/deque.tcc: Wrap overlong lines, constify
a few variables, reformat according to the coding standards.
* include/bits/list.tcc: Likewise.
* include/bits/stl_deque.h: Likewise.
* include/bits/stl_function.h: Likewise.
* include/bits/stl_iterator.h: Likewise.
* include/bits/stl_iterator_base_funcs.h: Likewise.
* include/bits/stl_iterator_base_types.h: Likewise.
* include/bits/stl_list.h: Likewise.
* include/bits/stl_map.h: Likewise.
* include/bits/stl_multimap.h: Likewise.
* include/bits/stl_multiset.h: Likewise.
* include/bits/stl_relops.h: Likewise.
* include/bits/stl_set.h: Likewise.
2004-02-01 Paolo Carlini <pcarlini@suse.de>
* include/bits/stl_bvector.h: Wrap overlong lines, constify

45
libstdc++-v3/include/bits/deque.tcc
View File

@ -1,6 +1,6 @@
// Deque implementation (out of line) -*- 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
@ -72,7 +72,8 @@ namespace __gnu_norm
if (&__x != this)
{
if (__len >= __x.size())
erase(std::copy(__x.begin(), __x.end(), this->_M_start), this->_M_finish);
erase(std::copy(__x.begin(), __x.end(), this->_M_start),
this->_M_finish);
else
{
const_iterator __mid = __x.begin() + difference_type(__len);
@ -137,8 +138,8 @@ namespace __gnu_norm
}
else
{
difference_type __n = __last - __first;
difference_type __elems_before = __first - this->_M_start;
const difference_type __n = __last - __first;
const difference_type __elems_before = __first - this->_M_start;
if (static_cast<size_type>(__elems_before) < (size() - __n) / 2)
{
std::copy_backward(this->_M_start, __first, __last);
@ -189,7 +190,8 @@ namespace __gnu_norm
template <typename _InputIterator>
void
deque<_Tp,_Alloc>
::_M_assign_aux(_InputIterator __first, _InputIterator __last, input_iterator_tag)
::_M_assign_aux(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
{
iterator __cur = begin();
for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
@ -288,7 +290,7 @@ namespace __gnu_norm
_M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
forward_iterator_tag)
{
size_type __n = std::distance(__first, __last);
const size_type __n = std::distance(__first, __last);
this->_M_initialize_map(__n);
_Map_pointer __cur_node;
@ -389,9 +391,7 @@ namespace __gnu_norm
_M_range_insert_aux(iterator __pos,
_InputIterator __first, _InputIterator __last,
input_iterator_tag)
{
std::copy(__first, __last, std::inserter(*this, __pos));
}
{ std::copy(__first, __last, std::inserter(*this, __pos)); }
template <typename _Tp, typename _Alloc>
template <typename _ForwardIterator>
@ -486,14 +486,16 @@ namespace __gnu_norm
if (__elems_before >= difference_type(__n))
{
iterator __start_n = this->_M_start + difference_type(__n);
std::uninitialized_copy(this->_M_start, __start_n, __new_start);
std::uninitialized_copy(this->_M_start, __start_n,
__new_start);
this->_M_start = __new_start;
std::copy(__start_n, __pos, __old_start);
fill(__pos - difference_type(__n), __pos, __x_copy);
}
else
{
std::__uninitialized_copy_fill(this->_M_start, __pos, __new_start,
std::__uninitialized_copy_fill(this->_M_start, __pos,
__new_start,
this->_M_start, __x_copy);
this->_M_start = __new_start;
std::fill(__old_start, __pos, __x_copy);
@ -517,7 +519,8 @@ namespace __gnu_norm
if (__elems_after > difference_type(__n))
{
iterator __finish_n = this->_M_finish - difference_type(__n);
std::uninitialized_copy(__finish_n, this->_M_finish, this->_M_finish);
std::uninitialized_copy(__finish_n, this->_M_finish,
this->_M_finish);
this->_M_finish = __new_finish;
std::copy_backward(__pos, __finish_n, __old_finish);
std::fill(__pos, __pos + difference_type(__n), __x_copy);
@ -526,7 +529,8 @@ namespace __gnu_norm
{
std::__uninitialized_fill_copy(this->_M_finish,
__pos + difference_type(__n),
__x_copy, __pos, this->_M_finish);
__x_copy, __pos,
this->_M_finish);
this->_M_finish = __new_finish;
std::fill(__pos, __old_finish, __x_copy);
}
@ -560,7 +564,8 @@ namespace __gnu_norm
if (__elemsbefore >= difference_type(__n))
{
iterator __start_n = this->_M_start + difference_type(__n);
std::uninitialized_copy(this->_M_start, __start_n, __new_start);
std::uninitialized_copy(this->_M_start, __start_n,
__new_start);
this->_M_start = __new_start;
std::copy(__start_n, __pos, __old_start);
std::copy(__first, __last, __pos - difference_type(__n));
@ -605,7 +610,8 @@ namespace __gnu_norm
_ForwardIterator __mid = __first;
std::advance(__mid, __elemsafter);
std::__uninitialized_copy_copy(__mid, __last, __pos,
this->_M_finish, this->_M_finish);
this->_M_finish,
this->_M_finish);
this->_M_finish = __new_finish;
std::copy(__first, __mid, __pos);
}
@ -675,8 +681,8 @@ namespace __gnu_norm
_Map_pointer __new_nstart;
if (this->_M_map_size > 2 * __new_num_nodes)
{
__new_nstart
= this->_M_map + (this->_M_map_size - __new_num_nodes) / 2
__new_nstart = this->_M_map + (this->_M_map_size
- __new_num_nodes) / 2
+ (__add_at_front ? __nodes_to_add : 0);
if (__new_nstart < this->_M_start._M_node)
std::copy(this->_M_start._M_node,
@ -689,8 +695,9 @@ namespace __gnu_norm
}
else
{
size_type __new_map_size =
this->_M_map_size + std::max(this->_M_map_size, __nodes_to_add) + 2;
size_type __new_map_size = this->_M_map_size
+ std::max(this->_M_map_size,
__nodes_to_add) + 2;
_Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
__new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2

24
libstdc++-v3/include/bits/list.tcc
View File

@ -1,6 +1,6 @@
// List implementation (out of line) -*- 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
@ -191,7 +191,8 @@ namespace __gnu_norm
{
iterator __first = begin();
iterator __last = end();
if (__first == __last) return;
if (__first == __last)
return;
iterator __next = __first;
while (++__next != __last)
{
@ -256,8 +257,10 @@ namespace __gnu_norm
__carry.swap(*__counter);
}
__carry.swap(*__counter);
if (__counter == __fill) ++__fill;
} while ( !empty() );
if (__counter == __fill)
++__fill;
}
while ( !empty() );
for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
__counter->merge( *(__counter-1) );
@ -277,7 +280,8 @@ namespace __gnu_norm
{
iterator __next = __first;
++__next;
if (__pred(*__first)) _M_erase(__first);
if (__pred(*__first))
_M_erase(__first);
__first = __next;
}
}
@ -337,8 +341,8 @@ namespace __gnu_norm
sort(_StrictWeakOrdering __comp)
{
// Do nothing if the list has length 0 or 1.
if (this->_M_node._M_next != &this->_M_node &&
this->_M_node._M_next->_M_next != &this->_M_node)
if (this->_M_node._M_next != &this->_M_node
&& this->_M_node._M_next->_M_next != &this->_M_node)
{
list __carry;
list __tmp[64];
@ -357,8 +361,10 @@ namespace __gnu_norm
__carry.swap(*__counter);
}
__carry.swap(*__counter);
if (__counter == __fill) ++__fill;
} while ( !empty() );
if (__counter == __fill)
++__fill;
}
while ( !empty() );
for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
__counter->merge( *(__counter-1), __comp );

374
libstdc++-v3/include/bits/stl_deque.h
View File

@ -1,6 +1,6 @@
// Deque 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
@ -101,7 +101,9 @@ namespace __gnu_norm
{
typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }
static size_t _S_buffer_size()
{ return __deque_buf_size(sizeof(_Tp)); }
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
@ -120,72 +122,101 @@ namespace __gnu_norm
_Deque_iterator(_Tp* __x, _Map_pointer __y)
: _M_cur(__x), _M_first(*__y),
_M_last(*__y + _S_buffer_size()), _M_node(__y) {}
_Deque_iterator() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {}
_Deque_iterator(const iterator& __x)
: _M_cur(__x._M_cur), _M_first(__x._M_first),
_M_last(__x._M_last), _M_node(__x._M_node) {}
reference operator*() const { return *_M_cur; }
pointer operator->() const { return _M_cur; }
reference
operator*() const
{ return *_M_cur; }
_Self& operator++() {
pointer
operator->() const
{ return _M_cur; }
_Self&
operator++()
{
++_M_cur;
if (_M_cur == _M_last) {
if (_M_cur == _M_last)
{
_M_set_node(_M_node + 1);
_M_cur = _M_first;
}
return *this;
}
_Self operator++(int) {
_Self
operator++(int)
{
_Self __tmp = *this;
++*this;
return __tmp;
}
_Self& operator--() {
if (_M_cur == _M_first) {
_Self&
operator--()
{
if (_M_cur == _M_first)
{
_M_set_node(_M_node - 1);
_M_cur = _M_last;
}
--_M_cur;
return *this;
}
_Self operator--(int) {
_Self
operator--(int)
{
_Self __tmp = *this;
--*this;
return __tmp;
}
_Self& operator+=(difference_type __n)
_Self&
operator+=(difference_type __n)
{
difference_type __offset = __n + (_M_cur - _M_first);
const difference_type __offset = __n + (_M_cur - _M_first);
if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
_M_cur += __n;
else {
difference_type __node_offset =
else
{
const difference_type __node_offset =
__offset > 0 ? __offset / difference_type(_S_buffer_size())
: -difference_type((-__offset - 1) / _S_buffer_size()) - 1;
: -difference_type((-__offset - 1)
/ _S_buffer_size()) - 1;
_M_set_node(_M_node + __node_offset);
_M_cur = _M_first +
(__offset - __node_offset * difference_type(_S_buffer_size()));
_M_cur = _M_first + (__offset - __node_offset
* difference_type(_S_buffer_size()));
}
return *this;
}
_Self operator+(difference_type __n) const
_Self
operator+(difference_type __n) const
{
_Self __tmp = *this;
return __tmp += __n;
}
_Self& operator-=(difference_type __n) { return *this += -__n; }
_Self&
operator-=(difference_type __n)
{ return *this += -__n; }
_Self operator-(difference_type __n) const {
_Self
operator-(difference_type __n) const
{
_Self __tmp = *this;
return __tmp -= __n;
}
reference operator[](difference_type __n) const { return *(*this + __n); }
reference
operator[](difference_type __n) const
{ return *(*this + __n); }
/** @if maint
* Prepares to traverse new_node. Sets everything except _M_cur, which
@ -209,105 +240,81 @@ namespace __gnu_norm
inline bool
operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return __x._M_cur == __y._M_cur;
}
{ return __x._M_cur == __y._M_cur; }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return __x._M_cur == __y._M_cur;
}
{ return __x._M_cur == __y._M_cur; }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return !(__x == __y);
}
{ return !(__x == __y); }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return !(__x == __y);
}
{ return !(__x == __y); }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return (__x._M_node == __y._M_node) ?
(__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
}
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
: (__x._M_node < __y._M_node); }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return (__x._M_node == __y._M_node) ?
(__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
}
{ return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
: (__x._M_node < __y._M_node); }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return __y < __x;
}
{ return __y < __x; }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return __y < __x;
}
{ return __y < __x; }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return !(__y < __x);
}
{ return !(__y < __x); }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return !(__y < __x);
}
{ return !(__y < __x); }
template<typename _Tp, typename _Ref, typename _Ptr>
inline bool
operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
{
return !(__x < __y);
}
{ return !(__x < __y); }
template<typename _Tp, typename _RefL, typename _PtrL,
typename _RefR, typename _PtrR>
inline bool
operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return !(__x < __y);
}
{ return !(__x < __y); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// According to the resolution of DR179 not only the various comparison
@ -320,17 +327,15 @@ namespace __gnu_norm
const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
{
return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
(_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size()) *
(__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first) +
(__y._M_last - __y._M_cur);
(_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
* (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+ (__y._M_last - __y._M_cur);
}
template<typename _Tp, typename _Ref, typename _Ptr>
inline _Deque_iterator<_Tp, _Ref, _Ptr>
operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
{
return __x + __n;
}
{ return __x + __n; }
/**
* @if maint
@ -350,7 +355,9 @@ namespace __gnu_norm
{
public:
typedef _Alloc allocator_type;
allocator_type get_allocator() const
allocator_type
get_allocator() const
{ return *static_cast<const _Alloc*>(this); }
typedef _Deque_iterator<_Tp,_Tp&,_Tp*> iterator;
@ -359,8 +366,10 @@ namespace __gnu_norm
_Deque_base(const allocator_type& __a, size_t __num_elements)
: _Alloc(__a), _M_start(), _M_finish()
{ _M_initialize_map(__num_elements); }
_Deque_base(const allocator_type& __a)
: _Alloc(__a), _M_start(), _M_finish() {}
: _Alloc(__a), _M_start(), _M_finish() { }
~_Deque_base();
protected:
@ -370,15 +379,11 @@ namespace __gnu_norm
_Tp*
_M_allocate_node()
{
return _Alloc::allocate(__deque_buf_size(sizeof(_Tp)));
}
{ return _Alloc::allocate(__deque_buf_size(sizeof(_Tp))); }
void
_M_deallocate_node(_Tp* __p)
{
_Alloc::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
}
{ _Alloc::deallocate(__p, __deque_buf_size(sizeof(_Tp))); }
_Tp**
_M_allocate_map(size_t __n)
@ -400,7 +405,6 @@ namespace __gnu_norm
iterator _M_finish;
};
template<typename _Tp, typename _Alloc>
_Deque_base<_Tp,_Alloc>::~_Deque_base()
{
@ -425,16 +429,16 @@ namespace __gnu_norm
void
_Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements)
{
size_t __num_nodes =
__num_elements / __deque_buf_size(sizeof(_Tp)) + 1;
size_t __num_nodes = __num_elements / __deque_buf_size(sizeof(_Tp)) + 1;
this->_M_map_size
= std::max((size_t) _S_initial_map_size, __num_nodes + 2);
this->_M_map_size = std::max((size_t) _S_initial_map_size,
__num_nodes + 2);
this->_M_map = _M_allocate_map(this->_M_map_size);
// For "small" maps (needing less than _M_map_size nodes), allocation
// starts in the middle elements and grows outwards. So nstart may be the
// beginning of _M_map, but for small maps it may be as far in as _M_map+3.
// starts in the middle elements and grows outwards. So nstart may be
// the beginning of _M_map, but for small maps it may be as far in as
// _M_map+3.
_Tp** __nstart = this->_M_map + (this->_M_map_size - __num_nodes) / 2;
_Tp** __nfinish = __nstart + __num_nodes;
@ -452,12 +456,13 @@ namespace __gnu_norm
_M_start._M_set_node(__nstart);
_M_finish._M_set_node(__nfinish - 1);
_M_start._M_cur = _M_start._M_first;
_M_finish._M_cur = _M_finish._M_first +
__num_elements % __deque_buf_size(sizeof(_Tp));
_M_finish._M_cur = _M_finish._M_first + __num_elements
% __deque_buf_size(sizeof(_Tp));
}
template<typename _Tp, typename _Alloc>
void _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
void
_Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
{
_Tp** __cur;
try
@ -480,7 +485,6 @@ namespace __gnu_norm
_M_deallocate_node(*__n);
}
/**
* @brief A standard container using fixed-size memory allocation and
* constant-time manipulation of elements at either end.
@ -589,7 +593,9 @@ namespace __gnu_norm
protected:
typedef pointer* _Map_pointer;
static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }
static size_t _S_buffer_size()
{ return __deque_buf_size(sizeof(_Tp)); }
// Functions controlling memory layout, and nothing else.
using _Base::_M_initialize_map;
@ -659,7 +665,8 @@ namespace __gnu_norm
* @param first An input iterator.
* @param last An input iterator.
*
* Create a %deque consisting of copies of the elements from [first,last).
* Create a %deque consisting of copies of the elements from [first,
* last).
*
* If the iterators are forward, bidirectional, or random-access, then
* this will call the elements' copy constructor N times (where N is
@ -682,7 +689,8 @@ namespace __gnu_norm
* themselves are pointers, the pointed-to memory is not touched in any
* way. Managing the pointer is the user's responsibilty.
*/
~deque() { std::_Destroy(this->_M_start, this->_M_finish); }
~deque()
{ std::_Destroy(this->_M_start, this->_M_finish); }
/**
* @brief %Deque assignment operator.
@ -705,7 +713,8 @@ namespace __gnu_norm
* Old data may be lost.
*/
void
assign(size_type __n, const value_type& __val) { _M_fill_assign(__n, __val); }
assign(size_type __n, const value_type& __val)
{ _M_fill_assign(__n, __val); }
/**
* @brief Assigns a range to a %deque.
@ -716,8 +725,8 @@ namespace __gnu_norm
* range [first,last).
*
* Note that the assignment completely changes the %deque and that the
* resulting %deque's size is the same as the number of elements assigned.
* Old data may be lost.
* resulting %deque's size is the same as the number of elements
* assigned. Old data may be lost.
*/
template<typename _InputIterator>
void
@ -729,7 +738,8 @@ namespace __gnu_norm
/// Get a copy of the memory allocation object.
allocator_type
get_allocator() const { return _Base::get_allocator(); }
get_allocator() const
{ return _Base::get_allocator(); }
// iterators
/**
@ -737,42 +747,49 @@ namespace __gnu_norm
* %deque. Iteration is done in ordinary element order.
*/
iterator
begin() { return this->_M_start; }
begin()
{ return this->_M_start; }
/**
* Returns a read-only (constant) iterator that points to the first element
* in the %deque. Iteration is done in ordinary element order.
* Returns a read-only (constant) iterator that points to the first
* element in the %deque. Iteration is done in ordinary element order.
*/
const_iterator
begin() const { return this->_M_start; }
begin() const
{ return this->_M_start; }
/**
* Returns a read/write iterator that points one past the last element in
* the %deque. Iteration is done in ordinary element order.
*/
iterator
end() { return this->_M_finish; }
end()
{ return this->_M_finish; }
/**
* Returns a read-only (constant) iterator that points one past the last
* element in the %deque. Iteration is done in ordinary element order.
*/
const_iterator
end() const { return this->_M_finish; }
end() const
{ return this->_M_finish; }
/**
* Returns a read/write reverse iterator that points to the last element in
* the %deque. Iteration is done in reverse element order.
* Returns a read/write reverse iterator that points to the last element
* in the %deque. Iteration is done in reverse element order.
*/
reverse_iterator
rbegin() { return reverse_iterator(this->_M_finish); }
rbegin()
{ return reverse_iterator(this->_M_finish); }
/**
* Returns a read-only (constant) reverse iterator that points to the last
* element in the %deque. Iteration is done in reverse element order.
* Returns a read-only (constant) reverse iterator that points to the
* last element in the %deque. Iteration is done in reverse element
* order.
*/
const_reverse_iterator
rbegin() const { return const_reverse_iterator(this->_M_finish); }
rbegin() const
{ return const_reverse_iterator(this->_M_finish); }
/**
* Returns a read/write reverse iterator that points to one before the
@ -788,16 +805,19 @@ namespace __gnu_norm
* element order.
*/
const_reverse_iterator
rend() const { return const_reverse_iterator(this->_M_start); }
rend() const
{ return const_reverse_iterator(this->_M_start); }
// [23.2.1.2] capacity
/** Returns the number of elements in the %deque. */
size_type
size() const { return this->_M_finish - this->_M_start; }
size() const
{ return this->_M_finish - this->_M_start; }
/** Returns the size() of the largest possible %deque. */
size_type
max_size() const { return size_type(-1); }
max_size() const
{ return size_type(-1); }
/**
* @brief Resizes the %deque to the specified number of elements.
@ -829,12 +849,15 @@ namespace __gnu_norm
* are default-constructed.
*/
void
resize(size_type new_size) { resize(new_size, value_type()); }
resize(size_type new_size)
{ resize(new_size, value_type()); }
/**
* Returns true if the %deque is empty. (Thus begin() would equal end().)
*/
bool empty() const { return this->_M_finish == this->_M_start; }
bool
empty() const
{ return this->_M_finish == this->_M_start; }
// element access
/**
@ -847,7 +870,8 @@ namespace __gnu_norm
* lookups are not defined. (For checked lookups see at().)
*/
reference
operator[](size_type __n) { return this->_M_start[difference_type(__n)]; }
operator[](size_type __n)
{ return this->_M_start[difference_type(__n)]; }
/**
* @brief Subscript access to the data contained in the %deque.
@ -859,9 +883,8 @@ namespace __gnu_norm
* lookups are not defined. (For checked lookups see at().)
*/
const_reference
operator[](size_type __n) const {
return this->_M_start[difference_type(__n)];
}
operator[](size_type __n) const
{ return this->_M_start[difference_type(__n)]; }
protected:
/// @if maint Safety check used only from at(). @endif
@ -884,7 +907,8 @@ namespace __gnu_norm
* out_of_range if the check fails.
*/
reference
at(size_type __n) { _M_range_check(__n); return (*this)[__n]; }
at(size_type __n)
{ _M_range_check(__n); return (*this)[__n]; }
/**
* @brief Provides access to the data contained in the %deque.
@ -897,21 +921,27 @@ namespace __gnu_norm
* out_of_range if the check fails.
*/
const_reference
at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; }
at(size_type __n) const
{
_M_range_check(__n);
return (*this)[__n];
}
/**
* Returns a read/write reference to the data at the first element of the
* %deque.
*/
reference
front() { return *this->_M_start; }
front()
{ return *this->_M_start; }
/**
* Returns a read-only (constant) reference to the data at the first
* element of the %deque.
*/
const_reference
front() const { return *this->_M_start; }
front() const
{ return *this->_M_start; }
/**
* Returns a read/write reference to the data at the last element of the
@ -949,7 +979,8 @@ namespace __gnu_norm
void
push_front(const value_type& __x)
{
if (this->_M_start._M_cur != this->_M_start._M_first) {
if (this->_M_start._M_cur != this->_M_start._M_first)
{
std::_Construct(this->_M_start._M_cur - 1, __x);
--this->_M_start._M_cur;
}
@ -968,7 +999,8 @@ namespace __gnu_norm
void
push_back(const value_type& __x)
{
if (this->_M_finish._M_cur != this->_M_finish._M_last - 1) {
if (this->_M_finish._M_cur != this->_M_finish._M_last - 1)
{
std::_Construct(this->_M_finish._M_cur, __x);
++this->_M_finish._M_cur;
}
@ -987,7 +1019,8 @@ namespace __gnu_norm
void
pop_front()
{
if (this->_M_start._M_cur != this->_M_start._M_last - 1) {
if (this->_M_start._M_cur != this->_M_start._M_last - 1)
{
std::_Destroy(this->_M_start._M_cur);
++this->_M_start._M_cur;
}
@ -1006,7 +1039,8 @@ namespace __gnu_norm
void
pop_back()
{
if (this->_M_finish._M_cur != this->_M_finish._M_first) {
if (this->_M_finish._M_cur != this->_M_finish._M_first)
{
--this->_M_finish._M_cur;
std::_Destroy(this->_M_finish._M_cur);
}
@ -1020,8 +1054,8 @@ namespace __gnu_norm
* @param x Data to be inserted.
* @return An iterator that points to the inserted data.
*
* This function will insert a copy of the given value before the specified
* location.
* This function will insert a copy of the given value before the
* specified location.
*/
iterator
insert(iterator position, const value_type& __x);
@ -1032,8 +1066,8 @@ namespace __gnu_norm
* @param n Number of elements to be inserted.
* @param x Data to be inserted.
*
* This function will insert a specified number of copies of the given data
* before the location specified by @a position.
* This function will insert a specified number of copies of the given
* data before the location specified by @a position.
*/
void
insert(iterator __position, size_type __n, const value_type& __x)
@ -1051,7 +1085,8 @@ namespace __gnu_norm
*/
template<typename _InputIterator>
void
insert(iterator __position, _InputIterator __first, _InputIterator __last)
insert(iterator __position, _InputIterator __first,
_InputIterator __last)
{
// Check whether it's an integral type. If so, it's not an iterator.
typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
@ -1067,9 +1102,9 @@ namespace __gnu_norm
* shorten the %deque by one.
*
* The user is cautioned that
* this function only erases the element, and that if the element is itself
* a pointer, the pointed-to memory is not touched in any way. Managing
* the pointer is the user's responsibilty.
* this function only erases the element, and that if the element is
* itself a pointer, the pointed-to memory is not touched in any way.
* Managing the pointer is the user's responsibilty.
*/
iterator
erase(iterator __position);
@ -1183,7 +1218,6 @@ namespace __gnu_norm
void
_M_fill_initialize(const value_type& __value);
// Internal assign functions follow. The *_aux functions do the actual
// assignment work for the range versions.
@ -1199,7 +1233,8 @@ namespace __gnu_norm
// called by the range assign to implement [23.1.1]/9
template<typename _InputIterator>
void
_M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type)
_M_assign_dispatch(_InputIterator __first, _InputIterator __last,
__false_type)
{
typedef typename iterator_traits<_InputIterator>::iterator_category
_IterCategory;
@ -1218,8 +1253,9 @@ namespace __gnu_norm
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
forward_iterator_tag)
{
size_type __len = std::distance(__first, __last);
if (__len > size()) {
const size_type __len = std::distance(__first, __last);
if (__len > size())
{
_ForwardIterator __mid = __first;
std::advance(__mid, size());
std::copy(__first, __mid, begin());
@ -1246,7 +1282,6 @@ namespace __gnu_norm
}
}
//@{
/**
* @if maint
@ -1259,7 +1294,6 @@ namespace __gnu_norm
void _M_pop_front_aux();
//@}
// Internal insert functions follow. The *_aux functions do the actual
// insertion work when all shortcuts fail.
@ -1298,8 +1332,8 @@ namespace __gnu_norm
_ForwardIterator __last, forward_iterator_tag);
// Called by insert(p,n,x), and the range insert when it turns out to be
// the same thing. Can use fill functions in optimal situations, otherwise
// passes off to insert_aux(p,n,x).
// the same thing. Can use fill functions in optimal situations,
// otherwise passes off to insert_aux(p,n,x).
void
_M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
@ -1328,7 +1362,8 @@ namespace __gnu_norm
iterator
_M_reserve_elements_at_front(size_type __n)
{
size_type __vacancies = this->_M_start._M_cur - this->_M_start._M_first;
const size_type __vacancies = this->_M_start._M_cur
- this->_M_start._M_first;
if (__n > __vacancies)
_M_new_elements_at_front(__n - __vacancies);
return this->_M_start - difference_type(__n);
@ -1337,8 +1372,8 @@ namespace __gnu_norm
iterator
_M_reserve_elements_at_back(size_type __n)
{
size_type __vacancies
= (this->_M_finish._M_last - this->_M_finish._M_cur) - 1;
const size_type __vacancies = (this->_M_finish._M_last
- this->_M_finish._M_cur) - 1;
if (__n > __vacancies)
_M_new_elements_at_back(__n - __vacancies);
return this->_M_finish + difference_type(__n);
@ -1365,8 +1400,8 @@ namespace __gnu_norm
void
_M_reserve_map_at_back (size_type __nodes_to_add = 1)
{
if (__nodes_to_add + 1
> this->_M_map_size - (this->_M_finish._M_node - this->_M_map))
if (__nodes_to_add + 1 > this->_M_map_size
- (this->_M_finish._M_node - this->_M_map))
_M_reallocate_map(__nodes_to_add, false);
}
@ -1394,12 +1429,11 @@ namespace __gnu_norm
* and if corresponding elements compare equal.
*/
template<typename _Tp, typename _Alloc>
inline bool operator==(const deque<_Tp, _Alloc>& __x,
inline bool
operator==(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{
return __x.size() == __y.size() &&
std::equal(__x.begin(), __x.end(), __y.begin());
}
{ return __x.size() == __y.size()
&& std::equal(__x.begin(), __x.end(), __y.begin()); }
/**
* @brief Deque ordering relation.
@ -1413,47 +1447,45 @@ namespace __gnu_norm
* See std::lexicographical_compare() for how the determination is made.
*/
template<typename _Tp, typename _Alloc>
inline bool operator<(const deque<_Tp, _Alloc>& __x,
inline bool
operator<(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{
return lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end());
}
{ return lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end()); }
/// Based on operator==
template<typename _Tp, typename _Alloc>
inline bool operator!=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y) {
return !(__x == __y);
}
inline bool
operator!=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return !(__x == __y); }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool operator>(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y) {
return __y < __x;
}
inline bool
operator>(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return __y < __x; }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool operator<=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y) {
return !(__y < __x);
}
inline bool
operator<=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return !(__y < __x); }
/// Based on operator<
template<typename _Tp, typename _Alloc>
inline bool operator>=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y) {
return !(__x < __y);
}
inline bool
operator>=(const deque<_Tp, _Alloc>& __x,
const deque<_Tp, _Alloc>& __y)
{ return !(__x < __y); }
/// See std::deque::swap().
template<typename _Tp, typename _Alloc>
inline void swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
{
__x.swap(__y);
}
inline void
swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
{ __x.swap(__y); }
} // namespace __gnu_norm
#endif /* _DEQUE_H */

992
libstdc++-v3/include/bits/stl_function.h
View File

File diff suppressed because it is too large Load Diff

72
libstdc++-v3/include/bits/stl_iterator.h
View File

@ -1,6 +1,6 @@
// Iterators -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 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
@ -137,7 +137,8 @@ namespace std
* @return @c current, the %iterator used for underlying work.
*/
iterator_type
base() const { return current; }
base() const
{ return current; }
/**
* @return TODO
@ -157,7 +158,8 @@ namespace std
* @doctodo
*/
pointer
operator->() const { return &(operator*()); }
operator->() const
{ return &(operator*()); }
/**
* @return TODO
@ -256,7 +258,8 @@ namespace std
* @doctodo
*/
reference
operator[](difference_type __n) const { return *(*this + __n); }
operator[](difference_type __n) const
{ return *(*this + __n); }
};
//@{
@ -364,15 +367,18 @@ namespace std
/// Simply returns *this.
back_insert_iterator&
operator*() { return *this; }
operator*()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
back_insert_iterator&
operator++() { return *this; }
operator++()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
back_insert_iterator
operator++(int) { return *this; }
operator++(int)
{ return *this; }
};
/**
@ -435,15 +441,18 @@ namespace std
/// Simply returns *this.
front_insert_iterator&
operator*() { return *this; }
operator*()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
front_insert_iterator&
operator++() { return *this; }
operator++()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
front_insert_iterator
operator++(int) { return *this; }
operator++(int)
{ return *this; }
};
/**
@ -528,15 +537,18 @@ namespace std
/// Simply returns *this.
insert_iterator&
operator*() { return *this; }
operator*()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
insert_iterator&
operator++() { return *this; }
operator++()
{ return *this; }
/// Simply returns *this. (This %iterator does not "move".)
insert_iterator&
operator++(int) { return *this; }
operator++(int)
{ return *this; }
};
/**
@ -592,28 +604,41 @@ namespace __gnu_cxx
// Allow iterator to const_iterator conversion
template<typename _Iter>
inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
inline __normal_iterator(const __normal_iterator<_Iter,
_Container>& __i)
: _M_current(__i.base()) { }
// Forward iterator requirements
reference
operator*() const { return *_M_current; }
operator*() const
{ return *_M_current; }
pointer
operator->() const { return _M_current; }
operator->() const
{ return _M_current; }
__normal_iterator&
operator++() { ++_M_current; return *this; }
operator++()
{
++_M_current;
return *this;
}
__normal_iterator
operator++(int) { return __normal_iterator(_M_current++); }
operator++(int)
{ return __normal_iterator(_M_current++); }
// Bidirectional iterator requirements
__normal_iterator&
operator--() { --_M_current; return *this; }
operator--()
{
--_M_current;
return *this;
}
__normal_iterator
operator--(int) { return __normal_iterator(_M_current--); }
operator--(int)
{ return __normal_iterator(_M_current--); }
// Random access iterator requirements
reference
@ -637,7 +662,8 @@ namespace __gnu_cxx
{ return __normal_iterator(_M_current - __n); }
const _Iterator&
base() const { return _M_current; }
base() const
{ return _M_current; }
};
// Note: In what follows, the left- and right-hand-side iterators are
@ -734,8 +760,8 @@ namespace __gnu_cxx
template<typename _Iterator, typename _Container>
inline __normal_iterator<_Iterator, _Container>
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n,
const __normal_iterator<_Iterator, _Container>& __i)
operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
__n, const __normal_iterator<_Iterator, _Container>& __i)
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
} // namespace __gnu_cxx

24
libstdc++-v3/include/bits/stl_iterator_base_funcs.h
View File

@ -1,6 +1,6 @@
// Functions used by iterators -*- 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
@ -78,8 +78,10 @@ namespace std
__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
typename iterator_traits<_InputIterator>::difference_type __n = 0;
while (__first != __last) {
++__first; ++__n;
while (__first != __last)
{
++__first;
++__n;
}
return __n;
}
@ -90,7 +92,8 @@ namespace std
random_access_iterator_tag)
{
// concept requirements
__glibcxx_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>)
__glibcxx_function_requires(_RandomAccessIteratorConcept<
_RandomAccessIterator>)
return __last - __first;
}
@ -111,7 +114,8 @@ namespace std
distance(_InputIterator __first, _InputIterator __last)
{
// concept requirements -- taken care of in __distance
return std::__distance(__first, __last, std::__iterator_category(__first));
return std::__distance(__first, __last,
std::__iterator_category(__first));
}
template<typename _InputIterator, typename _Distance>
@ -120,7 +124,8 @@ namespace std
{
// concept requirements
__glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
while (__n--) ++__i;
while (__n--)
++__i;
}
template<typename _BidirectionalIterator, typename _Distance>
@ -129,8 +134,8 @@ namespace std
bidirectional_iterator_tag)
{
// concept requirements
__glibcxx_function_requires(_BidirectionalIteratorConcept<_BidirectionalIterator>)
__glibcxx_function_requires(_BidirectionalIteratorConcept<
_BidirectionalIterator>)
if (__n > 0)
while (__n--) ++__i;
else
@ -143,7 +148,8 @@ namespace std
random_access_iterator_tag)
{
// concept requirements
__glibcxx_function_requires(_RandomAccessIteratorConcept<_RandomAccessIterator>)
__glibcxx_function_requires(_RandomAccessIteratorConcept<
_RandomAccessIterator>)
__i += __n;
}

8
libstdc++-v3/include/bits/stl_iterator_base_types.h
View File

@ -1,6 +1,6 @@
// Types used in iterator implementation -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 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
@ -82,9 +82,11 @@ namespace std
struct output_iterator_tag {};
/// Forward iterators support a superset of input iterator operations.
struct forward_iterator_tag : public input_iterator_tag {};
/// Bidirectional iterators support a superset of forward iterator operations.
/// Bidirectional iterators support a superset of forward iterator
/// operations.
struct bidirectional_iterator_tag : public forward_iterator_tag {};
/// Random-access iterators support a superset of bidirectional iterator operations.
/// Random-access iterators support a superset of bidirectional iterator
/// operations.
struct random_access_iterator_tag : public bidirectional_iterator_tag {};
//@}

80
libstdc++-v3/include/bits/stl_list.h
View File

@ -94,7 +94,6 @@ namespace __gnu_norm
_Tp _M_data; ///< User's data.
};
/**
* @brief A list::iterator.
*
@ -325,7 +324,6 @@ namespace __gnu_norm
}
};
/**
* @brief A standard container with linear time access to elements,
* and fixed time insertion/deletion at any point in the sequence.
@ -573,7 +571,8 @@ namespace __gnu_norm
/// Get a copy of the memory allocation object.
allocator_type
get_allocator() const { return _Base::get_allocator(); }
get_allocator() const
{ return _Base::get_allocator(); }
// iterators
/**
@ -581,7 +580,8 @@ namespace __gnu_norm
* %list. Iteration is done in ordinary element order.
*/
iterator
begin() { return this->_M_node._M_next; }
begin()
{ return this->_M_node._M_next; }
/**
* Returns a read-only (constant) iterator that points to the
@ -589,7 +589,8 @@ namespace __gnu_norm
* element order.
*/
const_iterator
begin() const { return this->_M_node._M_next; }
begin() const
{ return this->_M_node._M_next; }
/**
* Returns a read/write iterator that points one past the last
@ -605,7 +606,8 @@ namespace __gnu_norm
* element order.
*/
const_iterator
end() const { return &this->_M_node; }
end() const
{ return &this->_M_node; }
/**
* Returns a read/write reverse iterator that points to the last
@ -613,7 +615,8 @@ namespace __gnu_norm
* order.
*/
reverse_iterator
rbegin() { return reverse_iterator(end()); }
rbegin()
{ return reverse_iterator(end()); }
/**
* Returns a read-only (constant) reverse iterator that points to
@ -621,7 +624,8 @@ namespace __gnu_norm
* element order.
*/
const_reverse_iterator
rbegin() const { return const_reverse_iterator(end()); }
rbegin() const
{ return const_reverse_iterator(end()); }
/**
* Returns a read/write reverse iterator that points to one
@ -629,7 +633,8 @@ namespace __gnu_norm
* reverse element order.
*/
reverse_iterator
rend() { return reverse_iterator(begin()); }
rend()
{ return reverse_iterator(begin()); }
/**
* Returns a read-only (constant) reverse iterator that points to one
@ -646,15 +651,18 @@ namespace __gnu_norm
* end().)
*/
bool
empty() const { return this->_M_node._M_next == &this->_M_node; }
empty() const
{ return this->_M_node._M_next == &this->_M_node; }
/** Returns the number of elements in the %list. */
size_type
size() const { return std::distance(begin(), end()); }
size() const
{ return std::distance(begin(), end()); }
/** Returns the size() of the largest possible %list. */
size_type
max_size() const { return size_type(-1); }
max_size() const
{ return size_type(-1); }
/**
* @brief Resizes the %list to the specified number of elements.
@ -679,7 +687,8 @@ namespace __gnu_norm
* and new elements are default-constructed.
*/
void
resize(size_type __new_size) { this->resize(__new_size, value_type()); }
resize(size_type __new_size)
{ this->resize(__new_size, value_type()); }
// element access
/**
@ -687,28 +696,32 @@ namespace __gnu_norm
* element of the %list.
*/
reference
front() { return *begin(); }
front()
{ return *begin(); }
/**
* Returns a read-only (constant) reference to the data at the first
* element of the %list.
*/
const_reference
front() const { return *begin(); }
front() const
{ return *begin(); }
/**
* Returns a read/write reference to the data at the last element
* of the %list.
*/
reference
back() { return *(--end()); }
back()
{ return *(--end()); }
/**
* Returns a read-only (constant) reference to the data at the last
* element of the %list.
*/
const_reference
back() const { return *(--end()); }
back() const
{ return *(--end()); }
// [23.2.2.3] modifiers
/**
@ -722,7 +735,8 @@ namespace __gnu_norm
* references.
*/
void
push_front(const value_type& __x) { this->_M_insert(begin(), __x); }
push_front(const value_type& __x)
{ this->_M_insert(begin(), __x); }
/**
* @brief Removes first element.
@ -737,7 +751,8 @@ namespace __gnu_norm
* called.
*/
void
pop_front() { this->_M_erase(begin()); }
pop_front()
{ this->_M_erase(begin()); }
/**
* @brief Add data to the end of the %list.
@ -750,7 +765,8 @@ namespace __gnu_norm
* references.
*/
void
push_back(const value_type& __x) { this->_M_insert(end(), __x); }
push_back(const value_type& __x)
{ this->_M_insert(end(), __x); }
/**
* @brief Removes last element.
@ -764,7 +780,8 @@ namespace __gnu_norm
* is needed, it should be retrieved before pop_back() is called.
*/
void
pop_back() { this->_M_erase(this->_M_node._M_prev); }
pop_back()
{ this->_M_erase(this->_M_node._M_prev); }
/**
* @brief Inserts given value into %list before specified iterator.
@ -876,7 +893,8 @@ namespace __gnu_norm
* function.
*/
void
swap(list& __x) { _List_node_base::swap(this->_M_node,__x._M_node); }
swap(list& __x)
{ _List_node_base::swap(this->_M_node,__x._M_node); }
/**
* Erases all the elements. Note that this function only erases
@ -922,7 +940,8 @@ namespace __gnu_norm
{
iterator __j = __i;
++__j;
if (__position == __i || __position == __j) return;
if (__position == __i || __position == __j)
return;
this->_M_transfer(__position, __i, __j);
}
@ -1037,7 +1056,8 @@ namespace __gnu_norm
* Reverse the order of elements in the list in linear time.
*/
void
reverse() { this->_M_node.reverse(); }
reverse()
{ this->_M_node.reverse(); }
/**
* @brief Sort the elements.
@ -1118,16 +1138,13 @@ namespace __gnu_norm
// Moves the elements from [first,last) before position.
void
_M_transfer(iterator __position, iterator __first, iterator __last)
{
__position._M_node->transfer(__first._M_node,__last._M_node);
}
{ __position._M_node->transfer(__first._M_node,__last._M_node); }
// Inserts new element at position given and with value given.
void
_M_insert(iterator __position, const value_type& __x)
{
_Node* __tmp = _M_create_node(__x);
__tmp->hook(__position._M_node);
}
@ -1142,7 +1159,6 @@ namespace __gnu_norm
}
};
/**
* @brief List equality comparison.
* @param x A %list.
@ -1185,10 +1201,8 @@ namespace __gnu_norm
template<typename _Tp, typename _Alloc>
inline bool
operator<(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
{
return std::lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end());
}
{ return std::lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end()); }
/// Based on operator==
template<typename _Tp, typename _Alloc>

139
libstdc++-v3/include/bits/stl_map.h
View File

@ -1,6 +1,6 @@
// Map implementation -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 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
@ -92,7 +92,8 @@ namespace __gnu_norm
{
// concept requirements
__glibcxx_class_requires(_Tp, _SGIAssignableConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key,
_BinaryFunctionConcept)
public:
typedef _Key key_type;
@ -106,7 +107,10 @@ namespace __gnu_norm
friend class map<_Key,_Tp,_Compare,_Alloc>;
protected:
_Compare comp;
value_compare(_Compare __c) : comp(__c) {}
value_compare(_Compare __c)
: comp(__c) { }
public:
bool operator()(const value_type& __x, const value_type& __y) const
{ return comp(__x.first, __y.first); }
@ -134,14 +138,14 @@ namespace __gnu_norm
typedef typename _Rep_type::reverse_iterator reverse_iterator;
typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
// [23.3.1.1] construct/copy/destroy
// (get_allocator() is normally listed in this section, but seems to have
// been accidentally omitted in the printed standard)
/**
* @brief Default constructor creates no elements.
*/
map() : _M_t(_Compare(), allocator_type()) { }
map()
: _M_t(_Compare(), allocator_type()) { }
// for some reason this was made a separate function
/**
@ -217,15 +221,18 @@ namespace __gnu_norm
/// Get a copy of the memory allocation object.
allocator_type
get_allocator() const { return _M_t.get_allocator(); }
get_allocator() const
{ return _M_t.get_allocator(); }
// iterators
/**
* Returns a read/write iterator that points to the first pair in the %map.
* Returns a read/write iterator that points to the first pair in the
* %map.
* Iteration is done in ascending order according to the keys.
*/
iterator
begin() { return _M_t.begin(); }
begin()
{ return _M_t.begin(); }
/**
* Returns a read-only (constant) iterator that points to the first pair
@ -233,45 +240,52 @@ namespace __gnu_norm
* keys.
*/
const_iterator
begin() const { return _M_t.begin(); }
begin() const
{ return _M_t.begin(); }
/**
* Returns a read/write iterator that points one past the last pair in the
* %map. Iteration is done in ascending order according to the keys.
* Returns a read/write iterator that points one past the last pair in
* the %map. Iteration is done in ascending order according to the keys.
*/
iterator
end() { return _M_t.end(); }
end()
{ return _M_t.end(); }
/**
* Returns a read-only (constant) iterator that points one past the last
* pair in the %map. Iteration is done in ascending order according to the
* keys.
* pair in the %map. Iteration is done in ascending order according to
* the keys.
*/
const_iterator
end() const { return _M_t.end(); }
end() const
{ return _M_t.end(); }
/**
* Returns a read/write reverse iterator that points to the last pair in
* the %map. Iteration is done in descending order according to the keys.
* the %map. Iteration is done in descending order according to the
* keys.
*/
reverse_iterator
rbegin() { return _M_t.rbegin(); }
rbegin()
{ return _M_t.rbegin(); }
/**
* Returns a read-only (constant) reverse iterator that points to the last
* pair in the %map. Iteration is done in descending order according to
* the keys.
* Returns a read-only (constant) reverse iterator that points to the
* last pair in the %map. Iteration is done in descending order
* according to the keys.
*/
const_reverse_iterator
rbegin() const { return _M_t.rbegin(); }
rbegin() const
{ return _M_t.rbegin(); }
/**
* Returns a read/write reverse iterator that points to one before the
* first pair in the %map. Iteration is done in descending order according
* to the keys.
* first pair in the %map. Iteration is done in descending order
* according to the keys.
*/
reverse_iterator
rend() { return _M_t.rend(); }
rend()
{ return _M_t.rend(); }
/**
* Returns a read-only (constant) reverse iterator that points to one
@ -279,20 +293,26 @@ namespace __gnu_norm
* order according to the keys.
*/
const_reverse_iterator
rend() const { return _M_t.rend(); }
rend() const
{ return _M_t.rend(); }
// capacity
/** Returns true if the %map is empty. (Thus begin() would equal end().) */
/** Returns true if the %map is empty. (Thus begin() would equal
* end().)
*/
bool
empty() const { return _M_t.empty(); }
empty() const
{ return _M_t.empty(); }
/** Returns the size of the %map. */
size_type
size() const { return _M_t.size(); }
size() const
{ return _M_t.size(); }
/** Returns the maximum size of the %map. */
size_type
max_size() const { return _M_t.max_size(); }
max_size() const
{ return _M_t.max_size(); }
// [23.3.1.2] element access
/**
@ -380,13 +400,14 @@ namespace __gnu_norm
* @brief Erases an element from a %map.
* @param position An iterator pointing to the element to be erased.
*
* This function erases an element, pointed to by the given iterator, from
* a %map. Note that this function only erases the element, and that if
* the element is itself a pointer, the pointed-to memory is not touched
* in any way. Managing the pointer is the user's responsibilty.
* This function erases an element, pointed to by the given iterator,
* from a %map. Note that this function only erases the element, and
* that if the element is itself a pointer, the pointed-to memory is not
* touched in any way. Managing the pointer is the user's responsibilty.
*/
void
erase(iterator __position) { _M_t.erase(__position); }
erase(iterator __position)
{ _M_t.erase(__position); }
/**
* @brief Erases elements according to the provided key.
@ -400,11 +421,13 @@ namespace __gnu_norm
* in any way. Managing the pointer is the user's responsibilty.
*/
size_type
erase(const key_type& __x) { return _M_t.erase(__x); }
erase(const key_type& __x)
{ return _M_t.erase(__x); }
/**
* @brief Erases a [first,last) range of elements from a %map.
* @param first Iterator pointing to the start of the range to be erased.
* @param first Iterator pointing to the start of the range to be
* erased.
* @param last Iterator pointing to the end of the range to be erased.
*
* This function erases a sequence of elements from a %map.
@ -413,7 +436,8 @@ namespace __gnu_norm
* in any way. Managing the pointer is the user's responsibilty.
*/
void
erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); }
erase(iterator __first, iterator __last)
{ _M_t.erase(__first, __last); }
/**
* @brief Swaps data with another %map.
@ -427,7 +451,8 @@ namespace __gnu_norm
* std::swap(m1,m2) will feed to this function.
*/
void
swap(map& __x) { _M_t.swap(__x._M_t); }
swap(map& __x)
{ _M_t.swap(__x._M_t); }
/**
* Erases all elements in a %map. Note that this function only erases
@ -436,21 +461,25 @@ namespace __gnu_norm
* the user's responsibilty.
*/
void
clear() { _M_t.clear(); }
clear()
{ _M_t.clear(); }
// observers
/**
* Returns the key comparison object out of which the %map was constructed.
* Returns the key comparison object out of which the %map was
* constructed.
*/
key_compare
key_comp() const { return _M_t.key_comp(); }
key_comp() const
{ return _M_t.key_comp(); }
/**
* Returns a value comparison object, built from the key comparison
* object out of which the %map was constructed.
*/
value_compare
value_comp() const { return value_compare(_M_t.key_comp()); }
value_comp() const
{ return value_compare(_M_t.key_comp()); }
// [23.3.1.3] map operations
/**
@ -465,7 +494,8 @@ namespace __gnu_norm
* past-the-end ( @c end() ) iterator.
*/
iterator
find(const key_type& __x) { return _M_t.find(__x); }
find(const key_type& __x)
{ return _M_t.find(__x); }
/**
* @brief Tries to locate an element in a %map.
@ -474,12 +504,13 @@ namespace __gnu_norm
* element, or end() if not found.
*
* This function takes a key and tries to locate the element with which
* the key matches. If successful the function returns a constant iterator
* pointing to the sought after %pair. If unsuccessful it returns the
* past-the-end ( @c end() ) iterator.
* the key matches. If successful the function returns a constant
* iterator pointing to the sought after %pair. If unsuccessful it
* returns the past-the-end ( @c end() ) iterator.
*/
const_iterator
find(const key_type& __x) const { return _M_t.find(__x); }
find(const key_type& __x) const
{ return _M_t.find(__x); }
/**
* @brief Finds the number of elements with given key.
@ -505,7 +536,8 @@ namespace __gnu_norm
* or end() if no such element exists.
*/
iterator
lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); }
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
/**
* @brief Finds the beginning of a subsequence matching given key.
@ -519,7 +551,8 @@ namespace __gnu_norm
* or end() if no such element exists.
*/
const_iterator
lower_bound(const key_type& __x) const { return _M_t.lower_bound(__x); }
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
/**
* @brief Finds the end of a subsequence matching given key.
@ -528,7 +561,8 @@ namespace __gnu_norm
* greater than key, or end().
*/
iterator
upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); }
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
/**
* @brief Finds the end of a subsequence matching given key.
@ -562,8 +596,8 @@ namespace __gnu_norm
/**
* @brief Finds a subsequence matching given key.
* @param x Key of (key, value) pairs to be located.
* @return Pair of read-only (constant) iterators that possibly points to
* the subsequence matching given key.
* @return Pair of read-only (constant) iterators that possibly points
* to the subsequence matching given key.
*
* This function is equivalent to
* @code
@ -586,7 +620,6 @@ namespace __gnu_norm
const map<_K1,_T1,_C1,_A1>&);
};
/**
* @brief Map equality comparison.
* @param x A %map.

187
libstdc++-v3/include/bits/stl_multimap.h
View File

@ -1,6 +1,6 @@
// Multimap implementation -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 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
@ -106,7 +106,8 @@ namespace __gnu_norm
{
// concept requirements
__glibcxx_class_requires(_Tp, _SGIAssignableConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key,
_BinaryFunctionConcept)
public:
typedef _Key key_type;
@ -120,7 +121,10 @@ namespace __gnu_norm
friend class multimap<_Key,_Tp,_Compare,_Alloc>;
protected:
_Compare comp;
value_compare(_Compare __c) : comp(__c) {}
value_compare(_Compare __c)
: comp(__c) { }
public:
bool operator()(const value_type& __x, const value_type& __y) const
{ return comp(__x.first, __y.first); }
@ -154,14 +158,16 @@ namespace __gnu_norm
/**
* @brief Default constructor creates no elements.
*/
multimap() : _M_t(_Compare(), allocator_type()) { }
multimap()
: _M_t(_Compare(), allocator_type()) { }
// for some reason this was made a separate function
/**
* @brief Default constructor creates no elements.
*/
explicit
multimap(const _Compare& __comp, const allocator_type& __a = allocator_type())
multimap(const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a) { }
/**
@ -231,30 +237,36 @@ namespace __gnu_norm
/// Get a copy of the memory allocation object.
allocator_type
get_allocator() const { return _M_t.get_allocator(); }
get_allocator() const
{ return _M_t.get_allocator(); }
// iterators
/**
* Returns a read/write iterator that points to the first pair in the
* %multimap. Iteration is done in ascending order according to the keys.
* %multimap. Iteration is done in ascending order according to the
* keys.
*/
iterator
begin() { return _M_t.begin(); }
begin()
{ return _M_t.begin(); }
/**
* Returns a read-only (constant) iterator that points to the first pair
* in the %multimap. Iteration is done in ascending order according to the
* keys.
* in the %multimap. Iteration is done in ascending order according to
* the keys.
*/
const_iterator
begin() const { return _M_t.begin(); }
begin() const
{ return _M_t.begin(); }
/**
* Returns a read/write iterator that points one past the last pair in the
* %multimap. Iteration is done in ascending order according to the keys.
* Returns a read/write iterator that points one past the last pair in
* the %multimap. Iteration is done in ascending order according to the
* keys.
*/
iterator
end() { return _M_t.end(); }
end()
{ return _M_t.end(); }
/**
* Returns a read-only (constant) iterator that points one past the last
@ -262,7 +274,8 @@ namespace __gnu_norm
* to the keys.
*/
const_iterator
end() const { return _M_t.end(); }
end() const
{ return _M_t.end(); }
/**
* Returns a read/write reverse iterator that points to the last pair in
@ -270,15 +283,17 @@ namespace __gnu_norm
* keys.
*/
reverse_iterator
rbegin() { return _M_t.rbegin(); }
rbegin()
{ return _M_t.rbegin(); }
/**
* Returns a read-only (constant) reverse iterator that points to the last
* pair in the %multimap. Iteration is done in descending order according
* to the keys.
* Returns a read-only (constant) reverse iterator that points to the
* last pair in the %multimap. Iteration is done in descending order
* according to the keys.
*/
const_reverse_iterator
rbegin() const { return _M_t.rbegin(); }
rbegin() const
{ return _M_t.rbegin(); }
/**
* Returns a read/write reverse iterator that points to one before the
@ -286,56 +301,62 @@ namespace __gnu_norm
* according to the keys.
*/
reverse_iterator
rend() { return _M_t.rend(); }
rend()
{ return _M_t.rend(); }
/**
* Returns a read-only (constant) reverse iterator that points to one
* before the first pair in the %multimap. Iteration is done in descending
* order according to the keys.
* before the first pair in the %multimap. Iteration is done in
* descending order according to the keys.
*/
const_reverse_iterator
rend() const { return _M_t.rend(); }
rend() const
{ return _M_t.rend(); }
// capacity
/** Returns true if the %multimap is empty. */
bool
empty() const { return _M_t.empty(); }
empty() const
{ return _M_t.empty(); }
/** Returns the size of the %multimap. */
size_type
size() const { return _M_t.size(); }
size() const
{ return _M_t.size(); }
/** Returns the maximum size of the %multimap. */
size_type
max_size() const { return _M_t.max_size(); }
max_size() const
{ return _M_t.max_size(); }
// modifiers
/**
* @brief Inserts a std::pair into the %multimap.
* @param x Pair to be inserted (see std::make_pair for easy creation of
* pairs).
* @param x Pair to be inserted (see std::make_pair for easy creation
* of pairs).
* @return An iterator that points to the inserted (key,value) pair.
*
* This function inserts a (key, value) pair into the %multimap. Contrary
* to a std::map the %multimap does not rely on unique keys and thus
* multiple pairs with the same key can be inserted.
* This function inserts a (key, value) pair into the %multimap.
* Contrary to a std::map the %multimap does not rely on unique keys and
* thus multiple pairs with the same key can be inserted.
*
* Insertion requires logarithmic time.
*/
iterator
insert(const value_type& __x) { return _M_t.insert_equal(__x); }
insert(const value_type& __x)
{ return _M_t.insert_equal(__x); }
/**
* @brief Inserts a std::pair into the %multimap.
* @param position An iterator that serves as a hint as to where the
* pair should be inserted.
* @param x Pair to be inserted (see std::make_pair for easy creation of
* pairs).
* @param x Pair to be inserted (see std::make_pair for easy creation
* of pairs).
* @return An iterator that points to the inserted (key,value) pair.
*
* This function inserts a (key, value) pair into the %multimap. Contrary
* to a std::map the %multimap does not rely on unique keys and thus
* multiple pairs with the same key can be inserted.
* This function inserts a (key, value) pair into the %multimap.
* Contrary to a std::map the %multimap does not rely on unique keys and
* thus multiple pairs with the same key can be inserted.
* Note that the first parameter is only a hint and can potentially
* improve the performance of the insertion process. A bad hint would
* cause no gains in efficiency.
@ -366,13 +387,15 @@ namespace __gnu_norm
* @brief Erases an element from a %multimap.
* @param position An iterator pointing to the element to be erased.
*
* This function erases an element, pointed to by the given iterator, from
* a %multimap. Note that this function only erases the element, and that
* if the element is itself a pointer, the pointed-to memory is not
* touched in any way. Managing the pointer is the user's responsibilty.
* This function erases an element, pointed to by the given iterator,
* from a %multimap. Note that this function only erases the element,
* and that if the element is itself a pointer, the pointed-to memory is
* not touched in any way. Managing the pointer is the user's
* responsibilty.
*/
void
erase(iterator __position) { _M_t.erase(__position); }
erase(iterator __position)
{ _M_t.erase(__position); }
/**
* @brief Erases elements according to the provided key.
@ -386,11 +409,13 @@ namespace __gnu_norm
* in any way. Managing the pointer is the user's responsibilty.
*/
size_type
erase(const key_type& __x) { return _M_t.erase(__x); }
erase(const key_type& __x)
{ return _M_t.erase(__x); }
/**
* @brief Erases a [first,last) range of elements from a %multimap.
* @param first Iterator pointing to the start of the range to be erased.
* @param first Iterator pointing to the start of the range to be
* erased.
* @param last Iterator pointing to the end of the range to be erased.
*
* This function erases a sequence of elements from a %multimap.
@ -399,7 +424,8 @@ namespace __gnu_norm
* touched in any way. Managing the pointer is the user's responsibilty.
*/
void
erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); }
erase(iterator __first, iterator __last)
{ _M_t.erase(__first, __last); }
/**
* @brief Swaps data with another %multimap.
@ -413,16 +439,18 @@ namespace __gnu_norm
* std::swap(m1,m2) will feed to this function.
*/
void
swap(multimap& __x) { _M_t.swap(__x._M_t); }
swap(multimap& __x)
{ _M_t.swap(__x._M_t); }
/**
* Erases all elements in a %multimap. Note that this function only erases
* the elements, and that if the elements themselves are pointers, the
* pointed-to memory is not touched in any way. Managing the pointer is
* the user's responsibilty.
* Erases all elements in a %multimap. Note that this function only
* erases the elements, and that if the elements themselves are pointers,
* the pointed-to memory is not touched in any way. Managing the pointer
* is the user's responsibilty.
*/
void
clear() { _M_t.clear(); }
clear()
{ _M_t.clear(); }
// observers
/**
@ -430,14 +458,16 @@ namespace __gnu_norm
* was constructed.
*/
key_compare
key_comp() const { return _M_t.key_comp(); }
key_comp() const
{ return _M_t.key_comp(); }
/**
* Returns a value comparison object, built from the key comparison
* object out of which the %multimap was constructed.
*/
value_compare
value_comp() const { return value_compare(_M_t.key_comp()); }
value_comp() const
{ return value_compare(_M_t.key_comp()); }
// multimap operations
/**
@ -452,7 +482,8 @@ namespace __gnu_norm
* past-the-end ( @c end() ) iterator.
*/
iterator
find(const key_type& __x) { return _M_t.find(__x); }
find(const key_type& __x)
{ return _M_t.find(__x); }
/**
* @brief Tries to locate an element in a %multimap.
@ -461,12 +492,13 @@ namespace __gnu_norm
* element, or end() if not found.
*
* This function takes a key and tries to locate the element with which
* the key matches. If successful the function returns a constant iterator
* pointing to the sought after %pair. If unsuccessful it returns the
* past-the-end ( @c end() ) iterator.
* the key matches. If successful the function returns a constant
* iterator pointing to the sought after %pair. If unsuccessful it
* returns the past-the-end ( @c end() ) iterator.
*/
const_iterator
find(const key_type& __x) const { return _M_t.find(__x); }
find(const key_type& __x) const
{ return _M_t.find(__x); }
/**
* @brief Finds the number of elements with given key.
@ -474,7 +506,8 @@ namespace __gnu_norm
* @return Number of elements with specified key.
*/
size_type
count(const key_type& __x) const { return _M_t.count(__x); }
count(const key_type& __x) const
{ return _M_t.count(__x); }
/**
* @brief Finds the beginning of a subsequence matching given key.
@ -488,7 +521,8 @@ namespace __gnu_norm
* or end() if no such element exists.
*/
iterator
lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); }
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
/**
* @brief Finds the beginning of a subsequence matching given key.
@ -502,7 +536,8 @@ namespace __gnu_norm
* end().
*/
const_iterator
lower_bound(const key_type& __x) const { return _M_t.lower_bound(__x); }
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
/**
* @brief Finds the end of a subsequence matching given key.
@ -511,7 +546,8 @@ namespace __gnu_norm
* greater than key, or end().
*/
iterator
upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); }
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
/**
* @brief Finds the end of a subsequence matching given key.
@ -520,7 +556,8 @@ namespace __gnu_norm
* greater than key, or end().
*/
const_iterator
upper_bound(const key_type& __x) const { return _M_t.upper_bound(__x); }
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
/**
* @brief Finds a subsequence matching given key.
@ -536,13 +573,14 @@ namespace __gnu_norm
* (but is faster than making the calls separately).
*/
pair<iterator,iterator>
equal_range(const key_type& __x) { return _M_t.equal_range(__x); }
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
/**
* @brief Finds a subsequence matching given key.
* @param x Key of (key, value) pairs to be located.
* @return Pair of read-only (constant) iterators that possibly points to
* the subsequence matching given key.
* @return Pair of read-only (constant) iterators that possibly points
* to the subsequence matching given key.
*
* This function is equivalent to
* @code
@ -552,17 +590,20 @@ namespace __gnu_norm
* (but is faster than making the calls separately).
*/
pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const { return _M_t.equal_range(__x); }
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
template <typename _K1, typename _T1, typename _C1, typename _A1>
friend bool operator== (const multimap<_K1,_T1,_C1,_A1>&,
friend bool
operator== (const multimap<_K1,_T1,_C1,_A1>&,
const multimap<_K1,_T1,_C1,_A1>&);
template <typename _K1, typename _T1, typename _C1, typename _A1>
friend bool operator< (const multimap<_K1,_T1,_C1,_A1>&,
friend bool
operator< (const multimap<_K1,_T1,_C1,_A1>&,
const multimap<_K1,_T1,_C1,_A1>&);
};
/**
* @brief Multimap equality comparison.
* @param x A %multimap.
@ -577,9 +618,7 @@ namespace __gnu_norm
inline bool
operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
const multimap<_Key,_Tp,_Compare,_Alloc>& __y)
{
return __x._M_t == __y._M_t;
}
{ return __x._M_t == __y._M_t; }
/**
* @brief Multimap ordering relation.

178
libstdc++-v3/include/bits/stl_multiset.h
View File

@ -66,18 +66,17 @@
namespace __gnu_norm
{
// Forward declaration of operators < and ==, needed for friend declaration.
template <class _Key, class _Compare = less<_Key>,
// Forward declaration of operators < and ==, needed for friend declaration.
template <class _Key, class _Compare = less<_Key>,
class _Alloc = allocator<_Key> >
class multiset;
class multiset;
template <class _Key, class _Compare, class _Alloc>
inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x,
template <class _Key, class _Compare, class _Alloc>
inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y);
template <class _Key, class _Compare, class _Alloc>
inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
template <class _Key, class _Compare, class _Alloc>
inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
const multiset<_Key,_Compare,_Alloc>& __y);
/**
@ -105,12 +104,11 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
{
// concept requirements
__glibcxx_class_requires(_Key, _SGIAssignableConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key,
_BinaryFunctionConcept)
public:
// typedefs:
typedef _Key key_type;
typedef _Key value_type;
typedef _Compare key_compare;
@ -141,10 +139,12 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
/**
* @brief Default constructor creates no elements.
*/
multiset() : _M_t(_Compare(), allocator_type()) {}
multiset()
: _M_t(_Compare(), allocator_type()) { }
explicit multiset(const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a) {}
: _M_t(__comp, __a) { }
/**
* @brief Builds a %multiset from a range.
@ -175,7 +175,8 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
multiset(_InputIterator __first, _InputIterator __last,
const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
: _M_t(__comp, __a)
{ _M_t.insert_equal(__first, __last); }
/**
* @brief %Multiset copy constructor.
@ -184,7 +185,8 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* The newly-created %multiset uses a copy of the allocation object used
* by @a x.
*/
multiset(const multiset<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
multiset(const multiset<_Key,_Compare,_Alloc>& __x)
: _M_t(__x._M_t) { }
/**
* @brief %Multiset assignment operator.
@ -194,7 +196,8 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* the allocator object is not copied.
*/
multiset<_Key,_Compare,_Alloc>&
operator=(const multiset<_Key,_Compare,_Alloc>& __x) {
operator=(const multiset<_Key,_Compare,_Alloc>& __x)
{
_M_t = __x._M_t;
return *this;
}
@ -202,48 +205,68 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
// accessors:
/// Returns the comparison object.
key_compare key_comp() const { return _M_t.key_comp(); }
key_compare
key_comp() const
{ return _M_t.key_comp(); }
/// Returns the comparison object.
value_compare value_comp() const { return _M_t.key_comp(); }
value_compare
value_comp() const
{ return _M_t.key_comp(); }
/// Returns the memory allocation object.
allocator_type get_allocator() const { return _M_t.get_allocator(); }
allocator_type
get_allocator() const
{ return _M_t.get_allocator(); }
/**
* Returns a read/write iterator that points to the first element in the
* %multiset. Iteration is done in ascending order according to the
* keys.
*/
iterator begin() const { return _M_t.begin(); }
iterator
begin() const
{ return _M_t.begin(); }
/**
* Returns a read/write iterator that points one past the last element in
* the %multiset. Iteration is done in ascending order according to the
* keys.
*/
iterator end() const { return _M_t.end(); }
iterator
end() const
{ return _M_t.end(); }
/**
* Returns a read/write reverse iterator that points to the last element
* in the %multiset. Iteration is done in descending order according to
* the keys.
*/
reverse_iterator rbegin() const { return _M_t.rbegin(); }
reverse_iterator
rbegin() const
{ return _M_t.rbegin(); }
/**
* Returns a read/write reverse iterator that points to the last element
* in the %multiset. Iteration is done in descending order according to
* the keys.
*/
reverse_iterator rend() const { return _M_t.rend(); }
reverse_iterator
rend() const
{ return _M_t.rend(); }
/// Returns true if the %set is empty.
bool empty() const { return _M_t.empty(); }
bool
empty() const
{ return _M_t.empty(); }
/// Returns the size of the %set.
size_type size() const { return _M_t.size(); }
size_type
size() const
{ return _M_t.size(); }
/// Returns the maximum size of the %set.
size_type max_size() const { return _M_t.max_size(); }
size_type
max_size() const
{ return _M_t.max_size(); }
/**
* @brief Swaps data with another %multiset.
@ -256,7 +279,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* Note that the global std::swap() function is specialized such that
* std::swap(s1,s2) will feed to this function.
*/
void swap(multiset<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
void
swap(multiset<_Key,_Compare,_Alloc>& __x)
{ _M_t.swap(__x._M_t); }
// insert/erase
/**
@ -270,9 +295,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
*
* Insertion requires logarithmic time.
*/
iterator insert(const value_type& __x) {
return _M_t.insert_equal(__x);
}
iterator
insert(const value_type& __x)
{ return _M_t.insert_equal(__x); }
/**
* @brief Inserts an element into the %multiset.
@ -294,7 +319,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
*
* Insertion requires logarithmic time (if the hint is not taken).
*/
iterator insert(iterator __position, const value_type& __x) {
iterator
insert(iterator __position, const value_type& __x)
{
typedef typename _Rep_type::iterator _Rep_iterator;
return _M_t.insert_equal((_Rep_iterator&)__position, __x);
}
@ -308,9 +335,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* Complexity similar to that of the range constructor.
*/
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last) {
_M_t.insert_equal(__first, __last);
}
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t.insert_equal(__first, __last); }
/**
* @brief Erases an element from a %multiset.
@ -322,7 +349,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* not touched in any way. Managing the pointer is the user's
* responsibilty.
*/
void erase(iterator __position) {
void
erase(iterator __position)
{
typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__position);
}
@ -338,13 +367,14 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* the element is itself a pointer, the pointed-to memory is not touched
* in any way. Managing the pointer is the user's responsibilty.
*/
size_type erase(const key_type& __x) {
return _M_t.erase(__x);
}
size_type
erase(const key_type& __x)
{ return _M_t.erase(__x); }
/**
* @brief Erases a [first,last) range of elements from a %multiset.
* @param first Iterator pointing to the start of the range to be erased.
* @param first Iterator pointing to the start of the range to be
* erased.
* @param last Iterator pointing to the end of the range to be erased.
*
* This function erases a sequence of elements from a %multiset.
@ -352,7 +382,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* the elements themselves are pointers, the pointed-to memory is not
* touched in any way. Managing the pointer is the user's responsibilty.
*/
void erase(iterator __first, iterator __last) {
void
erase(iterator __first, iterator __last)
{
typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
}
@ -363,7 +395,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* the pointed-to memory is not touched in any way. Managing the pointer
* is the user's responsibilty.
*/
void clear() { _M_t.clear(); }
void
clear()
{ _M_t.clear(); }
// multiset operations:
@ -372,7 +406,9 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* @param x Key of elements to be located.
* @return Number of elements with specified key.
*/
size_type count(const key_type& __x) const { return _M_t.count(__x); }
size_type
count(const key_type& __x) const
{ return _M_t.count(__x); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 214. set::find() missing const overload
@ -388,8 +424,13 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* pointing to the sought after element. If unsuccessful it returns the
* past-the-end ( @c end() ) iterator.
*/
iterator find(const key_type& __x) { return _M_t.find(__x); }
const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); }
//@}
//@{
@ -404,12 +445,13 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* pointing to the first element that has a greater value than given key
* or end() if no such element exists.
*/
iterator lower_bound(const key_type& __x) {
return _M_t.lower_bound(__x);
}
const_iterator lower_bound(const key_type& __x) const {
return _M_t.lower_bound(__x);
}
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
const_iterator
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
//@}
//@{
@ -419,12 +461,13 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* @return Iterator pointing to the first element
* greater than key, or end().
*/
iterator upper_bound(const key_type& __x) {
return _M_t.upper_bound(__x);
}
const_iterator upper_bound(const key_type& __x) const {
return _M_t.upper_bound(__x);
}
iterator
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
const_iterator
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
//@}
//@{
@ -443,18 +486,22 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
*
* This function probably only makes sense for multisets.
*/
pair<iterator,iterator> equal_range(const key_type& __x) {
return _M_t.equal_range(__x);
}
pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
return _M_t.equal_range(__x);
}
pair<iterator,iterator>
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
template <class _K1, class _C1, class _A1>
friend bool operator== (const multiset<_K1,_C1,_A1>&,
friend bool
operator== (const multiset<_K1,_C1,_A1>&,
const multiset<_K1,_C1,_A1>&);
template <class _K1, class _C1, class _A1>
friend bool operator< (const multiset<_K1,_C1,_A1>&,
friend bool
operator< (const multiset<_K1,_C1,_A1>&,
const multiset<_K1,_C1,_A1>&);
};
@ -464,7 +511,8 @@ inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
* @param y A %multiset of the same type as @a x.
* @return True iff the size and elements of the multisets are equal.
*
* This is an equivalence relation. It is linear in the size of the multisets.
* This is an equivalence relation. It is linear in the size of the
* multisets.
* Multisets are considered equivalent if their sizes are equal, and if
* corresponding elements compare equal.
*/

50
libstdc++-v3/include/bits/stl_relops.h
View File

@ -1,6 +1,6 @@
// std::rel_ops implementation -*- C++ -*-
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// Copyright (C) 2001, 2002, 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
@ -79,57 +79,57 @@ namespace std
* @brief The generated relational operators are sequestered here.
*/
/**
/**
* @brief Defines @c != for arbitrary types, in terms of @c ==.
* @param x A thing.
* @param y Another thing.
* @return x != y
*
* This function uses @c == to determine its result.
*/
template <class _Tp>
inline bool operator!=(const _Tp& __x, const _Tp& __y) {
return !(__x == __y);
}
*/
template <class _Tp>
inline bool
operator!=(const _Tp& __x, const _Tp& __y)
{ return !(__x == __y); }
/**
/**
* @brief Defines @c > for arbitrary types, in terms of @c <.
* @param x A thing.
* @param y Another thing.
* @return x > y
*
* This function uses @c < to determine its result.
*/
template <class _Tp>
inline bool operator>(const _Tp& __x, const _Tp& __y) {
return __y < __x;
}
*/
template <class _Tp>
inline bool
operator>(const _Tp& __x, const _Tp& __y)
{ return __y < __x; }
/**
/**
* @brief Defines @c <= for arbitrary types, in terms of @c <.
* @param x A thing.
* @param y Another thing.
* @return x <= y
*
* This function uses @c < to determine its result.
*/
template <class _Tp>
inline bool operator<=(const _Tp& __x, const _Tp& __y) {
return !(__y < __x);
}
*/
template <class _Tp>
inline bool
operator<=(const _Tp& __x, const _Tp& __y)
{ return !(__y < __x); }
/**
/**
* @brief Defines @c >= for arbitrary types, in terms of @c <.
* @param x A thing.
* @param y Another thing.
* @return x >= y
*
* This function uses @c < to determine its result.
*/
template <class _Tp>
inline bool operator>=(const _Tp& __x, const _Tp& __y) {
return !(__x < __y);
}
*/
template <class _Tp>
inline bool
operator>=(const _Tp& __x, const _Tp& __y)
{ return !(__x < __y); }
} // namespace rel_ops
} // namespace std

140
libstdc++-v3/include/bits/stl_set.h
View File

@ -108,7 +108,8 @@ namespace __gnu_norm
{
// concept requirements
__glibcxx_class_requires(_Key, _SGIAssignableConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key,
_BinaryFunctionConcept)
public:
// typedefs:
@ -142,7 +143,8 @@ namespace __gnu_norm
// allocation/deallocation
/// Default constructor creates no elements.
set() : _M_t(_Compare(), allocator_type()) {}
set()
: _M_t(_Compare(), allocator_type()) {}
/**
* @brief Default constructor creates no elements.
@ -180,7 +182,8 @@ namespace __gnu_norm
* otherwise (where N is distance(first,last)).
*/
template<class _InputIterator>
set(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
set(_InputIterator __first, _InputIterator __last,
const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a)
{ _M_t.insert_unique(__first, __last); }
@ -192,7 +195,8 @@ namespace __gnu_norm
* The newly-created %set uses a copy of the allocation object used
* by @a x.
*/
set(const set<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
set(const set<_Key,_Compare,_Alloc>& __x)
: _M_t(__x._M_t) { }
/**
* @brief Set assignment operator.
@ -201,7 +205,8 @@ namespace __gnu_norm
* All the elements of @a x are copied, but unlike the copy constructor,
* the allocator object is not copied.
*/
set<_Key,_Compare,_Alloc>& operator=(const set<_Key, _Compare, _Alloc>& __x)
set<_Key,_Compare,_Alloc>&
operator=(const set<_Key, _Compare, _Alloc>& __x)
{
_M_t = __x._M_t;
return *this;
@ -210,45 +215,66 @@ namespace __gnu_norm
// accessors:
/// Returns the comparison object with which the %set was constructed.
key_compare key_comp() const { return _M_t.key_comp(); }
key_compare
key_comp() const
{ return _M_t.key_comp(); }
/// Returns the comparison object with which the %set was constructed.
value_compare value_comp() const { return _M_t.key_comp(); }
value_compare
value_comp() const
{ return _M_t.key_comp(); }
/// Returns the allocator object with which the %set was constructed.
allocator_type get_allocator() const { return _M_t.get_allocator(); }
allocator_type
get_allocator() const
{ return _M_t.get_allocator(); }
/**
* Returns a read/write iterator that points to the first element in the
* %set. Iteration is done in ascending order according to the keys.
*/
iterator begin() const { return _M_t.begin(); }
iterator
begin() const
{ return _M_t.begin(); }
/**
* Returns a read/write iterator that points one past the last element in
* the %set. Iteration is done in ascending order according to the keys.
*/
iterator end() const { return _M_t.end(); }
iterator
end() const
{ return _M_t.end(); }
/**
* Returns a read/write reverse iterator that points to the last element in
* the %set. Iteration is done in descending order according to the keys.
* Returns a read/write reverse iterator that points to the last element
* in the %set. Iteration is done in descending order according to the
* keys.
*/
reverse_iterator rbegin() const { return _M_t.rbegin(); }
reverse_iterator
rbegin() const
{ return _M_t.rbegin(); }
/**
* Returns a read-only (constant) reverse iterator that points to the last
* pair in the %map. Iteration is done in descending order according to
* the keys.
* Returns a read-only (constant) reverse iterator that points to the
* last pair in the %map. Iteration is done in descending order
* according to the keys.
*/
reverse_iterator rend() const { return _M_t.rend(); }
reverse_iterator
rend() const
{ return _M_t.rend(); }
/// Returns true if the %set is empty.
bool empty() const { return _M_t.empty(); }
bool
empty() const
{ return _M_t.empty(); }
/// Returns the size of the %set.
size_type size() const { return _M_t.size(); }
size_type
size() const
{ return _M_t.size(); }
/// Returns the maximum size of the %set.
size_type max_size() const { return _M_t.max_size(); }
size_type
max_size() const
{ return _M_t.max_size(); }
/**
* @brief Swaps data with another %set.
@ -261,15 +287,17 @@ namespace __gnu_norm
* Note that the global std::swap() function is specialized such that
* std::swap(s1,s2) will feed to this function.
*/
void swap(set<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
void
swap(set<_Key,_Compare,_Alloc>& __x)
{ _M_t.swap(__x._M_t); }
// insert/erase
/**
* @brief Attempts to insert an element into the %set.
* @param x Element to be inserted.
* @return A pair, of which the first element is an iterator that points
* to the possibly inserted element, and the second is a bool that
* is true if the element was actually inserted.
* to the possibly inserted element, and the second is a bool
* that is true if the element was actually inserted.
*
* This function attempts to insert an element into the %set. A %set
* relies on unique keys and thus an element is only inserted if it is
@ -277,7 +305,8 @@ namespace __gnu_norm
*
* Insertion requires logarithmic time.
*/
pair<iterator,bool> insert(const value_type& __x)
pair<iterator,bool>
insert(const value_type& __x)
{
pair<typename _Rep_type::iterator, bool> __p = _M_t.insert_unique(__x);
return pair<iterator, bool>(__p.first, __p.second);
@ -302,7 +331,8 @@ namespace __gnu_norm
*
* Insertion requires logarithmic time (if the hint is not taken).
*/
iterator insert(iterator __position, const value_type& __x)
iterator
insert(iterator __position, const value_type& __x)
{
typedef typename _Rep_type::iterator _Rep_iterator;
return _M_t.insert_unique((_Rep_iterator&)__position, __x);
@ -317,7 +347,8 @@ namespace __gnu_norm
* Complexity similar to that of the range constructor.
*/
template<class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last)
void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t.insert_unique(__first, __last); }
/**
@ -329,7 +360,8 @@ namespace __gnu_norm
* that if the element is itself a pointer, the pointed-to memory is not
* touched in any way. Managing the pointer is the user's responsibilty.
*/
void erase(iterator __position)
void
erase(iterator __position)
{
typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__position);
@ -346,11 +378,13 @@ namespace __gnu_norm
* the element is itself a pointer, the pointed-to memory is not touched
* in any way. Managing the pointer is the user's responsibilty.
*/
size_type erase(const key_type& __x) { return _M_t.erase(__x); }
size_type
erase(const key_type& __x) { return _M_t.erase(__x); }
/**
* @brief Erases a [first,last) range of elements from a %set.
* @param first Iterator pointing to the start of the range to be erased.
* @param first Iterator pointing to the start of the range to be
* erased.
* @param last Iterator pointing to the end of the range to be erased.
*
* This function erases a sequence of elements from a %set.
@ -358,7 +392,8 @@ namespace __gnu_norm
* the element is itself a pointer, the pointed-to memory is not touched
* in any way. Managing the pointer is the user's responsibilty.
*/
void erase(iterator __first, iterator __last)
void
erase(iterator __first, iterator __last)
{
typedef typename _Rep_type::iterator _Rep_iterator;
_M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
@ -370,7 +405,9 @@ namespace __gnu_norm
* pointed-to memory is not touched in any way. Managing the pointer is
* the user's responsibilty.
*/
void clear() { _M_t.clear(); }
void
clear()
{ _M_t.clear(); }
// set operations:
@ -382,7 +419,8 @@ namespace __gnu_norm
* This function only makes sense for multisets; for set the result will
* either be 0 (not present) or 1 (present).
*/
size_type count(const key_type& __x) const
size_type
count(const key_type& __x) const
{ return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
@ -399,8 +437,13 @@ namespace __gnu_norm
* pointing to the sought after element. If unsuccessful it returns the
* past-the-end ( @c end() ) iterator.
*/
iterator find(const key_type& __x) { return _M_t.find(__x); }
const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
iterator
find(const key_type& __x)
{ return _M_t.find(__x); }
const_iterator
find(const key_type& __x) const
{ return _M_t.find(__x); }
//@}
//@{
@ -415,9 +458,12 @@ namespace __gnu_norm
* pointing to the first element that has a greater value than given key
* or end() if no such element exists.
*/
iterator lower_bound(const key_type& __x)
iterator
lower_bound(const key_type& __x)
{ return _M_t.lower_bound(__x); }
const_iterator lower_bound(const key_type& __x) const
const_iterator
lower_bound(const key_type& __x) const
{ return _M_t.lower_bound(__x); }
//@}
@ -428,9 +474,12 @@ namespace __gnu_norm
* @return Iterator pointing to the first element
* greater than key, or end().
*/
iterator upper_bound(const key_type& __x)
iterator
upper_bound(const key_type& __x)
{ return _M_t.upper_bound(__x); }
const_iterator upper_bound(const key_type& __x) const
const_iterator
upper_bound(const key_type& __x) const
{ return _M_t.upper_bound(__x); }
//@}
@ -450,16 +499,22 @@ namespace __gnu_norm
*
* This function probably only makes sense for multisets.
*/
pair<iterator,iterator> equal_range(const key_type& __x)
pair<iterator,iterator>
equal_range(const key_type& __x)
{ return _M_t.equal_range(__x); }
pair<const_iterator,const_iterator> equal_range(const key_type& __x) const
pair<const_iterator,const_iterator>
equal_range(const key_type& __x) const
{ return _M_t.equal_range(__x); }
//@}
template<class _K1, class _C1, class _A1>
friend bool operator== (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
friend bool
operator== (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
template<class _K1, class _C1, class _A1>
friend bool operator< (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
friend bool
operator< (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
};
@ -510,7 +565,6 @@ namespace __gnu_norm
const set<_Key,_Compare,_Alloc>& __y)
{ return __y < __x; }
/// Returns !(y < x)
template<class _Key, class _Compare, class _Alloc>
inline bool